Async Websocket behaviour - waiting for input to send?

[JohannesNeu]

Hi everyone,

I use the microdot async websocket to forward serial data to xterm.js and it works very well.

When I set it up so that the websocket only sends data:

@app.route('/echo')
@with_websocket
async def echo(request, ws):
   while True:
      await ws.send(passthrough(uart.read()))

then I get a continuous stream of new data and every update will be pushed to the client.

As a next step I tried to allow for data to be received by the websocket and changed the code as follows:

@app.route('/echo')
@with_websocket
async def echo(request, ws):
   while True:
      await ws.send(passthrough(uart.read()))
      message = await ws.receive()
      uart.write(passthrough(message))

Now I can receive data! But the continuous stream of sent data is interrupted.
From a client perspective I would have to send new signals again and again to receive new data from the websocket.

I assume the way I wrote ws.send and ws.receive inside the while loop is the reason. I don't understand why though.
passthrough is a function that converts Nones to b'':

def passthrough(inputstream):
    if inputstream is None:
        return b''
    else:
        return inputstream

Would appreciate any help.

[miguelgrinberg]

The problem is that ws.receive() will block until the client sends something. Your uart.read() is also blocking, by the way, so you also have a potential issue there.

Basically what I think you want is to wait for data from your serial device and your client at the same time. The proper way to do this within asyncio would be :

• use an awaitable read for your serial device (I think you can do this with the asyncio.Stream class)
• use separate coroutines to read from serial and to read from WebSocket, so that they do not block each other

[JohannesNeu]

Hi @miguelgrinberg
I took your advice to heart and changed the uart function to an async setup.
It looks like this now:

uart = UART(2, 115200)

async def forwarded_from_uart():
    sreader = asyncio.StreamReader(uart)
    while True:
        res = await sreader.read(2048)
        if res is None:
            return b''
        else:
            return res

@app.route('/echo')
@with_websocket
async def echo(request, ws):
   while True:
      await ws.send(await forwarded_from_uart())

So far it works and I can receive the data.
Next I tried to implement the ws.receive() side and I am curious, what you think of the following implementation?
Is this correct/should it work?:

@app.route('/echo')
@with_websocket
async def echo(request, ws):
   while True:
      await ws.send(await forwarded_from_uart())
      await forward_to_uart(await ws.receive())

with a new async function called forward_to_uart.

I am asking, because when I tried to run this code with await print(await ws.receive()), I am getting TypeError: 'NoneType' object isn't iterable errors

[miguelgrinberg]

The print() function is not an awaitable. Use print(await ws.receive()) if you want to print what you receive from WebSocket.

I don't think your solution will work. When you use await you are blocking the function until the awaited function returns. I suggested you should use separate coroutines for the two operations, so that they do not block each other.

[JohannesNeu]

thank you for your advice, I honestly thought I already used separate coroutines, when I wrote:

      await ws.send(await forwarded_from_uart())
      await forward_to_uart(await ws.receive())

But I seem to be missing some basics.
Can you point me to documentation where I can read more about it, or tell me what I am missing?

[miguelgrinberg]

See the create_task() function https://docs.micropython.org/en/v1.14/library/uasyncio.html#uasyncio.create_task. This is the equivalent of starting a thread.

[JohannesNeu]

Thanks for the hint, I have been tinkering with it for quite some time now and tried to base my code on this tutorial.

I created the coroutine as follows:

async def forwarded_from_uart(ws):
    sreader = asyncio.StreamReader(uart)
    while True:
        res = await sreader.read(2048)
        if res is None:
            await ws.send(b'')
        else:
            await ws.send(res)
        await asyncio.sleep_ms(1)

from the tutorial I assume that it is necessary to add a asyncio sleep to allow it to snap out of this coroutine.
The main loop in microdot executes this:

@app.route('/echo')
@with_websocket
async def echo(request, ws):
    print("creating task")
    asyncio.create_task(await forwarded_from_uart(ws))
    print("task created")
    while True:
        print("Start While True in echo")
        asyncio.sleep_ms(1000)

async def main():
    await app.run(debug=True)

asyncio.run(main())

My understanding was, that I need to start the tasks and the add some sleeps inside the while loop to allow for the coroutines to take their time (similar to the howto).
But this doesn't work out, it prints the creating task line, but never prints the task created or Start While True in echo line.
So I assume it is stuck inside the task somehow?

[JohannesNeu]

I think I found the culprit:

- asyncio.sleep_ms(1000) needs an await in front of it

- forward_from_uart must not have an await in front of it

This seems to work so far (except of a different bug in the writer coroutine):

@app.route('/echo')
@with_websocket
async def echo(request, ws):
    asyncio.create_task(forwarded_from_uart(ws))
    asyncio.create_task(forward_to_uart(ws))    
    while True:
        await asyncio.sleep_ms(1000)

async def main():
    await app.run(debug=True)

asyncio.run(main())