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 _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
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."""
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 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 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 main():
# scan for all iBeacon advertisements from beacons with the specified uuid
scanner = BeaconScanner(
callback,
device_filter=IBeaconFilter(uuid="e7d61ea3-f8dd-49c8-8f2f-f2484c07acb9", major=1, minor=81)
)
scanner.start()
time.sleep(120)
scanner.stop()
write_file(datalist)
print('fin')
def _scan_beacons(**kwargs):
beacons_list = []
# read beaconstools callback
def _scans_callback(bt_addr, rssi, packet, additional_info):
beacon = IBeacon(bt_addr, packet.uuid, packet.major, packet.minor, packet.tx_power, rssi)
if beacon not in beacons_list:
beacons_list.append(beacon)
# create and start scanner in each cycle
beaconstools_scanner = BeaconScanner(
_scans_callback,
device_filter=IBeaconFilter(uuid=kwargs['uuid_filter'])
)
beaconstools_scanner.start()
time.sleep(kwargs['scan_tick'])
beaconstools_scanner.stop()
# return beacon_list
return beacons_list
def main():
try:
print("Starting")
scanner = BeaconScanner(callback)
print("Scanning")
scanner.start()
while not exit.is_set():
exit.wait(60)
print("All done!")
scanner.stop()
# perform any cleanup here
except:
return
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 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")