def get_mac_addr(self) -> str: try: with Popen(["bt-device", "--list"], stdout=PIPE, text=True) as btdevice_process: exit_code = btdevice_process.wait() if exit_code: raise ConnectionError("Failed to find any TAP decive") connected_bt_devices = btdevice_process.stdout.read( ).splitlines() tap_devices = list( filter(lambda line: line.startswith("Tap_"), connected_bt_devices)) for d in tap_devices: logger.info("Found tap device: {}".format(d)) if len(tap_devices) > 1: raise ValueError( "Found more than 1 Tap device. Set the MAC address of the device you want to connect to " "and try again.") if len(tap_devices) == 0: raise ValueError( "No Tap device was found. Make sure the device is connected and its human readable name " "starts with Tap_.") device_decs = tap_devices[0] tap_mac_address = device_decs[ -18:-1] # only the mac_address part of the description. return tap_mac_address except Exception as e: logger.error("Failed to find any TAP device: {}".format(e)) raise e
async def run(address, loop, debug=False): if debug: import sys # loop.set_debug(True) # l = logging.getLogger("asyncio") # l.setLevel(logging.DEBUG) # h = logging.StreamHandler(sys.stdout) # h.setLevel(logging.DEBUG) # l.addHandler(h) async with BleakClient(address, timeout=1.0, loop=loop) as client: queue = asyncio.Queue() def keypress_handler(sender, data): print('{}'.format(data.decode('ascii')), end='', flush=True) queue.put_nowait(data) x = await client.is_connected() logger.info("Connected: {0}".format(x)) current_string = "" await client.start_notify(RX_UUID, keypress_handler) while (1): await asyncio.sleep(0.1, loop=loop) try: send_data = queue.get_nowait() await client.write_gatt_char(TX_UUID, send_data) except: pass await client.stop_notify(RX_UUID)
async def run(loop, debug=False): if debug: import sys # loop.set_debug(True) l = logging.getLogger("asyncio") l.setLevel(logging.DEBUG) h = logging.StreamHandler(sys.stdout) h.setLevel(logging.INFO) l.addHandler(h) logger.addHandler(h) client = TapSDK(loop) # devices = await client.list_connected_taps() x = await client.manager.connect_retrieved() x = await client.manager.is_connected() logger.info("Connected: {0}".format(x)) await client.set_input_mode(TapInputMode("controller")) await client.register_air_gesture_events(OnGesture) await client.register_tap_events(OnTapped) # await client.register_raw_data_events(OnRawData) await client.register_mouse_events(OnMoused) await client.register_air_gesture_state_events(OnMouseModeChange) await asyncio.sleep(3) # await client.set_input_mode(TapInputMode("raw", sensitivity=[0,0,0])) # await asyncio.sleep(3) # await client.set_input_mode(TapInputMode("text")) # await asyncio.sleep(3) # await client.set_input_mode(TapInputMode("raw", sensitivity=[2,2,2])) # await client.send_vibration_sequence([100, 200, 300, 400, 500]) await asyncio.sleep(50.0, loop=loop)
async def run(address, loop, debug=False): if debug: import sys # loop.set_debug(True) # l = logging.getLogger("asyncio") # l.setLevel(logging.DEBUG) # h = logging.StreamHandler(sys.stdout) # h.setLevel(logging.DEBUG) # l.addHandler(h) async with BleakClient(address, loop=loop) as client: x = await client.is_connected() logger.info("Connected: {0}".format(x)) system_id = await client.read_gatt_char(SYSTEM_ID_UUID) print("System ID: {0}".format(":".join( ["{:02x}".format(x) for x in system_id[::-1]]))) model_number = await client.read_gatt_char(MODEL_NBR_UUID) print("Model Number: {0}".format("".join(map(chr, model_number)))) device_name = await client.read_gatt_char(DEVICE_NAME_UUID) print("Device Name: {0}".format("".join(map(chr, device_name)))) manufacturer_name = await client.read_gatt_char(MANUFACTURER_NAME_UUID) print("Manufacturer Name: {0}".format("".join( map(chr, manufacturer_name)))) firmware_revision = await client.read_gatt_char(FIRMWARE_REV_UUID) print("Firmware Revision: {0}".format("".join( map(chr, firmware_revision)))) hardware_revision = await client.read_gatt_char(HARDWARE_REV_UUID) print("Hardware Revision: {0}".format("".join( map(chr, hardware_revision)))) software_revision = await client.read_gatt_char(SOFTWARE_REV_UUID) print("Software Revision: {0}".format("".join( map(chr, software_revision)))) battery_level = await client.read_gatt_char(BATTERY_LEVEL_UUID) print("Battery Level: {0}%".format(int(battery_level[0]))) def keypress_handler(sender, data): print("{0}: {1}".format(sender, data)) write_value = bytearray([0xa0]) value = await client.read_gatt_char(IO_DATA_CHAR_UUID) print("I/O Data Pre-Write Value: {0}".format(value)) await client.write_gatt_char(IO_DATA_CHAR_UUID, write_value) value = await client.read_gatt_char(IO_DATA_CHAR_UUID) print("I/O Data Post-Write Value: {0}".format(value)) assert value == write_value await client.start_notify(KEY_PRESS_UUID, keypress_handler) await asyncio.sleep(5.0, loop=loop) await client.stop_notify(KEY_PRESS_UUID)
async def run(): devices = await discover() addresses = [] for d in devices: if d.metadata['uuids'] is not None: if service_uuid in d.metadata['uuids']: print(d.__dict__.keys()) addresses.append(d.address) # async with BleakClient(address, loop=loop) as client: address = addresses[0] for address in addresses: print('*'*80) print('address', address) async with BleakClient(address) as client: x = await client.is_connected() logger.info("Connected: {0}".format(x)) c = await client.read_gatt_char(rw_uuid) print('c: ',c) count = await client.read_gatt_char(count_uuid) print('count', count, int.from_bytes(bytes(count), byteorder='little')) await client.start_notify(data_uuid, notification_handler) await client.write_gatt_char(rw_uuid, bytearray(b'f')) await asyncio.sleep(15.0, loop=loop) await client.stop_notify(data_uuid)
async def run(loop=None, debug=False): if debug: import sys loop.set_debug(True) h = logging.StreamHandler(sys.stdout) h.setLevel(logging.WARNING) logger.addHandler(h) client = TapSDK(None, loop) if not await client.client.connect_retrieved(): logger.error("Failed to connect the the Device.") return logger.info("Connected to {}".format(client.client.address)) await client.set_input_mode(TapInputMode("controller")) await client.register_air_gesture_events(OnGesture) await client.register_tap_events(OnTapped) await client.register_raw_data_events(OnRawData) await client.register_mouse_events(OnMoused) await client.register_air_gesture_state_events(OnMouseModeChange) # logger.info("Changing to text mode") await client.set_input_mode(TapInputMode("text")) # await asyncio.sleep(30)) logger.info("Changing to raw mode") await client.set_input_mode(TapInputMode("raw")) # await client.send_vibration_sequence([100, 200, 300, 400, 500]) await asyncio.sleep(50.0, loop=loop)
async def connect_retrieved(self, **kwargs) -> bool: await self.connect() connected = await self.is_connected() if connected: logger.info("Connected to {0}".format(self.address)) await self.__debug() else: logger.error("Failed to connect to {0}".format(self.address)) return connected
async def sensortag_com_handler(address, debug=False): device = await BleakScanner.find_device_by_address(address) if not device: print("Could not find device with address {}".format(address)) return async with BleakClient(address) as client: x = await client.is_connected() logger.info("Connected: {0}".format(x)) system_id = await client.read_gatt_char(SYSTEM_ID_UUID) print( "System ID: {0}".format( ":".join(["{:02x}".format(x) for x in system_id[::-1]]) ) ) model_number = await client.read_gatt_char(MODEL_NBR_UUID) print("Model Number: {0}".format("".join(map(chr, model_number)))) try: device_name = await client.read_gatt_char(DEVICE_NAME_UUID) print("Device Name: {0}".format("".join(map(chr, device_name)))) except Exception: pass manufacturer_name = await client.read_gatt_char(MANUFACTURER_NAME_UUID) print("Manufacturer Name: {0}".format( "".join(map(chr, manufacturer_name)))) firmware_revision = await client.read_gatt_char(FIRMWARE_REV_UUID) print("Firmware Revision: {0}".format( "".join(map(chr, firmware_revision)))) hardware_revision = await client.read_gatt_char(HARDWARE_REV_UUID) print("Hardware Revision: {0}".format( "".join(map(chr, hardware_revision)))) software_revision = await client.read_gatt_char(SOFTWARE_REV_UUID) print("Software Revision: {0}".format( "".join(map(chr, software_revision)))) battery_level = await client.read_gatt_char(BATTERY_LEVEL_UUID) print("Battery Level: {0}%".format(int(battery_level[0]))) # activate temp/humid sensor write_value = bytearray([0x01]) await client.write_gatt_char(TEMP_CONFIG_CHAR_UUID, write_value) # subscribe await client.start_notify(TEMP_CHAR_UUID, notification_handler) while True: await asyncio.sleep(1.0)
async def connect(self, debug=False): if debug: import sys l = logging.getLogger("asyncio") l.setLevel(logging.DEBUG) h = logging.StreamHandler(sys.stdout) h.setLevel(logging.DEBUG) l.addHandler(h) logger.addHandler(h) self.client = BleakClient(self.wand_address, loop=self.loop) await self.client.connect() x = await self.client.is_connected() logger.info("Connected: {0}".format(x))
async def run(address, loop, debug=False): if debug: import sys l = logging.getLogger("asyncio") l.setLevel(logging.DEBUG) h = logging.StreamHandler(sys.stdout) h.setLevel(logging.DEBUG) l.addHandler(h) logger.addHandler(h) async with BleakClient(address, loop=loop) as client: x = await client.is_connected() logger.info("Connected: {0}".format(x)) await client.start_notify(CHARACTERISTIC_UUID, notification_handler) await asyncio.sleep(60.0, loop=loop) await client.stop_notify(CHARACTERISTIC_UUID)
def temp_handler(sender, data): global temp type = int(data[0]) count = int(data[1]) channel2 = int(data[2]) temperature = int(data[3]) - 40 humidity = int(data[4]) if count == 1: logger.info( "[+] DATA: type={}, count={} (CURRENT), channel2={}, TEMPERATURE={}℃ , HUMIDITY={}%" .format(type, count, channel2, temperature, humidity)) temp = (temperature, humidity) else: logger.info( "[+] DATA: type={}, count={} (archive), channel2={}, temperature={}℃ , humidity={}%" .format(type, count, channel2, temperature, humidity))
async def run(address, debug=False): global stream if debug: l = logging.getLogger("asyncio") l.setLevel(logging.DEBUG) h = logging.StreamHandler(sys.stdout) h.setLevel(logging.DEBUG) l.addHandler(h) logger.addHandler(h) print("Trying to connect...") async with BleakClient(address) as client: x = await client.is_connected() logger.info("Connected to: {0}".format(x)) await client.start_notify(SHORT_PATH_CHAR_UUID, notification_handler) await client.start_notify(LONG_PATH_CHAR_UUID, notification_handler) while stream: await asyncio.sleep(0.1) await client.stop_notify(CHARACTERISTIC_UUID)
async def __debug(self): for service in self.services: logger.info("[service] {}: {}".format(service.uuid, service.description)) for char in service.characteristics: if "read" in char.properties: try: value = bytes(await self.read_gatt_char(char.uuid)) except Exception as e: value = str(e).encode else: value = None # if value: logger.info( "\t[Characteristic] {0}: (Handle: {1}) ({2}) | Name: {3}, Value: {4} " .format( char.uuid, "<handle geos here>", # char.handle, ",".join(char.properties), char.description, value, ))
def OnRawData(identifier, *packets): identifier = "" imu_msg = dict([m for m in packets if m.get("type") == "imu"][0]) if len(imu_msg) > 0: OnRawData.cnt += 1 if OnRawData.cnt == 10: OnRawData.cnt = 0 logger.info(identifier + " raw imu : " + str(imu_msg["ts"])) for m in packets: if m.get("type") == "imu": # print("imu") print( "imu, " + "{:.3f}".format(time.time()) + ", " + str(list(map(lambda x: "{:7d}".format(x), m.get("payload"))))) OnRawData.imu_cnt += 1 if OnRawData.imu_cnt == 208: OnRawData.imu_cnt = 0 # print("imu, " + str(time.time()) + ", " + str(m.get("payload"))) if m.get("type") == "accl": # print("accl") OnRawData.accl_cnt += 1 if OnRawData.accl_cnt == 200: OnRawData.accl_cnt = 0
async def run(address): async with BleakClient(address) as client: logger.info(f"[*] Connected: {await client.is_connected()}") logger.info("[*] Reading Measurement Data") battery_level = int((await client.read_gatt_char(BATTERY_LEVEL_UUID))[0]) logger.info("[+] Battery Level: {0}%".format(battery_level)) while True: await client.start_notify(TEMP_NOTIFY_UUID, temp_handler) await asyncio.sleep(1.0) # await client.stop_notify(TEMP_NOTIFY_UUID) return temp
logging.addLevelName(LOG_DATA, "DATA") logging.basicConfig(format='%(asctime)s %(levelname)-8s %(message)s', level=LOG_DATA, datefmt='%Y-%m-%d %H:%M:%S') logger.setLevel(logging.INFO) succeeded = False while not succeeded: try: loop = asyncio.get_event_loop() ret = loop.run_until_complete(run_init(address)) succeeded = True except: logger.info("[!] Connection Error!") logger.log(LOG_DATA, ret) readagain = True while (loopdelay >= 0): while readagain: try: loop = asyncio.get_event_loop() ret = loop.run_until_complete(run(address)) readagain = False except: logger.info("[!] Connection Error!") readagain = True logger.log(LOG_DATA, ret) logger.info(
async def run_init(address): async with BleakClient(address) as client: logger.info(f"[*] Connected: {await client.is_connected()}") logger.info("[*] Reading Device Info...") system_id = await client.read_gatt_char(SYSTEM_ID_UUID) system_id = ":".join(["{:02x}".format(x) for x in system_id[::-1]]) logger.info("[+] System ID: " + system_id) model_number = ( await client.read_gatt_char(MODEL_NBR_UUID)).decode().rstrip("\x00") logger.info("[+] Model Number: " + model_number) device_name = ( await client.read_gatt_char(DEVICE_NAME_UUID)).decode().rstrip("\x00") logger.info("[+] Device Name: " + device_name) manufacturer_name = (await client.read_gatt_char(MANUFACTURER_NAME_UUID) ).decode().rstrip("\x00") logger.info("[+] Manufacturer Name: " + manufacturer_name) firmware_revision = ( await client.read_gatt_char(FIRMWARE_REV_UUID)).decode().rstrip("\x00") logger.info("[+] Firmware Revision: " + firmware_revision) hardware_revision = ( await client.read_gatt_char(HARDWARE_REV_UUID)).decode().rstrip("\x00") logger.info("[+] Hardware Revision: " + hardware_revision) software_revision = ( await client.read_gatt_char(SOFTWARE_REV_UUID)).decode().rstrip("\x00") logger.info("[+] Software Revision: " + software_revision) return (system_id, model_number, manufacturer_name, firmware_revision, hardware_revision, software_revision)
async def run_specific_device_leaf(addr, debug=False): global rxed_data global rxed_data_2 global dev_list global do_dev_list global is_leaf_locked global trigger_size if debug: import sys # loop.set_debug(True) l = logging.getLogger("asyncio") l.setLevel(logging.DEBUG) h = logging.StreamHandler(sys.stdout) h.setLevel(logging.DEBUG) l.addHandler(h) logger.addHandler(h) # Do an initial connection to wake it up #async with bleak.BleakClient(addr) as client: # x = await client.is_connected() # l.info("Connected: {0}".format(x)) #await asyncio.sleep(40.0) # Now do the connection where we lock and read data async with bleak.BleakClient(addr) as client: x = await client.is_connected() l.info("Connected: {0}".format(x)) y = await client.get_services() y_serv = y.get_service(SERVICE_UUID.lower()) l.info(y_serv) y_char = y.get_characteristic(READ_CHAR_UUID.lower()) l.info(y_char) l.info(y_char.service_uuid) await client.start_notify(READ_CHAR_UUID, notification_handler_leaf) if False: #await client.write_gatt_char(WRITE_CHAR_UUID, bytearray(struct.pack('<2I', INSTRUCTION_CODE__IDENTIFY_SELF, 0))) # no data, just send 0 #await asyncio.sleep(2.0) await client.write_gatt_char( WRITE_CHAR_UUID, bytearray( struct.pack('<2I', INSTRUCTION_CODE__QUERY_IS_SYNCED, 0))) # no data, just send 0 await asyncio.sleep(0.2) else: # #await client.write_gatt_char(WRITE_CHAR_UUID, bytearray([0xe,0,0,0,0xff,0xff,0xff,0xff])) await client.write_gatt_char( WRITE_CHAR_UUID, bytearray( struct.pack('<2I', INSTRUCTION_CODE__QUERY_IS_SYNCED, 0))) # no data, just send 0 await asyncio.sleep(0.2) await client.write_gatt_char( WRITE_CHAR_UUID, bytearray( struct.pack('<2I', INSTRUCTION_CODE__QUERY_CURRENT_TIME, 0))) # no data, just send 0 await asyncio.sleep(0.2) await client.write_gatt_char( WRITE_CHAR_UUID, bytearray(struct.pack('<2I', INSTRUCTION_CODE__IS_LOCKED, 0))) # no data, just send 0 await asyncio.sleep(0.2) #await client.write_gatt_char(WRITE_CHAR_UUID, bytearray(struct.pack('<2I', INSTRUCTION_CODE__LOCK, 0xFFFFFFFF))) # 0xFFFFFFFF means current time #await asyncio.sleep(0.4) await client.write_gatt_char( WRITE_CHAR_UUID, bytearray(struct.pack('<2I', INSTRUCTION_CODE__IS_LOCKED, 0))) # no data, just send 0 await asyncio.sleep( 5.) # Need to give sufficient time for the buffer to fill up. # If not sufficient, nothing will be returned rxed_data = b'' #await client.write_gatt_char(WRITE_CHAR_UUID, bytearray(struct.pack('<2I', INSTRUCTION_CODE__READ_OUT, 0))) # no data, just send 0 #await asyncio.sleep(0.2) a = 0 kk = 0 while a < 1000: await asyncio.sleep(1.0) if do_dev_list: do_dev_list = False for dd in dev_list: async with bleak.BleakClient(dd) as client_2: x_2 = await client.is_connected() l.info("Connected: {0}".format(x_2)) await client_2.start_notify( READ_CHAR_UUID, notification_handler_leaf_2) await asyncio.sleep(1.2) await client_2.write_gatt_char( WRITE_CHAR_UUID, bytearray( struct.pack('<2I', INSTRUCTION_CODE__QUERY_IS_SYNCED, 0))) # no data, just send 0 await asyncio.sleep(0.2) await client_2.write_gatt_char( WRITE_CHAR_UUID, bytearray( struct.pack( '<2I', INSTRUCTION_CODE__QUERY_CURRENT_TIME, 0))) # no data, just send 0 await asyncio.sleep(0.2) await client_2.write_gatt_char( WRITE_CHAR_UUID, bytearray( struct.pack('<2I', INSTRUCTION_CODE__IS_LOCKED, 0))) # no data, just send 0 await asyncio.sleep(0.4) await client_2.stop_notify(READ_CHAR_UUID) z_2 = await client_2.disconnect() l.info("Disconnected: {0}".format(z_2)) if trigger_size > 0: with open("Trigger_list.txt", "a") as f3: f3.write(datetime.datetime.now().strftime( "%Y/%m/%d %H:%M:%S ") + "{0} {1}\n".format(trigger_size, len(dev_list))) trigger_size = 0 for dd in dev_list: async with bleak.BleakClient(dd) as client_2: x_2 = await client.is_connected() l.info("Connected: {0}".format(x_2)) await client_2.start_notify( READ_CHAR_UUID, notification_handler_leaf_2) await asyncio.sleep(1.2) await client_2.write_gatt_char( WRITE_CHAR_UUID, bytearray( struct.pack('<2I', INSTRUCTION_CODE__QUERY_IS_SYNCED, 0))) # no data, just send 0 await asyncio.sleep(0.2) await client_2.write_gatt_char( WRITE_CHAR_UUID, bytearray( struct.pack( '<2I', INSTRUCTION_CODE__QUERY_CURRENT_TIME, 0))) # no data, just send 0 await asyncio.sleep(0.2) is_leaf_locked = False await client_2.write_gatt_char( WRITE_CHAR_UUID, bytearray( struct.pack('<2I', INSTRUCTION_CODE__IS_LOCKED, 0))) # no data, just send 0 await asyncio.sleep(0.4) if is_leaf_locked: rxed_data_2 = b'' await client_2.write_gatt_char( WRITE_CHAR_UUID, bytearray( struct.pack('<2I', INSTRUCTION_CODE__READ_OUT, 0))) # no data, just send 0 await asyncio.sleep(5.2) if len(rxed_data_2) > 0: with open( datetime.datetime.now().strftime( "%Y%m%d_%H%M%S_") + "{0:03d}_".format(kk) + dd + ".bin", "wb") as f1: f1.write(rxed_data_2) await client_2.stop_notify(READ_CHAR_UUID) z_2 = await client_2.disconnect() l.info("Disconnected: {0}".format(z_2)) kk += 1 a += 1 # Now save any data that has been received if len(rxed_data) > 0: with open(datetime.datetime.now().strftime("%Y%m%d_%H%M%S.bin"), "wb") as f1: f1.write(rxed_data) with open(datetime.datetime.now().strftime("%Y%m%d_%H%M%S.txt"), "w") as f1: i = 0 j = 0 while i + 8 <= len(rxed_data): tt = struct.unpack('<4h', rxed_data[i:i + 8]) f1.write("{0},{1},{2},{3},{4}\n".format( j, tt[0], tt[1], tt[2], tt[3])) i += 8 j += 1 rxed_data = b'' await client.stop_notify(READ_CHAR_UUID) z = await client.disconnect() logger.info("Disconnected: {0}".format(z)) await asyncio.sleep(1.0)
async def run_specific_device(addr, debug=False): if debug: import sys # loop.set_debug(True) l = logging.getLogger("asyncio") l.setLevel(logging.DEBUG) h = logging.StreamHandler(sys.stdout) h.setLevel(logging.DEBUG) l.addHandler(h) logger.addHandler(h) async with bleak.BleakClient(addr) as client: x = await client.is_connected() l.info("Connected: {0}".format(x)) y = await client.get_services() y_serv = y.get_service(SERVICE_UUID.lower()) l.info(y_serv) y_char = y.get_characteristic(READ_CHAR_UUID.lower()) l.info(y_char) l.info(y_char.service_uuid) #c_serv = y.get_service(CONFIG_SERVICE_UUID.lower()) #l.info(c_serv) #c_char = y.get_characteristic(CONFIG_3_CHAR_UUID.lower()) #l.info(c_char) #l.info(c_char.service_uuid) char_1_val = await client.read_gatt_char(CONFIG_1_CHAR_UUID.lower()) print("Char 1 Value: 0x{0:04X}".format(char_1_val[0])) print("Char 1 length: {0}".format(len(char_1_val))) char_2_val = await client.read_gatt_char(CONFIG_2_CHAR_UUID.lower()) print("Char 2 Value: 0x{0:02X} {1:02X} {2:02X} {3:02X}".format( char_2_val[0], char_2_val[1], char_2_val[2], char_2_val[3])) print("Char 2 length: {0}".format(len(char_2_val))) char_3_val = await client.read_gatt_char(CONFIG_3_CHAR_UUID.lower()) print("Char 3 Value: 0x{0:04X}".format(char_3_val[0])) print("Char 3 length: {0}".format(len(char_3_val))) if False: x = bytearray(randbytes(1)) print("Writing Char1 to 0x{0:02X}".format(x[0])) await client.write_gatt_char(CONFIG_1_CHAR_UUID, x) x = bytearray(randbytes(4)) print("Writing Char2 to 0x{0:02X} {1:02X} {2:02X} {3:02X}".format( x[0], x[1], x[2], x[3])) await client.write_gatt_char(CONFIG_2_CHAR_UUID, x) await asyncio.sleep(0.6) print("Done") await client.start_notify(READ_CHAR_UUID, notification_handler) # #await client.write_gatt_char(WRITE_CHAR_UUID, bytearray([0xe,0,0,0,0xff,0xff,0xff,0xff])) #await client.write_gatt_char(WRITE_CHAR_UUID, bytearray([0x21,0,0,0,0,0,0,0])) #await asyncio.sleep(0.2) #await client.write_gatt_char(WRITE_CHAR_UUID, bytearray([0x0E,0,0,0,0,0,0,0])) await asyncio.sleep(25.0) await client.stop_notify(READ_CHAR_UUID) z = await client.disconnect() logger.info("Disconnected: {0}".format(z)) await asyncio.sleep(1.0)
async def run(address_ledstrip): async with BleakClient(address_ledstrip) as client: x = await client.is_connected() logger.info("Connected: {0}".format(x)) await client.write_gatt_char(IO_DATA_CHAR_UUID, state_on)
async def run_all_devices(debug=False): if debug: import sys # loop.set_debug(True) l = logging.getLogger("asyncio") l.setLevel(logging.DEBUG) h = logging.StreamHandler(sys.stdout) h.setLevel(logging.DEBUG) l.addHandler(h) logger.addHandler(h) x = await bleak.BleakScanner.discover() l.info("*********** Start of discovered list *************") i = 1 for d in x: #l.info(d) #l.info(bleak.utils.mac_str_2_int(d.address)) print("[{0}] ".format(i) + d.address + " " + d.name) i += 1 if i >= 10: break #if d.address == TARGET_ADDRESS: # await found_unit(d) l.info("*********** End of discovered list ***************") print("Enter number to connect (or anything else to cancel):") s = input() try: j_s = int(s) except ValueError: j_s = -1 if j_s > 0 and j_s <= len(x): # a good value! async with bleak.BleakClient(x[j_s - 1].address) as client: y = await client.is_connected() l.info("Connected: {0}".format(y)) w = await client.get_services() w_serv = w.get_service(CONFIG_SERVICE_UUID.lower()) l.info(w_serv) w_char = [ w.get_characteristic(CONFIG_1_CHAR_UUID.lower()), w.get_characteristic(CONFIG_2_CHAR_UUID.lower()), w.get_characteristic(CONFIG_3_CHAR_UUID.lower()) ] l.info(w_char[0].service_uuid) l.info(w_char[0]) l.info(w_char[1].service_uuid) l.info(w_char[1]) l.info(w_char[2].service_uuid) l.info(w_char[2]) t_0 = await client.read_gatt_char(w_char[0]) t_1 = await client.read_gatt_char(w_char[1]) t_2 = await client.read_gatt_char(w_char[2]) print(t_0) print(t_1) print(t_2) is_central = False if len(t_0) >= 1: is_central = ((t_0[0] & 0x01) != 0) if is_central: print("This is a central device. Choose:") print("[1] change to peripheral") print("[2] no change (remain as central)") s = input() try: k_s = int(s) except ValueError: k_s = 2 if k_s == 1: await client.write_gatt_char(w_char[0], bytearray(b'\x00')) is_central = False print("Changed") else: print("This is a peripheral device. Choose:") print("[1] no change (remain as peripheral)") print("[2] change to central") s = input() try: k_s = int(s) except ValueError: k_s = 1 if k_s == 2: await client.write_gatt_char(w_char[0], bytearray(b'\x01')) print("Changed") is_central = True if len(t_1) >= 4 and is_central: val_2 = struct.unpack('<I', t_1)[0] print("This is a central device with trigger threshold {0}.". format(0x3FFF & val_2)) print("Enter a new value, or <Enter> to keep old one:") s = input() try: k_s = int(s) except ValueError: k_s = -1 if k_s >= 0: new_val = (val_2 & 0xFFFFC000) | (k_s & 0x3FFF) await client.write_gatt_char( w_char[1], bytearray(struct.pack('<I', new_val))) print("Changed") else: print("No change") z = await client.disconnect() logger.info("Disconnected: {0}".format(z)) await asyncio.sleep(1.0) await asyncio.sleep(1.0)