MicroPython: uasyncio

[Christoph M. (mchris)]

Im Moment beschäftige ich mich gerade mit Micropython.

Ich habe folgende Problemstellung:
1. Es soll jede Sekunde ein Zählerwert ausgegeben werden
2. Gleichzeitig soll es möglich sein, mittels eine User Input (REPL) den 
Zähler auf 0 zu setzen.

Ich habe es mal mit "uasyncio" probiert und zwei Tasks erzeugt.
https://github.com/peterhinch/micropython-async/blob/master/v3/docs/TUTORIAL.md
Im einen wird der Wert kontinuierlich ausgeben und der andere versucht, 
den User-Input zu lesen. Leider scheint aber das lesen wollen eines 
User-Inputs

        x=input()
        print(x)

das gesamte System zu blockieren und es geht erst weiter, wenn man eine 
Taste drückt.
Hat jemand eine Lösung für so ein Problem?

[Katon (Gast)]

Welcher Controller? Welche Eingabeschnittstelle?

Eingabe via UARTx:

...

z = UARTx.any()                # Anzahl der Zeichen im Eingabepuffer

if z > 0:
    c = UARTx.read(1)          # Zeichen abholen
    ...                        # Zeichen verarbeiten   

...

[Christoph M. (mchris)]

Ich verwende einen ESP32.
Die Idee mit der UART wäre gut, aber die Kommunikation geht über REPL 
und REPL blockiert UART0 (welche die richtig Schnittstelle wäre).

[Alex Z. (alexander_z49)]

Ich habe auf mehreren ESP32 µPython mit uasyncio laufen für 
Benutzereingaben über TCP und gleichzeitigem ansteueren von sk9822 LEDs. 
Würde helfen, wenn du uns deinen Code mal zeigst.

Welche Verbindung nutzt du um die REPL aufzurufen? Ich nehme an, der 
ESP32 ist über USB als virtueller Com-Port am PC erreichbar und du nutzt 
ein Terminal-Programm?

Alex

[Christoph M. (mchris)]

>Ich habe auf mehreren ESP32 µPython mit uasyncio laufen für
>Benutzereingaben über TCP und gleichzeitigem ansteueren von sk9822 LEDs.

Klingt gut. Hier ist der Code:

import uasyncio

async def count():
    counter=0
    while True:
        print(counter)
        counter=counter+1
        await uasyncio.sleep_ms(1000)

async def userInput():
    while True:
        print("wait for input")
        x=input()
        print(x)
        await uasyncio.sleep_ms(100)
        
async def main():
    uasyncio.create_task(count())
    uasyncio.create_task(userInput())
    await uasyncio.sleep_ms(10_000)

uasyncio.run(main())

Obwohl der Counter jede Sekunde ausgegeben werden sollte, passiert das 
nur, wenn man den "userInput" drückt.
Vielleicht liegt es ja an der Ausgabe und eine LED würde trotzdem 
blinken.

[Katon (Gast)]

Du kannst es mit einer nichtblockierenden Abfrage von 'stdin' lösen.

import sys, select

spoll = select.poll()
spoll.register(sys.stdin, select.POLLIN)

...

if spoll.poll(0):           # Zeichen im Eingangspuffer von stdin?
    c = sys.stdin.read(1)   # Zeichen abholen
    print(c)                # Zeichen verarbeiten/ausgeben

...

[Christoph M. (mchris)]

>Du kannst es mit einer nichtblockierenden Abfrage von 'stdin' lösen.

Danke, das scheint sehr gut zu funktionieren. Ich habe es mal in die 
Routine mit dem Zähler verpackt:

import sys, select
import utime as time

spoll = select.poll()

spoll.register(sys.stdin, select.POLLIN)

counter=0

while True:
    if spoll.poll(0):           # Zeichen im Eingangspuffer von stdin?
        c = sys.stdin.read(1)   # Zeichen abholen
        print("input: "+c)      # Zeichen verarbeiten/ausgeben
    time.sleep(0.1)
    print(counter)
    counter=counter+1

Wenn man es in der "Thonny" Umgebung debugged, muss man erst mal "Enter" 
drücken. Danach werden immer erst alle Zeichen im Tastaturbuffer 
gesammel und bei Enter erst übertragen. Das scheint aber eine 
Eigenschaft von "Thonny" zu sein.

Wenn man es mit minicom benutzt

minicom -D /dev/ttyUSB0

funktioniert es perfekt.

[Christoph M. (mchris)]

Die verwendete Funktion

time.sleep(0.1)

bremst das Polling auf 100ms pro Zeichen.
Es wäre besser, das Polling "full speed" während der Wartezeit zu 
machen.
Kennt jemand eine gute Methode dazu?

Es gibt hier

https://docs.micropython.org/en/latest/library/time.html

die Methode time_ticks_diff. Aber ich habe die Befürchtung, dass es 
einen Zeitbasis Überlauf geben könnte und dann das System hängt:

# Wait for GPIO pin to be asserted, but at most 500us
start = time.ticks_us()
while pin.value() == 0:
    if time.ticks_diff(time.ticks_us(), start) > 500:
        raise TimeoutError

[Kaj (Gast)]

Christoph M. schrieb:
> Es wäre besser, das Polling "full speed" während der Wartezeit zu
> machen.
> Kennt jemand eine gute Methode dazu?
Einfach das sleep weglassen?

[Christoph M. (mchris)]

>Einfach das sleep weglassen?

Ja, dann wäre es "full speed". Es soll aber auch der Counter alle 100ms 
erhöht und ausgegeben werden.