Continuous Scanning + Multi-connect #933
Replies: 2 comments 23 replies
-
|
Connecting while scanning doesn't really work well with BlueZ. Instead I would just scan for one device at a time, then stop scanning, then connect, then start scanning again for the next device. def match_known_address(device, adv_data):
return device.address in KNOWN_ADDRESS
async def scan_and_connect():
while True:
device = await BleakScanner. find_device_by_filter(match_known_address)
if device is None:
# maybe asyncio.sleep() here for some seconds if you aren't in a hurry
continue
client = BleakClient(device, disconnected_callback=...)
try:
await client.connect()
await client.start_notify(...)
...
except BleakError:
# if failed to connect, this is a no-op, if failed to start notifications, it will disconnect
await client.disconnect()
... |
Beta Was this translation helpful? Give feedback.
-
Instead of passing the
Many devices will "go to sleep" and will no longer be in a connectable state if there is too long of a delay between scanning and connecting which results in many support requests of "my device won't connect". Connecting a soon as a device is discovered seems to work in more cases. |
Beta Was this translation helpful? Give feedback.
-
|
@dlech David that's a great point. I missed the fact that BLEDevice can be fed directly to the Bleak Client. I revised the code as below. async def main():
foundDevices = set()
lock = asyncio.Lock()
running_tasks = {}
while True:
async with BleakScanner() as scanner:
await asyncio.sleep(scanDuration)
for d in scanner.discovered_devices:
if d.name[:3] == 'BLE':
foundDevices.add(d)
for device in foundDevices:
if device not in running_tasks or running_tasks[device].done():
task = asyncio.ensure_future(connect_to_device(device, lock))
running_tasks[device] = task
await asyncio.sleep(scanInterval)
await asyncio.gather(*running_tasks.values())
async def connect_to_device(device, lock):
try:
async with lock:
client = BleakClient(device, timeout=5.0)
await client.connect()
try:
await client.start_notify(notify_uuid, partial(callback, client))
await asyncio.sleep(runDuration)
finally:
await client.disconnect()
except Exception as e:
print(e)
if __name__ == "__main__":
asyncio.run(main())I think there is still room for improvement though. The |
Beta Was this translation helpful? Give feedback.
-
|
is it safe to say that once a BLE device has been connected, it can no longer be discovered (no longer send advertisement?) |
Beta Was this translation helpful? Give feedback.
-
|
This is how most devices behave, but there is no rule or technical limitation preventing it. |
Beta Was this translation helpful? Give feedback.
-
|
Thanks @dlech . In x11x's sample code, he/she has locks in comments that deals with the global connected_devices set, but he/she wasn't sure whether it's needed. I hope you can advise on that as I can't be sure either whether locks are needed in this case. |
Beta Was this translation helpful? Give feedback.
-
|
Maybe something like this would get you started, using the pattern David gave above. As he says, its important to minimize the delay between scanning and trying to connect, so its better to connect as soon as the device is discovered. I am not sure if you need to synchronize access to the I have not included all the sleeps you were doing. As David says, you can sleep if the device wasn't found. You can sleep anywhere and it will just give other coroutines a chance to run, its up to you to figure out what your application's requirements are and what makes it run the best. Also, this is just example code, in real code you would probably want to encapsulate it in a class so that import asyncio
import functools
from bleak import BleakClient, BleakScanner
#lock = asyncio.Lock()
connected_devices = set()
notify_uuid = "00002A37-0000-1000-8000-00805F9B34FB"
def callback(client, characteristic, data):
print(client.address, characteristic, data)
def disconnected_callback(client):
#with lock:
connected_devices.remove(client.address)
print("disconnect from", device.address)
def match_device(device, adv_data):
#with lock:
return adv_data.local_name.startswith('BLE') and device.address not in connected_devices
async def scan_and_connect():
while True:
device = await BleakScanner.find_device_by_filter(match_device)
if device is None:
# maybe asyncio.sleep() here for some seconds if you aren't in a hurry
continue
client = BleakClient(device, disconnected_callback=disconnected_callback)
try:
await client.connect()
print("connected to", device.address)
await client.start_notify(functools.partial(callback, client))
#with lock:
connected_devices.add(device.address)
except BleakError:
# if failed to connect, this is a no-op, if failed to start notifications, it will disconnect
await client.disconnect()
# I'm not sure if manually disconnecting triggers disconnected_callback, (pretty easy to figure this out though)
# if so, you will be getting disconnected_callback called twice
# if not, you should call it here
disconnected_callback(client)
if __name__ == "__main__":
asyncio.run(scan_and_connect())I have not run it. I'm trying to do something similar to your case, but slightly different. Hope it helps anyway |
Beta Was this translation helpful? Give feedback.
-
|
Maybe I missed reading this somewhere, but what is the actual goal of this code? To periodically check in on multiple devices throughout the day? |
Beta Was this translation helpful? Give feedback.
-
|
Sorry, no you did not miss it. I don't think I was being clear. Yes periodically check for specific device (or devices, as there may be a few device in range) connect to whatever is in range and get the heart rate value. The devices may go out of range, and come back into range. There may be zero device in range or multiple. Does that make sense? |
Beta Was this translation helpful? Give feedback.
-
|
Makes sense. Maybe it would work better to keep track of time since connect for each individual device? Then make the scan filter ignore devices that have been connected to recently. |
Beta Was this translation helpful? Give feedback.
-
Yes. My understanding - it connects them one at a time but they all remain connected. The loop doesn't wait for anything else - after it has connected and subscribed to notifications, it moves on and discovers, connects and enables notifications for the next as soon as it can. And notifications from all of them come in on the same callback (the client is curried in to the callback, you can check which one it came from by checking the client object). The clients need to be explicitly disconnected using So for your use case, you probably get the data you need in |
Beta Was this translation helpful? Give feedback.
-
|
Hi, 1.The notify_uuid = "00002A37-0000-1000-8000-00805F9B34FB" is defined once and never used. char_specifier – The characteristic to activate notifications/indications on a characteristic, specified by either integer handle, UUID or directly by the BleakGATTCharacteristic object representing it. Therefore, should the notify_uuid be the first parameter to the start_notify() function? So one of the lines should be Thanks |
Beta Was this translation helpful? Give feedback.
-
Scenario:
I am trying to have a raspberry Pi continuously scan for devices of interest and when they become visible, spin off tasks for each one to connect and start notifications. Then if a device of interest completes this process and disconnects for some time but is seen again later, reconnect and read data. Specifically say I have a heart rate monitor (continuous readings) and a blood pressure monitor (only advertises after a measurement and disconnects after data transmission). When the pi sees these devices I want it to connect to them and start reading. However once the first readings are done I want the pi to keep scanning for these devices if they disconnect to see if they ever become visible again and then connect and start the process over.
I know there has been other discussions around these topics and I have looked at them and tried their suggestions in different combinations but I can't quite get it to work.
Related issues and discussions: #105, #551, #345, #178
What I have tried:
This connects and reads from both devices, however, there is no continuous scanning (I want it to create simultaneous coroutines on the fly I think) additionally once a device disconnects the coroutine is done and therefore the device does not get picked up again. I've tried a couple ways to have the device be discovered again simultaneously but they didn't work and seemed wrong (like restarting a coroutine in the disconnect callback)
Output:
Tryin to get the continuous scanning and connecting/rescanning (Easiest read bottom up)
With this implementation it is able to continuously scan but if fails to connect to both devices. It can connect (albeit it makes duplicate connects and readings and I am not sure why) to the blood pressure monitor and read its data with being able to find it again after disconnection. However while trying to connect to the heart rate monitor at the same time it gets a timeout error as shown below.
Interestingly, after running this code, when I check
bluetoothctlthe heart rate sensor is connected in and I can interact with it...After reading the similar discussions it seems it may be caused by having multiple BleakScanners running in addition to trying to connect to devices but I am not sure because it seems to be connected at the bluez level.
Does anyone have any suggestions for this type of implementation?
Beta Was this translation helpful? Give feedback.
All reactions