uasyncio run_in_executor support

[saraverbeecke]

Hi,

is there a way to mimic the asyncio.run_in_executor of CPython in uasyncio?
run_in_executor is not available in the uasyncio, but I was wondering if someone has any experience in using the _thread module to come up with a asyncio.run_in_executor example.

If you have a long blocking call and have no asynchronous support for that call, it would be nice to run it in a thread using the asyncio.run_in_executor while the rest of the code can be executed in the event_loop.

[peterhinch]

I have written this doc which aims to describe using uasyncio with code running in other contexts including threaded code and code running on another core (RP2).

In particular this section details code for dealing with blocking functions.

[saraverbeecke]

@peterhinch amazing docs! Thank you for the explanations!

[saraverbeecke]

@peterhinch
I was asking this because for my project I have a NeoPixel that has some kind of "breathing" effect, where the brightness is changed continuously. My first thought was to put this in a coro and have some sort of delay await uasyncio.sleep(10). It works as expected, but since there will be some other code running it could happen that the breathing task is not scheduled fast enough so that the user will see some difference in the brightness update frequency (it should be updated fast enough so there you can't see the brightness "steps" i.e. flicker fusion threshold).
What would you suggest to approach this? I was thinking on putting in a separate thread instead of the asynchronous context, but is this the right approach?

[peterhinch]

It's hard to give a definitive answer without doing a detailed study of the code. My approach would be to start out using uasyncio and only resort to threading if a problem emerges which can't be fixed by other optimisation.

[cve2022]

I agree with @peterhinch . Still, just as a heads up, the neopixel requires a fairly tight timing to work (to distinguishing between zeros and ones on its input stream) so it may be a case where dedicating one core exclusively to send the stream can make sense to ensure the other activities do not prevent the correct transmission of it. I am assuming an RP2 is being used; it is not clear to me if that is the case from previous post from @saraverbeecke though.

[cricri-47]

@saraverbeecke I got the same kind of issue using a led strip while the Rp2040 is managing some web pages. It's quite too complex to manage the same time the 2 task. My current solution is the use of a single arduino (playing neopixel lib) receiving the datas by a serial communication from pico. That's able to simplify the task... By the way, juste managing html with some other parallel task is not so easy and the uasyncio is tricky :-) thanks @saraverbeecke for the doc !

[thierryppp]

Hello I've had the same problem with a neopixel strip.
In this micropython tuto ==> MicroPython: WS2812B Addressable RGB LEDs with ESP32 and ESP8266:
https://randomnerdtutorials.com/micropy ... 2-esp8266/
The problem ==> when you press the pushbutton to select an effect, it will only start when the effect that is running stops.
After some discussions with some people ==> @peterhinch answer me use ==> uasyncio.
see all the discussion : https://forum.micropython.org/viewtopic.php?f=16&t=11932&hilit=thierry

It was difficult but with the help of @peterhinch (thanks again to him) I succeeded.

# essai de test en aynchrone correspondant à des push button
from machine import Pin
import machine, neopixel, time
# Rajout
import uasyncio as asyncio
from primitives.pushbutton import Pushbutton
##
task = None  # Reference to currently running task
# bouton 1 ==> func clear et wait = 0?
pb1 = Pushbutton(Pin(15, Pin.IN))
# bouton 2 ==> func bounce et wait = 70ms
pb2 = Pushbutton(Pin(14, Pin.IN))
# bouton 3 ==> func cycle et wait = 50ms
pb3 = Pushbutton(Pin(12, Pin.IN))
# bouton 4 ==> func rainbow_cycle et wait = 1ms
pb4 = Pushbutton(Pin(13, Pin.IN),suppress=True)
##
# LED strip configuration
# number of pixels
n = 64
# strip control gpio
p = 5 
np = neopixel.NeoPixel(machine.Pin(p), n)

## tache principale
async def start(func, *var):
    global task
    print("task entree",task)
    print(*var)
    if task is not None:
        task.cancel()
        await asyncio.sleep_ms(0)  # Allow cancellation to occur
    task = asyncio.create_task(func(*var))
    print("task sortie",task,func,*var)
    

# FUNCTIONS FOR LIGHTING EFFECTS
#
# Bouton 1 ==> clear (var) ne sert à rien
async def clear(*var):
    # turn off all pixels
    print("clear")
    print(*var)
    for i in range(n):
        np[i] = (0, 0, 0)
        np.write()

# Bouton 2 ==> bounce
async def bounce(*var):
# les couleurs à utiliser
    print("bounce : ", *var)
    wait=70
    r = 23 
    g = 210
    b = 15
    for i in range(2 * n):
        for j in range(n):
            np[j] = (r, g, b)
        if (i // n) % 2 == 0:
            np[i % n] = (0, 0, 0)
        else:
            np[n - 1 - (i % n)] = (0, 0, 0)
        np.write()
        await asyncio.sleep_ms(wait)

# Bouton 3 ==> cycle
async def cycle(*var):
# les couleurs à utiliser
    print("cycle : ", *var)

    wait=50
    r = 123 
    g = 0
    b = 154
    for i in range(n):
        for j in range(n):
            np[j] = (0, 0, 0)
        np[i % n] = (r, g, b)
        np.write()
        await asyncio.sleep_ms(wait)

# Bouton 4 ==> rainbow
async def rainbow_cycle(*var):
    print("rainbow : ", *var)    
    wait=1
    for j in range(255):
        for i in range(n):
          rc_index = (i * 256 // n) + j
          np[i] = wheel(rc_index & 255)
        np.write()
        await asyncio.sleep_ms(wait)

# function to go through all colors 
def wheel(pos):
# Input a value 0 to 255 to get a color value.
# The colours are a transition r - g - b - back to r.
    if pos < 0 or pos > 255:
        return (0, 0, 0)
    if pos < 85:
        return (255 - pos * 3, pos * 3, 0)
    if pos < 170:
        pos -= 85
        return (0, 255 - pos * 3, pos * 3)
    pos -= 170
    #await asyncio.sleep_ms(1)
    return (pos * 3, 0, 255 - pos * 3)
    #await asyncio.sleep_ms(1)

async def main():
    pb1.press_func(start, (clear, ))
    pb2.press_func(start, (bounce, 23, 210, 15, 70,))
    pb3.press_func(start, (cycle, 123, 0, 154,50,))
    pb4.press_func(start, (rainbow_cycle, 1,))
    '''Test des 3 autres fonctions du bouton
    short_press = pb4.release_func(print, ("SHORT",))
    double_press = pb4.double_func(print, ("DOUBLE",))
    long_press = pb4.long_func(print, ("LONG",))'''

    while True:
        await asyncio.sleep(1)  # Replace with your code
        print('Running')

try:
    asyncio.run(main())
except KeyboardInterrupt:
    print('interrupted!')
    #prévoir le close
finally:
    print('Program finished')

It's a test program I force the variable (*var) and the wait values ​​are put for testing they must be adapted.
and for example in addition you can run a WEB wifi connexion

while True:
        await asyncio.sleep(1)  # Replace with your code
        print('Running')

Thierry.