def scan(self): service = DiscoveryService(self.bt_interface) \ if self.bt_interface else DiscoveryService() devices = service.discover(self.timeout_secs) return sorted([addr for addr, device in devices.items() if self.service_uuid in self._get_uuids(device)])
def search_for_authorized_eyeot_devices(): """ This function performs a BLE scan, finding all possible devices in range. It compares each device's name and MAC address against those already white listed. It returns a list of any authorized devices. Input: authorized_devices, a list containing the current MAC addresses of valid EyeoT devices in range Output: authorized_devices, a list containing the current MAC addresses of valid EyeoT devices in range """ auth_devices = list() # initialize empty service = DiscoveryService( pc.hci_num ) # use the USB BLE dongle at hci1, not the integrated Bluetooth card at hci0 devices = service.discover(2) # find all possible nearby BLE devices for address, name in devices.items(): # for all devices # if a discovered device's name and MAC address are pre-approved if address in arduino.mac_addresses: # TODO: (filter also by Arduino name?) print("Authorized EyeoT device: {} at MAC address: {}".format( name, address)) auth_devices.append(address) else: print("Rejected Device: {} at MAC address: {}".format( name, address)) return auth_devices
def list_devices_ble(): service = DiscoveryService() devices = service.discover(2) for address, name in devices.items(): print("searching devices BLE") print("name: {}, address: {}".format(name, address))
def find_dev(dev_name): service = DiscoveryService() while True: devices = service.discover(2) for address, name in devices.items(): if dev_name in name: return address
def low_scan(): # bluetooth low energy scan service = DiscoveryService() devices = service.discover(2) for address, name in devices.items(): print("name: {}, address: {}".format(name, address))
def handle(self, *args, **kwargs): while True: service = DiscoveryService() devices = service.discover(20) for address in devices: address = str(address) address = address.strip() try: b = BtScan.objects.get(bt_mac_addr=address.upper()) b.last_seen = datetime.now() b.save() print('Already known', address) except BtScan.DoesNotExist: # if new device, store it in this table then send off to workers to query it for services b = BtScan() b.created_at = datetime.now() b.last_seen = datetime.now() b.bt_mac_addr = address b.save() print('New device', address) bt_device_service_discovery.delay(address)
def find_new_xiaomi_devices(existing, duration): """ Finds all new xiaomi devices by name and address. Assigns a new name to the device in the form: Sensor xx, where xx is the next available index """ next_index = len(existing) + 1 x_devices = {} service = DiscoveryService() devices = service.discover(duration) print(f"Scanning found {len(devices)} devices.") for addr, name in devices.items(): if addr[:len(TEMP_HUM_DEV_ADDR_START)] == TEMP_HUM_DEV_ADDR_START or \ name == TEMP_HUM_DEV_NAME: if addr not in existing: device = { 'dev_name': name, 'addr': addr, 'sensor_name': "Sensor %02d" % next_index, 'history_file': f'sensor_{addr.replace(":", "")}_history.json', 'active': True, 'last_reading': None } next_index += 1 print(f"Found new device: {name}: {addr}") x_devices[addr] = device if len(x_devices): print(f"Only {len(x_devices)} were new") else: print("None were new") return x_devices
def ble(): s = DiscoveryService() devs = s.discover(2) for a, n in devs.items(): print(a, n) g.connect(True)
def scan_ble(duration=8): svc = DiscoveryService() devs = svc.discover(duration) print "Find %d devices: " % len(devs) if devs: for name, addr in devs.items(): print name, addr return devs
def bluetooth_low_energy_scan(timeout=10): """ currently Linux only """ if DiscoveryService is None: return None svc = DiscoveryService() return svc.discover(timeout)
def addresses_with_device_name(device_name): service = DiscoveryService() devices = service.discover(2) addresses = [ address for address, name in devices.items() if device_name in name ] return addresses
def register(room_id): if g.user['usertype_fk'] != 1: response = make_response( "You don't have permission to register a heater", 401) return reponse db = get_db() if request.method == 'POST': error = None mac = request.form['mac'] name = request.form['name'] room_id = request.form['room_id'] if not name: error = "You have to give the heater a name" if db.execute("SELECT * FROM heater WHERE name = ?;", (name, )).fetchone() is not None: error = "This heater is already registered" if error is None: cur = db.execute( "INSERT INTO heater(mac, name, room_fk) VALUES(?, ?, ?);", (mac, name, room_id)) db.commit() return redirect(url_for('room.view', room_id=room_id)) rooms = db.execute("SELECT * FROM room;").fetchall() room = db.execute("SELECT * FROM room WHERE id = ?;", (room_id, )).fetchone() # Scan for thermostats, try to get current status service = DiscoveryService() devices = service.discover(5) macs = [mac for mac in devices if devices[mac] == 'CC-RT-BLE'] db = get_db() heaters = [] for mac in macs: h = {} h['mac'] = mac heater = db.execute( "SELECT h.name, r.name as room FROM heater h JOIN room r ON h.room_fk = r.id WHERE h.mac = ?;", (mac, )).fetchone() if heater is not None: h['status'] = 'registered' h['name'] = heater['name'] h['assigned_to'] = heater['room'] else: h['status'] = 'unassigned' t = eq3bt.Thermostat(mac) try: t.update() h['target_temp'] = t.target_temperature h['mode'] = t.mode_readable except BTLEDisconnectError as e: print(f"Unable to connect to thermostat: {mac}") heaters.append(h) return render_template('heater/register.html', rooms=rooms, room=room, heaters=heaters)
def main(): pool = Pool(processes=1) while True: svc = DiscoveryService() devs = svc.discover(5) if devs: for addr, _ in devs.items(): pool.apply_async(handle_packet, [addr])
def bluetooth_low_energy_scan(timeout=10): svc = DiscoveryService() devs = svc.discover(timeout) print('found', len(devs), 'Bluetooth Low Energy (Smart) devices:') if devs: for u, n in devs.items(): print(u, n) return devs
def _scan_for_bt_ble_devices(self): """ :brief _scan_for_bt_ble_devices(): scan for ble devices and collect into a list. :description: The following function will be used to scan for bt devices within a 30m radius of the raspberry pi. """ service = DiscoveryService() devices = service.discover(2) for addr, name in zip(devices.keys(), devices.values()): if self._is_verified_bt_dev(name): self._bt_name_dev_dict[name] = Bt_Ble_Device(addr)
def scan(self): """ Scans for nearby BLE devices and returns their attributes """ service = DiscoveryService() print("Scanning...") dev_dict = service.discover(self.scan_duration) devices = [] for addr, name in dev_dict.items(): devices.append({'name': name, 'address': addr}) return devices
def __init__(self, mac="C4:C3:00:01:07:3F"): # Check for empty arg and correct MAC address format # Default MAC address is given otherwise if not re.match("[0-9a-f]{2}([-:])[0-9a-f]{2}(\\1[0-9a-f]{2}){4}$", mac.lower()): print("Using default MAC: C4:C3:00:01:07:3F") self.mac = "C4:C3:00:01:07:3F" else: self.mac = mac self.service = DiscoveryService() self.devices = self.service.discover(2) self.requester = GATTRequester(self.mac, False)
def scan_addresses_low_energy(self): """ Initiates a scan for bluetooth LE hardware """ service = DiscoveryService() devices = [] #print("Scanning low energy") for addr, name in service.discover(self.scan_timeout).items(): devices.append(addr) with self.available_devices_lock: self.le_devices = devices if not self.shutdown: threading.Timer(self.poll_frequency, self.scan_addresses_low_energy).start()
def scan(self): if self.bt_interface: service = DiscoveryService(self.bt_interface) else: service = DiscoveryService() print('Scanning for bluetooth low-energy devices') devices = list(service.discover(self.scan_timeout).keys()) print('Discovering Switchbot services') return [ dev for dev in devices if self.is_switchbot(dev, self.bt_interface, self.connect_timeout) ]
def discover_camera(): cameras = [] service = DiscoveryService() devices = service.discover(2) for address, name in devices.items(): if name.startswith("GoPro"): cameras.append([name, address]) if len(cameras) == 0: print("No cameras detected.") exit() if len(cameras) == 1: return cameras[0][1] for index, i in enumerate(cameras): print("[{}] {} - {}".format(index, i[0], i[1])) return cameras[int(input("ENTER BT GoPro ADDR: "))][1]
def discover_btle(self): if DiscoveryService is None: return logging.info("Scanning lowenergy devices") ledevices = DiscoveryService().discover(10) timestamp = datetime.now().isoformat() logging.info("Discovered %d low energy devices" % len(ledevices.keys())) for address, name in ledevices.items(): if name is not None and len(name) == 0: name = None if name is not None: self.send_reading('/'.join([address, "name"]), name) self.send_reading('/'.join([address, "le"]), True) self.send_reading('/'.join([address, "last_seen"]), timestamp)
def scan(self, interface: Optional[str] = None, duration: int = 10) -> BluetoothScanResponse: """ Scan for nearby bluetooth low-energy devices :param interface: Bluetooth adapter name to use (default configured if None) :param duration: Scan duration in seconds """ from bluetooth.ble import DiscoveryService if interface is None: interface = self.interface self._check_ble_support() svc = DiscoveryService(interface) devices = svc.discover(duration) return BluetoothScanResponse(devices)
def fixtureServer(): import requests import socket global lat global lon global location r = requests.get(send_url) j = json.loads(r.text) lat = j['latitude'] lon = j['longitude'] location = socket.gethostname() print "Location is " + location print "Latitude is " + str(lat) print "Longitude is " + str(lon) service = DiscoveryService() client = mqtt.Client("sensortagList") mqtt.Client.connected_flag = False client.on_connect = onConnect client.connect("127.0.0.1") client.on_message = onMessage client.loop_start() # Wait for connection while not client.connected_flag: pass # Subscribe to topics that control the tags behaviour client.subscribe("selectTag") #.subscribe("controlTag") # While we are connected while client.connected_flag: devices = service.discover(2) # scan for devices scan(devices) # stream MQTT data print fixture_list client.publish("fixture_list", payload=json.dumps(fixture_list), qos=2, retain=False) time.sleep(1) client.loop_stop() client.disconnect()
def __init__(self, devName, bleAccessToken): self.onScan = async .SubscribeHub() self.devName = devName self._token = bleAccessToken self._thread = _ScanThread_(DiscoveryService(devName), self._token, self._onDeviceDiscovered) self._seenMbs = collections.OrderedDict() self._notMbs = collections.deque(maxlen=self.max_seen_mbs)
class BLEScanner(DeviceScanner): def __init__(self, observation_queue): DeviceScanner.__init__(self, observation_queue) self.service = DiscoveryService() def scan(self): return self.service.discover(self.timeout)
def scanBLE(ser): postList = [] service = DiscoveryService() devices = service.discover(2) l = [] for address, name in devices.items(): address = address.replace(':', '') address = [ address[i * 2:i * 2 + 2] for i in xrange(len(address) / 2) ] #print (address) l.extend(address) #print (l) return l
def find_devices(self): mac_addrs = [] nearby_devices = bluetooth.discover_devices() if nearby_devices: be_addrs = [addr for addr, name in nearby_devices] if be_addrs: mac_addrs.extend(be_addrs) service = DiscoveryService() devices = service.discover(2) be_le_addrs = devices.keys() if be_le_addrs: mac_addrs.extend(be_le_addrs) if mac_addrs: mac_addrs = [ self.get_mac_vendor(mac_addr) for mac_addr in mac_addrs if self.get_mac_vendor(mac_addr) ] return mac_addrs
def scanForBTDevices(): bt_devices = {"devices_classic": {0: {}}, "devices_ble": {0: {}}} devices = bluetooth.discover_devices(lookup_names=True) i = 0 for dev in devices: x, y = dev bt_devices["devices_classic"][i] = {"name": y, "addr": x} i += 1 service = DiscoveryService() devices = service.discover(2) i = 0 for key in devices.keys(): bt_devices["devices_ble"][i] = {"name": devices[key], "addr": key} i += 1 #(lambda x: print(devices[x]))(devices.keys) #print(bt_devices) json_devices = json.dumps(bt_devices, indent=4) print(json_devices)
def main(): connected = 0 error = None target_addr = " " if request.method == 'POST': target_addr = request.form['ConnName'] service = DiscoveryService() devices = service.discover(2) for bluetooth_addr, name in devices.items(): if target_addr == bluetooth_addr: connected = 1 return redirect(url_for('connect')) # for bluetooth_addr in nearby_devices: # if target_name == bluetooth.lookup_name(bluetooth_addr): # target_address = bluetooth_addr # connected = 1 # return redirect(url_for('connect')) return render_template("bluetooth.html", connection=connected)
#!/usr/bin/env python3 from bluetooth.ble import DiscoveryService service = DiscoveryService() devices = service.discover(2) for address, name in devices.items(): print("name: {}, address: {}".format(name, address))
def scan(self): service = DiscoveryService(self.bt_interface) \ if self.bt_interface else DiscoveryService() devices = service.discover(self.timeout_secs) return list(devices.keys())
# bluetooth low energy scan from bluetooth.ble import DiscoveryService service = DiscoveryService() devices = service.discover(2) for address, name in devices.items(): print("name: {}, address: {}".format(name, address))