def __init__(self, hass, devices, bt_device_id): """Construct interface object.""" self.hass = hass # List of beacons to monitor self.devices = devices # Number of the bt device (hciX) self.bt_device_id = bt_device_id def callback(bt_addr, _, packet, additional_info): """Handle new packets.""" self.process_packet( additional_info["namespace"], additional_info["instance"], packet.temperature, ) from beacontools import ( # pylint: disable=import-error BeaconScanner, EddystoneFilter, EddystoneTLMFrame, ) device_filters = [ EddystoneFilter(d.namespace, d.instance) for d in devices ] self.scanner = BeaconScanner(callback, bt_device_id, device_filters, EddystoneTLMFrame) self.scanning = False
def _start_scanner(enabled_providers: list, timeout_seconds: int, simulate_beacons: bool, console_log: bool): if simulate_beacons: threading.Thread(name='background', target=_start_beacon_simulation).start() else: scanner = BeaconScanner(_beacon_callback) scanner.start() print("...started: Tilt scanner") print("Ready! Listening for beacons") start_time = time.time() end_time = start_time + timeout_seconds last_scanner_reset = time.time() time_to_reset_scanner = last_scanner_reset + 60 while True: _handle_pitch_queue(enabled_providers, console_log) if time.time() > time_to_reset_scanner: last_scanner_reset = time.time() time_to_reset_scanner = last_scanner_reset + 60 scanner.end() scanner = BeaconScanner(_beacon_callback) scanner.start() print("...restarted: Tilt scanner") # check timeout if timeout_seconds: current_time = time.time() if current_time > end_time: return # stop
def __init__(self, hass, devices, bt_device_id): """Construct interface object.""" self.hass = hass # List of beacons to monitor self.devices = devices # Number of the bt device (hciX) self.bt_device_id = bt_device_id def callback(bt_addr, _, packet, additional_info): """Handle new packets.""" temperature = struct.unpack('<h', struct.pack('>H', packet.temperature))[0] / 256 self.process_packet( additional_info['namespace'] if additional_info else None, additional_info['instance'] if additional_info else None, bt_addr, temperature) # pylint: disable=import-error from beacontools import ( BeaconScanner, BtAddrFilter, EddystoneFilter, EddystoneTLMFrame) device_filters = [(BtAddrFilter(d.mac) if d.mac else EddystoneFilter(d.namespace, d.instance)) for d in devices] self.scanner = BeaconScanner( callback, bt_device_id, device_filters, EddystoneTLMFrame) self.scanning = False
def start(self): def callback(bt_addr, rssi, packet, additional_info): self.scanner._mon.toggle_scan(False) sg = additional_info['minor'] / 1000 t_f = additional_info['major'] self.grav = 135.997 * (sg**3) - 630.272 * ( sg**2) + 1111.14 * sg - 616.868 self.temp = (t_f - 32) * 5 / 9. self.scanner = BeaconScanner(callback, packet_filter=IBeaconAdvertisement) async def run(): devices = await discover() loop = asyncio.get_event_loop() loop.run_until_complete(run()) self.scanner.start() def _run(): while True: time.sleep(self.period) self.scanner._mon.toggle_scan(True) threading.Thread(target=_run).start()
def test_process_packet_dev_filter4(self): """Test processing of a packet and callback execution with cj Monitor device filter.""" callback = MagicMock() scanner = BeaconScanner(callback, device_filter=CJMonitorFilter()) pkt = b"\x04\x3e\x29\x02\x01\x00\x00\x43\x56\x5b\x57\x0b\x00\x1d" \ b"\x02\x01\x06\x05\x02\x1a\x18\x00\x18" \ b"\x09\xff\x72\x04\xfe\x10\xbc\x0c\x37\x59" \ b"\x09\x09\x4d\x6f\x6e\x20\x35\x36\x34\x33\xaa" scanner._mon.process_packet(pkt) self.assertEqual(1, callback.call_count) args = callback.call_args[0] self.assertEqual("00:0b:57:5b:56:43", args[0]) self.assertEqual(-86, args[1]) self.assertIsInstance(args[2], CJMonitorAdvertisement) self.assertEqual( 'CJMonitorAdvertisement<name: Mon 5643, temp: 32.6,humidity: 55, light: 160>', str(args[2])) self.assertEqual( { "beacon_type": CJ_TEMPHUM_TYPE, "company_id": CJ_MANUFACTURER_ID, 'name': 'Mon 5643', 'light': 159.9, "temperature": 32.6, "humidity": 55 }, args[3]) # Test same packet with different beacon type, should be ignored. scanner = BeaconScanner( callback, device_filter=CJMonitorFilter(beacon_type=4351)) scanner._mon.process_packet(pkt) self.assertEqual(1, callback.call_count)
class Monitor(object): """Continously scan for BLE advertisements.""" def __init__(self, hass, devices, bt_device_id): """Construct interface object.""" self.hass = hass # list of beacons to monitor self.devices = devices # number of the bt device (hciX) self.bt_device_id = bt_device_id def callback(bt_addr, _, packet, additional_info): """Callback for new packets.""" self.process_packet(additional_info['namespace'], additional_info['instance'], packet.temperature) # pylint: disable=import-error from beacontools import (BeaconScanner, EddystoneFilter, EddystoneTLMFrame) # Create a device filter for each device device_filters = [ EddystoneFilter(d.namespace, d.instance) for d in devices ] self.scanner = BeaconScanner(callback, bt_device_id, device_filters, EddystoneTLMFrame) self.scanning = False def start(self): """Continously scan for BLE advertisements.""" if not self.scanning: self.scanner.start() self.scanning = True else: _LOGGER.debug("Warning: start() called, but scanner is already" " running") def process_packet(self, namespace, instance, temperature): """Assign temperature to hass device.""" _LOGGER.debug("Received temperature for <%s,%s>: %d", namespace, instance, temperature) for dev in self.devices: if dev.namespace == namespace and dev.instance == instance: if dev.temperature != temperature: dev.temperature = temperature dev.schedule_update_ha_state() def stop(self): """Signal runner to stop and join thread.""" if self.scanning: _LOGGER.debug("Stopping...") self.scanner.stop() _LOGGER.debug("Stopped") self.scanning = False else: _LOGGER.debug("Warning: stop() called but scanner was not" " running.")
class Monitor(object): """Continously scan for BLE advertisements.""" def __init__(self, hass, devices, bt_device_id): """Construct interface object.""" self.hass = hass # list of beacons to monitor self.devices = devices # number of the bt device (hciX) self.bt_device_id = bt_device_id def callback(bt_addr, _, packet, additional_info): """Callback for new packets.""" self.process_packet(additional_info['namespace'], additional_info['instance'], packet.temperature) # pylint: disable=import-error from beacontools import (BeaconScanner, EddystoneFilter, EddystoneTLMFrame) # Create a device filter for each device device_filters = [EddystoneFilter(d.namespace, d.instance) for d in devices] self.scanner = BeaconScanner(callback, bt_device_id, device_filters, EddystoneTLMFrame) self.scanning = False def start(self): """Continously scan for BLE advertisements.""" if not self.scanning: self.scanner.start() self.scanning = True else: _LOGGER.debug("Warning: start() called, but scanner is already" " running") def process_packet(self, namespace, instance, temperature): """Assign temperature to hass device.""" _LOGGER.debug("Received temperature for <%s,%s>: %d", namespace, instance, temperature) for dev in self.devices: if dev.namespace == namespace and dev.instance == instance: if dev.temperature != temperature: dev.temperature = temperature dev.schedule_update_ha_state() def stop(self): """Signal runner to stop and join thread.""" if self.scanning: _LOGGER.debug("Stopping...") self.scanner.stop() _LOGGER.debug("Stopped") self.scanning = False else: _LOGGER.debug("Warning: stop() called but scanner was not" " running.")
class Monitor: """Continuously scan for BLE advertisements.""" def __init__(self, hass, devices, bt_device_id): """Construct interface object.""" self.hass = hass # List of beacons to monitor self.devices = devices # Number of the bt device (hciX) self.bt_device_id = bt_device_id def callback(bt_addr, _, packet, additional_info): """Handle new packets.""" self.process_packet( additional_info["namespace"], additional_info["instance"], packet.temperature, ) device_filters = [EddystoneFilter(d.namespace, d.instance) for d in devices] self.scanner = BeaconScanner( callback, bt_device_id, device_filters, EddystoneTLMFrame ) self.scanning = False def start(self): """Continuously scan for BLE advertisements.""" if not self.scanning: self.scanner.start() self.scanning = True else: _LOGGER.debug("start() called, but scanner is already running") def process_packet(self, namespace, instance, temperature): """Assign temperature to device.""" _LOGGER.debug( "Received temperature for <%s,%s>: %d", namespace, instance, temperature ) for dev in self.devices: if ( dev.namespace == namespace and dev.instance == instance and dev.temperature != temperature ): dev.temperature = temperature dev.schedule_update_ha_state() def stop(self): """Signal runner to stop and join thread.""" if self.scanning: _LOGGER.debug("Stopping") self.scanner.stop() _LOGGER.debug("Stopped") self.scanning = False else: _LOGGER.debug("stop() called but scanner was not running")
class Monitor: """Continuously scan for BLE advertisements.""" def __init__(self, hass, devices, bt_device_id): """Construct interface object.""" self.hass = hass # List of beacons to monitor self.devices = devices # Number of the bt device (hciX) self.bt_device_id = bt_device_id def callback(bt_addr, _, packet, additional_info): """Handle new packets.""" temperature = struct.unpack('<h', struct.pack('>H', packet.temperature))[0] / 256 self.process_packet( additional_info['namespace'] if additional_info else None, additional_info['instance'] if additional_info else None, bt_addr, temperature) # pylint: disable=import-error from beacontools import ( BeaconScanner, BtAddrFilter, EddystoneFilter, EddystoneTLMFrame) device_filters = [(BtAddrFilter(d.mac) if d.mac else EddystoneFilter(d.namespace, d.instance)) for d in devices] self.scanner = BeaconScanner( callback, bt_device_id, device_filters, EddystoneTLMFrame) self.scanning = False def start(self): """Continuously scan for BLE advertisements.""" if not self.scanning: self.scanner.start() self.scanning = True else: _LOGGER.debug( "start() called, but scanner is already running") def process_packet(self, namespace, instance, mac, temperature): """Assign temperature to device.""" _LOGGER.debug("Received temperature for <%s,%s,%s>: %d", namespace, instance, mac, temperature) for dev in self.devices: if (dev.namespace and dev.instance and dev.namespace == namespace and dev.instance == instance) or (dev.mac and dev.mac == mac): if dev.temperature != temperature: dev.temperature = temperature dev.schedule_update_ha_state() def stop(self): """Signal runner to stop and join thread.""" if self.scanning: _LOGGER.debug("Stopping...") self.scanner.stop() _LOGGER.debug("Stopped") self.scanning = False else: _LOGGER.debug( "stop() called but scanner was not running")
def _start_scanner(enabled_providers: list, timeout_seconds: int, simulate_beacons: bool, console_log: bool): if simulate_beacons: # Set daemon true so this thread dies when the parent process/thread dies threading.Thread(name='background', target=_start_beacon_simulation, daemon=True).start() else: scanner = BeaconScanner(_beacon_callback, packet_filter=IBeaconAdvertisement) scanner.start() signal.signal(signal.SIGTERM, _trigger_graceful_termination) print("...started: Tilt scanner") print("Ready! Listening for beacons") start_time = time.time() end_time = start_time + timeout_seconds try: while True: _handle_pitch_queue(enabled_providers, console_log) # check timeout if timeout_seconds: current_time = time.time() if current_time > end_time: return # stop except KeyboardInterrupt as e: if not simulate_beacons: scanner.stop() print("...stopped: Tilt Scanner (keyboard interrupt)") except Exception as e: if not simulate_beacons: scanner.stop() print("...stopped: Tilt Scanner ({})".format(e))
def test_process_packet_exposure_notification_filter(self): """Test processing of a exposure notification with device filter.""" callback = MagicMock() scanner = BeaconScanner( callback, device_filter=ExposureNotificationFilter( identifier="0d3b4f65584c582160571dd19010d41c")) # correct identifier pkt = b"\x04\x3e\x2b\x02\x01\x03\x01\xe1\xac\xca\x3d\xea\x0d\x1f\x02\x01\x1a\x03\x03\x6f" \ b"\xfd\x17\x16\x6f\xfd\x0d\x3b\x4f\x65\x58\x4c\x58\x21\x60\x57\x1d\xd1\x90\x10\xd4" \ b"\x1c\x26\x60\xee\x34\xd1" # different identifier pkt2 = b"\x04\x3e\x2b\x02\x01\x03\x01\xe1\xac\xca\x3d\xea\x0d\x1f\x02\x01\x1a\x03\x03\x6f" \ b"\xfd\x17\x16\x6f\xfd\x0d\x3b\x40\x65\x58\x4c\x58\x21\x60\x57\x1d\xd1\x90\x10\xd4" \ b"\x1c\x26\x60\xee\x34\xd1" scanner._mon.process_packet(pkt) scanner._mon.process_packet(pkt2) self.assertEqual(callback.call_count, 1) args = callback.call_args[0] self.assertEqual(args[0], "0d:ea:3d:ca:ac:e1") self.assertEqual(args[1], -47) self.assertIsInstance(args[2], ExposureNotificationFrame) self.assertEqual( args[3], { "identifier": "0d3b4f65584c582160571dd19010d41c", "encrypted_metadata": b"\x26\x60\xee\x34" })
def __init__(self, hass, devices, bt_device_id): """Construct interface object.""" self.hass = hass # list of beacons to monitor self.devices = devices # number of the bt device (hciX) self.bt_device_id = bt_device_id def callback(bt_addr, _, packet, additional_info): """Callback for new packets.""" self.process_packet(additional_info['namespace'], additional_info['instance'], packet.temperature) # pylint: disable=import-error from beacontools import (BeaconScanner, EddystoneFilter, EddystoneTLMFrame) # Create a device filter for each device device_filters = [EddystoneFilter(d.namespace, d.instance) for d in devices] self.scanner = BeaconScanner(callback, bt_device_id, device_filters, EddystoneTLMFrame) self.scanning = False
def test_multiple_filters2(self): callback = MagicMock() scanner = BeaconScanner( callback, device_filter=[ EstimoteFilter(identifier="47a038d5eb032640", protocol_version=2), EddystoneFilter(instance="000000000001") ], packet_filter=[EstimoteTelemetryFrameB, EddystoneUIDFrame]) pkt = b"\x41\x3e\x41\x02\x01\x03\x01\x35\x94\xef\xcd\xd6\x1c\x19\x02\x01\x04\x03\x03\x9a"\ b"\xfe\x17\x16\x9a\xfe\x22\x47\xa0\x38\xd5\xeb\x03\x26\x40\x01\xff\xff\xff\xff\x49"\ b"\x25\x66\xbc\x2e\x50\xdd" scanner._mon.process_packet(pkt) pkt = b"\x41\x3e\x41\x02\x01\x03\x01\x35\x94\xef\xcd\xd6\x1c\x19\x02\x01\x04\x03\x03\x9a"\ b"\xfe\x17\x16\x9a\xfe\x12\x47\xa0\x38\xd5\xeb\x03\x26\x40\x00\x00\x01\x41\x44\x47"\ b"\xf0\x01\x00\x00\x00\xdd" scanner._mon.process_packet(pkt) pkt = b"\x41\x3e\x41\x02\x01\x03\x01\x35\x94\xef\xcd\xd6\x1c\x19\x02\x01\x06\x03\x03\xaa"\ b"\xfe\x11\x16\xaa\xfe\x00\xe3\x12\x34\x56\x78\x90\x12\x34\x67\x89\x01\x00\x00\x00"\ b"\x00\x00\x01\x00\x00\xdd" scanner._mon.process_packet(pkt) pkt = b"\x41\x3e\x41\x02\x01\x03\x01\x35\x94\xef\xcd\xd6\x1c\x19\x02\x01\x06\x03\x03\xaa"\ b"\xfe\x11\x16\xaa\xfe\x00\xe3\x12\x34\x56\x78\x90\x12\x34\x67\x89\x01\x00\x00\x00"\ b"\x00\x00\x02\x00\x00\xdd" scanner._mon.process_packet(pkt) pkt = b"\x41\x3e\x41\x02\x01\x03\x01\x35\x94\xef\xcd\xd6\x1c\x19\x02\x01\x06\x03\x03\xaa"\ b"\xfe\x11\x16\xaa\xfe\x00\xe3\x12\x34\x56\x78\x90\x12\x34\x67\x89\x01\x00\x00\x00"\ b"\x00\x00\x01\x00\x00\xdd" scanner._mon.process_packet(pkt) self.assertEqual(callback.call_count, 3)
async def main(): try: global HUB_MANAGER print("\nPython %s\n" % sys.version) HUB_MANAGER = await create_hubmanager() try: scanner = BeaconScanner(callback, ) scanner.start() print("BLE thread started") except: print("Error accessing bluetooth device...") sys.exit(1) except KeyboardInterrupt: print("Module stopped")
def test_process_packet_dev_filter2(self): """Test processing of a packet and callback execution.""" callback = MagicMock() scanner = BeaconScanner(callback, device_filter=EddystoneFilter(instance="000000000001")) pkt = b"\x41\x3e\x41\x02\x01\x03\x01\x35\x94\xef\xcd\xd6\x1c\x19\x02\x01\x06\x03\x03\xaa"\ b"\xfe\x11\x16\xaa\xfe\x20\x00\x0b\x18\x13\x00\x00\x00\x14\x67\x00\x00\x2a\xc4\xe4" scanner._mon.process_packet(pkt) callback.assert_not_called()
def start_scanner(url, name, private_key): logger.info("Starting scanner") scanner = BeaconScanner(_beacon_callback, packet_filter=IBeaconAdvertisement) scanner.start() logger.info("Scanner started") while True: data = tilt_queue.get() timestamp = data['time'].isoformat() celsius = round((data['temp'] - 32) * 5.0 / 9.0, 1) gravity = round(data['gravity'] * .001, 4) logger.info( "Beer %s, timestamp %s, temp F %d, temp C %1.2f, gravity %1.4f" % (name, timestamp, data['temp'], celsius, gravity)) payload = dict() payload['name'] = name payload['timestamp'] = timestamp payload['fahrenheit'] = data['temp'] payload['celsius'] = celsius payload['gravity'] = gravity payload['signature'] = sign_data( private_key, json.dumps(payload).encode('utf-8')).decode("utf-8") payload_json = json.dumps(payload) logger.debug("Sending to %s with headers %s the payload %s" % (url, headers, payload_json)) try: response = requests.post(url, data=payload_json, headers=headers, timeout=10) response.raise_for_status() except HTTPError as http_err: logger.exception(http_err) except Exception as err: logger.exception(err) else: logger.info("Payload delivered!")
def test_process_packet_filter_bad(self): """Test processing of a packet and callback execution with packet filter.""" callback = MagicMock() scanner = BeaconScanner(callback, packet_filter=EddystoneTLMFrame) pkt = b"\x41\x3e\x41\x02\x01\x03\x01\x35\x94\xef\xcd\xd6\x1c\x19\x02\x01\x06\x03\x03\xaa"\ b"\xfe\x11\x16\xaa\xfe\x00\xe3\x12\x34\x56\x78\x90\x12\x34\x67\x89\x01\x00\x00\x00"\ b"\x00\x00\x01\x00\x00\xdd" scanner._mon.process_packet(pkt) callback.assert_not_called()
def test_process_packet_bad_packet(self): """Test processing of a packet and callback execution with a bad packet.""" callback = MagicMock() scanner = BeaconScanner( callback, device_filter=EddystoneFilter(namespace="12345678901234678901"), packet_filter=EddystoneUIDFrame) pkt = b"\x41\x3e\x41\x02\x01\x03" scanner._mon.process_packet(pkt) callback.assert_not_called()
def _start_scanner(enabled_providers: list, timeout_seconds: int, simulate_beacons: bool, console_log: bool): if simulate_beacons: threading.Thread(name='background', target=_start_beacon_simulation).start() else: scanner = BeaconScanner(_beacon_callback, packet_filter=IBeaconAdvertisement) scanner.start() print("...started: Tilt scanner") print("Ready! Listening for beacons") start_time = time.time() end_time = start_time + timeout_seconds while True: time.sleep(0.01) _handle_pitch_queue(enabled_providers, console_log) # check timeout if timeout_seconds: current_time = time.time() if current_time > end_time: return # stop
def scan_ibeacons(): # callback to show beacons read def callback(bt_addr, rssi, packet, additional_info): print("[ MAC: {} | RSSI: {} ] - {}".format(bt_addr, rssi, packet)) # intance the parser parser = argparse.ArgumentParser() # parse uuid argument parser.add_argument( '--uuid', action='store', dest='uuid', help='iBeacon UUID. Def: {}'.format(DEFAULT_BEACON_UUID)) # parse scan_time argument parser.add_argument('--time', action='store', dest='scan_time', help='Scan time. Def: {}'.format(DEFAULT_TIME_TO_SCAN)) # get result of parse arguments in args args = parser.parse_args() uuid = args.uuid if args.uuid is not None else DEFAULT_BEACON_UUID scan_time = args.scan_time if args.scan_time is not None else DEFAULT_TIME_TO_SCAN # scan for all iBeacon advertisements from beacons with the specified uuid scanner = BeaconScanner(callback, device_filter=IBeaconFilter(uuid=uuid)) # start scanning print("Starting to scan beacons with UUID={} for {} seconds".format( uuid, scan_time)) scanner.start() time.sleep(scan_time) scanner.stop() print("Scan beacons finished!")
def _scan(self): """ This function scans for iBeacon packets, save them in a list, order packets by RSSI and update near beacons attrs accordingly """ def _scans_callback(bt_addr, rssi, packet, additional_info): beacon = IBeacon(bt_addr, packet.uuid, packet.major, packet.minor, packet.tx_power, rssi) if not self._is_beacon_in_list(beacon): self._beacons_list.append(beacon) while (self._run_flag): # clear beacon list self._beacons_list = [] # instance the scanner scanner = BeaconScanner( _scans_callback, device_filter=IBeaconFilter(uuid=self._uuid_filter)) # perform the scan scanner.start() time.sleep(self._scan_tick) scanner.stop() # order the beacons list by RSSI (Power received) if len(self._beacons_list) >= 1: self._order_beacons_list() self._last_nearest_beacon = self._nearest_beacon self._nearest_beacon = self._beacons_list[0] logging.info("Nearest beacon: {}".format(self._nearest_beacon)) else: self._last_nearest_beacon = self._nearest_beacon self._nearest_beacon = None logging.info("No beacons found in this scan") # evaluate if nearest beacon has changes, if so, invoke changes callback if self._check_if_nearest_beacon_changes(): self._invoke_changes_callback()
def pitch_main(): start_message() # add any webhooks defined in config add_webhook_providers(config) # Start cloud providers print("Starting...") for provider in all_providers: if provider.enabled(): enabled_providers.append(provider) provider_start_message = provider.start() if not provider_start_message: provider_start_message = '' print("...started: {} {}".format(provider, provider_start_message)) if config.simulate_beacons: threading.Thread(name='background', target=simulate_beacons).start() else: scanner = BeaconScanner(beacon_callback) scanner.start() print("...started: Tilt scanner") print("Ready! Listening for beacons")
def init(self): if not self.communicate: scanner_callback = proximity_callback else: publisher = MQTTPublisher() scanner_callback = functools.partial(communicate_callback, publisher) self.scanner = BeaconScanner( scanner_callback, scan_parameters={"address_type": BluetoothAddressType.PUBLIC}) self.start_scan()
def test_process_packet(self): """Test processing of a packet and callback execution.""" callback = MagicMock() scanner = BeaconScanner(callback) pkt = b"\x41\x3e\x41\x02\x01\x03\x01\x35\x94\xef\xcd\xd6\x1c\x19\x02\x01\x06\x03\x03\xaa"\ b"\xfe\x11\x16\xaa\xfe\x20\x00\x0b\x18\x13\x00\x00\x00\x14\x67\x00\x00\x2a\xc4\xe4" scanner._mon.process_packet(pkt) self.assertEqual(callback.call_count, 1) args = callback.call_args[0] self.assertEqual(args[0], "1c:d6:cd:ef:94:35") self.assertEqual(args[1], -28) self.assertIsInstance(args[2], EddystoneTLMFrame) self.assertEqual(args[3], None)
def test_exposure_notification(self): callback = MagicMock() scanner = BeaconScanner(callback, packet_filter=[ExposureNotificationFrame]) # Android and iOS seem to use slightly different packets android_pkt = b"\x04\x3E\x28\x02\x01\x03\x01\xBB\x7E\xB5\x2B\x86\x79\x1C\x03\x03\x6F\xFD\x17\x16"\ b"\x6F\xFD\x2C\xFB\x0D\xE0\x2B\x33\xD2\x0C\x5C\x27\x61\x12\x38\xE2\xD1\x07\x42\xB5"\ b"\x6E\xE5\xB8" scanner._mon.process_packet(android_pkt) ios_pkt = b"\x04\x3E\x2B\x02\x01\x03\x01\x08\xE6\xAE\x33\x0B\x3F\x1F\x02\x01\x1A\x03\x03\x6F"\ b"\xFD\x17\x16\x6F\xFD\xE9\x32\xE8\xB0\x68\x8D\xFA\xEC\x00\x62\xB7\xD6\xD3\x5E\xEF"\ b"\xB5\xEE\xAA\x91\xAC\xBA" scanner._mon.process_packet(ios_pkt) self.assertEqual(callback.call_count, 2)
def test_bad_arguments(self): """Test if wrong filters result in ValueError.""" tests = [ ([{"namespace" : "ABC"}], None), (None, EddystoneFilter()), (None, [EddystoneFilter()]), (EddystoneTLMFrame, []), ([EddystoneTLMFrame], None), ([EddystoneTLMFrame], [EddystoneFilter()]), ] for dev_filter, pkt_filter in tests: with self.assertRaises(ValueError): BeaconScanner(None, 0, dev_filter, pkt_filter)
def test_good_arguments(self): """Test if correct filters result in no exception.""" tests = [ (None, None), ([], []), ([EddystoneFilter()], None), (EddystoneFilter(), None), (None, EddystoneTLMFrame), (None, [EddystoneTLMFrame]), (EddystoneFilter(), [EddystoneTLMFrame]), ] for dev_filter, pkt_filter in tests: self.assertIsNotNone(BeaconScanner(None, 0, dev_filter, pkt_filter))
def main(): args = parser.parse_args() if args.config: save(args.config) # start MQTT client mqtt.setup() sensor_list = [] for sensor in config.sensors: if sensor.type == 'dht22': s = DHT(sensor.pin, sensor.topic, sensor.name, 'sensor', sensor.type) elif sensor.type == 'ibeacon': s = Scanner(sensor.name, sensor.topic, sensor.uuid, sensor.away_timeout) elif sensor.type == 'switch': s = Switch(sensor.name, sensor.pin, sensor.topic) elif sensor.type == 'reed': s = ReedSwitch(sensor.name, sensor.pin, sensor.topic, sensor.normally_open, sensor.get('device_type')) elif sensor.type == 'bme280': s = BME280(sensor.name, sensor.topic) elif sensor.type == 'hestiapi': s = HestiaPi(sensor.name, sensor.topic, sensor.heat_setpoint, sensor.cool_setpoint, dry_run=args.dry_run) else: logging.warn( 'Sensor {} found in config, but was not setup.'.format( sensor.name)) if s: sensor_list.append(s) try: scanner = BeaconScanner(sensor_list[1].process_ble_update) scanner.start() except: logging.error("Beacon scanner did not start") try: while True: for sensor in sensor_list: sensor.callback() time.sleep(300) except: traceback.print_exc() mqtt.client.loop_stop() if scanner: scanner.stop()
def read_ble(self): scanner = BeaconScanner( self.read_callback, packet_filter=[EddystoneUIDFrame], device_filter=EddystoneFilter(namespace=self.uuid)) scanner.start() print("Lendo beacon por {}'s".format(self.read_time)) time.sleep(self.read_time) scanner.stop() return self.rssi_list
def read_ble(sleep_time=1, loops=2): for loop in range(0, loops): scanner = BeaconScanner( read_callback, device_filter=EddystoneFilter(namespace="edd1ebeac04e5defa017"), packet_filter=[EddystoneUIDFrame] ) scanner.start() time.sleep(sleep_time) scanner.stop()
def main_Buletooth (): test = ly.Bluetooth() global data data = {} xd = [] yd = [] RSSIa = [] RSSIb = [] RSSIc = [] plt.figure() while( 1 ): scanner = BeaconScanner(ly.scan_base) scanner.start() #将rssi值与mac地址分开 flag = 1 while( flag ): time.sleep(0.5) #print (data) """传入参数 待改正""" for add in data.keys(): if add == u'10:01:12:ee:57:54': RSSIa.append(data[add]) print("RSSIa=",len(RSSIa)) #print("RSSIa=",RSSIa) elif add == u'20:01:14:9c:57:54': RSSIb.append(data[add]) print("RSSIb=",len(RSSIb)) #print("RSSIb=",RSSIb) else: RSSIc.append(data[add]) print("RSSIc=",len(RSSIc)) #print("RSSIc=",RSSIc) if len(RSSIa) >= 20 and len(RSSIb) >= 20 and len(RSSIc) >= 20: flag = 0 scanner.stop() ra = test.Gaussion_filter(RSSIa) rb = test.Gaussion_filter(RSSIb) rc = test.Gaussion_filter(RSSIc) #print(ra) #print(rb) #print(rc) r3 = test.RSSI_distance(ra) r1 = test.RSSI_distance(rb) r2 = test.RSSI_distance(rc) #print (r1) #print (r2) #print (r3) coordinate_D = test.fixed_point(r1,r2,r3) test.coordinate_system_data(coordinate_D) del RSSIa[:] del RSSIb[:] del RSSIc[:] data.clear()
def run(self): while True: scanner = BeaconScanner( callback, device_filter=IBeaconFilter( uuid='636f3f8f-6491-4bee-95f7-d8cc64a863b5') ) #"b9407f30-f5f8-466e-aff9-25556b57fe6d", major=30174, minor=5667)) #coconut2 #my rpi beacon uuid 636f3f8f-6491-4bee-95f7-d8cc64a863b5 scanner.start() time.sleep(5) scanner.stop()