Das deutsche Python-Forum

Code: Alles auswählen

# Bibliotheken laden
from machine import Pin, PWM
import time

# GPIO für Steuersignal
servo_pin = 28

# GPIO für Taster
btn_pin_up = 14
btn_pin_down = 15

# Wert für 0 Grad
valueMin = 0

# Wert für 180 Grad
valueMax = 180

# Position in Grad
value = 90

# Positionsänderung in Grad
step = 10

# Initialisierung der Taster
btn_up = Pin(btn_pin_up, Pin.IN, Pin.PULL_UP)
btn_up_last = time.ticks_ms()
btn_down = Pin(btn_pin_down, Pin.IN, Pin.PULL_UP)
btn_down_last = time.ticks_ms()

# Initialisierung PWM-Signal
servo = PWM(Pin(servo_pin))
servo.freq(50)

# Taster-Auswertung UP
def push_up(pin):
    global value, valueMin, valueMax, step, btn_up, btn_up_last
    if pin is btn_up:
        # Taster entprellen
        if time.ticks_diff(time.ticks_ms(), btn_up_last) > 200:
            value = value + step
            # Begrenzung des Wertebereichs
            if value < valueMin: value = valueMin
            if value > valueMax: value = valueMax
            servo_control(value)
            btn_up_last = time.ticks_ms()

# Taster-Auswertung DOWN
def push_down(pin):
    global value, valueMin, valueMax, btn_down, btn_down_last
    if pin is btn_down:
        # Taster entprellen
        if time.ticks_diff(time.ticks_ms(), btn_down_last) > 200:
            value = value - step
            # Begrenzung des Wertebereichs
            if value < valueMin: value = valueMin
            if value > valueMax: value = valueMax
            servo_control(value)
            btn_down_last = time.ticks_ms()

# Funktion: Servo steuern
def servo_control(value, minDuty=1638, maxDuty=8192):
    # Tastverhältnis berechnen
    newDuty = int(maxDuty - (value - valueMin) * (maxDuty - minDuty) / (valueMax - valueMin) )
    # Datenausgabe
    print('Grad:', value)
    print('Duty:', newDuty)
    print()
    # PWM-Signal ändern
    servo.duty_u16(newDuty)

# Hauptprogramm
print('STRG + C zum Benden')
print()

try:
    # Grundposition
    servo_control(value)
    # Interrupt für Taster UP
    btn_up.irq(trigger=Pin.IRQ_FALLING, handler=push_up)
    # Interrupt für Taster DOWN
    btn_down.irq(trigger=Pin.IRQ_FALLING, handler=push_down)
    # Wiederholung (damit das Programm weiterläuft)
    while True:
        time.sleep(1)
except (KeyboardInterrupt):
    pass
finally:
    servo.deinit()
    print('Beendet')

Code: Alles auswählen

import asyncio
from machine import PWM, Pin


class Servo:
    def __init__(
        self,
        name: str,
        pin: int,
        *,
        min_duty: int = 1638,
        max_duty: int = 8192,
        degrees_min: float | int = 0,
        degrees_max: float | int = 180,
        initial_angle=0,
        preferred_angle=90,
        print_debug=False,
    ):
        self.name = name
        self.min_duty = min_duty
        self.max_duty = max_duty
        self.degrees_min = degrees_min
        self.degrees_max = degrees_max
        self.initial_angle = initial_angle
        self.preferred_angle = preferred_angle
        self.pwm = PWM(pin, freq=50, duty_u16=self.new_duty(initial_angle))
        self.busy = False
        self.print_debug = print_debug

    def __call__(self, degrees: float | int):
        duty_u16 = self.new_duty(degrees)
        if self.print_debug:
            print(f"[{self.name}] Grad:", degrees)
            print(f"[{self.name}] Duty:", duty_u16)
            print()
        self.pwm.duty_u16(duty_u16)

    def new_duty(self, value: float | int) -> int:
        return int(
            self.max_duty
            - (value - self.degrees_min)
            * (self.max_duty - self.min_duty)
            / (self.degrees_max - self.degrees_min)
        )

    async def do_task(self, degrees: float | int | None = None):
        if self.busy:
            return

        degrees = degrees or self.preferred_angle
        self.busy = True
        self(degrees)
        await asyncio.sleep(3)
        self(self.initial_angle)
        # z.B. nach der Auslösung 200 ms warten, bis die
        # nächste Auslösung ermöglicht wird
        await asyncio.sleep_ms(200)
        self.busy = False


async def main():
    button_servo_mapping = {
        Pin(15, mode=Pin.IN, pull=Pin.PULL_DOWN): Servo(
            "Servo 1", 8, initial_angle=0, preferred_angle=90, print_debug=True
        ),
        Pin(16, mode=Pin.IN, pull=Pin.PULL_DOWN): Servo(
            "Servo 2", 3, initial_angle=90, preferred_angle=180, print_debug=True
        ),
    }

    while True:
        for button, servo in button_servo_mapping.items():
            if button() and not servo.busy:
                asyncio.create_task(servo.do_task())

        await asyncio.sleep_ms(10)


if __name__ == "__main__":
    asyncio.run(main())