Combining BLE Central and Peripheral with aioble fails.

[Jahor]

Hi,

I'm trying to implement a gateway of sorts with BLE on both sides.
I run peripheral device with Nordic UART service. It works fine.
After that connection is established to another device (as central this time). It finds the device, but when I try to connect I get:

Traceback (most recent call last):
  File "<stdin>", line 49, in connect_wind
  File "aioble/device.py", line 142, in connect
  File "aioble/central.py", line 125, in _connect
OSError: [Errno 107] ENOTCONN

If I move connection to peripheral before advertisement it connects to fine. But while pico still advertising and accepting connections, connecting actually gets stuck (tried with another Pico W and nrfConnect on iOS - both sit trying to connect for a long time).

Both functions work fine when separated.

bluetooth module mentions that it is possible to combine both roles. I haven't found anything about that in aioble documentation.

Micropython (from the offical website): MicroPython v1.23.0 on 2024-06-02; Raspberry Pi Pico W with RP2040
Aioble: 0.5.2

Here is a small example that shows the issue:

import aioble
import bluetooth
import asyncio
import sys

_ADV_INTERVAL_MS = 250_000
_ADV_APPEARANCE_GENERIC_COMPUTER = const(128)

_UART_UUID = bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
_UART_TX_UDID = bluetooth.UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E")
_UART_RX_UDID = bluetooth.UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E")

_ENVIRONMENT_SENSOR_UUID = bluetooth.UUID(0x181a)
_ENVIRONMENT_SENSOR_APPARENT_WIND_SPEED_UDID = bluetooth.UUID(0x2A72)
_ENVIRONMENT_SENSOR_APPARENT_WIND_DIRECTION_UDID = bluetooth.UUID(0x2A73)

async def find_wind_sensor():
    async with aioble.scan(5000, interval_us=30000, window_us=30000, active=True) as scanner:
        async for result in scanner:
            services = list(result.services())
            if _ENVIRONMENT_SENSOR_UUID in services:
                print("Found Anemometer", result.device, result.name(), result.connectable, services)
                if result.connectable:
                    return result.device
    return None


async def read_wind(connection):
    service = await connection.service(_ENVIRONMENT_SENSOR_UUID)
    apparent_speed = await service.characteristic(_ENVIRONMENT_SENSOR_APPARENT_WIND_SPEED_UDID)
    apparent_direction = await service.characteristic(_ENVIRONMENT_SENSOR_APPARENT_WIND_DIRECTION_UDID)
    while connection.is_connected():
        try:            
            directions = await apparent_direction.read()
            speeds = await apparent_speed.read()
            print(directions, speeds)
            await asyncio.sleep_ms(100)
        except aioble.DeviceDisconnectedError:
            print("Disconnected from", wind_connection.device)
            break


async def connect_wind():
    wind_device = await find_wind_sensor()
    if wind_device is not None:                
        try:
            wind_connection = await wind_device.connect()
            return asyncio.create_task(read_wind(wind_connection))
        except OSError as e:
            print("Failed to connect to wind sensor", e)
            sys.print_exception(e)
            return None
        

async def main():
    uart_service = aioble.Service(_UART_UUID)
    tx_characteristic = aioble.Characteristic(uart_service, _UART_TX_UDID, notify=True)
    rx_characteristic = aioble.BufferedCharacteristic(
        uart_service, _UART_RX_UDID, write=True, capture=True, max_len=128, append=True
        )
    aioble.register_services(uart_service)
    # Connecting before advertising
    # wind_task = await connect_wind()
    print("Waiting for connection...")
    
    connection = await aioble.advertise(
            _ADV_INTERVAL_MS,
            name="pyUART",
            services=[_UART_UUID],
            appearance=_ADV_APPEARANCE_GENERIC_COMPUTER,
        )
    print("Connection from", connection.device)
    
    disconnection = connection.disconnected(timeout_ms=None)
    receive = rx_characteristic.written(timeout_ms=None)
    uart_task = asyncio.gather(disconnection, receive)
    # Connecting after advertising
    wind_task = await connect_wind()
    await uart_task
    if wind_task:
        wind_task.cancel()


asyncio.run(main())

wind_task = await connect_wind() can be uncommented in one of 2 places.

[Jahor]

Never mind. It was due to the default limit on number of connections in BT stack.
May be that should be mentioned next to the fact that bluetooth module allows simultaneous central and peripheral operation.
Even with MAX_NR_HCI_CONNECTIONS and MAX_NR_GATT_CLIENTS set to 4 it does not seem to start advertising when one client is already connected (I'm calling aioble.advertise again).

[nastiliano]

Hello!

I posted in aioble forum, but no one answer me and I can't find any example of a simple "aioble" uart.

Could you give some example or link please?

Thank you very much