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, 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 __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 get_port_by_snr(snr):
serial_ports = BLEDriver.enum_serial_ports()
try:
serial_port = [d.port for d in serial_ports if d.serial_number.lstrip('0') == snr][0]
except IndexError:
raise NordicSemiException('board not found')
return serial_port
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 enumerate_ports():
descs = BLEDriver.enum_serial_ports()
click.echo('Please select connectivity serial port:')
for i, choice in enumerate(descs):
click.echo('\t{} : {} - {}'.format(i, choice.port, choice.serial_number))
index = click.prompt('Enter your choice: ', type=click.IntRange(0, len(descs)))
return descs[index].port
def enumerate_ports():
descs = BLEDriver.enum_serial_ports()
if len(descs) == 0:
return None
click.echo('Please select connectivity serial port:')
for i, choice in enumerate(descs):
click.echo('\t{} : {} - {}'.format(i, choice.port, choice.serial_number))
index = click.prompt('Enter your choice: ', type=click.IntRange(0, len(descs)))
return descs[index].port
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, 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():
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):
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 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 test_programming(self):
settings = Settings.current()
serial_ports = BLEDriver.enum_serial_ports()
# Check that from enumeration matches
# kits provided from settings
found_ports = list(map(lambda port: port.port, serial_ports))
for serial_port in settings.serial_ports:
self.assertIn(serial_port, found_ports)
for serial_port in serial_ports:
if serial_port.port in settings.serial_ports:
serial_number = serial_port.serial_number
logger.info("%s/%s deleting existing firmware",
serial_port.port, serial_number)
flasher = Flasher(serial_port=serial_port.port)
flasher.erase()
self.assertFalse(
flasher.fw_check(),
"#{} must be programmed because it is erased".format(
serial_number),
)
flasher.fw_flash()
logger.info("%s/%s programmed", serial_port.port,
serial_number)
self.assertTrue(
flasher.fw_check(),
"#{} is programmed, shall not be programmed again".format(
serial_number),
)
# Try to use the device with leading zeroes in serial number removed
flasher = Flasher(snr=serial_port.serial_number.lstrip('0'))
flasher.reset()
logger.info("%s/%s programmed successfully", serial_port.port,
serial_number)
def main(port):
descs = BLEDriver.enum_serial_ports()
print("enum_serial_ports: {} serial ports found".format(len(descs)))
for i, d in enumerate(descs):
print("\nSerial port #{}:".format(i))
print("|")
print("|- Port: \"{}\"".format(d.port))
print("|- Manufacturer: \"{}\"".format(d.manufacturer))
print("|- Serial Number: \"{}\"".format(d.serial_number))
print("|- PnP ID: \"{}\"".format(d.pnp_id))
print("|- Location ID: \"{}\"".format(d.location_id))
print("|- Vendor ID: \"{}\"".format(d.vendor_id))
print("|_ Product ID: \"{}\"".format(d.product_id))
if port != None:
flasher = Flasher(serial_port=port)
if flasher.fw_check():
print("Port \"{}\" already flashed with connectivity firmware".format(port))
else:
print("Flashing Port \"{}\"".format(port))
flasher.fw_flash()
print("Firmware flashed")
def main(port):
descs = BLEDriver.enum_serial_ports()
print("enum_serial_ports: {} serial ports found".format(len(descs)))
for i, d in enumerate(descs):
print("\nSerial port #{}:".format(i))
print("|")
print("|- Port: \"{}\"".format(d.port))
print("|- Manufacturer: \"{}\"".format(d.manufacturer))
print("|- Serial Number: \"{}\"".format(d.serial_number))
print("|- PnP ID: \"{}\"".format(d.pnp_id))
print("|- Location ID: \"{}\"".format(d.location_id))
print("|- Vendor ID: \"{}\"".format(d.vendor_id))
print("|_ Product ID: \"{}\"".format(d.product_id))
if port != None:
flasher = Flasher(serial_port=port)
if flasher.fw_check():
print("Port \"{}\" already flashed with connectivity firmware".
format(port))
else:
print("Flashing Port \"{}\"".format(port))
flasher.fw_flash()
print("Firmware flashed")
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
class BLECommonAPITest(unittest.TestCase):
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 test_ble_vs_uuid_add(self):
logger.info("Adding BLE_UUID_TYPE_VENDOR_BEGIN")
data = [
0x12,
0x34,
0x56,
0x78,
0xE4,
0x2F,
0x42,
0x98,
0xD6,
0x44,
0xB6,
0x1B,
0x00,
0x00,
0xDF,
0xC8,
]
base = BLEUUIDBase(data, driver.BLE_UUID_TYPE_VENDOR_BEGIN)
self.driver.ble_vs_uuid_add(base)
self.assertEqual(base.type, driver.BLE_UUID_TYPE_VENDOR_BEGIN)
def test_ble_version_get(self):
version = self.adapter.get_version()
self.assertIsNotNone(version)
self.assertIsNotNone(version.softdevice_info)
self.assertIsNotNone(version.subversion_number)
self.assertIsNotNone(version.version_number)
def tearDown(self):
self.adapter.close()
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(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()
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()
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()
for i, it in enumerate(item_list):
print('\t{} : {}'.format(i, it))
print(' ')
while True:
try:
choice = int(raw_input('Enter your choice: '))
if ((choice >= 0) and (choice < len(item_list))):
break
except Exception:
pass
print('\tTry again...')
return choice
if __name__ == "__main__":
serial_port = None
if len(sys.argv) < 2:
print("Please specify connectivity IC identifier (NRF51, NRF52)")
exit(1)
init(sys.argv[1])
if len(sys.argv) == 3:
serial_port = sys.argv[2]
else:
descs = BLEDriver.enum_serial_ports()
choices = ['{}: {}'.format(d.port, d.serial_number) for d in descs]
choice = item_choose(choices)
serial_port = descs[choice].port
main(serial_port)
quit()
for i, it in enumerate(item_list):
print('\t{} : {}'.format(i, it))
print(' ')
while True:
try:
choice = int(raw_input('Enter your choice: '))
if ((choice >= 0) and (choice < len(item_list))):
break
except Exception:
pass
print ('\tTry again...')
return choice
if __name__ == "__main__":
serial_port = None
if len(sys.argv) < 2:
print("Please specify connectivity IC identifier (NRF51, NRF52)")
exit(1)
init(sys.argv[1])
if len(sys.argv) == 3:
serial_port = sys.argv[2]
else:
descs = BLEDriver.enum_serial_ports()
choices = ['{}: {}'.format(d.port, d.serial_number) for d in descs]
choice = item_choose(choices)
serial_port = descs[choice].port
main(serial_port)
quit()
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))
