Absolutly lost in ASYNCIO... please help

[nastiliano]

Hello everyone.

I've been reading a lot of documentation about asynio but I can't find wich methods use to reach the following objective:

• 1st coro waits for a possible incoming Bluetooth connection and will do the respective modifications to non-volatile memory in my ESP32
• 2nd coro waits for a possible incoming Wifi connection and will do the respective modifications to non-volatile memory in my ESP32
• 3rd the "real firmware" of my ESP32 device. It waits for interruptions in my ESP32 gpio (as inputs) and will do something with gpio (as outputs) and then the same...

All executing "at the same time" asynchronous. Waiting all the time for "interrups" of BT, Wifi or pin inputs.

Here is my code:

#Bluetooth Coro
async def coro_Bluetooth():
    while True:
        print("At the moment nothing")
        await uasyncio.sleep(1)

#Wifi coro
async def coro_Wifi():
    while True:
        listen_socket = socket.socket(socket.AF_INET , socket.SOCK_STREAM)
        listen_socket.setsockopt(socket.SOL_SOCKET , socket.SO_REUSEADDR , 1)

        if wifi_mode == 0:
            listen_socket.bind(("192.168.4.1" , 19204))
        else:
            listen_socket.bind((IP_estacio.decode() , 19204))

        listen_socket.listen(1)

        client_socket , adre_port = listen_socket.accept()

        data = client_socket.recv(1024)

        ...  #All stuff of things: Save to NVM, etc...

        listen_socket.close()
        client_socket.close()

        await uasyncio.sleep(1)

#Device coro
async def coro_Device():
    while True:
        #... waiting for input interruptions and do something whit outputs

        await uasyncio.sleep(1)

#Execute tasks simultaniouly
async def main():
    await uasyncio.gather(coro_Bluetooth() , coro_Wifi() , coro_Device())

uasyncio.run(main())

¿Somebody could help me to find the exact methods I must use to execute this code continuously without getting stuck in any coro and to be the sensation like different 3 threads waiting for interruptions?

Thanks to everyone.
Best regards.

[bixb922]

You are not lost, you are on the right track!!! Having 3 coros and uasyncio.gather seems perfect.
You'll have to check that you don't block the execution for long times. For example, time.sleep() does that, use await uasyncio.sleep() instead. The keyword here is await: if something takes a lot of time (such as waiting for a network connection), it should be a asyncio function that can be awaited.
In the code you show, listen_socket.listen() will block all asyncio tasks while waiting for a incoming connection. Use uasyncio.start_server() instead. That will listen in an asyncio friendly way, and start awaitable stream objects to read and write data to the socket. Here is an example https://github.com/peterhinch/micropython-async/blob/master/v3/as_drivers/client_server/userver.py, thanks to @peterhinch.
For bluetooth, use aioble. It's easy to install with mpremote mip install, it's fully asyncio and rather easy to use. See https://github.com/micropython/micropython-lib/tree/master/micropython/bluetooth/aioble for examples.
For the device, there are several strategies possible. If the frequency that you need to access the device is low, for example every 50 milliseconds or slower, the easiest way is to poll the device, i.e. to make a loop of the form:

    ... initialize device ...
    while True:
        await asyncio.sleep_ms(50)
    .   ... insert code here to poll the device ...

Some devices generate interrupts. That allows to serve the device with lower latency. In the interrupt service routine, you could for example read data from the device and store in a preallocated array and then use ThreadSafeFlag to signal that information is available. In coro_Device() you await that event and process the data with more time. For many situations, this additional complexity is not necessary, and it may be sufficient to poll the device periodically. Again, https://github.com/peterhinch/micropython-async is a invaluable resource for this topic. Servicing interrupts can be tricky, there are many restrictions (https://docs.micropython.org/en/latest/reference/isr_rules.html), so I think polling is preferable if the latency to serve the device allows that.

[nastiliano]

Thank you very much @bixb922 !!

I understand the way to do it, but I'm a newbie and It's hard to me rewrite the @peterhinch code for my example.
It already was so hard to understand sockets in the traditional way (I was reading "RealPython's" tutorials, etc...).
Could you help me a little bit more? Could you give some clues how to write the asynchronic way to my code?
I made a lot of tries but I only achieved to start the server and running the 3 coros at the same time, but I haven't received any data yet from client...

Again thank you so much.

[bixb922]

Could you share your code?

[nastiliano]

Hello again.

My code is:

import esp32
import json
import machine
import network
import socket
import time
import uasyncio


#GLOBAL VARIABLES
area_param = esp32.NVS("area_param")
...
connection_type = area_param.get_i32("conn_typ")
wifi_mode = area_param.get_i32("mod_wifi")
host = bytearray(area_param.get_blob("host" , bytearray()))
area_param.get_blob("host" , host)
ssid = bytearray(area_param.get_blob("ssid" , bytearray()))
area_param.get_blob("ssid" , ssid)
network_password = bytearray(area_param.get_blob("net_pass" , bytearray()))
area_param.get_blob("net_pass" , network_password)
subnet_mask = bytearray(area_param.get_blob("subnet_mask" , bytearray()))
area_param.get_blob("subnet_mask" , subnet_mask)
dhcp = area_param.get_i32("dhcp")
IP_gateway = bytearray(area_param.get_blob("IP_gateway" , bytearray()))
area_param.get_blob("IP_gateway" , IP_gateway)
IP_station = bytearray(area_param.get_blob("IP_est" , bytearray()))
area_param.get_blob("IP_est" , IP_station)
...


# CONNECTION CONFIGURATION
#"Bluetooth" config
if connection_type == 0 or connection_type == 2:
    pass

#"Wifi" config
if connection_type == 1 or connection_type == 2:
    if wifi_mode == 0:
        #As Acces Point
        wlan = network.WLAN(network.AP_IF)
        wlan.config(max_clients = 1 , essid = ssid.decode() , authmode = 3 , password = network_password.decode())
        wlan.active(True)
    else:
        #As Station
        wlan = network.WLAN(network.STA_IF)
        wlan.active(True)
        if dhcp == 0:
            wlan.ifconfig((IP_station.decode() , subnet_mask.decode() , IP_gateway.decode() , IP_gateway.decode()))
        wlan.config(dhcp_hostname = host.decode())
        wlan.connect(ssid.decode() , network_password.decode())
        time.sleep(5)


#BLUETOOTH CORO
async def coro_Bluetooth(t):
    while True:
        print("Waiting for Bluetooth connection")

        await uasyncio.sleep(t)


#WIFI CORO
async def coro_Wifi(t):
    while True:
        
        listen_socket = socket.socket(socket.AF_INET , socket.SOCK_STREAM)
        listen_socket.setsockopt(socket.SOL_SOCKET , socket.SO_REUSEADDR , 1)

        #Config depending on mode
        if wifi_mode == 0:
            listen_socket.bind(("192.168.4.1" , 19204))
        else:
            listen_socket.bind((IP_station.decode() , 19204))

        #Waiting for Wifi socket
        listen_socket.listen(1)

        #"Client socket" to receiving data
        client_socket , adre_port = listen_socket.accept()

        ... #OMITED CODE (decrypting AES256)

        #Receiving serialized data
        serialized_data = client_socket.recv(1024)

        #Deserializing data
        deserialized_data = json.loads(serialized_data.decode())

        ... #OMITED CODE (verifying credentials user/pass if correct:)

        #Save to NVM (non-volatile)                    
        area_param = esp32.NVS("area_param")
        area_param.set_i32("conn_typ" , deserialized_data[4][0])
        area_param.set_i32("wifi_mod" , deserialized_data[4][1])
        area_param.set_blob("host" , deserialized_data[4][2])
        area_param.set_blob("ssid" , deserialized_data[4][3])
        ...
        area_param.commit()

        #Restart device
        await uasyncio.sleep(2)
        machine.reset()
        
        ... #OMITED CODE (if credentials are not correct, a code error is returned)
        
        #Closing all sockets
        listen_socket.close()
        client_socket.close()

        await uasyncio.sleep(t)


#"FIRMWARE" CORO
async def coro_Device(t):
    while True:
        print("Executing device firmware")

        await uasyncio.sleep(t)


#"MAIN"
async def main():
    await uasyncio.gather(coro_Bluetooth(1) , coro_Wifi(1) , coro_Device(1))

uasyncio.run(main())

[peterhinch]

To add some general points about sockets in uasyncio. There are two ways to prevent them from blocking (i.e. monpolising the processor so other tasks can't run). One is to use nonblocking sockets, as per asynchronous MQTT. Using these requires some attention to detail but offers a high degree of low level control.

The other approach, which is simplest in most cases, is to use the stream mechanism. This uses polling of a blocking socket via select.poll, but does it in a way which is simple and intuitive.

[bixb922]

This should be a starting point. To make this code ready for production, exception handling and network error handling should be added. At least, a global asyncio exception handler should be added (see https://github.com/peterhinch/micropython-async/blob/master/v3/docs/TUTORIAL.md#511-global-exception-handler). Network reads should have timeout and exception handling. The code below can be tested with the curl command on the PC.
If you want to implement http as a protocol, please use microdot or tinyweb, these are working web servers. If you want to implement MQTT as a protocol, there are clients available.

import uasyncio
import network

#Bluetooth Coro
async def coro_Bluetooth():
    while True:
        print("bluetooth coro running")
        await uasyncio.sleep(1)

#Wifi coro
async def coro_server( reader, writer ):
    data = await reader.read(1024)
    print(f"received {data=}")

    # Give a response so this can be tested with 
    # the command line command
    # curl http://192.168.xxx.xxx/
    writer.write(b'HTTP/1.0 200 OK\n\nBon dia\n')
    await writer.wait_closed()

#Device coro
async def coro_Device():
    while True:
        print("device coro running")
        await uasyncio.sleep(1)

async def do_connect():
    import secrets
    sta_if = network.WLAN(network.STA_IF)
    if not sta_if.isconnected():
        print('connecting to network...')
        sta_if.active(True)
        sta_if.connect( secrets.ssid,  secrets.key )
        while not sta_if.isconnected():
            await uasyncio.sleep_ms(100)
    print('connected, network config:', sta_if.ifconfig())

#Execute tasks simultaneouly
async def main():
    await do_connect()
    server = uasyncio.start_server( coro_server, "0.0.0.0", 80 )
    await uasyncio.gather(coro_Bluetooth() , server , coro_Device())

uasyncio.run(main())

[nastiliano]

It completly works!!! In a easiest way than synchro socket mode!!!

Thank you very very much !!! To everyone, but specially @bixb922 and @peterhinch obviously.

Now I'm gonna programing the device usung poll strategy.

Thanks again.
Cheers from Spain.