How to use asyncio with blocking method

[IlysvlVEizbr]

Is it possible to use await with blocking method?

For example I try the code below:

import uasyncio
from pyb import LED, UART
import select

uart = UART(6, 9600)
p = select.poll()
p.register(uart, select.POLLIN)

async def ioCoroutine(led):
    while True:
        led.toggle()
        await uasyncio.sleep(2)

async def uartCoroutine(led):
    while True:
        await p.ipoll()
        data = uart.read()
        # deal with uart data...
        led.toggle()
        await uasyncio.sleep(1)

async def main(led1, led2):
    await uasyncio.gather(
        ioCoroutine(led1),
        uartCoroutine(led2)
    )

uasyncio.run(main(LED(1), LED(3)))

I wish the blocking method ipoll or something like that could suspend the current task, allow other tasks to run, and wait for the event. But I didn't make it, the ipoll suspended the whole program once it called.

I know that I can use _thread instead. But in fact, the ipoll is just blocking there and waiting, the Python interpreter would always run in the other thread until the event comes, like running in single-threaded mode. So I'm here to discuss about maximize the performance (reduce the performance loss from multi-threading), and something like best practice in this situation.

Similarity, I try:

...
from pyb import LED, CAN
...
can = CAN( ... )
can.setfilter(0, ... )
...
async def canCoroutine(led):
    while True:
        data = await can.recv(0, timeout=-1)
        # deal with uart data...
        led.toggle()
        await uasyncio.sleep(1)
...

The can.recv(0, timeout=-1) would also block the whole program.

Would we need to add new code to micropython to let all these hardware bus blocking reader and poll work with asyncio?

[jimmo]

You need to use StreamReader to use the UART asynchronously. Then you can await uart.read(). See @peterhinch's excellent docs here: https://github.com/peterhinch/micropython-async/blob/master/v3/docs/TUTORIAL.md#63-using-the-stream-mechanism

Unfortunately StreamReader doesn't quite work with CAN. It does support the relevant ioctl for asyncio to poll it, but does not support read. What you could probably do is adapt StreamReader (see https://github.com/micropython/micropython/blob/master/extmod/uasyncio/stream.py ) to make a CANStreamReader. Basically it just needs a new read method that calls recv instead.

[IlysvlVEizbr]

Thanks, I got it. The document really helps.

As a conclusion, users should not await any blocking method or reader directly. Instead, they should use a function that would return immediately to check whether the data in hardware bus is ready to read, then use some kinds of code like below:

async def fun(...):
    while True:
        if (whether the data is ready to read):
            # read the data and deal it
            ...
        else:
           await uasyncio.sleep_ms(0)  # or sleep longer