Wery slow connect and read

[NikitaKozlovtcev]

• bleak version: 0.10.0
• Python version: 3.8.7
• Operating System: Windows 10 Pro version 2004 build OS 19041.804

Description

I have several BLE devices.
I read characteristc with 2 byte and it takes 10 to 30 seconds.
If i use android the speed is about 100ms
Some times BleakClient call returning Exception but err does not have a description

What I Did

I use this call
async with BleakClient(address_or_ble_device=target_mac, timeout=self.connection_timeout) as client

class SWT:
    def __init__(self, mac, timeout=10):
        self.number = None
        self.mac = mac
        self.name = ''
        self.rssi = ''
        self.voltage_akb = -1.00
        self.connection_timeout = timeout

    async def find_self(self):
        device = await BleakScanner.find_device_by_address(self.mac, timeout=self.connection_timeout)
        if device is not None:
            self.mac = device.address
            self.name = device.name
            self.rssi = device.rssi
            return True
        else:
            return False

    async def read_characteristic(self, target_mac, uuid_char):
        b = bytes()
        try:
            async with BleakClient(address_or_ble_device=target_mac, timeout=self.connection_timeout) as client:
                try:
                    if await client.is_connected() is True:
                        print(f"Check CONNECT ok")
                    b = bytes(await client.read_gatt_char(uuid_char))
                    await client.disconnect()
               except Exception as err:
                    print(f"\tclient.read_gatt_char(uuid_char) {target_mac}-> Err {type(err)} {err}")
                finally:
                    return b
        except Exception as err:
            print(f"\n\tBleakClient Connect {target_mac}-> Err {err}")
            return None

    async def get_akb_voltage(self, target_mac, uuid_char):
        raw_adc = await self.read_characteristic(target_mac, uuid_char)
        if raw_adc is not None:
            self.voltage_akb = await self.convert_bytes_to_volt(raw_adc)
        else:
            return False

    @staticmethod
    async def convert_bytes_to_volt(value):
        raw_adc = int.from_bytes(value[::-1], byteorder='big', signed=False)
        voltage_akb = (0.6 + (raw_adc * 2 * 1.2) / 42160) * 390 / 110
        return voltage_akb

    @staticmethod
    async def test(number, mac_address):
        ble = SWT(mac_address, timeout=120)
        while True:
            start = datetime.datetime.now()
            if await ble.find_self():
                if await ble.get_akb_voltage(target_mac=ble.mac, uuid_char=UUID_CHAR_VBATTERY) is not False:
                    stop = datetime.datetime.now()
                    request_time = stop - start
                    print(f"{start.strftime('%d-%m-%Y %H:%M:%S')},\t{request_time},\t{number},\t{AKB_LIST[number]}:\t"
                          f"{ble.mac}:", end=' ')
                    print(f"{ble.rssi} -> {format(ble.voltage_akb, '.3f')}")
            await asyncio.sleep(10)

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    try:
        loop = asyncio.get_event_loop()
        tasks = asyncio.gather(*(SWT.test(i, address) for i, address in enumerate(MAC_ADDRES_LIST)))
        loop.run_until_complete(tasks)
    except KeyboardInterrupt:
        pass
    finally:
        print("Closing loop")
        loop.close()

below is an excerpt from console output

19-02-2021 21:54:47,    0:00:18.681446, 3,      Li-Po-601215 №3:        FC:B4:83:89:21:41: -58 -> 3.972
19-02-2021 21:54:51,    0:00:19.244547, 0,      Li-Po-501225 №1:        F3:6B:C9:70:30:59: -66 -> 3.956
        BleakClient Connect E4:58:89:15:C7:2B-> Err
19-02-2021 21:55:10,    0:00:16.022488, 2,      Li-Po-601215 №2:        D7:8A:18:3A:11:F2: -56 -> 4.016
19-02-2021 21:55:16,    0:00:16.209630, 3,      Li-Po-601215 №3:        FC:B4:83:89:21:41: -56 -> 3.973
19-02-2021 21:55:24,    0:00:18.703494, 1,      Li-Po-601215 №1:        E4:58:89:15:C7:2B: -56 -> 3.946
19-02-2021 21:55:20,    0:00:26.663619, 0,      Li-Po-501225 №1:        F3:6B:C9:70:30:59: -68 -> 3.955
        BleakClient Connect D7:8A:18:3A:11:F2-> Err
19-02-2021 21:55:42,    0:00:17.310162, 3,      Li-Po-601215 №3:        FC:B4:83:89:21:41: -58 -> 3.973
19-02-2021 21:55:53,    0:00:18.987690, 1,      Li-Po-601215 №1:        E4:58:89:15:C7:2B: -56 -> 3.946
19-02-2021 21:55:56,    0:00:19.532747, 0,      Li-Po-501225 №1:        F3:6B:C9:70:30:59: -72 -> 3.955
19-02-2021 21:56:03,    0:00:18.872081, 2,      Li-Po-601215 №2:        D7:8A:18:3A:11:F2: -58 -> 4.016
19-02-2021 21:56:09,    0:00:27.132146, 3,      Li-Po-601215 №3:        FC:B4:83:89:21:41: -60 -> 3.972
        BleakClient Connect F3:6B:C9:70:30:59-> Err
19-02-2021 21:56:32,    0:00:14.419811, 2,      Li-Po-601215 №2:        D7:8A:18:3A:11:F2: -60 -> 4.015
19-02-2021 21:56:22,    0:00:31.763873, 1,      Li-Po-601215 №1:        E4:58:89:15:C7:2B: -56 -> 3.945

[hbldh]

A problem I see here is that you make a new connection each time you read a characteristic. That is bound to take a lot of time. Do connect (async with BleakClient) once and keep the connection alive. If you integrate into another class you might want to do manual connects instead. See usage documentation for examples.