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):
