def main(in_q, ble_out_q,ant_out_q): macaddresssmartrower = smartrowreader.connecttosmartrow() sleep(5) manager = gatt.DeviceManager(adapter_name='hci1') smartrow = smartrowreader.SmartRow(mac_address=macaddresssmartrower, manager=manager) SRtoBLEANT = DataLogger(smartrow) #sleep(10) #try: BC = threading.Thread(target=connectSR, args=(manager,smartrow)) BC.daemon = True BC.start() logger.info("SmartRow Ready and sending data to BLE and ANT Thread") sleep(20) print("heart beat") #todo: have a check to see if connection has been etablished HB = threading.Thread(target=heartbeat, args=([smartrow])) HB.daemon = True HB.start() reset(smartrow) sleep(1) while True: if not in_q.empty(): ResetRequest_ble = in_q.get() print(ResetRequest_ble) reset(smartrow) else: pass ble_out_q.append(SRtoBLEANT.WRValues) ant_out_q.append(SRtoBLEANT.WRValues) sleep(0.1)
def read_esp32_BLE_data(): manager = gatt.DeviceManager(adapter_name='hci0') class AnyDevice(gatt.Device): def services_resolved(self): super().services_resolved() device_information_service = next( s for s in self.services if s.uuid == '6e400001-b5a3-f393-e0a9-e50e24dcca9e') firmware_version_characteristic = next( c for c in device_information_service.characteristics if c.uuid == '6e400003-b5a3-f393-e0a9-e50e24dcca9e') firmware_version_characteristic.read_value() firmware_version_characteristic.enable_notifications() def characteristic_value_updated(self, characteristic, value): seconds = int(time.time()) with open('Dataset_MPU6050.csv', 'a') as pyfile: # Dataset_MPU6050.csv pyfile.write(str(seconds) + ',') with open("Dataset_MPU6050.csv", 'a') as file: writer = csv.writer(file,delimiter = '\'') writer.writerow([value.decode("utf-8")]) device = AnyDevice(mac_address='30:AE:A4:CC:26:12', manager=manager) device.connect() manager.run()
def initialize(on_state_change): manager = gatt.DeviceManager(adapter_name='hci0') device = GiikerDevice(mac_address='C2:DD:1F:F8:CB:DA', manager=manager, on_state_change=on_state_change) print("Connecting... ", end="") device.connect() print("connected!") manager.run()
def run_sphero(shared_resources, sphero_num, kill_switch): shared_resources.get_numpy_resources() manager = gatt.DeviceManager(adapter_name="hci0") mac_address = shared_resources.sphero_config["SPHEROMACS"][sphero_num] device = SpheroDevice(shared_resources, mac_address, manager, sphero_num, kill_switch) device.connect() manager.run()
def thread(): global manager, discovery_manager, Interface manager = gatt.DeviceManager( adapter_name=Interface) #Creating Device Manager discovery_manager = DiscoveryManager( adapter_name=Interface) #Creating Discovery Manager discovery_manager.start_discovery() #search for devices discovery_manager.run()
def init(): L.l.info('BMS module initialising') thread_pool.add_interval_callable(thread_run, run_interval_second=90) m.Bms.add_upsert_listener(bms_upsert_listener) P.manager = gatt.DeviceManager(adapter_name='hci0') P.bluetooth_manager = threading.Thread(target=bluetooth_manager_thread, args=[ P.manager, ]) P.bluetooth_manager.start() P.initialised = True
def main(): p = get_argparser() args = p.parse_args(sys.argv[1:]) if args.cmd == 'call': if args.args: args.args = json.loads(args.args) manager = gatt.DeviceManager(adapter_name=args.adapter) device = MosDevice(mac_address=args.address, manager=manager) device.connect() device.run_rpc_call(args.method, args.args)
def start_connector(completed_queue, adapter='hci0'): connect_queue = Queue() manager = gatt.DeviceManager(adapter) manager.start_discovery() Thread(target=manager.run, daemon=True).start() scheduler = Thread(target=connect_scheduler, args=(connect_queue, completed_queue, manager), daemon=True) scheduler.start() return scheduler, connect_queue
def __init__(self, bt_iface_name='hci0'): super(GattConnection, self).__init__() self._device = None self._iface = bt_iface_name try: self._manager = gatt.DeviceManager(adapter_name=self._iface) except TypeError: raise NotImplementedError("Gatt is not implemented for this platform") self._manager_thread = threading.Thread(target=self._manager.run) self._manager_thread.setDaemon(True) log.debug('Starting DeviceManager...')
def __init__(self, mac): super().__init__() self.setWindowTitle('Sonicare') self.client = SonicareClient( mac=mac, device_manager=gatt.DeviceManager(adapter_name='hci0'), ready_callback=self._on_ready, error_callback=self._on_error, disconnect_callback=self._on_disconnect) self.setCentralWidget(self._build_main_widget()) self.show()
def main(): if len(sys.argv) < 3: print(f"USAGE: {sys.argv[0]} toggle|introspect macaddress", file=sys.stderr) sys.exit(1) mac_address = sys.argv[2] # FIXME adapter_name should be configurable manager = gatt.DeviceManager(adapter_name="hci0") device = HueLight(sys.argv[1], mac_address=mac_address, manager=manager) device.connect() manager.run()
def conn_bluez(self,hub_mac,controller): # Mit internem BLE-Interface verbinden (nur Linux) self.backend = 'BlueZ' # vor Instanzierung muss DeviceManger gestartet sein logging.debug('BlueZ: DeviceManager Instanz erzeugen...') dev_manager = gatt.DeviceManager(adapter_name=controller) dman_thread = threading.Thread(target=dev_manager.run) logging.debug('BlueZ: DeviceManager starten...') dman_thread.start() #sleep(1) self.ble_iface=BlueZInterface(hub_mac,controller,dev_manager,dman_thread) print('BlueZ-Interface gestartet. Bitte MoveHub einschalten!') self.ble_iface.client_conn(hub_mac) print('BlueZ-Interface unter Linux verbunden.')
def server_proc(pipe_to_plotter, pipe_to_cursor, mac_address): global to_plotter global to_cursor to_plotter = pipe_to_plotter to_cursor = pipe_to_cursor print("server process started") manager = gatt.DeviceManager(adapter_name='hci0') hexiwear = HexiDevice(mac_address=mac_address, manager=manager) hexiwear.connect() manager.run()
def __init__(self, mac_address): logger.debug("Init Gatt Adapter") super().__init__(mac_address) self.manager = gatt.DeviceManager("hci0") self._device = Device(self.packet_collector, mac_address=self.mac_address, manager=self.manager) self._device.connect() self.ch_api_v2 = self._find_api_v2() self.ch_api_v2.enable_notifications() self._executor.submit(self.manager.run)
def __init__(self, mac_address=None, adapter_name='hci0', manager=None): self.characteristic_changed = threading.Event() if mac_address is None: mac_address = self._DiscoveryManager(adapter_name).find_dripper() if manager is None: manager = gatt.DeviceManager(adapter_name) self.manager_thread = threading.Thread(target=manager.run, daemon=True) self.manager_thread.start() super().__init__(mac_address, manager) self.connect() self.characteristic_changed.wait() self.characteristic_changed.clear()
def main(): if len(sys.argv) < 3: print(f"USAGE: {sys.argv[0]} toggle|brightness|introspect macaddress args...", file=sys.stderr) sys.exit(1) mac_address = sys.argv[2] # FIXME adapter_name should be configurable manager = gatt.DeviceManager(adapter_name="hci0") # this is a bit of a hack. gatt blocks indefinitely b = Barrier(2) device = HueLight(sys.argv[1], sys.argv[3:], mac_address=mac_address, manager=manager, barrier=b) def run(): device.connect() manager.run() t = Thread(target=run, daemon=True) t.start() b.wait()
def connectWs(MACaddress): class AnyDevice(gatt.Device): def connect_succeeded(self): super().connect_succeeded() global status status = "[" + self.mac_address + "] connected" # manager.stop() def connect_failed(self, error): ga = 1 super().connect_failed(error) global status status = "[" + self.mac_address + "] connection failed: " + str( error) print(status) manager.stop() def services_resolved(self): super().services_resolved() device_information_service = next( s for s in self.services if s.uuid == '49535343-fe7d-4ae5-8fa9-9fafd205e455') firmware_version_characteristic = next( c for c in device_information_service.characteristics if c.uuid == '49535343-1e4d-4bd9-ba61-23c647249616') firmware_version_characteristic.enable_notifications() firmware_version_characteristic.read_value() def characteristic_value_updated(self, characteristic, value): stringData = value.decode('utf-8').rstrip() out = json.loads(stringData) print(stringData) #connectCloud(out) fs.write(stringData + "\n") fs.flush() print("Connecting...") manager = gatt.DeviceManager(adapter_name='hci0') device = AnyDevice(manager=manager, mac_address=MACaddress) device.connect() manager.run() return status
def __init__(self, mac_address): logger.debug("Init Gatt Adapter") super().__init__(mac_address) self.manager = gatt.DeviceManager("hci0") self._device = Device( self.packet_collector, mac_address=self.mac_address, manager=self.manager) self._device.connect() ch_force_band = self._find_characteristic(SpheroCharacteristic.force_band.value) ch_force_band.write_value(b"usetheforce...band") self.ch_api_v2 = self._find_characteristic(SpheroCharacteristic.api_v2.value) self.ch_api_v2.enable_notifications() self._executor.submit(self.manager.run)
def __init__(self, mac_address, *args, **kwargs): self.manager = gatt.DeviceManager(adapter_name='hci0') self.logs = [] self.lock = Lock() self.serial_master = None self.serial_slave = None self.first_read = True self.device = BLEComm(self.logs, self.lock, False, on_message_received=self.on_message_received, manager=self.manager, mac_address=mac_address) self.device.connect() self.blecomm_thread = Thread(target=self.manager.run) self.blecomm_thread.start()
def read_HR_BLE_data(running_time): manager = gatt.DeviceManager(adapter_name='hci0') start = time.time() class AnyDevice(gatt.Device): def services_resolved(self): super().services_resolved() device_information_service = next( s for s in self.services if s.uuid == '0000180d-0000-1000-8000-00805f9b34fb') # 0x2A37 firmware_version_characteristic = next( c for c in device_information_service.characteristics if c.uuid == '00002a37-0000-1000-8000-00805f9b34fb') firmware_version_characteristic.read_value() firmware_version_characteristic.enable_notifications() def characteristic_value_updated(self, characteristic, value): seconds = int(time.time()) rri = value[2] | value[3] << 8 rr = float(rri) / 1000 - 0 #print(str(seconds) + "," ) #print(value[1], " ", rr) with open('HR_Data.csv', 'a') as pyfile: pyfile.write(str(seconds) + ',') with open("HR_Data.csv", 'a') as file: writer = csv.writer(file, delimiter=',') writer.writerow([str(value[1]), str(rr)]) end = time.time() if (end - start) > (running_time): self.disconnect() print("Esp32 disconnected.") self.manager.stop() device = AnyDevice(mac_address='D0:41:AF:74:F6:F1', manager=manager) device.connect() print("Esp32 connected.") manager.run()
def __init__(self, mac_address=TOKYDOOR, adapter_name='hci0', command="ONCE", uuid="", database=None): """ Prepare the access to the door's BLE :param mac_address: the BLE mac address :param adapter_name: the Raspberry Pi's Bluettoth device name (check with 'hciconfig') :param command: the coomand to send to the BLE on the characteristic uuid :param uuid: characteristic to use to send the commad. Must be 'writable'. :param database: optional - to log errors in table tb_log """ self.mac_address = mac_address self.door_characteristic = uuid or TOKYUUID self.command = command self.adapter_name = adapter_name self.manager = gatt.DeviceManager(adapter_name=self.adapter_name) self.db = database
def main(): # Connect bluetooth DEVICE1 = "00:3E:50:04:00:36" DEVICE2 = "00:40:40:0C:00:4A" global manager global sum manager = gatt.DeviceManager(adapter_name='hci0') hexiwear1 = HexiDevice(mac_address=DEVICE1, manager=manager) hexiwear1.connect() # Multiprocessing client #cli = Client(('192.168.56.1', 5005)) #cli = Client(('localhost',5005)) manager.run() print("Gyro end") return sum
def disconnectWs(MACaddress): import gatt class AnyDevice(gatt.Device): def disconnect_succeeded(self): super().disconnect_succeeded() global status status="[" + MACaddress + "] disconnected" manager.stop() print("Disconnecting...") manager = gatt.DeviceManager(adapter_name='hci0') device = AnyDevice(manager=manager, mac_address=MACaddress) device.connect() device.disconnect() manager.run() return status
def main(in_q, ble_out_q, ant_out_q): # this starts discovery, calls manager.run() and returns manager.smartrowmac # macaddresssmartrower = smartrowreader.connecttosmartrow() manager = gatt.DeviceManager(adapter_name='hci0') smartrow = smartrowreader.SmartRow(mac_address=macaddresssmartrower, manager=manager) SRtoBLEANT = DataLogger(smartrow) BC = threading.Thread(target=connectSR, args=(manager, smartrow)) BC.daemon = True BC.start() logger.info("SmartRow Ready and sending data to BLE and ANT Thread") while not smartrow.ready(): sleep(0.2) print("starting heart beat") HB = threading.Thread(target=heartbeat, args=([smartrow])) HB.daemon = True HB.start() sleep( 3 ) # this sleep is needed in order give the user time to putt back the handle after pulling it to activate it. # The SmartRow device is very sensitive to touches which then triggers 1 m very easy after a reset which then already starts after a restart. reset(smartrow) sleep(1) SRtoBLEANT.Initial_reset = True # this should help to check if the first reset has been performed while True: if not in_q.empty(): ResetRequest_ble = in_q.get() print(ResetRequest_ble) reset(smartrow) else: pass ble_out_q.append(SRtoBLEANT.WRValues) ant_out_q.append(SRtoBLEANT.WRValues) sleep(0.1)
def __init__(self, adapter_name): # A quick way to test how often are issues causes by adapter naming logger.debug("Using adapter (self.ble_adapter_name): %s" % adapter_name) import subprocess output = subprocess.check_output("hciconfig") logger.debug("Adapter (from hciconfig): %s " % str(output.split()[0])) self._adapter_name = adapter_name self._gatt_manager = gatt.DeviceManager(self._adapter_name) self._manager = nuimo.ControllerManager(self._adapter_name) self._manager.listener = self self._is_running = False # Prevents from considering D-Bus events if we aren't running self._discovery_timeout_timer = None self._connect_timeout_timer = None self._controller = None self._required_mac_address = None self._discovery_duration = None self._connect_duration = None self._nuimo_connected = False self._nuimo_onboarding_attempts = 0 # A control flag not to do any action while restart # is underway self._bt_restart_underway = False
def _restart_bluetooth(self): """ Restarts BlueZ and hard resets the BT module. Sets the self._bt_restart_underway to false to signal the end of bt restart. It also reinitialises the python objects of this class responsible for interacting with the underlying bt infrastructure. """ hard_reset_module_cmd = "systemctl restart enable-bt-module" restart_bluez_cmd = "systemctl restart bluetooth" logger.debug("Hard restarting systemd bluetooth related services") subprocess.run(hard_reset_module_cmd.split()) subprocess.run(restart_bluez_cmd.split()) # Reinitialise the depend on the bt module # Assumed this is needed, not confirmed logger.debug("Reinitialisng python object after restart") del self._gatt_manager del self._manager self._gatt_manager = gatt.DeviceManager(self._adapter_name) self._manager = nuimo.ControllerManager(self._adapter_name) # This smells like it could cause trouble. # Do doubt it for it wasn't thought of deeply. del self._manager.listener self._manager.listener = self self._controller = None logger.debug("Powering BT module after restart") self._manager.is_adapter_powered = True self._bt_restart_underway = False logger.info("Bluetooth restart done")
def init_bt_connect_start(dev_id, dev_address, adapter_dev): """ init_bt_connect_start 함수 설명 : Bt_dev에 connect 상태로 저장된 장치의 실제 데이터를 받아 Bt_data DB에 저장함 상세 설명 1. 정상적으로 연결될 경우 : CONNECTING (연결시도) -> CONNECTED (연결됨) 2. Bt_dev status에는 connect 인데 실제로 연결이 안되는 경우 : CONNECTING (연결시도) -> CONNECT FAILED (연결실패) 3. 블루투스 연결이 중간에 종료될 경우 : DISCONNECT (연결종료) 4. 비정상적 종료시 : CONNECT EXIT (연결 강제 종료) 5. services_resolved 함수에서 GATT 프로파일의 서비스를 불러오고 characteristic_value_updated 함수에서 characteristics의 값을 계속 읽는 방식 6. 블루투스 장치에서 예를들어 38.5,46.2,96.5 의 값으로 넘어오면 ','로 파싱해서 DB에 저장 """ from .models import Bt_dev, Bt_data from django.db.models import Q import gatt global exit_signal manager = gatt.DeviceManager(adapter_name=adapter_dev) class AnyDevice(gatt.Device): def __init__(self, mac_address, manager, auto_reconnect=False): super().__init__(mac_address=mac_address, manager=manager) self.auto_reconnect = auto_reconnect self.init_connect_flag = True self.init_disconnect_flag = True def connect(self): print("[CONNECTING] {} : {} {} {}".format(model_dir, dev_id, dev_address, "연결중")) super().connect() def connect_succeeded(self): super().connect_succeeded() print("[CONNECTED] {} : {} {} {}".format(model_dir, dev_id, dev_address, "연결완료")) def connect_failed(self, error): super().connect_failed(error) print("[CONNECT FAILED] {} : {} {} {}".format(model_dir, dev_id, dev_address, "연결실패")) btdev = Bt_dev.objects.filter(bt_address=self.mac_address) for btv in btdev: # disconnect 상태로 변경 btv.status='disconnect' btv.save(update_fields=['status']) if "{}@{}".format(dev_id, dev_address) in connect_list: connect_list.remove("{}@{}".format(dev_id, dev_address)) manager.stop() raise CustomError("{}@{}".format(dev_id, dev_address)) def disconnect_succeeded(self): super().disconnect_succeeded() print("[DISCONNECTED] {} : {} {} {}".format(model_dir, dev_id, dev_address, "연결종료")) btdev = Bt_dev.objects.filter(bt_address=self.mac_address) for btv in btdev: # disconnect 상태로 변경 btv.status='disconnect' btv.save(update_fields=['status']) if "{}@{}".format(dev_id, dev_address) in connect_list: connect_list.remove("{}@{}".format(dev_id, dev_address)) if self.auto_reconnect: self.connect() manager.stop() # raise CustomError("{}@{}".format(dev_id, dev_address)) # 5. services_resolved 함수에서 GATT 프로파일의 서비스 정보를 볼러옴 def services_resolved(self): super().services_resolved() device_information_service = next( s for s in self.services if s.uuid == '0000ffe0-0000-1000-8000-00805f9b34fb') device_bluetooth_data = next( c for c in device_information_service.characteristics if c.uuid == '0000ffe1-0000-1000-8000-00805f9b34fb') device_bluetooth_data.enable_notifications() device_bluetooth_data.read_value() # 5-1. 매칭된 서비스의 characteristics의 값을 계속 읽어옴 def characteristic_value_updated(self, characteristic, value): try: if value==b'\x01' and self.init_connect_flag==True: # 초기 값 버림 self.init_connect_flag=False elif value==b'/' and self.init_connect_flag==True: # 초기 값 버림 self.init_connect_flag=False elif value==b'v' and self.init_connect_flag==True: # 초기 값 버림 self.init_connect_flag=False elif value==b'\r' and self.init_connect_flag==True: # 초기 값 버림 self.init_connect_flag=False else: # 6. 블루투스에서 예를 들어 38.5,46.2,96.5 의 값으로 넘어오면 ','로 파싱해서 Bt_data DB에 저장 new_bt_data = value.decode('utf-8').rstrip().strip() new_bt_data_sp=new_bt_data.split(',') new_btd = Bt_data(bt_id=dev_id, temp=float(new_bt_data_sp[0]), bpm=float(new_bt_data_sp[1]), battery=float(new_bt_data_sp[2])) new_btd.save() # DB에 저장 print("[UPDATE] {} : {} {}".format(model_dir, dev_id, new_bt_data)) except: print("[UPDATE FAIL] {} {} {}".format(model_dir, dev_id, value )) # 디버깅용 try: device = AnyDevice(mac_address=dev_address, manager=manager, auto_reconnect=False) device.connect() manager.run() except (CustomError, KeyboardInterrupt, SystemExit): if "{}@{}".format(dev_id, dev_address) in connect_list: connect_list.remove("{}@{}".format(dev_id, dev_address)) manager.stop()
def disconnect_succeeded(self): """Print the mac adress of the device disconnected """ super().disconnect_succeeded() print("[%s] Disconnected" % (self.mac_address)) def services_resolved(self): """Print the services and its characteristics if they are similar to the Lego Hub UUID """ super().services_resolved() print("[%s] Resolved services" % (self.mac_address)) for service in self.services: if service == LEGO_Hub_Service: print("[%s] Service [%s]" % (self.mac_address, service.uuid)) for characteristic in service.characteristics: if str(characteristic.uuid) == LEGO_Hub_Characteristic: print("[%s] Characteristic [%s]" % (self.mac_address, characteristic.uuid)) # Initialize the manager with the hci0 adaptater manager = gatt.DeviceManager(adapter_name='hci0') # Create the device device = AnyDevice(mac_address='90:84:2B:50:36:43', manager=manager) # Connect self to device device.connect() # The main loop that is necessary to receive Bluetooth events from the Bluetooth adapter manager.run() # It can be stopped by executing the stop() method
def __init__(self, adapter_name, device_mac): self.manager = gatt.DeviceManager(adapter_name) self.device_mac = device_mac self._connect()
import gatt manager = gatt.DeviceManager(adapter_name='hci0') # defines the device class AnyDevice(gatt.Device): def connect_succeeded(self): super().connect_succeeded() print("[%s] Connected" % (self.mac_address)) def connect_failed(self, error): super().connect_failed(error) print("[%s] Connection failed: %s" % (self.mac_address, str(error))) def disconnect_succeeded(self): super().disconnect_succeeded() print("[%s] Disconnected" % (self.mac_address)) def services_resolved(self): super().services_resolved() print("[%s] Resolved services" % (self.mac_address)) for service in self.services: print("[%s] Service [%s]" % (self.mac_address, service.uuid)) for characteristic in service.characteristics: print("[%s] Characteristic [%s]" % (self.mac_address, characteristic.uuid)) device = AnyDevice(mac_address='AA:BB:CC:DD:EE:FF', manager=manager) device.connect() manager.run()