def __init__(self, device_addr, adapter_addr=None): if adapter_addr is None: self.dongle = adapter.Adapter() logger.debug('Adapter is: {}'.format(self.dongle.address)) else: self.dongle = adapter.Adapter(adapter_addr) if not self.dongle.powered: self.dongle.powered = True logger.debug('Adapter was off, now powered on') self.rmt_device = device.Device(self.dongle.address, device_addr) self._characteristics = []
def __init__(self, adapter_addr=None): """Default initialiser. Creates the BLE beacon object If an adapter object exists then give it as an optional argument If an adapter object is not given then the first adapter found is used :param adapter_addr: Optional Python adapter object. """ self.dongle = None if adapter_addr is None: self.dongle = adapter.Adapter(adapter.list_adapters()[0]) else: self.dongle = adapter.Adapter(adapter_addr) self.broadcaster = advertisement.Advertisement(1, 'broadcast')
def __init__(self): self.bus = dbus.SystemBus() self.app = localGATT.Application() self.srv = localGATT.Service(1, SERVICE_UUID, True) self.light = localGATT.Characteristic(1, LIGHT_UUID, self.srv, [0xAA], True, ['read', 'notify']) self.switch = localGATT.Characteristic(2, SWITCH_UUID, self.srv, [0xBB], True, ['read', 'write', 'notify']) self.light.service = self.srv.path self.app.add_managed_object(self.srv) self.app.add_managed_object(self.light) self.app.add_managed_object(self.switch) self.srv_mng = GATT.GattManager(adapter.list_adapters()[0]) self.srv_mng.register_application(self.app, {}) self.dongle = adapter.Adapter(adapter.list_adapters()[0]) advert = advertisement.Advertisement(1, 'peripheral') advert.service_UUIDs = [SERVICE_UUID] if not self.dongle.powered: self.dongle.powered = True ad_manager = advertisement.AdvertisingManager(self.dongle.path) ad_manager.register_advertisement(advert, {})
def create_mqtt_proxy(client, newline): bus = dbus.SystemBus() app = localGATT.Application() srv = localGATT.Service(1, MQTT_SRVC, True) receive = Receive(srv, MQTT_RX_CHRC, client, newline) transmit = Transmit(srv, MQTT_TX_CHRC, client) app.add_managed_object(srv) app.add_managed_object(receive) app.add_managed_object(transmit) srv_mng = GATT.GattManager(adapter.list_adapters()[0]) srv_mng.register_application(app, {}) dongle = adapter.Adapter(adapter.list_adapters()[0]) if not dongle.powered: # bring hci0 up if down dongle.powered = True advert = advertisement.Advertisement(1, 'peripheral') advert.service_UUIDs = [MQTT_SRVC] ad_manager = advertisement.AdvertisingManager(dongle.address) ad_manager.register_advertisement(advert, {})
def start_beacon_scan(cls, on_eddystone_url=None, on_eddystone_uid=None, on_ibeacon=None, on_altbeacon=None): """ Start scan for beacons. Provided callback will be called if matching beacon type is found. All callbacks take one argument which is a named tuple with the fields relevant for that format. - Eddystone URL = ['url', 'tx_pwr', 'rssi'] - Eddystone UID = ['namespace', 'instance', 'tx_pwr', 'rssi'] - iBeacon = ['UUID', 'major', 'minor', 'tx_pwr', 'rssi'] - AltBeacon = ['UUID', 'major', 'minor', 'tx_pwr', 'rssi'] :param on_eddystone_url: Callback for Eddystone URL format :param on_eddystone_uid: Callback for Eddystone UID format :param on_ibeacon: Callback for iBeacon format :param on_altbeacon: Callback for AltBeacon format """ cls.dongle = adapter.Adapter() cls.on_eddystone_url = on_eddystone_url cls.on_eddystone_uid = on_eddystone_uid cls.on_ibeacon = on_ibeacon cls.on_altbeacon = on_altbeacon cls.dongle.on_device_found = cls.on_device_found cls.dongle.show_duplicates() cls.dongle.start_discovery() try: cls.start_event_loop() except KeyboardInterrupt: cls.stop_scan()
def __init__(self): self.bus = dbus.SystemBus() self.app = localGATT.Application() ''' service_id: 1 uuid: VEERING_SRVC primary: True ''' self.srv = localGATT.Service(1, VEERING_SRVC, True) self.charc = VeeringChrc(self.srv) self.charc.service = self.srv.path self.app.add_managed_object(self.srv) self.app.add_managed_object(self.charc) self.srv_mng = GATT.GattManager(adapter.list_adapters()[0]) self.srv_mng.register_application(self.app, {}) self.dongle = adapter.Adapter(adapter.list_adapters()[0]) self.advert = advertisement.Advertisement(1, 'peripheral') self.advert.service_UUIDs = [VEERING_SRVC] if not self.dongle.powered: self.dongle.powered = True self.ad_manager = advertisement.AdvertisingManager(self.dongle.path) self.ad_manager.register_advertisement(self.advert, {})
def __init__(self): self.bus = dbus.SystemBus() self.app = localGATT.Application() self.srv = localGATT.Service(1, SVC_UUID, True) self.idsCharc = DeviceIDsChrc(self.srv) self.attrCharc = DeviceAttrChrc(self.srv) self.idsCharc.service = self.srv.path self.attrCharc.service = self.srv.path self.app.add_managed_object(self.srv) self.app.add_managed_object(self.idsCharc) self.app.add_managed_object(self.attrCharc) self.srv_mng = GATT.GattManager(adapter.list_adapters()[0]) self.srv_mng.register_application(self.app, {}) self.dongle = adapter.Adapter(adapter.list_adapters()[0]) advert = advertisement.Advertisement(1, 'peripheral') advert.service_UUIDs = [SVC_UUID] # eddystone_data = tools.url_to_advert(WEB_BLINKT, 0x10, TX_POWER) # advert.service_data = {EDDYSTONE: eddystone_data} if not self.dongle.powered: self.dongle.powered = True ad_manager = advertisement.AdvertisingManager(self.dongle.address) ad_manager.register_advertisement(advert, {})
def __init__(self, name=None, address=None): """ Initialization of an instance of a remote Blinkt BLE device :param name: Will look for a BLE device with this string in its name :param address: Will look for a BLE device with this address (Currently not implemented) """ self.name = name self.address = address self.dongle = adapter.Adapter(adapter.list_adapters()[0]) if not self.dongle.powered: self.dongle.powered = True logger.debug('Adapter powered') logger.debug('Start discovery') self.dongle.nearby_discovery() device_path = None if name is not None: device_path = tools.get_dbus_path( constants.DEVICE_INTERFACE, 'Name', name) elif address is not None: device_path = tools.get_dbus_path( constants.DEVICE_INTERFACE, 'Address', address) self.blnkt = device.Device(device_path[0]) self.blinkt_srv_path = None self.blinkt_chrc_path = None
def __init__(self): self.bus = dbus.SystemBus() self.app = localGATT.Application() self.srv = localGATT.Service( 1, HR_UUID, True) # HR_UUID = '0000180d-0000-1000-8000-00805f9b34fb' self.charc = HeartRateMeasurementChrc(self.srv) self.charc.service = self.srv.path self.app.add_managed_object(self.srv) self.app.add_managed_object(self.charc) self.srv_mng = GATT.GattManager(adapter.list_adapters()[0]) self.srv_mng.register_application(self.app, {}) self.dongle = adapter.Adapter(adapter.list_adapters()[0]) advert = advertisement.Advertisement(1, 'peripheral', 'HeartRate') # advert.appearance = [0x0341] # Actually will give Error: Failed to register advertisement: org.bluez.Error.Failed: Failed to register advertisement advert.service_UUIDs = [HR_UUID] if not self.dongle.powered: self.dongle.powered = True ad_manager = advertisement.AdvertisingManager(self.dongle.address) ad_manager.register_advertisement(advert, {})
def __init__(self): self.bus = dbus.SystemBus() self.app = localGATT.Application() self.srv = localGATT.Service(1, SERVICE_UUID, True) self.charc = localGATT.Characteristic(1, CHAR_UUID, self.srv, [0xBB], True, ['write']) self.charc.service = self.srv.path self.app.add_managed_object(self.srv) self.app.add_managed_object(self.charc) self.srv_mng = GATT.GattManager(adapter.list_adapters()[0]) self.srv_mng.register_application(self.app, {}) self.dongle = adapter.Adapter(adapter.list_adapters()[0]) advert = advertisement.Advertisement(1, 'peripheral') advert.service_UUIDs = [SERVICE_UUID] eddystone_data = tools.url_to_advert(WEB_BLINKT, 0x10, TX_POWER) advert.service_data = {EDDYSTONE: eddystone_data} if not self.dongle.powered: self.dongle.powered = True ad_manager = advertisement.AdvertisingManager(self.dongle.path) ad_manager.register_advertisement(advert, {})
def central(address): dongle = adapter.Adapter(adapter.list_adapters()[0]) if not dongle.powered: dongle.powered = True # Find nearby devices dongle.nearby_discovery() ubit = microbit(address) sense_buttons = True ubit.connect() led2.on() buzz.on() sleep(BEEP_TIME) buzz.off() while sense_buttons: btn_a = ubit.read_button_a() btn_b = ubit.read_button_b() # print('Button states: a={} b={}'.format(btn_a, btn_b)) if btn_a > 0 and btn_b < 1: print('Button A') led1.on() led3.off() elif btn_a < 1 and btn_b > 0: print('Button B') led1.off() led3.on() elif btn_a > 0 and btn_b > 0: sense_buttons = False led1.on() led3.on() buzz.on() sleep(BEEP_TIME) buzz.off() print('Bye bye!!!') elif btn_a < 1 and btn_b < 1: led1.off() led3.off() if not ubit.connected: sense_buttons = False led1.on() led2.on() led3.on() buzz.on() sleep(BEEP_TIME) buzz.off() sleep(0.02) # Disconnect device ubit.disconnect() # Read the connected status property led1.off() led2.off() led3.off() buzz.off()
def __init__(self, reading_callback): self.bus = dbus.SystemBus() self.app = localGATT.Application() self.srv = localGATT.Service(1, AQI_PM_SRVC, True) self.pm_2_5_charc = AQIChrc(1, PM_2_5_CHRC, self.srv, 0.0, 'PM 2.5', reading_callback) self.pm_2_5_charc.service = self.srv.path self.pm_10_charc = AQIChrc(2, PM_10_CHRC, self.srv, 0.0, 'PM 10', reading_callback) self.pm_10_charc.service = self.srv.path pm_2_5_format_value = dbus.Array([ dbus.Byte(0x0E), dbus.Byte(0xFE), dbus.Byte(0x2F), dbus.Byte(0x27), dbus.Byte(0x01), dbus.Byte(0x00), dbus.Byte(0x00) ]) pm_10_format_value = dbus.Array([ dbus.Byte(0x0E), dbus.Byte(0xFE), dbus.Byte(0x2F), dbus.Byte(0x27), dbus.Byte(0x01), dbus.Byte(0x00), dbus.Byte(0x00) ]) self.pm_2_5_format = localGATT.Descriptor(4, PM_2_5_FMT_DSCP, self.pm_2_5_charc, pm_2_5_format_value, ['read']) self.pm_10_format = localGATT.Descriptor(5, PM_10_FMT_DSCP, self.pm_10_charc, pm_10_format_value, ['read']) self.app.add_managed_object(self.srv) self.app.add_managed_object(self.pm_2_5_charc) self.app.add_managed_object(self.pm_2_5_format) self.app.add_managed_object(self.pm_10_charc) self.app.add_managed_object(self.pm_10_format) self.srv_mng = GATT.GattManager(adapter.list_adapters()[0]) self.srv_mng.register_application(self.app, {}) self.dongle = adapter.Adapter(adapter.list_adapters()[0]) advert = advertisement.Advertisement(1, 'peripheral') advert.service_UUIDs = [AQI_PM_SRVC] if not self.dongle.powered: self.dongle.powered = True ad_manager = advertisement.AdvertisingManager(self.dongle.address) ad_manager.register_advertisement(advert, {})
def __init__(self): super(MainUi, self).__init__() self.acellData = { "x": { "x": [], "y": [] }, "y": { "x": [], "y": [] }, "z": { "x": [], "y": [] } } self.xtrack = 0 self.threadpool = QThreadPool.globalInstance().setMaxThreadCount(2) dongles = adapter.list_adapters() dongle = adapter.Adapter(dongles[0]) self.t = QThread(self, objectName='conThread') self.connectionThread = mBitConnection.Worker(self, self.t) self.connectionThread.connected.connect(self.HandelConnectEvent) self.connectionThread.newstate.connect(self.mBitStatusUpdate) self.connectionThread.disconnected.connect(self.HandeldisconnectEvent) self.showPixels_evnt.connect(self.connectionThread.showPixels) self.showText_evnt.connect(self.connectionThread.showText) self.clear_evnt.connect(self.connectionThread.clearMatrix) self.connect_evnt.connect(self.connectionThread.connectToMbit) self.disconnect_evnt.connect(self.connectionThread.disconnectFromMbit) self.t.started.connect(self.connectionThread.start) self.t.start() self.tGif = QThread(self, objectName='gifThread') self.gifworker = gifAnimation.Worker(self.connectionThread, self, self.tGif) self.tGif.started.connect(self.gifworker.run) self.gifworker.moveToThread(self.tGif) self.tGif.start() self.adapterAddr = str(dongle.address) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ui.hostMAC_txtBox.setText(self.adapterAddr) self.make_connection_ScrollSpeed(self.ui.scrollSpeedSlider) self.Buttonconnect(self.ui.connectButton, self.connectToMbit) self.ScrollingSpeed = 0 self.ui.matrixTab.setEnabled(False) self.ui.miscStateTab.setEnabled(False) self.Buttonconnect(self.ui.openGifButton, self.loadImage) self.Buttonconnect(self.ui.gifStateButton, self.playgif) for row in self.ui.groupBox_MatrixState.findChildren(QWidget): for checkbox in row.findChildren(QCheckBox): checkbox.clicked.connect(self.handelMatrixCheckbox) self.Buttonconnect(self.ui.matrixClear, self.MatrixClearButton) self.Buttonconnect(self.ui.pushButton_showText, self.SendTextHandler)
def client(): dongle = adapter.Adapter(adapter.list_adapters()[0]) if not dongle.powered: dongle.powered = True dongle.nearby_discovery() cc2650 = device.Device( tools.device_dbus_path(constants.DEVICE_INTERFACE, 'SensorTag')[0]) # Connect to device cc2650.connect() while not cc2650.services_resolved: sleep(0.5) # constants TMP_CONF_PATH = Characteristic( tools.uuid_dbus_path(constants.GATT_CHRC_IFACE, 'F000AA02-0451-4000-B000-000000000000')[0]) TMP_DATA_PATH = Characteristic( tools.uuid_dbus_path(constants.GATT_CHRC_IFACE, 'F000AA01-0451-4000-B000-000000000000')[0]) OPT_CONF_PATH = Characteristic( tools.uuid_dbus_path(constants.GATT_CHRC_IFACE, 'F000AA72-0451-4000-B000-000000000000')[0]) OPT_DATA_PATH = Characteristic( tools.uuid_dbus_path(constants.GATT_CHRC_IFACE, 'F000AA71-0451-4000-B000-000000000000')[0]) BAR_CONF_PATH = Characteristic( tools.uuid_dbus_path(constants.GATT_CHRC_IFACE, 'F000AA42-0451-4000-B000-000000000000')[0]) BAR_DATA_PATH = Characteristic( tools.uuid_dbus_path(constants.GATT_CHRC_IFACE, 'F000AA41-0451-4000-B000-000000000000')[0]) HUM_CONF_PATH = Characteristic( tools.uuid_dbus_path(constants.GATT_CHRC_IFACE, 'F000AA22-0451-4000-B000-000000000000')[0]) HUM_DATA_PATH = Characteristic( tools.uuid_dbus_path(constants.GATT_CHRC_IFACE, 'F000AA21-0451-4000-B000-000000000000')[0]) # Read the connected status property if cc2650.connected: # IR Temperature Sensor print('\nIR Temperature Sensor') read_sensor(TMP_CONF_PATH, TMP_DATA_PATH) # Optical Sensor print('\nOptical Sensor') read_sensor(OPT_CONF_PATH, OPT_DATA_PATH) # Barometric Pressure Sensor print('\nBarometric Pressure Sensor') read_sensor(BAR_CONF_PATH, BAR_DATA_PATH) # Humidity Sensor print('\nHumidity Sensor') read_sensor(HUM_CONF_PATH, HUM_DATA_PATH) # Disconnect device cc2650.disconnect()
def __init__(self, adapter_address, local_name=None, appearance=None): self.app = localGATT.Application() self.srv_mng = GATT.GattManager(adapter_address) self.services = [] self.characteristics = [] self.descriptors = [] self.primary_services = [] self.dongle = adapter.Adapter(adapter_address) self.local_name = local_name self.appearance = appearance self.advert = advertisement.Advertisement(1, 'peripheral') self.ad_manager = advertisement.AdvertisingManager(adapter_address) self.mainloop = async_tools.EventLoop()
def advertise_beacon(): dongle = adapter.Adapter('/org/bluez/hci0') advertiser0 = advertisement.Advertisement(0, 'peripheral') advertiser0.service_UUIDs = ['FEAA'] advertiser0.service_data = { 'FEAA': [0x10, 0x08, 0x0E, 70, 97, 116, 79, 110, 101] } if not dongle.powered: dongle.powered = True ad_manager = advertisement.AdvertisingManager(dongle.path) ad_manager.register_advertisement(advertiser0, {}) return ad_manager, advertiser0
def test_on_device_found(self): device_address = '11:01:02:03:04:05' class ForTest: found_address = None @classmethod def new_dev(cls, device): cls.found_address = device.address self.dbusmock_bluez.AddAdapter('hci0', 'My-Test-Device') dongle = adapter.Adapter() dongle.on_device_found = ForTest.new_dev self.dbusmock_bluez.AddDevice('hci0', device_address, 'My-Peripheral-Device') run_pending_events() self.assertEqual(device_address, ForTest.found_address)
def __init__(self): self.mainloop = async_tools.EventLoop() self.app = localGATT.Application() self.srv = localGATT.Service(1, CPU_TMP_SRVC, True) self.charc = TemperatureChrc(self.srv) self.charc.service = self.srv.path cpu_format_value = dbus.Array([dbus.Byte(0x0E), dbus.Byte(0xFE), dbus.Byte(0x2F), dbus.Byte(0x27), dbus.Byte(0x01), dbus.Byte(0x00), dbus.Byte(0x00)]) self.cpu_format = localGATT.Descriptor(4, CPU_FMT_DSCP, self.charc, cpu_format_value, ['read']) self.app.add_managed_object(self.srv) self.app.add_managed_object(self.charc) self.app.add_managed_object(self.cpu_format) self.srv_mng = GATT.GattManager(adapter.list_adapters()[0]) self.srv_mng.register_application(self.app, {}) self.dongle = adapter.Adapter(adapter.list_adapters()[0]) advert = advertisement.Advertisement(1, 'peripheral') advert.service_UUIDs = [CPU_TMP_SRVC] advert.local_name = 'CPU Temp' advert.appearance = 1344 # eddystone_data = tools.url_to_advert(WEB_BLINKT, 0x10, TX_POWER) # advert.service_data = {EDDYSTONE: eddystone_data} if not self.dongle.powered: self.dongle.powered = True ad_manager = advertisement.AdvertisingManager(self.dongle.address) ad_manager.register_advertisement(advert, {})
def __init__(self, device_id=None): """Default initialiser. 1. Initialises the program loop using ``GObject``. 2. Registers the Application on the D-Bus. 3. Initialises the list of services offered by the application. """ # Initialise the loop that the application runs in self.mainloop = async_tools.EventLoop() # Initialise the D-Bus path and register it self.bus = dbus.SystemBus() self.path = '/ukBaz/bluezero/application{}'.format(id(self)) self.bus_name = dbus.service.BusName('ukBaz.bluezero', self.bus) dbus.service.Object.__init__(self, self.bus_name, self.path) # Initialise services within the application self.services = [] self.dongle = adapter.Adapter(device_id)
def main(): dongles = adapter.list_adapters() print('dongles available: ', dongles) dongle = adapter.Adapter(dongles[0]) print('address: ', dongle.address) print('name: ', dongle.name) print('alias: ', dongle.alias) print('powered: ', dongle.powered) print('pairable: ', dongle.pairable) print('pairable timeout: ', dongle.pairabletimeout) print('discoverable: ', dongle.discoverable) print('discoverable timeout: ', dongle.discoverabletimeout) print('discovering: ', dongle.discovering) print('Powered: ', dongle.powered) if not dongle.powered: dongle.powered = True print('Now powered: ', dongle.powered) print('Start discovering') dongle.nearby_discovery()
def sendbtn_clicked(self): dongles = adapter.list_adapters() dongle = adapter.Adapter(dongles[0]) if (not dongle.discoverable): dongle.discoverable = True if not dongle.powered: dongle.powered = True print("scaning . . . ") scanner = Scanner().withDelegate(DefaultDelegate.__init__(self)) devices = scanner.scan(10.0) for dev in devices: print(dev.addr) if (dev.addr == "a4:cf:12:0a:7e:c2"): connection = btle.Peripheral(dev.addr, dev.addrType) #connection.connect(dev.addr,dev.addrType) print("connected") connection.pair() print("paired") print("failed")
def __init__(self, adapter_addr=None): self.bus = dbus.SystemBus() if adapter_addr is None: adapters = list(adapter.Adapter.available()) if len(adapters) > 0: use_adapter = adapters[0] adapter_addr = use_adapter.address else: use_adapter = adapter.Adapter(adapter_addr) if not use_adapter.discoverable: use_adapter.discoverable = True self.advert_mngr_path = dbus_tools.get_dbus_path(adapter=adapter_addr) self.advert_mngr_obj = self.bus.get_object( constants.BLUEZ_SERVICE_NAME, self.advert_mngr_path) self.advert_mngr_methods = dbus.Interface( self.advert_mngr_obj, constants.LE_ADVERTISING_MANAGER_IFACE) self.advert_mngr_props = dbus.Interface(self.advert_mngr_obj, dbus.PROPERTIES_IFACE)
def __init__(self, name=None, address=None): """ Initialization of an instance of a remote microbit :param name: Will look for a BLE device with this string in its name :param address: Will look for a BLE device with this address (Currently not implemented) """ self.name = name self.address = address self.dongle = adapter.Adapter(adapter.list_adapters()[0]) if not self.dongle.powered: self.dongle.powered = True logger.debug('Adapter powered') logger.debug('Start discovery') self.dongle.nearby_discovery() self.ubit = device.Device( tools.get_dbus_path(constants.DEVICE_INTERFACE, 'Name', name)[0]) self.accel_srv_path = None self.accel_data_path = None self.aceel_period_path = None self.magneto_srv_path = None self.magneto_data_path = None self.magneto_period_path = None self.magneto_bearing_path = None self.btn_srv_path = None self.btn_a_state_path = None self.btn_b_state_path = None self.io_pin_srv_path = None self.io_pin_data_path = None self.io_ad_config_path = None self.io_pin_config_path = None self.io_pin_pwm_path = None self.led_srv_path = None self.led_state_path = None self.led_text_path = None self.led_scroll_path = None self.temp_srv_path = None self.temp_data_path = None self.temp_period_path = None
def __init__(self): self.bus = dbus.SystemBus() self.app = localGATT.Application() self.srv = localGATT.Service(1, UART_SRVC, True) self.receive = UartRxChrc(self.srv) self.transmit = UartTxChrc(self.srv, self.receive) self.app.add_managed_object(self.srv) self.app.add_managed_object(self.receive) self.app.add_managed_object(self.transmit) self.srv_mng = GATT.GattManager(adapter.list_adapters()[0]) self.srv_mng.register_application(self.app, {}) self.dongle = adapter.Adapter(adapter.list_adapters()[0]) advert = advertisement.Advertisement(1, 'peripheral') advert.service_UUIDs = [UART_SRVC] if not self.dongle.powered: self.dongle.powered = True ad_manager = advertisement.AdvertisingManager(self.dongle.address) ad_manager.register_advertisement(advert, {})
from time import sleep import logging from bluezero import adapter, central from binascii import b2a_hex from struct import unpack dongle = adapter.Adapter(adapter.list_adapters()[0]) LOGGER = logging.getLogger(__name__) def dict_compare(d1, d2): d1_keys = set(d1.keys()) d2_keys = set(d2.keys()) intersect_keys = d1_keys.intersection(d2_keys) added = d1_keys - d2_keys removed = d2_keys - d1_keys modified = {o: (d1[o], d2[o]) for o in intersect_keys if d1[o] != d2[o]} same = set(o for o in intersect_keys if d1[o] == d2[o]) return added, removed, modified, same class BLEGuitar: BLE_GUITAR_SERVICE = '533E1523-3ABE-F33F-CD00-594E8B0A8EA3' BLE_GUITAR_CHAR = '533E1524-3ABE-F33F-CD00-594E8B0A8EA3' def __init__(self, device_addr, adapter_addr=dongle.address): self._guitar = central.Central(adapter_addr=adapter_addr, device_addr=device_addr) self._guitar_rx = self._guitar.add_characteristic(
def test_one_adapter(self): self.dbusmock_bluez.AddAdapter('hci0', 'My-Test-Device') dongle = adapter.Adapter() name = dongle.name self.assertEqual('My-Test-Device', name)
# Need to update micro:bit class so the user callback # has one parameter which is the button value as an integer print('button a') print('args = ', args) print('kwargs = ', kwargs) def btn_b_action(*args, **kwargs): print('button b') print('args = ', args) print('kwargs = ', kwargs) def exit_test(): print('Times up!') if dongle.discovering: dongle.stop_discovery() eloop.quit() return False dongle = adapter.Adapter() eloop = async_tools.EventLoop() dongle.on_device_found = device_found_handler eloop.add_timer(500, start_disco) eloop.add_timer(300000, exit_test) eloop.run()
value = changed_props.get('Value', None) if not value: return value = int.from_bytes(value, byteorder='little', signed=False) if value > 0: global display_on display_on = False print('Off') lights.clear() lights.show() print('power adapter') dongle = adapter.Adapter('/org/bluez/hci0') if not dongle.powered(): dongle.powered(True) print('discovery') dongle.nearby_discovery() ubit = device.Device( tools.device_dbus_path(constants.DEVICE_INTERFACE, 'puteg')[0]) while True: print('connect...') while not ubit.connected(): ubit.connect() while not ubit.services_resolved(): lights.set_pixel(1, 1, 255, 0, 0) sleep(0.1) lights.show() lights.clear()
try: f = open(file, "rb+") b = f.read() finally: if f is not None: f.close() return b logging.info(os.getpid()) # sleep(10) # wait device to initialize wireless modules # enable_ble() sleep(2) dongles = adapter.list_adapters() logging.info('dongles available: %s', dongles) dongle = adapter.Adapter(dongles[0]) SELF = dongle.address logging.info('address: %s', SELF) try: bs = readBytes('/home/pi/id') node_id = str(struct.unpack('H', bs)[0]) except Exception as e: logging.error(e) node_id = "not-set" logging.info('node id: %s', node_id) def writeBytes(file, value=65535):