def readTilt(cache): dev_id = 0 while True: try: logTilt("Starting Bluetooth connection") sock = bluez.hci_open_dev(dev_id) blescan.hci_le_set_scan_parameters(sock) blescan.hci_enable_le_scan(sock) while True: beacons = distinct(blescan.parse_events(sock, 10)) for beacon in beacons: if beacon['uuid'] in list(TILTS.keys()): cache[TILTS[beacon['uuid']]] = { 'Temp': beacon['major'], 'Gravity': beacon['minor'] } #logTilt("Tilt data received: Temp %s Gravity %s" % (beacon['major'], beacon['minor'])) time.sleep(4) except Exception as e: logTilt("Error starting Bluetooth device, exception: %s" % str(e)) logTilt("Restarting Bluetooth process in 10 seconds") time.sleep(10)
def perform_scan(dev_id = SCAN_DEVICE): sock = bluez.hci_open_dev(dev_id) mode = read_inquiry_mode(sock) if mode != 1: write_inquiry_mode(sock, 1) names = {} for line in bluetooth.discover_devices(duration=5, lookup_names=True, device_id = dev_id): names[line[0].lower()] = line[1] devices = {} for line in device_inquiry_with_with_rssi(sock): addr = line[0].lower() rssi = line[1] if addr in devices: devices[addr].append(rssi) else: devices[addr] = [rssi] result = {} for addr in names: name = names[addr] if addr not in devices: continue rssis = devices[addr]; result[addr] = [name, sum(rssis) / len(rssis)] return result
def monitor(opts, dev_id=0): mqtt_config = { 'server': opts.mqttserver, 'port': opts.mqttport if opts.mqttport else PORT, 'topic_prefix': opts.mqtttopic if opts.mqtttopic else TOPIC_PREFIX } try: sock = bluez.hci_open_dev(dev_id) except: print("FATAL: Can't access bluetooth device...") sys.exit(1) hci_le_set_scan_parameters(sock) hci_enable_le_scan(sock) while True: alive = {} dead = [] reports = process_brewometers(sock) for addr, report in reports.iteritems(): now = time.time() if now - report['timestamp'] > TIMEOUT: dead.append(addr) else: alive[addr] = report if opts.mqttserver: publish_mqtt(mqtt_config, alive) if dead: print("Brewometers: %s are no longer reporting.." % dead) for addr in dead: del brewometers[addr]
def _gethcisock (device_id = -1): try: sock = _bt.hci_open_dev (device_id) return sock except: debug("error accessing bluetooth device") exit(0)
def set_bt_name(name, src_hci, src, dst): """ Sets the name of the local bluetooth device to 'name'. Params: - 'name' - The new name of the device - 'src_hci' - Name of the bluetooth device to change the name of - 'src' - The bluetooth address of the local device - 'dst' - Bluetooth address of a remote device to temporarily connect with (sets the REMOTE_NAME in 'dst') """ # Create raw HCI sock to set our BT name raw_sock = bt.hci_open_dev(bt.hci_devid(src_hci)) flt = bt.hci_filter_new() bt.hci_filter_all_ptypes(flt) bt.hci_filter_all_events(flt) raw_sock.setsockopt(bt.SOL_HCI, bt.HCI_FILTER, flt) # Send raw HCI command to controller (first 3 bytes are padding for alignment) raw_sock.sendall( binascii.unhexlify('01130cf8cccccc') + name.ljust(MAX_BT_NAME, b'\x00')) raw_sock.close() time.sleep(0.1) # Connect to BNEP to "refresh" the name bnep = bluetooth.BluetoothSocket(bluetooth.L2CAP) bnep.bind((src, 0)) bnep.connect((dst, BNEP_PSM)) bnep.close() # Close ACL connection again util.exec_command_block(["hcitool", "dc", dst])
def advertisment(self): """Get values for the accesories of the airpod and genrates an le advertising with them """ if self.args.random: left_speaker, right_speaker, case = self.random_values() else: left_speaker = (100,) right_speaker = (100,) case = (100,) interval = self.args.interval toggle_device(self.args.ble_iface, True) data1 = (0x1e, 0xff, 0x4c, 0x00, 0x07, 0x19, 0x01, 0x02, 0x20, 0x75, 0xaa, 0x30, 0x01, 0x00, 0x00, 0x45) data2 = (0xda, 0x29, 0x58, 0xab, 0x8d, 0x29, 0x40, 0x3d, 0x5c, 0x1b, 0x93, 0x3a) try: sock = bluez.hci_open_dev(args.ble_iface) except: print(f"Cannot open bluetooth device {self.args.ble_iface}") return try: print("Start advertising press ctrl + c to quit...") start_le_advertising(sock, adv_type=0x03, min_interval=interval, max_interval=interval, data=(data1 + left_speaker + right_speaker + case + data2)) while True: sleep(2) except: stop_le_advertising(sock) print() print("Bye")
def get_RSSI(addr): # Open an hci socket hci_sock = bluez.hci_open_dev() hci_fd = hci_sock.fileno () # Try to open a connection to remote BT device try: bt_sock = bluez.SDPSession () bt_sock.connect(addr) except: bt_sock.close() hci_sock.close() return None # Get handle to ACL connection to remote BT device reqstr = struct.pack ("6sB17s", bluez.str2ba (addr), bluez.ACL_LINK, "\0" * 17) request = array.array ("c", reqstr) fcntl.ioctl (hci_fd, bluez.HCIGETCONNINFO, request, 1) handle = struct.unpack ("8xH14x", request.tostring ())[0] # Get RSSI cmd_pkt=struct.pack('H', handle) RSSI = bluez.hci_send_req(hci_sock, bluez.OGF_STATUS_PARAM, bluez.OCF_READ_RSSI, bluez.EVT_CMD_COMPLETE, 4, cmd_pkt) RSSI = struct.unpack('b', RSSI[3])[0] bt_sock.close() hci_sock.close() return RSSI
def adv_airdrop(self): while True: dev_id = self.dev_id toggle_device(dev_id, True) header = (0x02, 0x01, 0x1a, 0x1b, 0xff, 0x4c, 0x00) data1 = (0x05, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01) apple_id = (0x00, 0x00) phone = (0x00, 0x00) email = (0xb7, 0x9b) data2 = (0x00, 0x00, 0x00, 0x10, 0x02, 0x0b, 0x00) try: sock = bluez.hci_open_dev(dev_id) except: print("Cannot open bluetooth device %i" % dev_id) raise start_le_advertising(sock, adv_type=0x02, min_interval=500, max_interval=500, data=(header + data1 + apple_id + phone + email + data2)) time.sleep(10) stop_le_advertising(sock)
def _open_bluetooth(self): try: self._dev_sock = bluez.hci_open_dev(0) except: logging.error("Fail to open bluetooth device.") return False return True
def find_local_bdaddr(self): dev_id = 0 hci_sock = _bt.hci_open_dev(dev_id) old_filter = hci_sock.getsockopt( _bt.SOL_HCI, _bt.HCI_FILTER, 14) flt = _bt.hci_filter_new() opcode = _bt.cmd_opcode_pack(_bt.OGF_INFO_PARAM, _bt.OCF_READ_BD_ADDR) _bt.hci_filter_set_ptype(flt, _bt.HCI_EVENT_PKT) _bt.hci_filter_set_event(flt, _bt.EVT_CMD_COMPLETE); _bt.hci_filter_set_opcode(flt, opcode) hci_sock.setsockopt(_bt.SOL_HCI, _bt.HCI_FILTER, flt) _bt.hci_send_cmd(hci_sock, _bt.OGF_INFO_PARAM, _bt.OCF_READ_BD_ADDR) pkt = hci_sock.recv(255) status,raw_bdaddr = struct.unpack("xxxxxxB6s", pkt) assert status == 0 t = [ "%X" % ord(b) for b in raw_bdaddr ] t.reverse() bdaddr = ":".join(t) # restore old filter hci_sock.setsockopt( _bt.SOL_HCI, _bt.HCI_FILTER, old_filter ) return bdaddr
def rssi_main(): dev_id = 0 try: sock = bluez.hci_open_dev(dev_id) except: print("error accessing bluetooth device...") sys.exit(1) try: mode = read_inquiry_mode(sock) except Exception as e: print("error reading inquiry mode. ") print("Are you sure this a bluetooth 1.2 device?") print(e) sys.exit(1) print("current inquiry mode is %d" % mode) if mode != 1: print("writing inquiry mode...") try: result = write_inquiry_mode(sock, 1) except Exception as e: print("error writing inquiry mode. Are you sure you're root?") print(e) sys.exit(1) if result != 0: print("error while setting inquiry mode") #print("result: %d" % result) devs = device_inquiry_with_with_rssi(sock) return devs
def setup_bluetooth(): #Open bluetooth device try: bt_device = bluez.hci_open_dev(dev_id) except Exception as e: errorMsg("Error accessing bluetooth device:", e) #Read the inquiry mode try: mode = read_inquiry_mode(bt_device) except Exception as e: errorMsg("Error reading inquiry mode:", e) #Write inquiry mode if mode != 1: try: result = write_inquiry_mode(bt_device, 1) if result != 0: errorMsg("Error while setting inquiry mode:", None) except Exception as e: errorMsg("Error writing inquiry mode:", e) #Return bluetooth device if setup sucessful return bt_device
def le_set_scan_response_data( self, cmd_params={ 'Scan_Response_Data_Length': 0x1f, 'Scan_Response_Data': bytes(0x1f) } ) -> dict: dd = hci_open_dev(self.devid) bin_cmd_params = cmd_params['Scan_Response_Data_Length'].to_bytes(1, 'little') + \ cmd_params['Scan_Response_Data'] flt = hci_filter_new() hci_filter_set_ptype(flt, HCI_EVENT_PKT) hci_filter_set_event(flt, EVT_CMD_COMPLETE) hci_filter_set_opcode( flt, cmd_opcode_pack(OGF_LE_CTL, OCF_LE_SET_SCAN_RESPONSE_DATA)) dd.setsockopt(SOL_HCI, HCI_FILTER, flt) hci_send_cmd(dd, OGF_LE_CTL, OCF_LE_SET_SCAN_RESPONSE_DATA, bin_cmd_params) event_params = dd.recv(3 + EVT_CMD_COMPLETE_SIZE + 1)[3:] num_hci_cmd_pkts, cmd_opcode, status = struct.unpack( '<BHB', event_params) event_params = { 'Num_HCI_Command_Packets': num_hci_cmd_pkts, 'Command_Opcode': cmd_opcode, 'Status': status } hci_close_dev(dd.fileno()) return event_params
def getRSSI(self): """Detects whether the device is near by or not""" addr = self.address # Open hci socket hci_sock = bt.hci_open_dev() hci_fd = hci_sock.fileno() # Connect to device (to whatever you like) bt_sock = bluetooth.BluetoothSocket(bluetooth.L2CAP) bt_sock.settimeout(10) result = bt_sock.connect_ex((addr, 1)) # PSM 1 - Service Discovery try: # Get ConnInfo reqstr = struct.pack("6sB17s", bt.str2ba(addr), bt.ACL_LINK, "\0" * 17) request = array.array("c", reqstr ) handle = fcntl.ioctl(hci_fd, bt.HCIGETCONNINFO, request, 1) handle = struct.unpack("8xH14x", request.tostring())[0] # Get RSSI cmd_pkt=struct.pack('H', handle) rssi = bt.hci_send_req(hci_sock, bt.OGF_STATUS_PARAM, bt.OCF_READ_RSSI, bt.EVT_CMD_COMPLETE, 4, cmd_pkt) rssi = struct.unpack('b', rssi[3])[0] # Close sockets bt_sock.close() hci_sock.close() return rssi except Exception, e: return None
def _init_bluetooth(): os.system("sudo hciconfig hci0 down") os.system("sudo hciconfig hci0 up") try: return bluez.hci_open_dev(0) except: sys.exit(1)
def main(): dev_id = 0 try: sock = bluez.hci_open_dev(dev_id) except: print("error accessing bluetooth device...") sys.exit(1) try: mode = read_inquiry_mode(sock) except Exception as e: print("error reading inquiry mode. ") print("Are you sure this a bluetooth 1.2 device?") print(e) sys.exit(1) #print("current inquiry mode is %d" % mode) if mode != 1: print("writing inquiry mode...") try: result = write_inquiry_mode(sock, 1) except Exception as e: print("error writing inquiry mode. Are you sure you're root?") print(e) sys.exit(1) if result != 0: print("error while setting inquiry mode") print("result: %d" % result) device_inquiry_with_with_rssi(sock)
def read_Sg(): try: sock = bluez.hci_open_dev(dev_id) except: print("error accessing bluetooth device...") sys.exit(1) blescan.hci_le_set_scan_parameters(sock) blescan.hci_enable_le_scan(sock) #gotData = 0 #while (gotData == 0): returnedList = blescan.parse_events(sock, 10) for beacon in returnedList: #returnedList is a list datatype of string datatypes seperated by commas (,) output = beacon.split( ',') #split the list into individual strings in an array if output[1] == green: #Change this to the colour of you tilt #gotData = 1 tiltSG = int(output[3], 16) / 1000 print("testing") print(tiltSG) print("-----") blescan.hci_disable_le_scan(sock) return tiltSG
def bluetooth_init (): dev_id = 0 try: sock = bluez.hci_open_dev(dev_id) except: print("error accessing bluetooth device...") sys.exit(1) try: mode = read_inquiry_mode(sock) except Exception as e: print("error reading inquiry mode. ") print("bluetooth is OFF, please turn it ON") print(e) sys.exit(1) #print("current inquiry mode is %d" % mode) if mode != 1: print("writing inquiry mode...") try: result = write_inquiry_mode(sock, 1) except Exception as e: print("error writing inquiry mode. Are you sure you're root?") print(e) sys.exit(1) if result != 0: print("error while setting inquiry mode") print("result: %d" % result) return sock
def main(): dev_id = 0 loadXML() try: sock = bluez.hci_open_dev(dev_id) print "ble thread started" except: print "error accessing bluetooth device..." sys.exit(1) blescan.hci_le_set_scan_parameters(sock) print "set ble scan parameters" blescan.hci_enable_le_scan(sock) print "enable ble" #blescan.initSerial() thread1 = threading.Thread(target = blescan.parse_events, args = (sock, )) thread1.start() thread2 = threading.Thread(target = blescan.checkAndPrint, args = ( )) thread2.start() while True: time.sleep(1) if len(blescan.postList) > 0: #and internet_on(): #print "now start to post ..." lock1 = threading.Lock() lock1.acquire() #postXML(blescan.postList) lock1.release()
def bcm_write_local_bdaddr(adapter: int, dsbtaddr: str) -> None: import bluetooth._bluetooth as _bt try: # Open hci socket hci_sock = _bt.hci_open_dev(adapter) # Get bytes from bluetooth address baddrtospoof = bytearray.fromhex(dsbtaddr.replace(":", "")) baddrtospoof.reverse() # Send HCI request cmd_pkt = bytes(baddrtospoof) # BCM WRITE ADDR command # https://github.com/pauloborges/bluez/blob/master/tools/bdaddr.c _bt.hci_send_req( hci_sock, _bt.OGF_VENDOR_CMD, 0x0001, #OCF_BCM_WRITE_BD_ADDR 0x00000000, 1000, cmd_pkt) hci_sock.close() except _bt.error as e: raise BluetoothError(*e.args)
def lookup_name(self,address, device=-1, timeout=10): """ Linux only Tries to determine the friendly name (human readable) of the device with the specified bluetooth address. Returns the name on success, and None on failure. timeout=10 how many seconds to search before giving up. """ logger.debug("Device: %s " % (device)) if sys.platform == "linux2": # NOTE: I had to rewrite this for the latest bluez, # the reason this is complicated is because I need to select the device, # before making the call. # http://code.google.com/p/pybluez/source/detail?spec=svn27&r=22 if not bluetooth.is_valid_address(address): raise ValueError("%s is not a valid Bluetooth address" % address) try: sock = _bt.hci_open_dev (device) except: raise ValueError("error accessing bluetooth device") timeoutms = int (timeout * 1000) try: name = _bt.hci_read_remote_name (sock, address, timeoutms) except _bt.error, e: # name lookup failed. either a timeout, or I/O error name = None sock.close() return name
def read_remote_supported_features(self, cmd_params: dict) -> dict: ''' cmd_params -- {'Connection_Handle': 0x0000 to 0x0EFF} ''' dd = hci_open_dev(self.devid) bin_cmd_params = cmd_params['Connection_Handle'].to_bytes(2, 'little') flt = hci_filter_new() hci_filter_set_ptype(flt, HCI_EVENT_PKT) hci_filter_set_event(flt, EVT_READ_REMOTE_FEATURES_COMPLETE) dd.setsockopt(SOL_HCI, HCI_FILTER, flt) hci_send_cmd(dd, OGF_LINK_CTL, OCF_READ_REMOTE_FEATURES, bin_cmd_params) while True: event_params = dd.recv(3 + EVT_READ_REMOTE_FEATURES_COMPLETE_SIZE)[3:] status, conn_handle, lmp_features = struct.unpack( '<BH8s', event_params) event_params = { 'Status': status, 'Connection_Handle': conn_handle, 'LMP_Features': lmp_features } if event_params['Connection_Handle'] == cmd_params[ 'Connection_Handle']: break hci_close_dev(dd.fileno()) return event_params
def set_event_filter(self, cmd_params: dict) -> dict: '''A little complicated. see the core specification BLUETOOTH CORE SPECIFICATION Version 5.2 | Vol 4, Part E page 2078. Only support Filter_Type = 0x00 now. ''' dd = hci_open_dev(self.devid) bin_cmd_params = cmd_params['Filter_Type'].to_bytes(1, 'little') flt = hci_filter_new() hci_filter_set_ptype(flt, HCI_EVENT_PKT) hci_filter_set_event(flt, EVT_CMD_COMPLETE) hci_filter_set_opcode(flt, cmd_opcode_pack(OGF_HOST_CTL, OCF_SET_EVENT_FLT)) dd.setsockopt(SOL_HCI, HCI_FILTER, flt) hci_send_cmd(dd, OGF_HOST_CTL, OCF_SET_EVENT_FLT, bin_cmd_params) event_params = dd.recv(3 + EVT_CMD_COMPLETE_SIZE + 1)[3:] num_hci_cmd_pkts, cmd_opcode, status = struct.unpack( '<BHB', event_params) event_params = { 'Num_HCI_Command_Packets': num_hci_cmd_pkts, 'Command_Opcode': cmd_opcode, 'Status': status } hci_close_dev(dd.fileno()) return event_params
def create_connection_cancel(self, cmd_params: dict) -> dict: ''' cmd_params -- { 'BD_ADDR': str } ''' dd = hci_open_dev(self.devid) bin_cmd_params = bytes.fromhex(cmd_params['BD_ADDR'].replace(':', '')[::-1]) flt = hci_filter_new() hci_filter_set_ptype(flt, HCI_EVENT_PKT) hci_filter_set_event(flt, EVT_CMD_COMPLETE) hci_filter_set_opcode( flt, cmd_opcode_pack(OGF_LINK_CTL, OCF_CREATE_CONN_CANCEL)) dd.setsockopt(SOL_HCI, HCI_FILTER, flt) hci_send_cmd(dd, OGF_LINK_CTL, OCF_CREATE_CONN_CANCEL, bin_cmd_params) event_params = dd.recv(3 + EVT_CMD_COMPLETE_SIZE + 7)[3:] num_hci_cmd_pkts, cmd_opcode, status, \ bdaddr = struct.unpack('<BHB6s', event_params) hci_close_dev(dd.fileno()) return event_params
def disconnect(self, cmd_params: dict) -> dict: ''' cmd_params -- { 'Connection_Handle': int, 2 bytes, 'Reason': int, 1 bytes } ''' dd = hci_open_dev(self.devid) flt = hci_filter_new() hci_filter_clear(flt) hci_filter_set_ptype(flt, HCI_EVENT_PKT) hci_filter_set_event(flt, EVT_DISCONN_COMPLETE) dd.setsockopt(SOL_HCI, HCI_FILTER, flt) bin_cmd_params = cmd_params['Connection_Handle'].to_bytes(2, 'little') + \ cmd_params['Reason'].to_bytes(1, 'little') hci_send_cmd(dd, OGF_LINK_CTL, OCF_DISCONNECT, bin_cmd_params) # Receive and exclude HCI packet type (1 B) event_params = dd.recv(3 + EVT_DISCONN_COMPLETE_SIZE)[3:] status, conn_handle, reason, = struct.unpack('<BHB', event_params) event_params = { 'Status': status, 'Connection_Handle': conn_handle, 'Reason': reason } hci_close_dev(dd.fileno()) return event_params
def exit_periodic_inquiry_mode(self) -> dict: ''' Return -- { 'Num_HCI_Command_Packets': int, 'Command_Opcode': int, 'Status': int } ''' dd = hci_open_dev(self.devid) flt = hci_filter_new() hci_filter_set_ptype(flt, HCI_EVENT_PKT) hci_filter_set_event(flt, EVT_CMD_COMPLETE) hci_filter_set_opcode( flt, cmd_opcode_pack(OGF_LINK_CTL, OCF_EXIT_PERIODIC_INQUIRY)) dd.setsockopt(SOL_HCI, HCI_FILTER, flt) hci_send_cmd(dd, OGF_LINK_CTL, OCF_EXIT_PERIODIC_INQUIRY) event_params = dd.recv(3 + EVT_CMD_COMPLETE_SIZE + 1)[3:] num_hci_cmd_pkts, cmd_opcode, status = struct.unpack( '<BHB', event_params) event_params = { 'Num_HCI_Command_Packets': num_hci_cmd_pkts, 'Command_Opcode': cmd_opcode, 'Status': status } hci_close_dev(dd.fileno()) return status
def read_bd_addr(self) -> dict: r"""'Return BD_ADDR string "XX:XX:XX:XX:XX:XX'""" dd = hci_open_dev(self.devid) flt = hci_filter_new() hci_filter_set_ptype(flt, HCI_EVENT_PKT) hci_filter_set_event(flt, EVT_CMD_COMPLETE) hci_filter_set_opcode( flt, cmd_opcode_pack(OGF_INFO_PARAM, OCF_READ_BD_ADDR)) dd.setsockopt(SOL_HCI, HCI_FILTER, flt) hci_send_cmd(dd, OGF_INFO_PARAM, OCF_READ_BD_ADDR) event_params = dd.recv(HCI_MAX_EVENT_SIZE)[3:] num_hci_cmd_pkts, cmd_opcode, status, bd_addr = struct.unpack( "<BHB6s", event_params) bd_addr = ["%02X" % b for b in bd_addr] bd_addr.reverse() event_params = { 'Num_HCI_Command_Packets': num_hci_cmd_pkts, 'Command_Opcode': cmd_opcode, 'Status': status, 'BD_ADDR': ':'.join(bd_addr) } hci_close_dev(dd.fileno()) return event_params
def read_local_bdaddr(): try: hci_sock = _bt.hci_open_dev(0) old_filter = hci_sock.getsockopt(_bt.SOL_HCI, _bt.HCI_FILTER, 14) flt = _bt.hci_filter_new() opcode = _bt.cmd_opcode_pack(_bt.OGF_INFO_PARAM, _bt.OCF_READ_BD_ADDR) _bt.hci_filter_set_ptype(flt, _bt.HCI_EVENT_PKT) _bt.hci_filter_set_event(flt, _bt.EVT_CMD_COMPLETE) _bt.hci_filter_set_opcode(flt, opcode) hci_sock.setsockopt(_bt.SOL_HCI, _bt.HCI_FILTER, flt) _bt.hci_send_cmd(hci_sock, _bt.OGF_INFO_PARAM, _bt.OCF_READ_BD_ADDR) pkt = hci_sock.recv(255) status, raw_bdaddr = struct.unpack("xxxxxxB6s", pkt) assert status == 0 t = ["%02X" % get_byte(b) for b in raw_bdaddr] t.reverse() bdaddr = ":".join(t) # restore old filter hci_sock.setsockopt(_bt.SOL_HCI, _bt.HCI_FILTER, old_filter) return [bdaddr] except _bt.error as e: raise BluetoothError(*e.args)
def getRSSI(self): """Detects whether the device is near by or not using RSSI""" addr = self.address # Open hci socket hci_sock = bt.hci_open_dev() hci_fd = hci_sock.fileno() # Connect to device (to whatever you like) bt_sock = bluetooth.BluetoothSocket(bluetooth.L2CAP) bt_sock.settimeout(10) result = bt_sock.connect_ex((addr, 1)) # PSM 1 - Service Discovery try: # Get ConnInfo reqstr = struct.pack("6sB17s", bt.str2ba(addr), bt.ACL_LINK, "\0" * 17) request = array.array("c", reqstr ) handle = fcntl.ioctl(hci_fd, bt.HCIGETCONNINFO, request, 1) handle = struct.unpack("8xH14x", request.tostring())[0] # Get RSSI cmd_pkt=struct.pack('H', handle) rssi = bt.hci_send_req(hci_sock, bt.OGF_STATUS_PARAM, bt.OCF_READ_RSSI, bt.EVT_CMD_COMPLETE, 4, cmd_pkt) rssi = struct.unpack('b', rssi[3])[0] # Close sockets bt_sock.close() hci_sock.close() return rssi except Exception, e: #self.logger.error("<Bluetooth> (getRSSI) %s" % (repr(e))) return None
def isNewNukiStateAvailable(self): if self.device != None: self.device.disconnect() self.device = None dev_id = 0 try: sock = bluez.hci_open_dev(dev_id) except: print "error accessing bluetooth device..." sys.exit(1) blescan.hci_le_set_scan_parameters(sock) blescan.hci_enable_le_scan(sock) returnedList = blescan.parse_events(sock, 10) newStateAvailable = -1 print "isNewNukiStateAvailable() -> search through %d received beacons..." % len(returnedList) for beacon in returnedList: beaconElements = beacon.split(',') if beaconElements[0] == self.macAddress.lower() and beaconElements[1] == "a92ee200550111e4916c0800200c9a66": print "Nuki beacon found, new state element: %s" % beaconElements[4] if beaconElements[4] == '-60': newStateAvailable = 0 else: newStateAvailable = 1 break else: print "non-Nuki beacon found: mac=%s, signature=%s" % (beaconElements[0],beaconElements[1]) print "isNewNukiStateAvailable() -> result=%d" % newStateAvailable return newStateAvailable
def lookup_name(self, address, device=-1, timeout=10): """ Linux only Tries to determine the friendly name (human readable) of the device with the specified bluetooth address. Returns the name on success, and None on failure. timeout=10 how many seconds to search before giving up. """ logger.debug("Device: %s " % (device)) if sys.platform == "linux2": # NOTE: I had to rewrite this for the latest bluez, # the reason this is complicated is because I need to select the device, # before making the call. # http://code.google.com/p/pybluez/source/detail?spec=svn27&r=22 if not bluetooth.is_valid_address(address): raise ValueError("%s is not a valid Bluetooth address" % address) try: sock = _bt.hci_open_dev(device) except: raise ValueError("error accessing bluetooth device") timeoutms = int(timeout * 1000) try: name = _bt.hci_read_remote_name(sock, address, timeoutms) except _bt.error, e: # name lookup failed. either a timeout, or I/O error name = None sock.close() return name
def __init__(self): rospy.init_node("blescanner", anonymous=True) dev_id = 0 try: self.sock = bluez.hci_open_dev(dev_id) print "ble thread started" except: print "error accessing bluetooth device..." sys.exit(1) blescan.hci_le_set_scan_parameters(self.sock) blescan.hci_enable_le_scan(self.sock) self.pub = rospy.Publisher('ble_data', BLEData, queue_size=10, latch=True) while not rospy.is_shutdown(): self.returnedList = blescan.parse_events(self.sock, 10) msg = BLEData() msg.header.stamp = rospy.Time.now() for beacon in self.returnedList: submsg = BLEBeacon() submsg.mac_address = beacon[0:17] submsg.rssi = int(beacon[-3:]) msg.data.append(submsg) # print submsg # print "MAC ADDRESS: ", beacon[0:17] # print "RSSI: ", beacon[-3:] # print beacon self.pub.publish(msg)
def scan(self): try: sock = bluez.hci_open_dev(self.dev_id) except Exception, e: print "ERROR: Accessing bluetooth device: " + e.message sys.exit(1)
def bluetooth_rssi(addr): # Open hci socket hci_sock = bt.hci_open_dev() hci_fd = hci_sock.fileno() # Connect to device (to whatever you like) bt_sock = bluetooth.BluetoothSocket(bluetooth.L2CAP) bt_sock.settimeout(10) result = bt_sock.connect_ex((addr, 1)) # PSM 1 - Service Discovery try: # Get ConnInfo reqstr = struct.pack("6sB17s", bt.str2ba(addr), bt.ACL_LINK, "\0" * 17) request = array.array("c", reqstr) handle = fcntl.ioctl(hci_fd, bt.HCIGETCONNINFO, request, 1) handle = struct.unpack("8xH14x", request.tostring())[0] # Get RSSI cmd_pkt = struct.pack('H', handle) rssi = bt.hci_send_req(hci_sock, bt.OGF_STATUS_PARAM, bt.OCF_READ_RSSI, bt.EVT_CMD_COMPLETE, 4, cmd_pkt) rssi = struct.unpack('b', rssi[3])[0] # Close sockets bt_sock.close() hci_sock.close() return rssi except: return None
def scan(self): try: sock = bluez.hci_open_dev(self.dev_id) except: print "error accessing bluetooth device..." sys.exit(1) blescan.hci_le_set_scan_parameters(sock) blescan.hci_enable_le_scan(sock) #Keep scanning until the manager is told to stop. while self.scanning: returnedList = blescan.parse_events(sock, 10) for beacon in returnedList: beaconParts = beacon.split(",") #Resolve whether the received BLE event is for a brewometer by looking at the UUID. name = self.brewometerName(beaconParts[1]) #If the event is for a brewometer, process the data if name is not None: #Get the temperature and convert to C if needed. temperature = beaconParts[2] if not self.inFarenheight: temperature = self.convertFtoC(temperature) #Get the gravity. gravity = self.convertSG(beaconParts[3]) #Store the retrieved values in the relevant brewometer object. self.storeValue(name, temperature, gravity)
def le_set_advertising_enable(self, cmd_params={'Advertising_Enable': 0x00}) -> dict: dd = hci_open_dev(self.devid) bin_cmd_params = cmd_params['Advertising_Enable'].to_bytes(1, 'little') flt = hci_filter_new() hci_filter_set_ptype(flt, HCI_EVENT_PKT) hci_filter_set_event(flt, EVT_CMD_COMPLETE) hci_filter_set_opcode( flt, cmd_opcode_pack(OGF_LE_CTL, OCF_LE_SET_ADVERTISING_ENABLE)) dd.setsockopt(SOL_HCI, HCI_FILTER, flt) hci_send_cmd(dd, OGF_LE_CTL, OCF_LE_SET_ADVERTISING_ENABLE, bin_cmd_params) event_params = dd.recv(3 + EVT_CMD_COMPLETE_SIZE + 1)[3:] num_hci_cmd_pkts, cmd_opcode, status = struct.unpack( '<BHB', event_params) event_params = { 'Num_HCI_Command_Packets': num_hci_cmd_pkts, 'Command_Opcode': cmd_opcode, 'Status': status } hci_close_dev(dd.fileno()) return event_params
def get_RSSI_and_TX(iterations, authorized): # Value containers rssi_list = [] tx_power_list = [] rssi = 0 tx_power = 0 # Open BLE socket try: sock = bluez.hci_open_dev(0) print("Start BLE communication") except: print("error accessing bluetooth device...") sys.exit(1) hci_le_set_scan_parameters(sock) hci_enable_le_scan(sock) # Loop to scan the beacons for x in range(iterations): returnedList = parse_events(sock, 10) for beacon in returnedList: details = beacon.split(',') #print(details) if details[0] in authorized: rssi_list.append(details[5]) tx_power_list.append(details[4]) if len(rssi_list) > 0 or len(tx_power_list) > 0: rssi = max(set(rssi_list), key=rssi_list.count) tx_power = max(set(tx_power_list), key=tx_power_list.count) return int(rssi), int(tx_power)
def _find_local_bdaddr(self): dev_id = 0 hci_sock = _bt.hci_open_dev(dev_id) old_filter = hci_sock.getsockopt(_bt.SOL_HCI, _bt.HCI_FILTER, 14) flt = _bt.hci_filter_new() opcode = _bt.cmd_opcode_pack(_bt.OGF_INFO_PARAM, _bt.OCF_READ_BD_ADDR) _bt.hci_filter_set_ptype(flt, _bt.HCI_EVENT_PKT) _bt.hci_filter_set_event(flt, _bt.EVT_CMD_COMPLETE) _bt.hci_filter_set_opcode(flt, opcode) hci_sock.setsockopt(_bt.SOL_HCI, _bt.HCI_FILTER, flt) _bt.hci_send_cmd(hci_sock, _bt.OGF_INFO_PARAM, _bt.OCF_READ_BD_ADDR) pkt = hci_sock.recv(255) status, raw_bdaddr = struct.unpack("xxxxxxB6s", pkt) assert status == 0 t = ["%X" % ord(b) for b in raw_bdaddr] t.reverse() bdaddr = ":".join(t) # restore old filter hci_sock.setsockopt(_bt.SOL_HCI, _bt.HCI_FILTER, old_filter) return bdaddr
def bluetooth_rssi(addr): # Open hci socket hci_sock = bt.hci_open_dev() hci_fd = hci_sock.fileno() # Connect to device (to whatever you like) bt_sock = bluetooth.BluetoothSocket(bluetooth.L2CAP) bt_sock.settimeout(10) result = bt_sock.connect_ex((addr, 1)) # PSM 1 - Service Discovery try: # Get ConnInfo reqstr = struct.pack('6sB17s', bt.str2ba(addr), bt.ACL_LINK, '\0' * 17) request = array.array('c', reqstr ) handle = fcntl.ioctl(hci_fd, bt.HCIGETCONNINFO, request, 1) handle = struct.unpack('8xH14x', request.tostring())[0] # Get RSSI cmd_pkt=struct.pack('H', handle) rssi = bt.hci_send_req(hci_sock, bt.OGF_STATUS_PARAM, bt.OCF_READ_RSSI, bt.EVT_CMD_COMPLETE, 4, cmd_pkt) rssi = struct.unpack('b', rssi[3])[0] # Close sockets bt_sock.close() hci_sock.close() return rssi except: return None
def _gethcisock(device_id=-1): try: sock = _bt.hci_open_dev(device_id) except _bt.error as e: raise BluetoothError(e.args[0], "error accessing bluetooth device: " + e.args[1]) return sock
def main(): #connect to cloudant database client = Cloudant("<account>", "<password>", account="<account>", connect=True, auto_renew=True, timeout=300) dev_id = 0 try: sock = bluez.hci_open_dev(dev_id) except: print("error accessing bluetooth device...") sys.exit(1) blescan.hci_le_set_scan_parameters(sock) blescan.hci_enable_le_scan(sock) count = 0 my_document = client['present']['<ble Device UDID>'] while count < 30: returnedList = blescan.parse_events(sock, 10) for beacon in returnedList: if beacon.split(",")[1] == "<ble Device UDID>": my_document['present'] = True my_document.save() return count += 1 my_document['present'] = False my_document.save()
def runLeash(self): dev_id = 0 # Set we have not found the device for the next pass self.setFoundDevice(False) # try to open the dev via the dev id, if not exit try: sock = bluez.hci_open_dev(dev_id) except: print("error accessing bluetooth device...") sys.exit(1) # Try to check the inqury mode try: mode = self.read_inquiry_mode(sock) except Exception as e: print("error reading inquiry mode. ") print(e) sys.exit(1) # print("current inquiry mode is %d" % mode) # inquiry the devices to find the target print('Attempting to Find Device') self.device_inquiry_with_with_rssi(sock)
def hci_cc(adapter: int, ps4btaddr: str) -> None: import bluetooth._bluetooth as _bt try: hci_sock = _bt.hci_open_dev(adapter) # Get bytes from bluetooth address baps4addr = bytearray.fromhex(ps4btaddr.replace(":", "")) baps4addr.reverse() # HCI CONNECT # BLUETOOTH SPECIFICATION Version 5.0 | Vol 2, Part E page 774 # https://github.com/pauloborges/bluez/blob/master/tools/hcitool.c => cmd_cc # https://github.com/pauloborges/bluez/blob/master/lib/hci.c => hci_create_connection cmd_pkt = bytes( baps4addr ) + bytes([ # Target BTADDR on 6 bytes reverse order, 0x18, 0xCC, # pkt_type HCI_DM1 | HCI_DM3 | HCI_DM5 | HCI_DH1 | HCI_DH3 | HCI_DH5 0x02, # pscan_rep_mode 0x00, # pscan_mode (reserved) 0x00, 0x00, # clock_offset 0x01 ]) # role_switch # Send HCI request _bt.hci_send_req(hci_sock, _bt.OGF_LINK_CTL, _bt.OCF_CREATE_CONN, _bt.EVT_CONN_COMPLETE, 1000, cmd_pkt) hci_sock.close() except _bt.error as e: raise BluetoothError(*e.args)
def open_bt_sock(): dev_id = 0 try: sock = bluez.hci_open_dev(dev_id) except: print "error accessing bluetooth device..." sys.exit(1) return sock
def __init__(self): subprocess.call(["/usr/sbin/hciconfig", "hci0", "down"]) subprocess.check_call(["/usr/sbin/hciconfig", "hci0", "up"]) dev_id = 0 self.sock = bluez.hci_open_dev(dev_id) self.old_filter = self.sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14) self.hci_disable_le_scan()
def __init__(self, deviceId = 0, loops = 1): self.deviceId = deviceId self.loops = loops try: self.sock = bluez.hci_open_dev(self.deviceId) blescan.hci_le_set_scan_parameters(self.sock) blescan.hci_enable_le_scan(self.sock) except Exception, e: print e
def init_connection(): dev_id = 0 connection = -1 try: sock = bluez.hci_open_dev(dev_id) except: print "error accessing bluetooth device..." sys.exit(1) return sock
def __init__(self, watchaddr = None, verbose = False,debug=True): self.CRC=CRC_CCITT(); self._last_tx_time = time.clock() self.verbose = verbose self.debug=debug self.invertDisplay=False while watchaddr == None or watchaddr == "none": print "performing inquiry..." if bluetooth: nearby_devices = bluetooth.discover_devices(lookup_names = True) else: # Need to strip the third "device class" tuple element from results nearby_devices = map(lambda x:x[:2], lightblue.finddevices()) print "found %d devices" % len(nearby_devices) for addr, name in nearby_devices: print " %s - '%s'" % (addr, name) if name and ('MetaWatch Digital' in name or 'Fossil Digital' in name) : watchaddr=addr; print "Identified Watch at %s" % watchaddr; # MetaWatch doesn't run the Service Discovery Protocol. # Instead we manually use the portnumber. port=1; print "Connecting to %s on port %i." % (watchaddr, port); if bluetooth: sock=bluetooth.BluetoothSocket(bluetooth.RFCOMM); # print rssi print "Computing rssi" dev_id = 0 try: self.sock_monitor = bluez.hci_open_dev(dev_id) except: print "error accessing bluetooth device..." sys.exit(1) try: mode = read_inquiry_mode(self.sock_monitor) except Exception, e: print "error reading inquiry mode. " print "Are you sure this a bluetooth 1.2 device?" print e sys.exit(1) print "current inquiry mode is %d" % mode if mode != 1: print "writing inquiry mode..." try: result = write_inquiry_mode(sock_monitor, 1) except Exception, e: print "error writing inquiry mode. Are you sure you're root?" print e sys.exit(1) if result != 0: print "error while setting inquiry mode" print "result: %d" % result
def write_flush_timeout( addr, timeout ): hci_sock = bt.hci_open_dev() # get the ACL connection handle to the remote device handle = __get_acl_conn_handle(hci_sock, addr) pkt = struct.pack("HH", handle, bt.htobs(timeout)) response = bt.hci_send_req(hci_sock, bt.OGF_HOST_CTL, 0x0028, bt.EVT_CMD_COMPLETE, 3, pkt) status = struct.unpack("B", response[0])[0] rhandle = struct.unpack("H", response[1:3])[0] assert rhandle == handle assert status == 0
def __init__(self, deviceId=0, loops=1): """Initialize scanner.""" self.deviceId = deviceId self.loops = loops try: self.sock = bluez.hci_open_dev(self.deviceId) blescan.hci_le_set_scan_parameters(self.sock) blescan.hci_enable_le_scan(self.sock) except Exception, e: logger.critical('Scan failed: {}'.format(str(e))) print e
def __init__(self) : try: self.sock = bluez.hci_open_dev(self.dev_id) old_filter = self.sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14) enable = 1 cmd_pkt = struct.pack("<BB", enable, 0x00) bluez.hci_send_cmd(self.sock, OGF_LE_CTL, OCF_LE_SET_SCAN_ENABLE, cmd_pkt) except: print "error accessing blue tooth device..." sys.exit(1)
def setup(device_id): """ Setup a BLE scanner on a device """ try: sock = bluez.hci_open_dev(device_id) except: sys.exit('Error: Unable to open device %s' % device_id) hci_le_set_scan_parameters(sock) hci_enable_le_scan(sock) return sock
def init_ble(): try: sock = bluez.hci_open_dev(devid) print "ble thread started" except: print "error accessing bluetooth device..." sys.exit(1) blescan.hci_le_set_scan_parameters(sock) blescan.hci_enable_le_scan(sock) return sock
def init_BLE_thread(): dev_id = 0 try: sock = bluez.hci_open_dev(dev_id) hci_le_set_scan_parameters(sock) hci_enable_le_scan(sock) ## NEW THREAD ## thread.start_new_thread( Catch_and_Store_advertisement_meassages, (sock,) ) BLE_thread_init = "OK - accessing bluetooth device..." except Exception,e: BLE_thread_init = ("ERROR - accessing bluetooth device and catch thread..." + str(e)) error_reporting(BLE_thread_init)
def init(self): """ Initialise the Bluetooth device used for scanning. @return 0 on success, 1 on failure. """ try: self.sock = bluez.hci_open_dev(self.device_id) except: s = 'Error opening Bluetooth device %i' % self.device_id self.mgr.main.log_error('Error', '%s.' % s) self.mgr.debug(s) return 1 try: mode = self._read_inquiry_mode() except: s = 'Error reading inquiry mode on device %i. ' % self.device_id + \ 'We need a 1.2+ Bluetooth device' self.mgr.main.log_error('Error', '%s.' % s) self.mgr.debug(s) return 1 if mode != 1: try: result = self._write_inquiry_mode(1) except: s = 'Error writing inquiry mode on device %i' % self.device_id self.mgr.main.log_error('Error', '%s.' % s) self.mgr.debug(s) return 1 if result != 0: s = 'Adapter %s does not support RSSI enabled ' % self.mac \ + 'inquiries, disabling RSSI detections' self.mgr.log_info(s) try: result = self._write_inquiry_mode(0) except: s = 'Error writing inquiry mode on device %i' % \ self.device_id self.mgr.main.log_error('Error', '%s.' % s) self.mgr.debug(s) return 1 if result != 0: s = 'Error setting inquiry mode on ' + \ 'device %i' % self.device_id self.mgr.main.log_error('Error', '%s.' % s) self.mgr.debug(s) return 1 return 0
def __init__(self,app): self.app = app pg.setConfigOptions(antialias=True) self.win = pg.GraphicsWindow(title="Basic plotting examples") self.win.resize(800,800) self.win.setWindowTitle('SmartPolyTech Beacon System') self.p = self.win.addPlot(title='RSSI graph') self.graphView = self.win.addViewBox(row=1,col=0) #self.graphView.setLimits(xMin=-5, xMax=5, yMin = -5, yMax=5) self.graphView.setAspectLocked() self.graphView.setRange(rect=QtCore.QRectF(-6,6,12,-12)) box = QtGui.QGraphicsRectItem(-10, 5, 20, -10) box.setPen(pg.mkPen("w")) box.setBrush(pg.mkBrush(None)) self.graphView.addItem(box) self.graphView.show() self.graph = pg.GraphItem() self.graphView.addItem(self.graph) self.bufferLength = 20 self.p.setRange(QtCore.QRectF(0, 0, self.bufferLength, 100)) self.p.setLabel('bottom', 'Samples') self.p.setLabel('left', 'Signal Strength') self.p.setAutoVisible(y=True) #cross hair try: dev_id = 0 self.sock = bluez.hci_open_dev(dev_id) print "ble thread started" except: print "error accessing bluetooth device..." sys.exit(1) #Variables self.lastTime = time() self.fps = None #Timers self.timerBluetooth = QtCore.QTimer() self.timerBluetooth.timeout.connect(self.updateBluetooth) self.timerBluetooth.start(300) self.timer = QtCore.QTimer() self.timer.timeout.connect(self.compute) self.timer.start(100) #self.p.scene().sigMouseMoved.connect(self.mouseMoved) self.signalList = {} self.curveList = {}
def read_flush_timeout( addr ): hci_sock = bt.hci_open_dev() # get the ACL connection handle to the remote device handle = __get_acl_conn_handle(hci_sock, addr) pkt = struct.pack("H", handle) response = bt.hci_send_req(hci_sock, bt.OGF_HOST_CTL, 0x0027, bt.EVT_CMD_COMPLETE, 5, pkt) status = struct.unpack("B", response[0])[0] rhandle = struct.unpack("H", response[1:3])[0] assert rhandle == handle assert status == 0 fto = struct.unpack("H", response[3:5])[0] return fto