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):
print("Serial port used: {}".format(serial_port))
driver = BLEDriver(serial_port=serial_port, baud_rate=1000000)
observer = TimeoutObserver()
adv_data = BLEAdvData(complete_local_name="pc_ble_driver_py")
driver.observer_register(observer)
driver.open()
if config.__conn_ic_id__.upper() == "NRF51":
driver.ble_enable(
BLEEnableParams(
vs_uuid_count=0,
service_changed=0,
periph_conn_count=1,
central_conn_count=0,
central_sec_count=0,
)
)
elif config.__conn_ic_id__.upper() == "NRF52":
driver.ble_enable()
driver.ble_gap_adv_data_set(adv_data)
driver.ble_gap_adv_start()
observer.wait_for_timeout()
print("Closing")
driver.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('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(self):
settings = Settings.current()
self.driver = BLEDriver(
serial_port=settings.serial_ports[0],
auto_flash=False,
baud_rate=settings.baud_rate,
retransmission_interval=settings.retransmission_interval,
response_timeout=settings.response_timeout,
log_severity_level=settings.driver_log_level,
)
self.adapter = BLEAdapter(self.driver)
self.adapter.open()
if settings.nrf_family == "NRF51":
self.adapter.driver.ble_enable(
BLEEnableParams(
vs_uuid_count=1,
service_changed=0,
periph_conn_count=0,
central_conn_count=1,
central_sec_count=0,
))
elif settings.nrf_family == "NRF52":
gatt_cfg = BLEConfigConnGatt()
gatt_cfg.att_mtu = self.adapter.default_mtu
gatt_cfg.tag = 1
self.adapter.driver.ble_cfg_set(BLEConfig.conn_gatt, gatt_cfg)
self.adapter.driver.ble_enable()
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 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 __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 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(serial_port):
print("Serial port used: {}".format(serial_port))
driver = BLEDriver(serial_port=serial_port, auto_flash=True)
observer = TimeoutObserver()
adv_data = BLEAdvData(complete_local_name='Example')
driver.observer_register(observer)
driver.open()
driver.ble_enable()
driver.ble_gap_adv_data_set(adv_data)
driver.ble_gap_adv_start()
observer.wait_for_timeout()
print("Closing")
driver.close()
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 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():
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 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))
def test_open_close(self):
settings = Settings.current()
driver = BLEDriver(
serial_port=settings.serial_ports[0],
auto_flash=False,
baud_rate=settings.baud_rate,
retransmission_interval=settings.retransmission_interval,
response_timeout=settings.response_timeout,
log_severity_level=settings.driver_log_level,
)
adapter = BLEAdapter(driver)
central = Central(adapter)
logger.info("Number of iterations: %s", settings.number_of_iterations)
for _ in range(0, settings.number_of_iterations):
adapter.open()
if settings.nrf_family == "NRF51":
adapter.driver.ble_enable(
BLEEnableParams(
vs_uuid_count=1,
service_changed=0,
periph_conn_count=0,
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 = 1
adapter.driver.ble_cfg_set(BLEConfig.conn_gatt, gatt_cfg)
adapter.driver.ble_enable()
adapter.driver.ble_gap_scan_start()
time.sleep(1)
self.assertTrue(central.adv_received)
adapter.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()
