def _doScan(self, devid=-1): status = 0 seenaddresses = [] try: if self.lastScanTimestamp: print "[SCN] last scan was performed %.2f seconds ago" % round(time.time() - self.lastScanTimestamp, 2) self.lastScanTimestamp = time.time() try: # try to use a specific Bluetooth interface: print "[SCN] address scanning using hci%s..." % devid seenaddresses = bluetooth.discover_devices(device_id=devid) except TypeError: # if there is no support for multiple interfaces, use the default one: print "[SCN] address scanning using default interface (no support for multiple interfaces)" seenaddresses = bluetooth.discover_devices() status = seenaddresses.__len__() print "[SCN] done. took %.2f sec. seen addresses:" % (round(time.time() - self.lastScanTimestamp, 2)), seenaddresses self.numErrors = 0 except bluetooth.btcommon.BluetoothError: # if an error occurs, try to recover status = -1 self.numErrors += 1 print "[SCN] bluetooth error (%d of %d tolerated)" % (self.numErrors, self.numErrorsUntilReset) if self.numErrors == self.numErrorsUntilReset+1: print "[SCN] BT ERROR: Resetting interface hci%d" % devid basics.Exec().execlp('hciconfig', ['hci'+str(devid), 'down'], wait=True) elif self.numErrors == self.numErrorsUntilReset+3: print "[SCN] BT ERROR: Critical, restarting hotspot :(" #basics.Exec().execlp('reboot') return (status, seenaddresses)
def _scan(self): """ Encapsulate the call to the callback function. Catch exception and test thread stop. """ while not self._stop.isSet(): self.log.info(u"Scanning") self.log.debug(self._devices) try: found = bluetooth.discover_devices() for dev in self._devices: if dev in found and self._devices[dev]['status'] == 0: # toggle from not seen to seen data = {} data['current'] = 1 data['device'] = dev self._send_xpl('sensor.basic', data) self._devices[dev]['hyster'] = 0 self._devices[dev]['status'] = 1 self.log.info(u"dev {0} moved from away to seen".format(dev)) elif dev not in found and self._devices[dev]['status'] == 0 and self._devices[dev]['hyster'] == self._hysteresis: data = {} data['current'] = 0 data['device'] = dev self._send_xpl('sensor.basic', data) self.log.info(u"dev {0} moved from seen to away".format(dev)) elif dev not in found and self._devices[dev]['hyster'] < self._hysteresis: # not seen and previous not seen, but hysteresis not reached self._devices[dev]['hyster'] += 1 self._devices[dev]['status'] = 0 self._stop.wait(self._scan_delay) except Exception as exp: self.log.info(u"Error happend waiting for {0} seconds".format(self._error_delay)) self.log.debug(exp) self._stop.wait(self._error_delay)
def find_host(): for host, name in bluetooth.discover_devices(lookup_names=True): print host, name #if (name == 'Nexus 10' or host == 'BC:20:A4:74:7E:43'): if (host == "04:E4:51:11:19:09"): print "name: ", name return host
def __linuxSearch(): from bluetooth import discover_devices, lookup_name import time, threading ## Threads are used to look up names to avoid the ## problem of waiting for each device to respond before ## moving on to the next which may have left 'discoverable' ## mode. It may be possible to get this info when we do the ## initial search... class LinuxNameGetter(threading.Thread): def __init__(self, address): print "Address: ", address self.name = None ## set up the stuff needed for threading threading.Thread.__init__(self) self.addr = address def run(self): print "Starting thread for addr %s" % self.addr self.name = lookup_name(self.addr) print "addr %s --> %s" % (self.addr, self.name) print "Searching for wiimotes..." addresses = discover_devices(0) print "Found %i devices" % len(addresses) ## create the thread things threads = [LinuxNameGetter(x) for x in addresses] for t in threads: t.start() while any([t.isAlive() for t in threads]): ## checks if any threads are still running time.sleep(0.1) return [(t.addr, t.name) for t in threads]
def __init__(self, watchaddr = None, verbose = False): self.CRC=CRC_CCITT(); self._last_tx_time = time.clock() self.verbose = verbose while watchaddr == None or watchaddr == "none": print("performing inquiry...") nearby_devices = bluetooth.discover_devices(lookup_names = True) 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)); sock=bluetooth.BluetoothSocket(bluetooth.RFCOMM); sock.setblocking(True) self.sock = sock; sock.connect((watchaddr, port)); sock.settimeout(10); # IMPORTANT Must be patient, must come after connect(). self.setclock()
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 sendComannd(command): """Método que faz a modificação do comando :Param command: O novo comando :Type command: String """ try: nearby_devices = bluetooth.discover_devices() if (len(nearby_devices) > 0): for bdaddr in nearby_devices: if bdaddr in address_list: print "ip encontrado" target_address = bdaddr break if target_address is not None: print "Dispositivo encontrado com o endereço ", target_address sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM ) sock.connect((target_address, port)) print("conexao aceita") sock.send(command) sock.close() return True else: print "Nenhum dispositivo encontrado." except Exception as e: print "except",e return False return False
def __init__(self, watchaddr=None): self.CRC=CRC_CCITT(); while watchaddr==None or watchaddr=="none": print "performing inquiry..." nearby_devices = bluetooth.discover_devices(lookup_names = True) print "found %d devices" % len(nearby_devices) for addr, name in nearby_devices: print " %s - '%s'" % (addr, name) if name=='Fossil Digital Watch V2': 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); sock=bluetooth.BluetoothSocket(bluetooth.RFCOMM); self.sock=sock; sock.connect((watchaddr,port)); sock.settimeout(10); #IMPORTANT Must be patient. #Grab settings from the watch. try: print "Connected to %s" % self.getinfo(); self.setclock(); self.getclock(); except: print "Connection probably failed. Continuing anyways."
def discover_bluetooth_devices(): """ This is a generator function that returns (address, name) tuples of all nearby bluetooth devices found. If the user has python-bluez installed, it will be used. If not, we're trying to use "hcitool". If neither python-bluez or hcitool are available, this function is the empty generator. """ try: # If the user has python-bluez installed import bluetooth log('Using python-bluez to find nearby bluetooth devices') for name, addr in bluetooth.discover_devices(lookup_names=True): yield (name, addr) except: if find_command('hcitool') is not None: log('Using hcitool to find nearby bluetooth devices') # If the user has "hcitool" installed p=subprocess.Popen(['hcitool', 'scan'], stdout=subprocess.PIPE) for line in p.stdout: match=re.match('^\t([^\t]+)\t([^\t]+)\n$', line) if match is not None: (addr, name)=match.groups() yield (name, addr) else: log('Cannot find either python-bluez or hcitool - no bluetooth?') return # <= empty generator
def find(self, serial=False): """ :param serial: Serial port (True) or MAC address (False) :type serial: bool. :returns: MAC address or serial of each device found Searches for bluetooth devices nearby. Possible return formats: ========= ===================================================== ===================== *serial* Returns Examples ========= ===================================================== ===================== True List of port names containing ``bitalino`` or ``COM`` ``['COM1','COM3']`` False List of (tuples) with MAC address and name ``[('00:0a:95:9d:68:16','bitalino_name')]`` ========= ===================================================== ===================== """ try: if serial: nearby_devices = list(port[0] for port in list_ports.comports() if 'bitalino' or 'COM' in port[0]) else: nearby_devices = discover_devices(lookup_names=True) return nearby_devices except: return -1
def search(self, name): """Searches nearby devices for a given name. Args: name: The name of the device to search for. Returns: The MAC address of the device with the given name if it was found. Otherwise returns None """ self.name = name logging.debug("Searching for nearby devices.") nearby_devices = bluetooth.discover_devices() max_attempts = 3 while max_attempts > 0: for addr in nearby_devices: logging.info("Found device: %s", addr) if bluetooth.lookup_name(addr) == name: logging.info("Device %s is %s", addr, name) return addr logging.debug("Device not found. Attempts remaining: %s", max_attempts) max_attempts = max_attempts - 1 return None
def listen_discovery(): """ Listen to bluetooth adaptator. This method use the bluetooth.discover_devices(). It takes approcimatively 10 seconds to proceed. Phones must be "visible" in bluetooth. """ try: nearby_devices = bluetooth.discover_devices() syslog.syslog(syslog.LOG_DEBUG, 'listen_discovery devices discovered %s' % nearby_devices) for phon in phones.keys(): if phones[phon]["status"] == 1 : if phone not in nearby_devices: phones[phon]["count"] = phones[phon]["count"] + 1 if phones[phon]["count"] >= hysteresis: client.emitEvent(ex_bluescan%phon,"event.device.statechanged", "0", "") phones[phon]["status"] = 0 syslog.syslog(syslog.LOG_DEBUG, "%s has gone"%phon) for phon in nearby_devices: if phon in phones.keys(): if 'name' not in phones[phon] : phones[phon]['name'] = bluetooth.lookup_name(phon) phones[phon]["count"] = 0 if phones[phon]["status"] == 0: phones[phon]["status"] = 1 client.emitEvent(ex_bluescan%phon,"event.device.statechanged", "255", "") syslog.syslog(syslog.LOG_DEBUG, "%s is here"%phon) return True except : error = traceback.format_exc() syslog.syslog(syslog.LOG_ERR, 'Error when discovering devices in listen_discovery') log_exception(error) return False
def _listen_adaptator_discovery(self): """ Listen to bluetooth adaptator. This method use the bluetooth.discover_devices(). It takes approcimatively 10 seconds to proceed. Phones must be "visible" in bluetooth. """ try: # self.log.debug("_listen_adaptator_discovery : Start \ #bluetooth.discover_devices at %s" % datetime.datetime.today()) nearby_devices = bluetooth.discover_devices() # self.log.debug("_listen_adaptator_discovery : Stop \ #bluetooth.discover_devices at %s" % datetime.datetime.today()) for aaddr in self._targets: if self._targets[aaddr]["status"] == HIGH : if aaddr not in nearby_devices: self._targets[aaddr]["count"] = \ self._targets[aaddr]["count"] +1 if self._targets[aaddr]["count"] >= self._hysteresis: self._trig_detect("xpl-trig", aaddr, LOW) for bdaddr in nearby_devices: target_name = bluetooth.lookup_name( bdaddr ) if bdaddr in self._targets: self._targets[bdaddr]["count"] = 0 if self._targets[bdaddr]["status"] == LOW: self._trig_detect("xpl-trig", bdaddr, HIGH) self.log.info("Match bluetooth device %s with address %s" % (target_name, bdaddr)) return True except: self.log.error("_listen_adaptator : Error with bluetooth adaptator") error = "traceback : %s" % \ (traceback.format_exc()) self.log.error("listen_adaptator : " + error) return False
def scan(self, args = None): """ Scan for bluetooth devices """ self._log.debug("scan : Start ...") data = [] fmtret = "%-15s | %-15s" nb = 0 try: nearby_devices = bluetooth.discover_devices() data.append(fmtret % ("Address", "Name")) data.append(fmtret % ("---------------", "---------------")) for bdaddr in nearby_devices: nb = nb+1 target_name = bluetooth.lookup_name(bdaddr) data.append(fmtret % (bdaddr, target_name)) data.append(fmtret % ("---------------", "---------------")) data.append("Found %s bluetooth devices." % nb) except: data.append("Error with bluetooth adaptator. Look at logs.") self._log.error("Error with bluetooth adaptator") error = "traceback : %s" % \ (traceback.format_exc()) self._log.error("Exception : " + error) self._log.debug("telldusHelper.list : Done") return data
def timerEvent(): # Prepare the timer for the next run ... global t, lock, database t = threading.Timer(period, timerEvent) t.start() if lock == True: return try: lock = True print "timer", time.localtime() print "performing inquiry ..." nearby_devices = () try: # Search for bluetooth devices ... nearby_devices = bluetooth.discover_devices(lookup_names = True) except: print "bluetooth network not found" # For each device found, add the address and the name to the database for addr, name in nearby_devices: print " processing %s - %s" % (addr, name) newPing = ping(device(name, addr), username, location) database.saveDevice(newPing) database.savePing(newPing) except: None finally: lock = False
def scanThings(): """scan the things""" f = open("./Schema/vibrate.cleaned.json") # scanResult = json.loads(f.read()) deviceList = bluetooth.discover_devices(lookup_names=True) deviceProfiles = []; for MACaddress, deviceName in deviceList: splittedName = deviceName.split('::') # print(splittedName) if len(splittedName) == 4: deviceName = splittedName[1] deviceProfURL = splittedName[2] deviceKey = splittedName[3] requestPayload = { "deviceID": deviceName, "appID" : IMPROMPTO_APP_ID, "key" : deviceKey, "context[]" : IOT_CONTEXT } encodedRequestPayload = urllib.parse.urlencode(requestPayload) full_url = deviceProfURL + "?" + encodedRequestPayload data = urllib.request.urlopen(full_url) deviceProfile = json.loads(data.read().decode('UTF-8')) if "IOT" in deviceProfile.keys(): deviceProfile = deviceProfile["IOT"] deviceProfile["rssi"] = "-22" # temp workaround deviceProfile["uuid"] = deviceName deviceProfile["name"] = deviceName deviceProfiles.append(deviceProfile) scanResult = deviceProfiles print(scanResult) return scanResult
def main(): ## FrameCreator() print "Performing inquiry.." target_address = "00:12:02:28:73:47" target_name = "jyl2" port = 1 nearby_devices = bluetooth.discover_devices(lookup_names=True) print "found %d devices" % len(nearby_devices) for name, addr in nearby_devices: print " %s - %s" % (addr,name) #bluetooth address of the bluetooth module is 00:12:02:28:73:47 global client_socket, window client_socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM) client_socket.connect((target_address, port)) #client connects to the server on port 1 print "connected to server" window =Tk() window.geometry("291x300") window.title("Dienes Blocks Application") window.configure(background='black') window.tk_setPalette(background='black', foreground='white', activeBackground='black', activeForeground='white') window.iconbitmap(default='favicon.ico') ## w=Tkinter.Label(window,image=photo) ## w.grid(row=0, column=1) app = HomeScreen(window) window.protocol("WM_DELETE_WINDOW", handler) window.mainloop()
def find_devices(): print("Searching for nearby devices") nearby_devices = bluetooth.discover_devices(lookup_names=True) print("found %d devices" % len(nearby_devices)) for addr, name in nearby_devices: print(" %s - %s" % (addr, name))
def __init__(self): print "Connecting to bluetooth..." target_name = "Onetouch Idol 3" #target_name = "Galaxy Mega" target_address = None nearby_devices = bluetooth.discover_devices() print nearby_devices for addr in nearby_devices: print bluetooth.lookup_name(addr) if target_name == bluetooth.lookup_name(addr): target_address = addr break print target_address uuid = "fa87c0d0-afac-11de-8a39-0800200c9a66" service_matches = bluetooth.find_service(uuid = uuid, address = target_address) if len(service_matches) == 0: print "Could not find service" sys.exit(0) port = service_matches[0]["port"] name = service_matches[0]["name"] host = service_matches[0]["host"] self.socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM) self.socket.connect((host, port))
def discover(self): address = None bluetoothdevices = bluetooth.discover_devices(duration=6, lookup_names=True) for bluetoothdevice in bluetoothdevices: if bluetoothdevice[1] == BLUETOOTH_NAME: address = bluetoothdevice[0] return address
def search(reader, devices, pusher, history): while True: nearby_devices = bluetooth.discover_devices() # get all nearby devices eligibleMacs = list(map(lambda d: d["MAC"], devices)) # convert devices to list of macs registered_devices = list(set(nearby_devices) & set(eligibleMacs)) # get the intersection of eligible devices and available devices if len(registered_devices) > 0: try: # if pushbullet and db exist, continue if pusher is not None and history is not None: pushed_devices = [] for device in registered_devices: try: devObj = list(filter(lambda d: d["MAC"] == device, devices))[0] # get the device with a given MAC address iden = devObj["pushbullet_iden"] # get the device_iden of pushbullet name = devObj["name"] # get the person name pusher.pushNotification(reader["temperature"], "bt", name=name, device=iden) # send the notification to the person pushed_devices.append(device) # successfully pushed except IndexError as err: print(err) continue except KeyError: print("please check your configuration file") continue except: print("Fail to call pushbullet API") continue history.writeHistory(pushed_devices, reader["temperature"], reader["deviceid"]) # write history for all successfull pushes except (exceptions.InfluxDBClientError, exceptions.InfluxDBServerError) as err: print(err) break time.sleep(3) #Sleep three seconds
def __init__(self,btaddr): import bluetooth; if btaddr==None or btaddr=="none" or btaddr=="bluetooth": print "performing inquiry..." nearby_devices = bluetooth.discover_devices(lookup_names = True) print "found %d devices" % len(nearby_devices) for addr, name in nearby_devices: print " %s - '%s'" % (addr, name) #TODO switch to wildcards. if name=='FireFly-A6BD': btaddr=addr; if name=='RN42-A94A': btaddr=addr; print "Please set $GOODFET to the address of your device."; sys.exit(); print "Identified GoodFET at %s" % btaddr; # Manually use the portnumber. port=1; print "Connecting to %s on port %i." % (btaddr, port); sock=bluetooth.BluetoothSocket(bluetooth.RFCOMM); self.sock=sock; sock.connect((btaddr,port)); sock.settimeout(10); #IMPORTANT Must be patient. ##This is what we'd do for a normal reset. #str=""; #while not str.endswith("goodfet.sf.net/"): # str=self.read(64); # print str; # Instead, just return and hope for the best. return;
def discover(self,id=False,name=False): devices = bluetooth.discover_devices(lookup_names=True) if len(devices) > 0: services = bluetooth.find_service() if id: for device in devices: if device[0] == id: localservices = list() for service in services: if service['host'] == device[0]: localservices.append(service) self.send(["OK",device,localservices],"outbox") break else: self.send(["ERROR",id]) elif name: for device in devices: if device[1] == name: localservices = list() for service in services: if service['host'] == device[0]: localservices.append(service) self.send(["OK",device,localservices],"outbox") break else: self.send(["ERROR",name]) else: if len(devices) == 0: self.send(["ERROR","No Devices Found"],"outbox") else: self.send([devices,services],"outbox")
def discover_devices(): """Discover Bluetooth devices.""" result = bluetooth.discover_devices( duration=8, lookup_names=True, flush_cache=True, lookup_class=False) _LOGGER.debug("Bluetooth devices discovered = %d", len(result)) return result
def find_lights(): """ Finds nearby lights and adds them to the dictionary """ print("Discovering devices...") nearby_devices = bt.discover_devices() for address in nearby_devices: name = bt.lookup_name(address) # Ignore non-lights if name.startswith("Light"): # Get the light number from the name num = int(name[-2:]) # Check to see if we already found the light if not num in lights: # Create a light object print("Found light", num) lights[num] = Light(address, num) elif not lights[num].is_connected: # We found the light, but it wasn't able to connect. Try again print("Attempting to reconnect light", num) lights[num].connect_light() # Figure out how many lights are connected count = 0 for light in lights: if lights[light].is_connected: count += 1 if count == 0: print("No lights are connected!") else: # Save the lights pickle.dump(lights, open("saved_lights.p", "wb")) return count
def searchControll(self): try: nearby_devices = bluetooth.discover_devices() for bdaddr in nearby_devices: if self.target_name == bluetooth.lookup_name( bdaddr ): self.target_address = bdaddr break if self.target_address is not None: print "Dispositivo encontrado com o endereço ", self.target_address #recebe do dispostivo #envia pra o controle sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM ) sock.connect((self.target_address, self.port)) print("conexao aceita") sock.send(self.comannd) sock.close() else: print "Nao há dispositivos na proximidade" except Exception as e: print e
def __init__(self): target = "BT-GPS" nearby_devices = bluetooth.discover_devices() for dev in nearby_devices: if bluetooth.lookup_name(dev) == target: # Get GPS stuff pass
def find_device(self): while self.run and not self.connected: if bluetooth_available: if self.last_mac: for i in range(100): print "lost connection? trying to reconnect to last mac, try:" , i try: self.btconnect(self.last_mac) break except Exception, e: print e print traceback.format_exc() time.sleep(0.3) devices_macs = bluetooth.discover_devices() print "found: " , devices_macs for device_mac in devices_macs: if device_mac in config.macs: self.btconnect(device_mac) return for device_mac in devices_macs: if bluetooth.lookup_name(device_mac) in config.names: self.btconnect(device_mac) #time.sleep(2) return try: self.sock = None self.ser = serial.Serial(self.list_serial_ports()[0], 115200, timeout=1) print "connected to " , self.ser self.flush_input() self.connected = True return except Exception as e: print("could not connect, retrying in 3s\n", e ) time.sleep(3)
def get_nearest_phone(self): #finds the phone with the best rssi value. returns a tuple with phone_name,mac_address,rssi_value nearest_phone = None snatcher = RSSI_snatcher(self.logger) #class that gets the signal strength of a phone devices = bluetooth.discover_devices() for address in devices: new_phone = snatcher.get_device_strength(address) print("NewPhone: "+str(new_phone)) print >> self.logger, "NewPhone: "+str(new_phone) if self.is_valid(new_phone): #executes if phone is registered print("Phone: "+new_phone[0]+" is registered") print >> self.logger, "Phone: "+new_phone[0]+" is registered" if nearest_phone == None: nearest_phone = new_phone elif new_phone[1] >= nearest_phone[1]: #checks RSSI value is stronger and sets the strongest as nearest phone nearest_phone = new_phone else: print("Phone: "+new_phone[0]+" is not registered") print >> self.logger, "Phone: "+new_phone[0]+" is not registered" if nearest_phone != None: #creates final return value nearest_phone = (bluetooth.lookup_name(nearest_phone[0]) ,nearest_phone[0],nearest_phone[1]) else: nearest_phone = "No Devices Detected" print("NearestPhone: "+str(nearest_phone)) print >> self.logger, "NearestPhone: "+str(nearest_phone) return nearest_phone
# Simple APRS Receiver and GPX Exporter for Python 3.5 # Works only with Mobilinkd TNC with Bluetooth # # Copyright (C) 2019, Juha-Pekka Varjonen, Juvar, OH1FWW # Version 1.0 # import bluetooth, re, ax25 from datetime import datetime import zipfile, zlib # search all available bt devices and put them to array results = [] try: btDevices = bluetooth.discover_devices(lookup_names=True, flush_cache=True, duration=8) except bluetooth.btcommon.BluetoothError as err: print("Info: %s" % err.args) exit() except OSError: #No such device (if no bt adapters) print("Info: No adapters") exit() for addr, name in btDevices: results.append([name, addr, 1]) # inform user about available bt devices # Automatically select Mobilinkd TNC # exit if not any bt devices mobilinkd = "" if (len(results) > 0):
def runMenu(): while(True): print() print("1. engineer") print("2. user") selection = input("Select an option: ") print() if(selection == "1"): print() print("3. scan QR") print("4. open the car") selection1 = input("Select an option: ") print() if (selection1 == "3"): while True: _, img = cap.read() data, bbox, _ = detector.detectAndDecode(img) if(bbox is not None): for i in range(len(bbox)): cv2.line(img, tuple(bbox[i][0]), tuple(bbox[(i+1) % len(bbox)][0]), color=(255, 0, 255), thickness=2) cv2.putText(img, data, (int(bbox[0][0][0]), int(bbox[0][0][1]) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) conn = sqlite3.connect(DB_NAME) conn.row_factory = sqlite3.Row c = conn.cursor() print(data) with conn: c.execute("SELECT * FROM engineer WHERE AccountID = ?", (data)) row = c.fetchone() print(row) cv2.imshow("code detector", img) if(cv2.waitKey(1) == ord("q")): break else: print("Performing inquiry...") nearby_devices = bluetooth.discover_devices(duration=8, lookup_names=True, flush_cache=True, lookup_class=False) print("Found {} devices".format(len(nearby_devices))) for addr, name in nearby_devices: try: print(" {} - {}".format(addr, name)) if addr == "8C:83:E1:D0:84:03": print ("the car is open") else: print ("Alert") except UnicodeEncodeError: print(" {} - {}".format(addr, name.encode("utf-8", "replace"))) else: print() print("1. use the username and password") print("2. facial checking") selection2 = input("Select an option: ") print() if (selection2 == "1"): name = input("username: "******"password:"******"nhan.jpg") my_face_encoding = face_recognition.face_encodings(picture_of_me)[0] # Load a second sample picture and learn how to recognize it. duy = face_recognition.load_image_file("duy.jpg") duy_face_encoding = face_recognition.face_encodings(duy)[0] # Create arrays of known face encodings and their names known_face_encodings = [ my_face_encoding, duy_face_encoding ] known_face_names = [ "Thanh Nhan","Khang Duy" ] # Initialize some variables face_locations = [] face_encodings = [] face_names = [] process_this_frame = True count=0 # dbx = dropbox.Dropbox('6lYXOy3Wb2AAAAAAAAAADjd3j3ycNSoJ7e3FoakEJ-hqk3DMeMsPZe-9TVZAFilf') # Get a reference to webcam #0 (the default one) while True: var = input("Launch The Security Service? ") if str(var) == "Yes": break while True: # Grab a single frame of video ret, frame = cap.read() # Resize frame of video to 1/4 size for faster face recognition processing small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25) # Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses) rgb_small_frame = small_frame[:, :, ::-1] # Only process every other frame of video to save time if process_this_frame: # Find all the faces and face encodings in the current frame of video face_locations = face_recognition.face_locations(rgb_small_frame) face_encodings = face_recognition.face_encodings(rgb_small_frame, face_locations) face_names = [] for face_encoding in face_encodings: # See if the face is a match for the known face(s) matches = face_recognition.compare_faces(known_face_encodings, face_encoding) name = "Unknown" # If a match was found in known_face_encodings, just use the first one. if True in matches: first_match_index = matches.index(True) name = known_face_names[first_match_index] face_names.append(name) if name == "Unknown": print("Unknown people Warning") else: print("Car Door Opening...!!!!") break process_this_frame = not process_this_frame # Display the results for (top, right, bottom, left), name in zip(face_locations, face_names): # Scale back up face locations since the frame we detected in was scaled to 1/4 size top *= 4 right *= 4 bottom *= 4 left *= 4 # Draw a box around the face cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2) # Draw a label with a name below the face cv2.rectangle(frame, (left, bottom - 35), (right, bottom), (0, 0, 255), cv2.FILLED) font = cv2.FONT_HERSHEY_DUPLEX cv2.putText(frame, name, (left + 6, bottom - 6), font, 1.0, (255, 255, 255), 1) # Display the resulting image cv2.imshow('Video', frame) # Hit 'q' on the keyboard to quit! if cv2.waitKey(1) & 0xFF == ord('q'): print("System Shutdown!!") break
def Discover(self): self.btDevices = bluetooth.discover_devices(lookup_names=True) if len(self.btDevices) > 0: return self.btDevices else: return None
def push_request(): nearby_devices = bluetooth.discover_devices(duration=10, lookup_names=True) return nearby_devices
#!/usr/bin/python3 import bluetooth as bt for (addr, name) in bt.discover_devices(lookup_names=True): print("%s %s" % (addr, name))
f.write(imgdata) f.close() client_sock.close() server_sock.close() print "Screenshot received from client. Image save as \'", filename, "\'" elif (choice0 == 2): print "------------------------------------------------------------------" print "1) Discover New Device \t\t 2) Enter MAC Address Manually" print "------------------------------------------------------------------" print choice1 = int(input("Choice? ")) if (choice1 == 1): print "Searching for nearby bluetooth-enabled devices for 10 seconds" devices = bluetooth.discover_devices(duration = 10, lookup_names = True) i = 1 for address, name in devices: print "\t", i, ") ", name, " : ", address i += 1 choice2 = int(input("Choice? ")) if (1 <= choice2 <= len(devices)): MAC_Address = devices[choice2-1][0] elif(choice1 == 2): MAC_Address = input("Enter MAC Address: ") sock = bluetooth.BluetoothSocket(bluetooth.L2CAP) bt_addr = MAC_Address port = 0x1001
def run(file_flag): # Shimer MAC addresses # shimm_addr= ["00:06:66:46:9A:67", "00:06:66:46:B6:4A"]#, "00:06:66:46:BD:8D", "00:06:66:46:9A:1A", "00:06:66:46:BD:BF"] shimm_addr = ["00:06:66:46:B7:D4"] emg_addr = [] # ["00:06:66:46:9A:1A", "00:06:66:46:BD:BF"] # Configuration parameters scan_flag = 1 plot_flag = 0 sock_port = 1 nodes = [] plt_axx = 500 plt_ylim = 4000 plt_rate = 20 rng_size = 50 # rng_acc_x=RingBuffer(50) # Add sample to ringbuffer # rng_acc_x.append(pack_0) # buff1= np.zeros((n_nodes,10,rng_size),dtype=np.int) # buff2= np.zeros((n_nodes,10,rng_size),dtype=np.int) # buff_flag= 1 # buff= [[[0 for x in range(10)] for y in range(2)] for z in range(rng_size)] # buff_idx= 0 if plot_flag == 1: # plot parameters sample_idx = 0 analogData = AnalogData(plt_axx) # Get the list of available nodes if scan_flag == 0: target_addr = shimm_addr else: try: target_addr = [] print("Scanning bluetooth devices...") nearby_devices = bluetooth.discover_devices() for bdaddr in nearby_devices: print(" " + str(bdaddr) + " - " + bluetooth.lookup_name(bdaddr)) if bdaddr in shimm_addr: target_addr.append(bdaddr) except: print("[Error] Problem while scanning bluetooth") sys.exit(1) n_nodes = len(target_addr) if n_nodes > 0: print(("Found %d target Shimmer nodes") % (len(target_addr))) else: print("Could not find target bluetooth device nearby. Exiting") sys.exit(1) print("Configuring the nodes...") for node_idx, bdaddr in enumerate(target_addr): try: # Connecting to the sensors sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) if bdaddr in emg_addr: n = shimmer_node(bdaddr, sock, 0x2) else: n = shimmer_node(bdaddr, sock, 0x1) nodes.append(n) print((bdaddr, sock_port), end=' ') nodes[-1].sock.connect((bdaddr, sock_port)) print(" Shimmer %d (" % (node_idx) + bluetooth.lookup_name(bdaddr) + ") [Connected]") # send the set sensors command nodes[-1].sock.send( struct.pack('BBB', 0x08, nodes[-1].senscfg_hi, nodes[-1].senscfg_lo)) nodes[-1].wait_for_ack() # send the set sampling rate command nodes[-1].sock.send(struct.pack('BB', 0x05, 0x14)) # 51.2Hz nodes[-1].wait_for_ack() # Inquiry command print(" Shimmer %d (" % (node_idx) + bluetooth.lookup_name(bdaddr) + ") [Configured]") nodes[-1].sock.send(struct.pack('B', 0x01)) nodes[-1].wait_for_ack() inq = nodes[-1].read_inquiry() except bluetooth.btcommon.BluetoothError as e: print(("BluetoothError during read_data: {0}".format(e.strerror))) print("Unable to connect to the nodes. Exiting") sys.exit(1) # Create file and plot try: if file_flag == 1: # Create buffer now = datetime.datetime.now() qc.make_dirs('../DATA') logname = "../DATA/IMU_" + now.strftime("%Y%m%d%H%M") + ".log" print("[cnbi_shimmer] Creating file: %s" % (logname)) outfile = open(logname, "w") for node_idx, shim in enumerate(nodes): outfile.write(str(node_idx) + ": " + str(shim.addr) + "\n") outfile.close() fname = "../DATA/IMU_" + now.strftime("%Y%m%d%H%M") + ".dat" print("[cnbi_shimmer] Creating file: %s" % (fname)) outfile = open(fname, "w") # Create plot if plot_flag == 1: analogPlot = AnalogPlot(analogData) plt.axis([0, plt_axx, 0, plt_ylim]) plt.ion() plt.show() except: print("[Error]: Error creating file/plot!! Exiting") # close the socket print("Closing nodes") for node_idx, shim in enumerate(nodes): shim.sock.close() print(" Shimmer %d [Ok]" % (node_idx)) sys.exit(1) print( "[cnbi_shimmer] Recording started. Press Ctrl+C to finish recording.") # send start streaming command for shim in nodes: shim.sock.send(struct.pack('B', 0x07)) for node_idx, shim in enumerate(nodes): shim.wait_for_ack() shim.up = 1 print(" Shimmer %d [Ok]" % (node_idx)) # Main acquisition loop while True: try: sample = [] sample_lslclock = [] for shim in nodes: if shim.up == 1: sample.append(shim.read_data()) else: sample.append([0] * (shim.n_fields)) for samp in sample: sample_lslclock.append([pylsl.local_clock()] + list(samp[1:])) if file_flag == 1: simplejson.dump(sample_lslclock, outfile, separators=(',', ';')) outfile.write('\n') # print sample # plt.title(str(sample[0][0])) # leeq if plot_flag == 1: analogData.add([sample[0][1], sample[0][2]]) sample_idx = sample_idx + 1 if sample_idx % plt_rate == 0: analogPlot.update(analogData) if file_flag == 0: print(qc.list2string(sample_lslclock[1], '%9.1f', ' ')) # Exit if key is pressed except KeyboardInterrupt: print("\n[cnbi_shimmer] Stopping acquisition....") break except bluetooth.btcommon.BluetoothError as e: print(("[Error] BluetoothError during read_data: {0}".format( e.strerror))) # send stop streaming command print("[cnbi_shimmer] Stopping streaming") try: for shim in nodes: shim.sock.send(struct.pack('B', 0x20)) for node_idx, shim in enumerate(nodes): shim.wait_for_ack() print(" Shimmer %d [Ok]" % (node_idx)) except bluetooth.btcommon.BluetoothError as e: print(("[Error] BluetoothError during read_data: {0}".format( e.strerror))) ''' n_nodes = len(target_addr) while n_nodes>0: sample= [] for node_idx,shim in enumerate(nodes): pckt= shim.wait_stop_streaming() print " Shimmer %d [waiting]" % (node_idx) if len(pckt) != 1: sample.append(pckt) else: sample.append(str("0"*(shim.samplesize))) nodes.remove(shim) n_nodes= n_nodes-1 print " Shimmer %d [Ok]" % (node_idx) simplejson.dump(sample, outfile, separators=(',',';')) analogData.add([sample[0][1],sample[1][1]]) analogPlot.update(analogData) ''' # Closing file if file_flag == 1: print("[cnbi_shimmer] Closing file: %s" % (fname)) try: outfile.close() except: print(" [Error] Problem closing file!") # close the socket print("[cnbi_shimmer] Closing nodes") for node_idx, shim in enumerate(nodes): shim.sock.close() print(" Shimmer %d [Ok]" % (node_idx)) print("[cnbi_shimmer] Recording Finished. Please close this window.") getch()
def search(): devices = bluetooth.discover_devices(duration=5, lookup_names = True) return devices
def scan(self): nearby_devices = bluetooth.discover_devices(lookup_names=True) print("Found {} devices.".format(len(nearby_devices))) for addr, name in nearby_devices: print(" {} - {}".format(addr, name))
def scan(self, duration=10): devices = bluetooth.discover_devices(duration, lookup_names=True) for addr, name in devices: if str(name).startswith('Spark'): logging.debug('Found {0} MAC {1}'.format(name, addr)) self.spark_mac = addr
def lookUpNearbyBluetoothDevices(): nearby_devices = bluetooth.discover_devices() for bdaddr in nearby_devices: print str(bluetooth.lookup_name( bdaddr )) + " [" + str(bdaddr) + "]"
def prog( data, timing ): #Function containing the actual identifying of Bluetooth devices in the server print('IN?') t = 1 print(timing) data.writerow(timing) for t in range( t, 120 ): #looped 120 times, since each loop takes about 1 minute, results in a two hour loop file_time = time.strftime('%D %H:%M:%S', time.gmtime()) device_lookup = bluetooth.discover_devices( lookup_names=True) #Looking up Bluetooth Devices blue(device_lookup) for addr, name in device_lookup: ident = '%s' % (name) address = '%s' % (addr) print(time.strftime('%a, %D %H:%M:%S', time.gmtime())) result = bluetooth.lookup_name(address, timeout=5) if ( result != None ): #If devices are present, the program will search firebase for their codes server = firebase.get( '/ais', None ) #Searches a directory we named ais for the Bluetooth devices values = server.values( ) #Shows all Bluetooth Addresses present on the server print(values) position = str(values).find( str(address) ) #Searches for any common devices amongst the perceived devices and those on the server print(position) position = position - 3 n = position % 22 #Position returns an integer which represents the position of the first starting character of the address #Each address takes up about 22 character spaces #When looking up the item in the list, its list number must be found, which is its position relative to its character number #hence it is position divided 22 final_integer = int( math.floor(n) ) #This would return a decimal, thus we need the closest integer rounded down #We take the math.floor value of the decimal n print(final_integer) if ( int(position) < 0 ): #This is present to prevent the non-server addresses from interfering with the rest of the empty = [] empty.append(final_integer) elif ( position >= 0 ): #Finds the perceived devices also present on the server, then writes them to the csv file value_final = values[final_integer] result_final = bluetooth.lookup_name(value_final, timeout=5) data.writerow(result_final + ' ' + value_final + ' ' + file_time) if (result == None): #writes none if no devices are detected print('none found at the moment') data.writerow('None Found at the Moment') t = t + 1 time.sleep(10)
def discover(): nearby_devices = bluetooth.discover_devices(lookup_names=True) LOGGER.info(f'discovered {nearby_devices}') return nearby_devices
def find_bricks(host=None, name=None): for h, n in bluetooth.discover_devices(lookup_names=True): if _check_brick(host, h) and _check_brick(name, n): yield BlueSock(h)
# -*- coding: utf-8 -*- """ Spyder Editor This is a temporary script file. """ # simple inquiry example import bluetooth nearby = bluetooth.discover_devices() for b in nearby: print(bluetooth.lookup_name(b))
import bluetooth as bt print "Searching for devices..." print "" nearby_devices = bt.discover_devices() #Run through all the devices found and list their name num = 0 print "Select your device by entering its coresponding number..." for i in nearby_devices: num+=1 print num , ": " , bt.lookup_name( i ) selection = input("> ") - 1 print "You have selected", bluetooth.lookup_name(nearby_devices[selection]) bd_addr = nearby_devices[selection] port = 1 print "Generating Socket..." sock = bt.BluetoothSocket(RFCOMM) sock.connect((bd_addr,port)) while True: command = input("> Enter command to be sent to the robot...") sock.send(command)
#!/usr/bin/env python3 #ifdef _WIN32 #include <Winsock2.h> #endif import bluetooth print("local Bluetooth device address - {}".format( bluetooth.read_local_bdaddr())) print("Performing inquiry...") nearby_devices = bluetooth.discover_devices(duration=8, lookup_names=True, flush_cache=True, lookup_class=False) print("Found {} devices".format(len(nearby_devices))) for addr, name in nearby_devices: try: print(" {} - {}".format(addr, name)) except UnicodeEncodeError: print(" {} - {}".format(addr, name.encode("utf-8", "replace"))) print(nearby_devices) Engineer_devices = ['9C:B6:D0:FA:B0:54', 'others'] print(Engineer_devices) for addr, name in nearby_devices:
def __init__(self): pygame.init() # Used to manage how fast the screen updates self._clock = pygame.time.Clock() # Loop until the user clicks the close button. self._done = False # Used to manage how fast the screen updates self._clock = pygame.time.Clock() # Kinect runtime object, we want only color and body frames self._kinect = PyKinectRuntime.PyKinectRuntime( PyKinectV2.FrameSourceTypes_Infrared) # back buffer surface for getting Kinect infrared frames, 8bit grey, width and height equal to the Kinect color frame size self._frame_surface = pygame.Surface( (self._kinect.infrared_frame_desc.Width, self._kinect.infrared_frame_desc.Height), 0, 24) # here we will store skeleton data self._bodies = None # Set the width and height of the screen [width, height] self._infoObject = pygame.display.Info() self._screen = pygame.display.set_mode( (self._kinect.infrared_frame_desc.Width, self._kinect.infrared_frame_desc.Height), pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.RESIZABLE, 32) self.target = [100, 100] self.turnCheck = False pygame.display.set_caption("Kinect for Windows v2 Infrared") ## Bluetooth target_name = "HC-05" target_address = None while (target_address is None): nearby_devices = bluetooth.discover_devices() print(nearby_devices) for bdaddr in nearby_devices: print(bluetooth.lookup_name(bdaddr)) if target_name == bluetooth.lookup_name(bdaddr): target_address = bdaddr break if target_address is not None: print("found target bluetooth device with address ", target_address) self.sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) print("Trying connection") i = 0 # ---- your port range starts here maxPort = 3 # ---- your port range ends here err = True while err == True and i <= maxPort: print("Checking Port ", i) port = i try: self.sock.connect((target_address, port)) err = False except Exception: ## print the exception if you like i += 1 if i > maxPort: print("Port detection Failed.") return # print("Trying sending") # self.sock.send("1 2 3") # print("Finished sending") else: print("could not find target bluetooth device nearby")
def search(): devices = bluetooth.discover_devices(duration = 5,flush_cache=True, lookup_names = False) return devices
# file: inquiry.py # auth: Albert Huang <*****@*****.**> # desc: performs a simple device inquiry followed by a remote name request of # each discovered device # $Id: inquiry.py 401 2006-05-05 19:07:48Z albert $ # #If you are getting errors running this, sudo apt-get install bluetooth. import bluetooth print("performing inquiry...") nearby_devices = bluetooth.discover_devices(lookup_names=True) print("found %d devices" % len(nearby_devices)) for addr, name in nearby_devices: print(" %s - %s" % (addr, name))
def get_socket_stream_list(self): paired_devices = bluetooth.discover_devices(lookup_names=True) return paired_devices
def lookUpNearbyBluetoothDevices(): print("Scanning...") nearby_devices = bluetooth.discover_devices() for bdaddr in nearby_devices: print(str(bluetooth.lookup_name(bdaddr)) + " [" + str(bdaddr) + "]")
def listAvailable(self): nearbyDevices = bluetooth.discover_devices(lookup_names=True) print("found %d devices" % len(nearbyDevices)) for addr, name in nearbyDevices: print(" %s - %s" % (addr, name))
def lookUpNearbyBluetoothDevices(): nearby_devices = bt.discover_devices() for bdaddr in nearby_devices: print((bt.lookup_name(bdaddr)) + " [" + (bdaddr) + "]")
def run(self): nearby_devices = bluetooth.discover_devices(lookup_names = True) return nearby_devices
while 1: line = ser.readline() if line: f.write(line) except KeyboardInterrupt: f.close() ser.close() """ data_json = {"y": [], "x": [], "button_R": [], "button_L": []} ############ serial ########### ############################### print "Searching for devices..." print "" devices = bluetooth.discover_devices() num = 0 print "Select your device by entering its coresponding number..." for i in devices: num += 1 print num, ": ", bluetooth.lookup_name(i) selection = input("> ") - 1 print "You have selected", bluetooth.lookup_name(devices[selection]) bd_addr = devices[selection] print "--", bd_addr port = 1 sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
search_time = 10 led_pin = "P8_7" # You can hardcode the desired device ID here as a string to skip the discovery stage addr = None print("Welcome to the Bluetooth Detection Demo! \nMake sure your desired Bluetooth-capable device is turned on and discoverable.") if addr == None: try: input("When you are ready to begin, press the Enter key to continue...") except SyntaxError: pass print("Searching for devices...") nearby_devices = bluetooth.discover_devices(duration=search_time, flush_cache=True, lookup_names=True) if len(nearby_devices) > 0: print("Found %d devices!" % len(nearby_devices)) else: print("No devices found! Please check your Bluetooth device and restart the demo!") exit(0) i = 0 # Just an incrementer for labeling the list entries # Print out a list of all the discovered Bluetooth Devices for addr, name in nearby_devices: print("%s. %s - %s" % (i, addr, name)) i =+ 1 device_num = input("Please specify the number of the device you want to track: ")
def BTDiscover(timeout): if hasBT: return bt.discover_devices(timeout, flush_cache=True, lookup_names=True) return []
def scan_button_clicked(self, widget): print "Scanning process initiated." self.quit_button.set_sensitive(False) self.scan_button.set_sensitive(False) # Inititiate WIFI Scan ############################################## # we first do the wifi scan because sometimes bluetooth discovery disables wifi connection if self.wifi: # if wifi is enabled print "Wifi scan started." ip_ = 1 while ip_ < 255: ip_ = ip_ + 1 IP = self.server_IP_template + str( ip_) # create 1xx.xx.xx.i IP's if IP == self.server_IP: # if IP is our own, continue continue if IP in self.addresses.values( ): # if already connected, continue print "Already connected to %s" % IP continue try: # discover using threads t = threading.Thread(target=self.discover, args=(IP, )) self.thread_list.append(t) except Exception as e: template = "An exception of type {0} occured. Arguments:{1!r}" mesg = template.format(type(e).__name__, e.args) print mesg for thread in self.thread_list: # start all threads thread.start() for thread in self.thread_list: # then wait for them to finish thread.join() del self.thread_list[:] # remove all threads print "Wifi scan ended." else: "Wifi scan skipped, not connected to wifi." # Initiate bluetooth scan ########################################### if self.bluetooth: print "Bluetooth scan started." for addr, name in bluetooth.discover_devices( lookup_names=True ): # discover nearby devices using library function if addr in self.addresses.values(): print "Already connected to %s" % addr continue try: # use threads to connect to bluetooth devices t = threading.Thread(target=self.discover_bluetooth, args=( addr, name, )) self.thread_list.append(t) except Exception as e: template = "An exception of type {0} occured. Arguments:{1!r}" mesg = template.format(type(e).__name__, e.args) print mesg for thread in self.thread_list: thread.start() for thread in self.thread_list: thread.join() del self.thread_list[:] print "Bluetooth scan ended." self.quit_button.set_sensitive(True) self.scan_button.set_sensitive(True) print "Done"
def _findMindwaveMobileAddress(self): nearby_devices = bluetooth.discover_devices(lookup_names=True) for address, name in nearby_devices: if (name == "MindWave Mobile"): return address return None
def debug_bt_bt(): print "looking for nearby devices..." nearby_devices = bluetooth.discover_devices(lookup_names=True, flush_cache=True, duration=20) print "found %d devices" % len(nearby_devices) for addr, name in nearby_devices: print " %s - %s" % (addr, name) print_services(bluetooth.find_service(address=addr))