ESP32: Motor mit PWM, Strommessung, Fenster-Funktion und Timeout

import time

from collections import deque
from machine import Pin, I2C, ADC, PWM
from ina226 import INA226


class Poti:
    def __init__(self, pin):
        self._adc = ADC(Pin(pin))
        self._last = None

    @property
    def value(self):
        current = round(self._adc.read_u16() / 65535 * 100)
        if self._last is not None and self._last != current:
            # print(f"Abschaltung bei {current} mA")
            ...

        self._last = current
        return current


SDA = Pin(15)
SCL = Pin(16)
ON = Pin(3, mode=Pin.IN, pull=Pin.PULL_DOWN)
MOT = PWM(Pin(5), freq=5000, duty_u16=0)

bus = I2C(1, sda=SDA, scl=SCL)
ina = INA226(bus, 0x40)
poti = Poti(9)

timeout = None
window_timeout = None
window_active = True

motor_deaktiviert = False

queue = deque([0]*20, 100)

while True:
    # hier wird zur Schlange einfach der Status das Eingangs (0 oder 1)
    # angehangen. Wenn die Schlange voll ist, wird das älteste Element verworfen
    queue.append(ON())

    # Eingang abfragen
    # Anstatt den Eingang direkt abzufragen, müssen alle
    # Elemente in der Warteschalnge 1 sein
    if all(queue):
        # Wenn der Timeout gesetzt ist und größer als die aktuelle Zeit (in ms),
        # wird der Motor deaktiviert und zurück zum Kopf der Endlosschleife
        if timeout is not None and time.ticks_ms() > timeout:
            MOT.duty(0)
            if motor_deaktiviert:
                print("Motor ist blockiert, Eingangssignal wird ignoriert und der Motor abgeschaltet")
                motor_deaktiviert = False
            continue

        # Bedingung des Timeouts noch nicht erfüllt
        # dann wird diese Position erreicht
        MOT.duty(512)

        # Fenster-Funktion, um eine vorgegebene Zeit keine
        # Strom-Messungen durchzuführen. Hilft bei Getriebemotoren zur
        # Überwindung der Hemmung.

        # Fenster ist aktiv, aber noch kein Timeout für das
        # Fensrer gesetzt.
        if window_active and window_timeout is None:
            window_timeout = time.ticks_ms() + 5000
            print("Fenster geöffnet")
            continue
        # Fenster ist aktib und der Timeout ist auch gesetzt
        elif window_active and window_timeout:
            if time.ticks_ms() < window_timeout:
                continue

        if window_active:
            print("Fenster geschlossen")
        # window_active wird jetzt zurückgesetzt

        # wenn keine der vorheringen Bedingungen erfüllt ist,
        # wird diese Position erreicht
        # Fenster-Funktion zurücksetzen
        window_active = False
        window_timeout = None

        # Ausgabe des Stroms in mA
        current = round(ina.current * 1000, 0)

        # Wenn der Strom größer ist, als durch das Poti der vorgebene Wert (bis 100mA)
        # wird dieser Zweig ausgeführt
        if current > poti.value:
            # print(f"Motor: {current:.0f} mA")
            # Motor anhalten
            MOT.duty(0)
            # Timeout setzen, damit der Motor nach gegebener Zeit
            # den aktiven Steuerbefehl ignoriert
            if timeout is None:
                timeout = time.ticks_ms() + 2_000
    else:
        # Motor wird nicht angesteuert
        # Motor anhalten
        # timeout zurücksetzen
        # Fenster aktiv schalten und die None window_timeout zuweisen

        MOT.duty(0)
        timeout = None
        window_active = True
        window_timeout = None

        motor_deaktiviert = True