def __init__(self, adapter: str = 'hci0', address_type: str = 'public'): """Create new instance of the backend.""" # super(BluepyBackend, self).__init__(adapter, address_type) self._adapter = BLEAdapter( BLEDriver(serial_port=adapter, auto_flash=False, baud_rate=1000000, log_severity_level="info")) self._adapter.driver.open() self._adapter.driver.ble_enable() self._connection = None
def __init__(self, com_port, periph_name, s_conn): driver = BLEDriver(serial_port=com_port, baud_rate=1000000) adapter = BLEAdapter(driver) self.evt_sync = EvtSync(['connected', 'disconnected']) self.target_device_name = periph_name self.target_device_addr = 0 self.conn_handle = None self.adapter = adapter self.notifications_q = queue.Queue() self.adapter.observer_register(self) self.adapter.driver.observer_register(self) self.s_conn = s_conn self.adapter.driver.open() if nrf_sd_ble_api_ver >= 3: logger.info("\nBLE: ble_enable with local ATT MTU: {}".format(DFUAdapter.LOCAL_ATT_MTU)) gatt_cfg = BLEConfigConnGatt() gatt_cfg.att_mtu = self.adapter.default_mtu gatt_cfg.tag = CFG_TAG self.adapter.driver.ble_cfg_set(BLEConfig.conn_gatt, gatt_cfg) self.adapter.driver.ble_enable() self.adapter.driver.ble_vs_uuid_add(BleSerial.BASE_UUID) self.connect()
def __init__(self, comport, periph_name, s_conn): driver = BLEDriver(serial_port = comport, baud_rate = 115200) adapter = BLEAdapter(driver) self.evt_sync = EvtSync(['connected', 'disconnected']) self.target_device_name = periph_name self.target_device_addr = 0 self.conn_handle = None self.adapter = adapter self.notifications_q = Queue.Queue() self.adapter.observer_register(self) self.adapter.driver.observer_register(self) self.s_conn = s_conn self.adapter.driver.open() ble_enable_params = BLEEnableParams(vs_uuid_count = 10, service_changed = False, periph_conn_count = 0, central_conn_count = 1, central_sec_count = 1) if nrf_sd_ble_api_ver >= 3: logger.info("\nBLE: ble_enable with local ATT MTU: {}".format(DFUAdapter.LOCAL_ATT_MTU)) ble_enable_params.att_mtu = BLE_Serial.LOCAL_ATT_MTU self.adapter.driver.ble_enable(ble_enable_params) self.adapter.driver.ble_vs_uuid_add(BLE_Serial.BASE_UUID) self.connect()
def main(serial_port, address): print('Serial port used: {}'.format(serial_port)) driver = BLEDriver(serial_port=serial_port, auto_flash=True) adapter = BLEAdapter(driver) collector = Collector(adapter, uuids, address) collector.open() for i in xrange(CONNECTIONS): conn_handle = collector.connect_and_discover() fig1.canvas.mpl_connect('button_press_event', onClick) anim1 = animation.FuncAnimation(fig1, animate_acc, blit=False, interval=1000, repeat=True) #plt.show() anim2 = animation.FuncAnimation(fig2, animate_acc_fft, interval=2000) anim3 = animation.FuncAnimation(fig3, animate_pre, blit=False, interval=1000, repeat=True) plt.show() while (True): pass
def setup_adapter( port, auto_flash, baud_rate, retransmission_interval, response_timeout, driver_log_level, ): settings = Settings.current() driver = BLEDriver( serial_port=port, auto_flash=auto_flash, baud_rate=baud_rate, retransmission_interval=retransmission_interval, response_timeout=response_timeout, log_severity_level=driver_log_level, ) adapter = BLEAdapter(driver) adapter.default_mtu = settings.mtu adapter.open() if settings.nrf_family == "NRF51": adapter.driver.ble_enable( BLEEnableParams( vs_uuid_count=1, service_changed=0, periph_conn_count=1, central_conn_count=1, central_sec_count=0, )) elif settings.nrf_family == "NRF52": gatt_cfg = BLEConfigConnGatt() gatt_cfg.att_mtu = adapter.default_mtu gatt_cfg.tag = Settings.CFG_TAG adapter.driver.ble_cfg_set(BLEConfig.conn_gatt, gatt_cfg) if hasattr(settings, "event_length"): gap_cfg = BLEConfigConnGap() gap_cfg.event_length = settings.event_length adapter.driver.ble_cfg_set(BLEConfig.conn_gap, gap_cfg) adapter.driver.ble_enable() return adapter
def main(serial_port, address): print('Serial port used: {}'.format(serial_port)) driver = BLEDriver(serial_port=serial_port, auto_flash=True) adapter = BLEAdapter(driver) collector = Collector(adapter, uuids, address) collector.open() for i in xrange(CONNECTIONS): conn_handle = collector.connect_and_discover() while (True): pass
def main(serial_port): print('Serial port used: {}'.format(serial_port)) driver = BLEDriver(serial_port=serial_port, auto_flash=True) adapter = BLEAdapter(driver) collector = HRCollector(adapter) collector.open() for i in xrange(CONNECTIONS): conn_handle = collector.connect_and_discover() time.sleep(30) print('Closing') collector.close()
def main(serial_port): print('Serial port used: {}'.format(serial_port)) driver = BLEDriver(serial_port=serial_port, auto_flash=True) adapter = BLEAdapter(driver) collector = NUSCollector(adapter) collector.open() for i in xrange(CONNECTIONS): conn_handle = collector.connect_and_discover() #Call to write_control_point to write test data to target device following successful pairing collector.write_control_point(conn_handle, TEST_DATA) time.sleep(60) print('Closing') collector.close()
def open(self): if self.dfu_adapter: raise IllegalStateException('DFU Adapter is already open') super(DfuTransportBle, self).open() driver = BLEDriver(serial_port=self.serial_port, baud_rate=self.baud_rate) adapter = BLEAdapter(driver) self.dfu_adapter = DFUAdapter(adapter=adapter) self.dfu_adapter.open() self.target_device_name, self.target_device_addr = self.dfu_adapter.connect( target_device_name=self.target_device_name, target_device_addr=self.target_device_addr) self.__set_prn()
def main(selected_serial_port): print("Serial port used: {}".format(selected_serial_port)) driver = BLEDriver(serial_port=selected_serial_port, auto_flash=False, baud_rate=1000000) adapter = BLEAdapter(driver) collector = HRCollector(adapter) collector.open() conn = collector.connect_and_discover() if conn: time.sleep(10) collector.close()
def main(): print('Possible dongles are at:') descs = BLEDriver.enum_serial_ports() for _, d in enumerate(descs): print(' {}: {} Serial Number {}'.format(d.port, d.manufacturer, d.serial_number)) driver = BLEDriver( serial_port='COM8', auto_flash=True, ) adapter = BLEAdapter(driver) collector = BatteryCollector(adapter) collector.open() conn = collector.connect_and_discover() if conn is not None: while True: pass collector.close()
def main(serial_port, address): print('Serial port used: {}'.format(serial_port)) driver = BLEDriver(serial_port=serial_port, auto_flash=True) adapter = BLEAdapter(driver) collector = Collector(adapter, uuids, address) collector.open() for i in xrange(CONNECTIONS): conn_handle = collector.connect_and_discover() #fig1.canvas.mpl_connect('key_press_event', on_press) #ani = animation.FuncAnimation(fig1, animate_acc, interval=300) #ani.running = True #ani.direction = +1 fig1.canvas.mpl_connect('button_press_event', onClick) anim = animation.FuncAnimation(fig1, animate_acc, blit=False, interval=300, repeat=True) plt.show() #ani = animation.FuncAnimation(figure2, animate_acc, interval=300) plt.show() while (True): pass
self.adapter.driver.ble_gap_scan_start(scan_params=params) try: new_conn = self.conn_q.get(timeout=scan_duration) print(new_conn) self.adapter.service_discovery(new_conn) self.adapter.enable_notification(new_conn, BLEUUID(BLEUUID.Standard.unknown)) return new_conn except Empty: print("Nothing found.") return None if __name__ == "__main__": logging.basicConfig(level=logging.DEBUG) serial_port = "COM7" driver = BLEDriver(serial_port=serial_port, auto_flash=False, baud_rate=1000000, log_severity_level="info") adapter = BLEAdapter(driver) ble_handler = BLEhandler(adapter) ble_handler.open() conn = ble_handler.connect_and_discover() print(conn) if conn is not None: time.sleep(10) ble_handler.close()
class NrfBackend: mac_string_to_bin = lambda mac: list( map(lambda x: int(x, 16), mac.split(":"))) mac_bin_to_string = lambda mac: ":".join("{0:02X}".format(b) for b in mac) def __init__(self, adapter: str = 'hci0', address_type: str = 'public'): """Create new instance of the backend.""" # super(BluepyBackend, self).__init__(adapter, address_type) self._adapter = BLEAdapter( BLEDriver(serial_port=adapter, auto_flash=False, baud_rate=1000000, log_severity_level="info")) self._adapter.driver.open() self._adapter.driver.ble_enable() self._connection = None def write_handle(self, handle: int, value: bytes, uuid_type: int = 1): """Write a value to a handle. You must be connected to a device first.""" self._adapter.write_req( self._connection, BLEUUID(handle, BLEUUIDBase(uuid_type=uuid_type)), value) def read_handle(self, handle: int, uuid_type: int = 1) -> bytes: """Read a handle from the device. You must be connected to do this. """ return self._adapter.read_req( self._connection, BLEUUID(handle, BLEUUIDBase(uuid_type=uuid_type))) def wait_for_notification(self, handle: int, delegate, notification_timeout: float, uuid_type: int = 1): """ registers as a listener and calls the delegate's handleNotification for each notification received @param handle - the handle to use to register for notifications @param delegate - the delegate object's handleNotification is called for every notification received @param notification_timeout - wait this amount of seconds for notifications """ class NoticationObserver(BLEAdapterObserver): def on_notification(self, ble_adapter, conn_handle, uuid, data): if uuid == BLEUUID(handle, BLEUUIDBase(uuid_type=uuid_type)): delegate.handleNotification(handle, data) observer = NoticationObserver() self._adapter.observer_register(observer) return self._adapter.enable_notification( self._connection, BLEUUID(handle, BLEUUIDBase(uuid_type=uuid_type))) def connect(self, mac: str): """Connect to a device.""" print("connected to DD:A9:BB:27:C8:C8") class ConnectionObserver(BLEDriverObserver): def __init__(self): self.connected = False self.connection_id = None def on_gap_evt_connected(self, ble_driver, conn_handle, peer_addr, role, conn_params): self.connected = True self.connection_id = conn_handle observer = ConnectionObserver() self._adapter.driver.observer_register(observer) self._adapter.connect( BLEGapAddr(BLEGapAddr.Types.random_static, NrfBackend.mac_string_to_bin(mac))) while not observer.connected: pass self._connection = observer.connection_id sleep(2) self._adapter.service_discovery(self._connection) sleep(2) self._adapter.authenticate(self._connection, BLEGapRoles.central) def disconnect(self): """disconnect from a device. Only required by some backends""" self._adapter.disconnect(self._connection) @staticmethod def scan_for_devices(timeout, adapter) -> List[Tuple[str, str]]: """Scan for additional devices. Returns a list of all the mac addresses of ble devices found. """ class ScanDriverObserver(BLEDriverObserver): def __init__(self): super(ScanDriverObserver, self).__init__() self.advertised_devices = [] def on_gap_evt_adv_report(self, ble_driver, conn_handle, peer_addr, rssi, adv_type, adv_data): if BLEAdvData.Types.complete_local_name in adv_data.records: dev_name_list = adv_data.records[ BLEAdvData.Types.complete_local_name] elif BLEAdvData.Types.short_local_name in adv_data.records: dev_name_list = adv_data.records[ BLEAdvData.Types.short_local_name] else: return dev_name = "".join(chr(e) for e in dev_name_list) dev_addr = NrfBackend.mac_bin_to_string(peer_addr.addr) self.advertised_devices.append((dev_name, dev_addr)) observer = ScanDriverObserver() driver = BLEDriver(serial_port=adapter, auto_flash=False, baud_rate=1000000, log_severity_level="debug") driver.open() driver.ble_enable() driver.observer_register(observer) driver.ble_gap_scan_start(scan_params=BLEGapScanParams( interval_ms=200, window_ms=150, timeout_s=timeout)) sleep(timeout) driver.close() return list(set(observer.advertised_devices))