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 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_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)
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 __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 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 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 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 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 test_process_packet_dev_filter(self):
"""Test processing of a packet and callback execution with device filter."""
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\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, 1)
args = callback.call_args[0]
self.assertEqual(args[0], "1c:d6:cd:ef:94:35")
self.assertEqual(args[1], -35)
self.assertIsInstance(args[2], EddystoneUIDFrame)
self.assertEqual(args[3], {
"namespace":"12345678901234678901",
"instance":"000000000001"
})
# need to check if keys() method is supported, because additional_info can be None
# better way to check is to see if packet is an instance of EddystoneUIDFrame
if isinstance(additional_info,dict):
if 'namespace' in additional_info.keys() and 'instance' in additional_info.keys():
for _idx,(_bcon,_cmd) in enumerate(zip(beacon_list,command_list),1):
if _bcon == additional_info['namespace']:
print('-'*60)
print('Beacon {} found'.format(_idx)) # print device info
print('Distance {}'.format(rssi)) # print distance (rssi)
print('-'*60)
os.system(_cmd) # execute bash command. os.system waits for command to finish
time.sleep(60) # sleep - turned off for now
device_filter_list = []
for _bcon in beacon_list:
device_filter_list.append(EddystoneFilter(namespace=_bcon))
scanner = BeaconScanner(callback,device_filter=device_filter_list)
scanner.start()
print('Press Ctrl+C to exit...')
while True:
try:
time.sleep(10)
except KeyboardInterrupt as e:
break
scanner.stop()
print('Exiting due to Ctrl+C event. Goodbye!' )
try:
id = "namespace:" + additional_info[
"namespace"] + " Instance:" + additional_info["instance"]
print("<Receive> %s " % (id))
if not (id in bt_list):
print("<IN> %s " % (id))
currentCPUTime = time.perf_counter()
bt_list[id] = currentCPUTime
except:
print(sys.exc_info())
# scan for all TLM frames of beacons in the namespace "01020304050607080910"
scanner = BeaconScanner(
callback,
device_filter=EddystoneFilter(namespace="01020304050607080910"),
packet_filter=[EddystoneTLMFrame, EddystoneUIDFrame])
scanner.start()
try:
while True:
for i in list(bt_list):
#Wait 30s for detecting to exit beacon.
if (time.perf_counter() - bt_list[i] > 30):
print("<OUT> %s " % (i))
del bt_list[i]
else:
print("<Listing> %s %d" %
(i, time.perf_counter() - bt_list[i]))
time.sleep(1)
except KeyboardInterrupt:
import time
from beacontools import BeaconScanner, EddystoneTLMFrame, EddystoneFilter, EddystoneUIDFrame
from callback import callback
scanner = BeaconScanner(
callback,
device_filter=EddystoneFilter(namespace="8b9cc73c3ae747ef65bc"),
packet_filter=[EddystoneTLMFrame, EddystoneUIDFrame])
scanner.start()
#time.sleep(10)
#scanner.stop()
import time
from beacontools import BeaconScanner, EddystoneTLMFrame, EddystoneFilter, \
EddystoneUIDFrame, EddystoneURLFrame
def callback(bt_addr, rssi, packet, additional_info):
print("<%s, %d> %s %s" % (bt_addr, rssi, packet, additional_info))
# scan for all TLM frames of beacons in the namespace "12345678901234678901"
scanner = BeaconScanner(
callback,
device_filter=EddystoneFilter(namespace="12345678901234678901"),
packet_filter=[EddystoneTLMFrame, EddystoneUIDFrame])
scanner.start()
time.sleep(10)
scanner.stop()
# scan for all URL frames without filtering for a specific beacon
scanner = BeaconScanner(callback, packet_filter=EddystoneURLFrame)
scanner.start()
time.sleep(10)
scanner.stop()
import time
from beacontools import BeaconScanner, EddystoneTLMFrame, EddystoneFilter
def callback(bt_addr, rssi, packet, additional_info):
print("<%s, %d> %s %s" % (bt_addr, rssi, packet, additional_info))
# scan for all TLM frames of beacons in the namespace "12345678901234678901"
scanner = BeaconScanner(callback,
device_filter=EddystoneFilter(
namespace="2f234454-cf6d-4a0f-ad2-f4911ba9ffa6"),
packet_filter=EddystoneTLMFrame)
scanner.start()
time.sleep(10)
scanner.stop()
scanner.start()
while True:
pass
scanner.stop()
elif beacon_type == 'e':
try:
if input("all/one (a/o): ") == 'o':
# scan for all TLM frames of beacons in the namespace
scanner = BeaconScanner(callback,
device_filter=EddystoneFilter(namespace="edd1ebeac04e5defa017"),
packet_filter=EddystoneTLMFrame
)
scanner.start()
time.sleep(10)
else:
scanner = BeaconScanner(callback, packet_filter=[EddystoneUIDFrame])
scanner.start()
time.sleep(10)
scanner.stop()