Infinite recursion in asyncio.run?

[fipscode]

MP: MicroPython v1.23.0-preview.126.gf9704ce36.dirty on 2024-02-16; NUCLEO-WB55 with STM32WB55RGV6

I'm trying to get along with aioble and hopefully hit the last showstopper:

from aioble import (
        Service,
        Characteristic,
        scan,
        advertise,
        register_services,
)
from asyncio import run
from bluetooth import UUID
import sys

class BLE:
    def __init__(self, name, services=tuple()):
        self._name = name
        self._services = services
        if len(services)>0:
            self._register_services()
    def _register_services(self):
        register_services(*self._services)

def listfunc(device):
    print('seen device with address %s and name %s'%(device.name(),device.addr_hex()))

class Central(BLE):
    def list_peripherals(self,
            listfunc=listfunc,
            duration_ms=10000,
            interval_us=30000,
            window_us=30000,
            active=True,
    ):
        async def _listfunc_sub():
            async with scan(duration_ms, interval_us, window_us, active) as scanner:
                async for res in scanner:
                    if listfunc(res)==False:
                        return
        run(_listfunc_sub())
    def connect(peripheral, timeout_ms=2000):
        async def _connect_sub():
            return await peripheral.connect(timeout_ms)
        return run(_connect_sub())

class Peripheral(BLE):
    def listen(self, interval_us=30000):
        async def _listen_sub():
            return await advertise(interval_us, name=self._name)
        return run(_listen_sub())



gap_role = 'central'
nus_uuid = UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
nus_rx_uuid = UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E")
nus_tx_uuid = UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E")

res = None
dev = None
def listfunc_fipstest(result):
    global res,dev
    res = result
    if result.name()=='Fipstest Peripheral':
        dev = result.device
        return False

if gap_role=='central':
    ble = Central('Fipstest Central')
    ble.list_peripherals(listfunc_fipstest)
    if dev is None:
        print('no device found')
        sys.exit(42)
    conn = ble.connect(dev)
elif gap_role=='peripheral':
    nus = Service(nus_uuid)
    nus_rx = Characteristic(nus, nus_rx_uuid, write=True, write_no_response=True)
    nus_tx = Characteristic(nus, nus_tx_uuid, read=True, notify=True)
    ble = Peripheral('Fipstest Peripheral', (nus,))
    conn = ble.listen()
else:
    print('invalid gap_role')
    sys.exit(42)

But I get the following infinite recursion for this and can't see the cause of the problem?

Traceback (most recent call last):
  File "<stdin>", line 71, in <module>
  File "<stdin>", line 41, in connect
  File "asyncio/core.py", line 1, in run
  File "asyncio/core.py", line 1, in run_until_complete
  File "asyncio/core.py", line 1, in run_until_complete
  File "<stdin>", line 40, in _connect_sub
  [...]
  File "<stdin>", line 41, in connect
  File "asyncio/core.py", line 1, in run
RuntimeError: maximum recursion depth exceeded

Any hints?

[mendenm]

listfunc(res) always returns None, not False, since it has no return, so this goes on forever.

[mendenm]

your connect() method should not be async, should it? It has an await inside it, so it isn't returning a coroutine.

[bixb922]

The following line async def connect(peripheral, timeout_ms=2000): should be
async def connect(self, peripheral, timeout_ms=2000):

As it is, the variable "peripheral" is set to the ble object (i.e. Central) and so return await peripheral.connect(timeout_ms)calls recursively Central.connect()

As for the question if using the basic bluetooth module or aioble is better: I found aioble much simpler and very stable. I'd stick with aioble.

[fipscode]

Argh, I was obviously too tired to still be working on it!
Now I'm almost there but still get an exception raised on this peripheral/server:

from asyncio import run
from ble import UUID, Service, Characteristic, Peripheral

async def main():
	nus_uuid    = UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
	nus_rx_uuid = UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E")
	nus_tx_uuid = UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E")

	nus = Service(nus_uuid)
	nus_rx = Characteristic(nus, nus_rx_uuid, read=True, notify=True)
	nus_tx = Characteristic(nus, nus_tx_uuid, write=True, write_no_response=True)
	peripheral = Peripheral('Fipstest Peripheral', (nus,))
	conn = await peripheral.listen()
	print('connected')
	request = await nus_tx.read()
	print(request)
	await nus_rx.write(b'Response')
	peripheral.disconnect(conn.device)

run(main())

which gets me

connected
None
Traceback (most recent call last):
  File "<stdin>", line 20, in <module>
  File "asyncio/core.py", line 1, in run
  File "asyncio/core.py", line 1, in run_until_complete
  File "asyncio/core.py", line 1, in run_until_complete
  File "<stdin>", line 17, in main
TypeError: 'NoneType' object isn't iterable

While it's certainly true that NoneType is not iterable, I have no clue who claims or/and where?
Also, the transmitted data should be printed instead of "None" anyway, why is it not?
Lastly, why does the peripheral sometimes not properly advertise with the exact same code? At least it's not visible to any central...

Anyway, thank you so much for your help so far, especially to @bixb922

[bixb922]

I think you'll have do await .written() before await read()

[fipscode]

After the print('connected') line, before I've even written a single bit? That makes the peripheral to hang.
Maybe we aren't talking about the same. I therefore post again the whole stuff:

# ble.py
from aioble import (
		Service,
		Characteristic,
		scan,
		advertise,
		register_services,
)
from bluetooth import UUID
import sys

class BLE:
	def __init__(self, name, services=tuple()):
		self._name = name
		self._services = services
		self._connections = {}
		if len(services)>0:
			self._register_services()
	def _register_services(self):
		register_services(*self._services)
	def _add_connection(self, connection):
		self._connections[connection.device] = connection
	def _del_connection(self, connection):
		del self._connections[connection.device]
	async def disconnect(self, device):
		connection = device.connection
		device.disconnect()
		self._del_connection(connection)

def listfunc(device):
	print('seen device with address %s and name %s'%(device.name(),device.addr_hex()))

class Central(BLE):
	async def list_peripherals(self,
			listfunc=listfunc,
			duration_ms=10000,
			interval_us=30000,
			window_us=30000,
			active=True,
	):
		async with scan(duration_ms, interval_us, window_us, active) as scanner:
			async for res in scanner:
				dev = listfunc(res)
				if dev is not None:
					return dev
	async def connect(self, peripheral, timeout_ms=2000):
		conn = await peripheral.connect(timeout_ms)
		self._add_connection(conn)
		return conn

class Peripheral(BLE):
	async def listen(self, interval_us=30000):
		return await advertise(interval_us, name=self._name)

# central.py
from asyncio import run
import sys
from ble import UUID, Central

async def main():
	nus_uuid    = UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
	nus_rx_uuid = UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E")
	nus_tx_uuid = UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E")
	
	def listfunc_fipstest(result):
		if result.name()=='Fipstest Peripheral':
			return result.device
	central = Central('Fipstest Central')
	peripheral = await central.list_peripherals(listfunc_fipstest)
	if peripheral is None:
		print('fipstest: no device found')
		sys.exit(42)
	conn = await central.connect(peripheral)
	print('connected')
	nus = await conn.service(nus_uuid)
	nus_rx = await nus.characteristic(nus_rx_uuid)
	nus_tx = await nus.characteristic(nus_tx_uuid)
	await nus_tx.write(b'Request')
	response = await nus_rx.read()
	print(response)
	central.disconnect(peripheral)

run(main())

# peripheral.py
from asyncio import run
from ble import UUID, Service, Characteristic, Peripheral

async def main():
	nus_uuid    = UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
	nus_rx_uuid = UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E")
	nus_tx_uuid = UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E")

	nus = Service(nus_uuid)
	nus_rx = Characteristic(nus, nus_rx_uuid, read=True, notify=True)
	nus_tx = Characteristic(nus, nus_tx_uuid, write=True, write_no_response=True)
	peripheral = Peripheral('Fipstest Peripheral', (nus,))
	conn = await peripheral.listen()
	print('connected')
	#await nus_tx.written()
	request = await nus_tx.read()
	print(request)
	await nus_rx.write(b'Response')
	peripheral.disconnect(conn.device)

run(main())

[bixb922]

Try this:

# peripheral.py
from asyncio import run, sleep_ms
from ble import UUID, Service, Characteristic, Peripheral

async def main():
	print("starting")
	nus_uuid    = UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
	nus_rx_uuid = UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E")
	nus_tx_uuid = UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E")

	nus = Service(nus_uuid)
	nus_rx = Characteristic(nus, nus_rx_uuid, read=True,  notify=True)
	nus_tx = Characteristic(nus, nus_tx_uuid, write=True, capture=True)
	peripheral = Peripheral('Fipstest Peripheral', (nus,))
	print("listening")
	conn = await peripheral.listen()
	print('connected')
	async with conn:
		received_on_connection, data = await nus_tx.written()
		nus_rx.notify(conn, data=bytearray(b'Response'+data) )
		peripheral.disconnect(conn.device)

run(main())