ESP32 BLE : question about 'multitest' instructions

[BOB63]

Hi,
I'm trying to learn somthing about BLE use in micropython on an esp32-c3 and I'm jumped inside this git repository
https://github.com/micropython/micropython-lib/tree/master/micropython/bluetooth/aioble/multitests

where there are a lot of examples that I would like use to gain skill.

Looking some of the examples i see that are used some instructions related to "multitest" ( multitest.wait() multitest,next() ) , but I don't understand what multitest refers to, since I don't see it among the micropython modules and I can't find any explanations online either. I've loaded the below example on an esp32 and apparently it works without error so I'm more and more confused .
Is it something similar to asyncio and where can I find detailed documentation about how use it ?

Here below one of the examples :

import sys

# ruff: noqa: E402
sys.path.append("")

from micropython import const
import machine
import time

import asyncio
import aioble
import bluetooth

TIMEOUT_MS = 5000

SERVICE_UUID = bluetooth.UUID("A5A5A5A5-FFFF-9999-1111-5A5A5A5A5A5A")
CHAR_UUID = bluetooth.UUID("00000000-1111-2222-3333-444444444444")


# Acting in peripheral role.
async def instance0_task():
    service = aioble.Service(SERVICE_UUID)
    characteristic = aioble.Characteristic(service, CHAR_UUID, read=True, notify=True)
    aioble.register_services(service)

    multitest.globals(BDADDR=aioble.config("mac"))
    multitest.next()

    # Wait for central to connect to us.
    print("advertise")
    connection = await aioble.advertise(
        20_000, adv_data=b"\x02\x01\x06\x04\xffMPY", timeout_ms=TIMEOUT_MS
    )
    print("connected")

    # Send a subscribed-write (but client isn't subscribed, won't send anything).
    multitest.wait("discovery")
    await asyncio.sleep_ms(100)
    characteristic.write("before-subscribe", send_update=True)

    # Send a subscribed-write (now client is subscribed, client should get notified).
    multitest.wait("subscribed")
    await asyncio.sleep_ms(100)
    characteristic.write("after-subscribe", send_update=True)

    # Send a subscribed-write (now client is unsubscribed, won't send anything).
    multitest.wait("unsubscribed")
    await asyncio.sleep_ms(100)
    characteristic.write("after-unsubscribe", send_update=True)

    # Send 5 direct notifications.
    multitest.wait("start-direct")
    for i in range(5):
        # Send 1 notification each time, except for 3 quick notifications the third time.
        # The client should only see the last one.
        for j in range(3 if i == 2 else 1):
            if j > 0:
                await asyncio.sleep_ms(100)
            msg = "direct-{}-{}".format(i, j)
            print("notify", msg)
            characteristic.notify(connection, msg)

        # Tell client to wait for notification.
        multitest.broadcast("notified")
        # Wait until client is ready for next notification.
        multitest.wait("next")

    # Wait for the central to disconnect.
    await connection.disconnected(timeout_ms=TIMEOUT_MS)
    print("disconnected")


def instance0():
    try:
        asyncio.run(instance0_task())
    finally:
        aioble.stop()


# Acting in central role.
async def instance1_task():
    multitest.next()

    # Connect to peripheral and then disconnect.
    print("connect")
    device = aioble.Device(*BDADDR)
    connection = await device.connect(timeout_ms=TIMEOUT_MS)

    # Discover characteristics.
    service = await connection.service(SERVICE_UUID)
    print("service", service.uuid)
    characteristic = await service.characteristic(CHAR_UUID)
    print("characteristic", characteristic.uuid)

    # Expect to not receive a notification (not subscribed).
    multitest.broadcast("discovery")
    try:
        await characteristic.notified(timeout_ms=500)
        print("fail")
        return
    except asyncio.TimeoutError:
        print("no notification")

    # Subscribe and expect a notification.
    await characteristic.subscribe(notify=True)
    multitest.broadcast("subscribed")
    value = await characteristic.notified()
    print("notified", value)

    # Unsubscribe, and expect not to receive a notification.
    await characteristic.subscribe(notify=False)
    multitest.broadcast("unsubscribed")
    try:
        await characteristic.notified(timeout_ms=500)
        print("fail")
        return
    except asyncio.TimeoutError:
        print("no notification")

    # Receive 5 notifications.
    multitest.broadcast("start-direct")
    for i in range(5):
        multitest.wait("notified")
        await asyncio.sleep_ms(200)
        value = await characteristic.notified()
        print("notified", value)

        # Expect that after receiving a notification we don't get another one
        # until we broadcast to the server.
        try:
            value = await characteristic.notified(timeout_ms=100)
            print("unexpected notify", value)
        except asyncio.TimeoutError:
            pass

        multitest.broadcast("next")

    # Disconnect from peripheral.
    print("disconnect")
    await connection.disconnect(timeout_ms=TIMEOUT_MS)
    print("disconnected")


def instance1():
    try:
        asyncio.run(instance1_task())
    finally:
        aioble.stop()

[BOB63]

Really nobody knows what multitest.wait() and multitest.next() referr to ?

[andrewleech]

Support here regularly come from community volunteers like myself, micropython is a busy project so you often need to wait a while for feedback.

The multitest scripts are intended for use with the test suite tools in the micropython repo itself, in particular: https://github.com/micropython/micropython/blob/master/tests/run-multitests.py

You can use it like so when you've got two BLE capable micropython devices plugged in on Linux / wsl2. Change the port specifiers for windows.

cd ~/micropython/tests
python run-multitests.py -i pyb:/dev/ttyACM1 -i pyb:/dev/ttyACM0 ~/micropython-lib/micropython/bluetooth/aioble/multitests/ble_advertise_services.py

[BOB63]

Thanks @andrewleech ,
ok , for the moment multitest scripts seems to be some more steps haed of what I need at the moment as I'm trying just to understand how program BLE in micropython from the basics.

Thanks for the answare.