def _connect(cfg, mqtt_client): address = cfg['address'] read_services = cfg['read'] write_services = cfg.get('write', None) try: print('Attempting to connect to host {}'.format(address)) p = btle.Peripheral(address, "random") except btle.BTLEException: print("Failed to connect to host {}".format(address)) return None print("Connected to {}".format(address)) chars_dict = dict() for svname, service in read_services.items(): for chname, ch in service['characteristics'].items(): chdev = enable_notify(p, service['UUID'], ch['UUID']) print('Notification enabled on {} ' 'for service {}'.format(ch['UUID'], service['UUID'])) chars_dict[chdev.getHandle()] = ch print('Characteristic {} on service {} is registered as name \'' '{}\''.format(ch['UUID'], service['UUID'], ch['mqtt_topic'])) if write_services is not None: for svname, service in write_services.items(): service_handle = p.getServiceByUUID(service['UUID']) for chname, ch in service['characteristics'].items(): write_char = service_handle.getCharacteristics(ch['UUID']) ch['write_char'] = write_char[0] print( 'Characteristic {} on service write enabled on {}'.format( ch['UUID'], service['UUID'], ch['mqtt_topic'])) p.setDelegate(BTLEDelegate(chars_dict, mqtt_client, True)) cfg['periferal'] = p return p
def connectproc(self): prevstate = self.connected self.conninprogress = True try: misc.addLog( rpieGlobals.LOG_LEVEL_INFO, "BLE connection initiated to " + str(self.taskdevicepluginconfig[0])) self.BLEPeripheral = btle.Peripheral( str(self.taskdevicepluginconfig[0])) self.connected = True self.afterconnection() except: self.setdisconnectstate() # disconnected! self.conninprogress = False self.isconnected() publishchange = (self.connected != prevstate) if self.connected: self.set_value(2, self.connected, publishchange) else: self.set_value(1, 0, False) self.set_value(2, 0, publishchange, suserssi=-100, susebattery=0) misc.addLog( rpieGlobals.LOG_LEVEL_ERROR, "BLE connection failed " + str(self.taskdevicepluginconfig[0])) return False if self.connected and self.handshake: misc.addLog( rpieGlobals.LOG_LEVEL_INFO, "BLE connected to " + str(self.taskdevicepluginconfig[0])) self.waitnotifications = True while self.waitnotifications: try: self.BLEPeripheral.waitForNotifications(0.5) except Exception as e: self.waitnotifications = False self.setdisconnectstate() # disconnected! self.setdisconnectstate(False) # disconnected!
def setblerequest(status, devicemac, bleHandle, bleValue): # Send the BLE request code via bluetooth to the valve global deviceblelock if trace: print("Connecting " + devicemac + "...") if deviceblelock == False: deviceblelock = True try: device = btle.Peripheral(str(devicemac)) bleValueByte = bleValue.encode('utf-8') device.writeCharacteristic(0x0073, bleValueByte, withResponse=True) except btle.BTLEDisconnectError: print( "Connection error when sending BLE message to valve (BTLEDisconnectError)" ) pass if trace: print("Wait " + str(waittime) + " seconds...") time.sleep(int(waittime)) device.disconnect() deviceblelock = False else: time.sleep(5) setblerequest(status, devicemac, bleHandle, bleValue)
def __enter__(self): """ Context manager __enter__ for connecting the device :rtype: btle.Peripheral :return: """ conn_state = "conn" if self._conn: # connection active, check if still connected try: conn_state = self._conn.getState() except (btle.BTLEInternalError, btle.BTLEDisconnectError): # connection not active, set _conn object to None self._conn = None if self._conn is None or conn_state != "conn": # no active connection, connect now self._conn = btle.Peripheral() self._conn.withDelegate(self) _LOGGER.debug("Trying to connect to %s", self._mac) self.connect(self._iface) _LOGGER.debug("Connected to %s", self._mac) return self
def getTemp(device): peripheralDevice = device randomAddress = 'random' print('[i] Connecting to {}'.format(peripheralDevice)) try: p = btle.Peripheral(peripheralDevice, randomAddress) except btle.BTLEDisconnectError: print('[w] Your BTLE device is not connected') print('[i] Quitting the program') exit(1) # for svc in p.getServices(): # print(f"Services : {svc.uuid.get}") svc = p.getServiceByUUID('e95d6100-251d-470a-a062-fa1922dfa9a8') temperature = svc.getCharacteristics( "e95d9250-251d-470a-a062-fa1922dfa9a8")[0] print('[i] End of the connection...') t = temperature.read() #a = accelerometer.read() #print("Temperature: {}".format(ord(t))) p.disconnect() return ord(t)
def InitPeripheralConnection(obj, address): global PeripheralConnection global PeripheralAddrName global SensorThread global lock_periphal global lock_CharRead tries = 0 #lock_periphal.acquire() try: while not PeripheralAddrName and not PeripheralConnection and tries < 10: #print( "connecting to %s ...." % (address)) try: if SensorThread: #print("Found SensorThread. Killing...") SensorThread.running = False time.sleep(5) PeripheralConnection = btle.Peripheral(address, addrType=btle.ADDR_TYPE_PUBLIC) #print("PeripheralConnection=%s" % (str(PeripheralConnection))) SensorThread = BLE_ReadSensorValues(PeripheralConnection, 4.5) SensorThread.start() PeripheralAddrName = address time.sleep(3) except Exception as e: if SensorThread: SensorThread.running = False #print("InitPeripheralConnection::Couldn't connect::", str(e)) tries += 1 #print("connection attempt %d (%s)" % (tries + 1, str(obj))) time.sleep(1) finally: pass
def get_services(self, device): print(f"{device.addr} - attempting to fetch services") if not device.connectable: # Device is not currently in connectable state print( f"{device.addr} - services could not be fetched (not connectable)" ) return [] try: # Connect to the device and fetch services peripheral = btle.Peripheral(device) services = peripheral.getServices() if services is None: # Device has no services print(f"{device.addr} - has no services") return [] services_dict = [] for service in services: # Get characteristics of service services_dict.append({ "uuid": service.uuid.getCommonName(), "characteristics": self.get_characteristics(service) }) print(f"{device.addr} - fetched {len(services_dict)} services") return services_dict except btle.BTLEDisconnectError as exception: print( f"{device.addr} - services could not be fetched ({exception})") return []
def sens_th1(mac): try: peripheral = btle.Peripheral(mac) characteristic = peripheral.readCharacteristic(0x28) (temp, humid, unknown1, unknown2, unknown3) = struct.unpack('<hhBBB', characteristic) sensorValue = { 'created': getTimeSTR(), 'Temperature': temp / 100, 'Humidity': humid / 100, 'external': unknown1, 'unknown2': unknown2, 'unknown3': unknown3, 'RAW': characteristic, } return sensorValue except btle.BTLEException as e: logging.warning("[sens_th1] bulepy Exception:{}" + format(e)) return None except Exception as e: logging.error("[sens_th1] Eception :{}" + format(e)) return None
def __init__(self, deviceAddress): btle.DefaultDelegate.__init__(self) # Address type must be "random" or it won't connect. self.peripheral = btle.Peripheral(deviceAddress, btle.ADDR_TYPE_RANDOM) self.peripheral.setDelegate(self) self.seq = 0 # Attribute UUIDs are identical to Ollie. self.antidos = self.getSpheroCharacteristic('2bbd') self.wakecpu = self.getSpheroCharacteristic('2bbf') self.txpower = self.getSpheroCharacteristic('2bb2') self.roll = self.getSpheroCharacteristic('2ba1') self.notify = self.getSpheroCharacteristic('2ba6') # This startup sequence is also identical to the one for Ollie. # It even uses the same unlock code. print 'Sending antidos' self.antidos.write('011i3', withResponse=True) print 'Sending txpower' self.txpower.write('\x0007', withResponse=True) print 'Sending wakecpu' self.wakecpu.write('\x01', withResponse=True)
def __init__(self, deviceAddress): btle.DefaultDelegate.__init__(self) self.curCoords = b'\x00\x00' self.startCoords = b'\x0c\xfb' self.endCoords = b'\xf5\x1d' self.panStatus = "" self.peripheral = btle.Peripheral(deviceAddress, btle.ADDR_TYPE_PUBLIC) self.peripheral.setDelegate(self) for svc in self.peripheral.services: print str(svc) self.service = self.peripheral.getServiceByUUID("0000fee9-0000-1000-8000-00805f9b34fb") #Quintic self.characteristic = self.service.getCharacteristics() for cha in self.characteristic: print str(cha) print "Notifications enabled" self.peripheral.writeCharacteristic(0x33, struct.pack('<BB', 0x01, 0x00), withResponse=True) self.peripheral.writeCharacteristic(0x30, struct.pack('<BB', 0x01, 0x00), withResponse=True) print "Device name:" hexdump(self.peripheral.readCharacteristic(0x0003)) uuidWrite = btle.UUID("d44bc439-abfd-45a2-b575-925416129600") #44, 0x2C uuidRead = btle.UUID("d44bc439-abfd-45a2-b575-925416129601") #47, 0x2F uuid = btle.UUID("d44bc439-abfd-45a2-b575-925416129610") #50, 0x32 self.chaWrite = self.service.getCharacteristics(uuidWrite)[0] self.chaRead = self.service.getCharacteristics(uuidRead)[0] self.cha = self.service.getCharacteristics(uuid)[0]
def device_add_command(address, addr_type): """Adds the device but does not connect to it. Arguments: address (str): The MAC address of the device. """ try: # check the mac address if is_valid_address(address): global devices # check that the device exists if address not in devices: # check the address type if addr_type == btle.ADDR_TYPE_PUBLIC or addr_type == btle.ADDR_TYPE_RANDOM: devices[address] = btle.Peripheral(address=address) else: click.secho('Cannot add device, device address type {} not valid!'.format(addr_type), fg='red') else: click.secho('Command cannot be run. Device {} already exists!'.format(address), fg='red') else: click.secho('Command cannot be run. Device MAC {} not valid!'.format(address), fg='red') except btle.BTLEException as e: click.secho('A BTLEException has occured!\n{}'.format(e), fg='red')
def read_data(address): print("Connecting to", address) data = '' tries = 5 while tries > 0: try: tries -= 1 dev = btle.Peripheral(address) service = dev.getServiceByUUID(btle.UUID(SVC_UUID)) for svc in dev.services: print(str(svc)) for ch in service.getCharacteristics(): print(str(ch)) idsChrc = service.getCharacteristics(btle.UUID(DEV_IDS_CHR))[0] attrChrc = service.getCharacteristics(btle.UUID(DEV_ATTR_CHRC))[0] idsBytes = idsChrc.read() attrBytes = attrChrc.read() ids = bytes(idsBytes) attrs = bytes(attrBytes).decode('utf-8') print("ids, attrs", ids, attrs) break except Exception as e: print(e) return data
def __init__(self, mac, mesh_name="unpaired", mesh_password="******"): """ Args : mac: The light's MAC address as a string in the form AA:BB:CC:DD:EE:FF mesh_name: The mesh name as a string. mesh_password: The mesh password as a string. """ self.mac = mac self.mesh_id = 0 self.btdevice = btle.Peripheral() self.session_key = None self.command_char = None self.mesh_name = mesh_name.encode() self.mesh_password = mesh_password.encode() # Light status self.white_brightness = None self.white_temp = None self.color_brightness = None self.red = None self.green = None self.blue = None self.mode = None self.status = None
def getInfo(self): # if properties=='READ', readType and readMsg info = { } # {service1:{chara1:[handle, properties, readType, readMsg], chara2}} try: d = btle.Peripheral(self.addr, self.addrType) except: return 1 try: for ser in d.getServices(): dict1 = {} for chara in ser.getCharacteristics(): list1 = [] list1.append(str(chara.getHandle())) list1.append(chara.propertiesToString()) if (chara.supportsRead()): list1.append(type(chara.read())) list1.append(chara.read()) dict1[str(chara)] = list1 info[str(ser)] = dict1 except: return 2 d.disconnect() return info
def main(): # get args args = get_args() print("Connecting…") nano_sense = btle.Peripheral(args.mac_address) print("Discovering Services…") _ = nano_sense.services environmental_sensing_service = nano_sense.getServiceByUUID("181A") print("Discovering Characteristics…") _ = environmental_sensing_service.getCharacteristics() updateTime = read_updateTime(environmental_sensing_service) while True: print("\n") read_temperature(environmental_sensing_service) read_humidity(environmental_sensing_service) read_pressure(environmental_sensing_service) #read_color(environmental_sensing_service) time.sleep(updateTime) # transmission frequency set on IoT device
def connect(self): #self.ble_device.connect() #print(self.ble_device) self.conn = btle.Peripheral(self.ble_device, btle.ADDR_TYPE_RANDOM) logger.debug("Attempting to discover characteristics...") #self.ble_device.discover([UART_SERVICE_UUID], [TX_CHAR_UUID, RX_CHAR_UUID]) #conn = btle.Peripheral(self.ble_device, btle.ADDR_TYPE_RANDOM) # Find the UART service and its characteristics. self.uart = self.conn.getServiceByUUID(UART_SERVICE_UUID) self.rx = self.uart.getCharacteristics(RX_CHAR_UUID)[0] self.tx = self.uart.getCharacteristics(TX_CHAR_UUID)[0] # Turn on notification of RX characteristics using the callback above. logger.debug('Subscribing to RX characteristic changes...') #self.rx.write(struct.pack('<bb',0x01,0x00)) # doesn't work. not sure why #conn.writeCharacteristic(handle=self.rx.getHandle(),val=struct.pack('<bb', 0x00, 0x00)) CONFIG_HANDLE = 0x000c self.conn.writeCharacteristic(handle=CONFIG_HANDLE, val=struct.pack('<bb', 0x01, 0x00)) self.conn.setDelegate(SimpleDelegate(bleconn=self))
def read(self): if (datetime.now() - timedelta(seconds=self.timeout) > self._last_read) and (self.busy == False): self._last_read = datetime.now() try: self.busy = True peripheral = btle.Peripheral(self.address) peripheral.writeCharacteristic(_HANDLE_WRITE_MODE_CHANGE, _DATA_MODE_CHANGE, withResponse=True) received_bytes = bytearray( peripheral.readCharacteristic(_HANDLE_READ_SENSOR_DATA)) # print("ble read ",received_bytes) # DEBUG! self._temperature, self._light, self._moisture, self._conductivity = unpack( '<hxIBhxxxxxx', received_bytes) self._temperature = float(self._temperature) / 10.0 peripheral.disconnect() self.busy = False return True except Exception as e: print(e) self.busy = False return False
def __init__(self,addr): self.address=addr self.dev=btle.Peripheral(self.address,u'random') self.position=0.0 self.velocity=0.0 self.torque=0.0 self.accel_x=0.0 self.accel_y=0.0 self.accel_z=0.0 self.temp=0 self.gyro_x=0 self.gyro_y=0 self.gyro_z=0 for v in self.dev.getCharacteristics(): if v.uuid==u'f1400001-8936-4d35-a0ed-dfcd795baa8c': self.motor_control_handle=v.getHandle() if v.uuid==u'f1400003-8936-4d35-a0ed-dfcd795baa8c': self.motor_led_handle=v.getHandle() if v.uuid==u'f1400004-8936-4d35-a0ed-dfcd795baa8c': self.motor_measurement_handle=v.getHandle() if v.uuid==u'f1400005-8936-4d35-a0ed-dfcd795baa8c': self.motor_imu_measurement_handle=v.getHandle() if v.uuid==u'f1400006-8936-4d35-a0ed-dfcd795baa8c': self.motor_settings_handle=v.getHandle()
def get_data(self, now=None): try: from bluepy import btle p = btle.Peripheral(self.address) #self.name = ''.join(map(chr, p.readCharacteristic(0x3))) #self.firmware = ''.join(map(chr, p.readCharacteristic(0x24))) if self.last_battery is None or ( utcnow() - self.last_battery).seconds >= 3600: self.battery = p.readCharacteristic(0x18)[0] self.last_battery = utcnow() delegate = XiomiHygroThermoDelegate() p.withDelegate(delegate) p.writeCharacteristic(0x10, bytearray([1, 0]), True) while not delegate.received: p.waitForNotifications(30.0) self.temperature = delegate.temperature self.humidity = delegate.humidity ok = True except Exception as ex: if isinstance(ex, btle.BTLEException): _LOGGER.warning("BT connection error: {}".format(ex)) else: _LOGGER.error("Unexpected error: {}".format(ex)) ok = False for i in [0, 1]: changed = self.entities[i].set_state( ok, self.battery, self.temperature if i == 0 else self.humidity) if (not now is None) and changed: self.entities[i].async_schedule_update_ha_state()
from bluepy import btle battery_handle = 0x0011 def get_battery(peripheral): """ returns the battery level of the myo """ return peripheral.readCharacteristic(battery_handle) if __name__ == "__main__": per = btle.Peripheral("EF:CD:C9:EA:16:6C") print get_battery(per)
from bluepy import btle btle_device = btle.Peripheral("00:13:AA:00:2A:9F") for service in btle_device.services: print(str(service))
print("Data received") #Get currente datetime now = datetime.datetime.now() #Is file exist, open it, create if not filename = now.strftime("%m-%y") + "_log.txt" #Open file in append mode file = open(filename, 'a') #Decide data decoded = data.decode('utf-8') #Write data with format a0,b0,...z0;a1,b1,..,z1;a2,b2,..,z2 writer = file.write(decoded + ';') BLELADDR = str("D4:36:39:67:7F:2A") p = btle.Peripheral(BLELADDR) p.withDelegate(ReadDelegate()) #Infinity loop while True: #Notification will be handled ever Data received while p.waitForNotifications(1): pass #Disconnect p.disconnect()
def __init__(self): self.dev = btle.Peripheral(iface=0) print(self.dev.iface)
def do_decode_pcap(self, args): """ Creates a FIFO pipe at /tmp/pipe by default (or this can be specified). Stream an input PCAP format to parse the BTLE data: > decode_pcap > decode_pcap /tmp/pipe For PCAP format (especially when using FIFO with Btlejack) use the 'll_phdr' format within the tool itself. E.g.: > btlejack -c <BDADDRESS> -w /tmp/pipe -x ll_phdr Or use a static PCAP file as an input (this will also parse out the Write/Read commands and Handles): > decode_pcap /home/user/test.pcap The supplemental arguments available are as follows: -a : Displays both inbound and outbound packets (Default: Outbound) -x : Displays data as raw hex rather than a decoded format -w : Add the Write commands to the internal storage for later replay via 'writeblk x' -r : Replay directly during PCAP parsing (Only via static PCAP file input) - Infers -w """ filename = self.FIFO fifo_scapy = False decode_val = True _view_response = False self._pcap_add_write_blk = False _replay = False args = shlex.split(args) for arg in args: if re.match('([/][\w\d]{1,})', arg) or re.match( '^((.+)\/([^/]+))$', arg): filename = arg continue elif arg == "-x": decode_val = False self.pp.info("Displaying Raw Hex") continue elif arg == "-a": _view_response = True self.pp.info("Displaying Inbound and Outbound") elif arg == "-w": self._pcap_add_write_blk = True elif arg == "-r": self._pcap_add_write_blk = True _replay = True if decode_val: self.pp.info("Decoding BLE Data") if not _view_response: self.pp.info("Displaying Outbound Only") if args: if re.match('([/][\w\d]{1,})', filename) and ".pcap" not in filename: self.pp.info(f"Parsing PCAP via FIFO: {filename}") self.FIFO = filename fifo_scapy = True elif ".pcap" in filename: self.pp.info(f"Parsing PCAP as file: {filename}") fifo_scapy = False if fifo_scapy or not args: if os.path.exists(filename): self.pp.info(f"Using FIFO Pipe: {self.FIFO}") else: self.pp.info(f"Creating FIFO Pipe: {self.FIFO}") try: self.make_pipe() except: try: self.destroy_pipe() self.make_pipe() except: self.pp.error( f"Error: Unable to make pipe: {self.FIFO}") return self.pp.info("FIFO opened") fifo = open(filename, "rb", buffering=0) self._decode_pcap_fifo = True self.pp.ok("Opcode Command : Handle : Data") while True: try: for pkt in (PcapReader(fifo)): try: self.parse_pcap(pkt, decode_val, _view_response) except: continue except: self.pp.info("Exited Decoder") self.destroy_pipe() if self._target_changed_pcap_decode and self._pcap_add_write_blk: self.pp.ok(f"Set new target as {self._target}") return else: self._decode_pcap_fifo = False self.pp.ok("Opcode Command : Handle : Data") for pkt in PcapReader(filename): self.parse_pcap(pkt, decode_val, _view_response) if self._target_changed_pcap_decode and self._pcap_add_write_blk: self.pp.ok(f"Set new target as {self._target}") if _replay: try: _device = btle.Peripheral(self._target, addrType=self._hci_type, iface=int(self._interface)) except: self.pp.error("Error: Unable to connect") return for x in self._block_data: self.pp.info(f"Sending write cmd: {x}") self.write(x, _device)
if data[0] == 'I': print("Interaction Code: %s" % payload[0]) else: print("handleNotification handle 0x%04X unknown" % (cHandle)) notifOn = b"\x01\x00" notifOff = b"\x00\x00" gf_ble_mac = "BB:A0:50:03:31:19" GATTUUID = "0000cdd0-0000-1000-8000-00805f9b34fb" WRITEUUID = "0003cdd2-0000-1000-8000-00805f9b0131" NOTIFYUUID = "0003cdd1-0000-1000-8000-00805f9b0131" print("Connecting to BLE device MAC: " + gf_ble_mac) per = btle.Peripheral(gf_ble_mac) services = per.getServices() services[2].getCharacteristics(WRITEUUID) gfService = per.getServiceByUUID(GATTUUID) writechar = gfService.getCharacteristics(WRITEUUID)[0] writehandle = gfService.getCharacteristics(WRITEUUID)[0].getHandle() notifychar = gfService.getCharacteristics(NOTIFYUUID)[0] notifyhandle = gfService.getCharacteristics(NOTIFYUUID)[0].getHandle() per.withDelegate(MyDelegate(notifyhandle)) print("Enabling notifications...") char = per.getCharacteristics(uuid=NOTIFYUUID)[0] ccc_desc = char.getDescriptors(forUUID=0x2902)[0] ccc_desc.write(notifOn, withResponse=True) print("\tDone") per.waitForNotifications(0.5)
def do_writeblk(self, args): """ Enter multiple 'write' commands as 'Handle Data': > write > 0x1e 5468697349736154657374 > 0x09 5468697349736154657374 > 0xa3 5468697349736154657374 > end Note: If you suffix the command with 'string' this will be converted to a hex string: > write > 0x1e 5468697349736154657374 > 0x09 'ThisIsATest' string > 0xa3 5468697349736154657374 > end Alternatively, if you've already run a block previously, you can re-run this by sending the 'x' argument: > write -x """ _send_stored_block = False _send_repeat = False args = shlex.split(args) for arg in args: if arg == "-x": _send_stored_block = True if _send_stored_block is False: self._block_data = [] _block_input = "" self.pp.info( "Enter one command per line as 'handle data' and then 'end' to finish. E.g: 0x1e 305721e4a290 " ) while True: _block_input = input() if _block_input.lower() != "end": self._block_data.append(_block_input) else: self.pp.info("Write command input finished!") _send_stored_block = True break if len(self._block_data) > 0 and _send_stored_block: self.pp.info("Sending previous block of write commands...") self.pp.info("Connecting...") try: _device = btle.Peripheral(self._target, addrType=self._hci_type, iface=int(self._interface)) except: self.pp.error("Error: Unable to connect") return self.pp.ok(f"Connected to {self._target}") for x in self._block_data: self.pp.info(f"Sending write cmd: {x}") self.write(x, _device) self.pp.ok("Commands sent") else: self.pp.warn("No write commands specified")
def do_scan(self, args): """ Perform a BLE scan for devices within range. Optional argument is a timeout for scan time: > scan > scan 3 > scan 20 """ if not self._interface: return # Set scanner timeout - default 5 seconds if args: _timeout = int(args) else: _timeout = 2 # Start scanner self.pp.info("Starting BLE scan...") scanner = btle.Scanner(self._interface) try: self._devices = scanner.scan(timeout=_timeout) except: self.pp.error( f"Error: Can't connect to Bluetooth interface hci{self._interface}" ) return self.pp.ok("Scan complete!") self.pp.info( f"Identifying device names for {str(len(self._devices))} devices.." ) _headerrow = [ 'Bluetooth Address', 'Device Name', 'RSSI', 'Connectable', 'Address Type' ] self._targetcompletions = [] _rows = [] self._disc_devices = [] for x in self._devices: _address = x.addr _rssi = x.rssi if _rssi > -50: _rssi = self.pp.green(str(_rssi)) elif _rssi <= -50 and _rssi > -65: _rssi = self.pp.yellow(str(_rssi)) else: _rssi = self.pp.red(str(_rssi)) _type = x.addrType if x.connectable == 1 or x.connectable == "1": _connect = True _connect_str = self.pp.green("True") else: _connect = False _connect_str = self.pp.red("False") # Attempt to read Device Name if _connect and _type.lower().strip() == "public": try: _device = btle.Peripheral(_address, addrType=self._hci_type, iface=int(self._interface)) _device_name = _device.readCharacteristic(0x3).decode( "utf-8") _device.disconnect() except: _device_name = "" else: _device_name = "" _row = [_address, _device_name, _rssi, _connect_str, _type] self._targetcompletions.append(_address) _rows.append(_row) self._disc_devices.append(_row) self.displayDevices("")
for x in range(0, len(device_addr)): os.system("sudo hciconfig hci0 down") time.sleep(1) os.system("sudo hciconfig hci0 up") time.sleep(1) print("connecting to %s ... " % (device_addr[x])) textout = open("/home/pi/temp_log.txt", "a") textout.write("\nconnecting to %s at " % device_addr[x]) textout.write(now.strftime("%m-%d-%Y %H:%M") + "\n") try: dev = btle.Peripheral(device_addr[x], "random") dev.setDelegate(MyDelegate()) print("connected") service_uuid = btle.UUID(BLE_SERVICE_UUID) ble_service = dev.getServiceByUUID(service_uuid) uuidConfig = btle.UUID(BLE_CHARACTERISTIC_UUID) data_chrc = ble_service.getCharacteristics(uuidConfig)[0] data_chrc = data_chrc.valHandle + 1 dev.writeCharacteristic(data_chrc, "\x01\x00") time.sleep(1.0) # Allow sensor to stabilise while True:
print( "Offset calibration and 2 Point calibration can't be used together" ) os._exit(1) if not args.name: args.name = args.device if args.callback: dataThread = threading.Thread(target=thread_SendingData) dataThread.start() signal.signal(signal.SIGINT, signal_handler) if args.device: p = btle.Peripheral() cnt = 0 connected = False #logging.basicConfig(level=logging.DEBUG) logging.basicConfig(level=logging.ERROR) logging.debug("Debug: Starting script...") pid = os.getpid() bluepypid = None unconnectedTime = None connectionLostCounter = 0 watchdogThread = threading.Thread(target=watchDog_Thread) watchdogThread.start() logging.debug("watchdogThread started")
def _connect(self): logging.info("Connecting...") self.conn = btle.Peripheral(self.device_mac, btle.ADDR_TYPE_RANDOM) #self.conn.setSecurityLevel("medium") logging.info("Connected...") self._enable()