Aioble bluetooth

[daniquedamen]

I am trying to connect a microcontroller to another microcontroller. On the client site, I think everything goes well since I can obtain the characteristics of the service on my android phone. However, on the server site, I have the following code with corresponding output. As you can see, the connection can be made. However, the service/characteristics are None. I really do not know what to do anymore.

import sys
sys.path.append("")

import uasyncio as asyncio
import aioble
import bluetooth

_SENSE_UUID = bluetooth.UUID(0x183E)
interaction_service = aioble.Service(_SENSE_UUID)

_SENSE_IMU_UUID = bluetooth.UUID(0x0541)
interaction_char = aioble.Characteristic(interaction_service, _SENSE_IMU_UUID, read=True, notify=True)

aioble.register_services(interaction_service)

async def find_Plushie():
    async with aioble.scan(5000, interval_us=30000, window_us=3000, active=True) as scanner:
        async for result in scanner:
            if result.name() == "Plushie":
                print("Plushie found")
                return result.device
    return None

async def main():
    device = await find_Plushie()
    if not device:
        print("Plushie not found...")
        return
    
    try:
        print("Connection to", device)
        connection = await device.connect()
        print(connection)
        print(connection.service(_SENSE_UUID))
    except asyncio.TimeoutError:
        print("Timeout during connection")
        return
    
    async with connection:
        imu_service = await connection.service(_SENSE_UUID)
        print(imu_service) 
        
        data = await interaction_char.read()
        #imu_characteristic = await imu_service.characteristic(_SENSE_IMU_UUID)
        print("imu_characteristic:", data)

        #await imu_characteristic.start_notify()  # Enable notifications
        
        while True:
         #   data = await imu_characteristic.read()  # Read data when notified
          #  print("imu_data:", data)
            await asyncio.sleep_ms(1000)

if __name__ == "__main__":
    asyncio.run(main())

The output:

MPY: soft reboot
Plushie found
Connection to Device(ADDR_PUBLIC, ea:eb:62:75:2f:be)
<DeviceConnection object at 2001c4b0>
<generator object 'service' at 2001c820>
None
imu_characteristic: None

(Edited by @jimmo to fix code formatting)

[bixb922]

I don't know what's happening, but the NRF connect for mobile app by Nordic Semiconductors (free) has helped me to see what's going on, explore service, characteristics, etc

[andrewleech]

The lines near the top registering services / characteristics don't look right to me, that only applies to the server side, not the client

interaction_service = aioble.Service(_SENSE_UUID)
interaction_char = aioble.Characteristic(interaction_service, _SENSE_IMU_UUID, read=True, notify=True)
aioble.register_services(interaction_service)

I presume the rest of the code here was based on the temp_client example

the <generator object 'service' at 2001c820> part of your output comes from print(connection.service(_SENSE_UUID)) - this won't work as-is because it's an async function, but you try to await it correclty further down so that's fine.

data = await interaction_char.read() also wont work because it's a locally created characteristic, not the remove service one. imu_characteristic = await imu_service.characteristic(_SENSE_IMU_UUID) looks correct (without the # but I'm guessing it failed due to imu_service being None; this is the bit that needs to be fixed first.

Have you tried running temp_client.py and temp_sensor.py unmodified on your two devices to see if they work?

Another thing to try, add this above imu_service = await connection.service(_SENSE_UUID)

    async for service in connection.services():
        print("service:", service)

[jimmo]

@daniquedamen Yes, just to confirm that what @andrewleech is saying is correct:

print(connection.service(_SENSE_UUID))
...
service = await connection.service(_SENSE_UUID)

this will not work, because the first line triggers a service discovery (which is never completed because it's not awaited), and then the second one will be unable to start.

Like Andrew said, you should almost be able to copy temp_client.py exactly.

[daniquedamen]

Thank you. It now works indeed! But only for two reads and then it crashes into an error. Is this due to a too high frequency of reading or is there another issue?

import sys

sys.path.append("")

from micropython import const

import uasyncio as asyncio
import aioble
import bluetooth
import struct

service_UUID = bluetooth.UUID("00000000-0000-0000-0000-00000000183e")
char_UUID = bluetooth.UUID("00000000-0000-0000-0000-000000000541")


def data_processing(data):
    return struct.unpack("<h",data)[0]


async def find_Plushie():
    async with aioble.scan(5000, interval_us=30000, window_us=30000, active=True) as scanner:
        async for result in scanner:
            if result.name() == "Plushie" and service_UUID in result.services():
                return result.device
    return None


async def main():
    device = await find_Plushie()
    if not device:
        print("Server not found")
        return

    try:
        print("Connecting to server:", device)
        connection = await device.connect()
    except asyncio.TimeoutError:
        print("Timeout during connection")
        return

    async with connection:
        try:
            IMU_service = await connection.service(service_UUID)
            IMU_characteristic = await IMU_service.characteristic(char_UUID)
        except asyncio.TimeoutError:
            print("Timeout discovering services/characteristics")
            return

        while True:
            interaction = data_processing(await IMU_characteristic.read())
            print(interaction)
            await asyncio.sleep_ms(1000)


asyncio.run(main())

[jimmo]

Is this due to a too high frequency of reading or is there another issue?

@daniquedamen What is the error you see? There should not be any issue with the frequency, especially with that 1 second sleep!

[daniquedamen]

It is a timeouterror without further notification. However, I fixed it by instead of using read, using notify like this: Thanks!

            await IMU_characteristic.subscribe(notify=True)
            while True:
                interaction = data_processing(await IMU_characteristic.notified())