def run(self):
"""Run scanner thread."""
_LOGGER.debug("Scanner thread: run")
try:
socket = aiobs.create_bt_socket(self._interface)
except OSError as error:
_LOGGER.error("Scanner thread: OS error: %s", error)
return
_LOGGER.debug("Scanner thread: creating connection")
self._event_loop = asyncio.new_event_loop()
asyncio.set_event_loop(self._event_loop)
fac = self._event_loop._create_connection_transport(
socket, BLEActiveScanRequester, None, None)
conn, btctrl = self._event_loop.run_until_complete(fac)
_LOGGER.debug("Scanner thread: connection established")
btctrl.process = self.process_events
btctrl.send_scan_request()
_LOGGER.debug("Scanner thread: start event loop")
try:
self._event_loop.run_forever()
finally:
_LOGGER.debug("Scanner thread: event loop stopped, cleaning up")
btctrl.stop_scan_request()
conn.close()
self._event_loop.run_until_complete(asyncio.sleep(0))
self._event_loop.close()
_LOGGER.debug("Scanner thread: Run finished")
def run(self):
"""Run HCIdump thread."""
_LOGGER.debug("HCIdump thread: Run")
try:
mysocket = aiobs.create_bt_socket(self._interface)
except OSError as error:
_LOGGER.error("HCIdump thread: OS error: %s", error)
else:
self._event_loop = asyncio.new_event_loop()
asyncio.set_event_loop(self._event_loop)
fac = self._event_loop._create_connection_transport(
mysocket, aiobs.BLEScanRequester, None, None)
_LOGGER.debug("HCIdump thread: Connection")
conn, btctrl = self._event_loop.run_until_complete(fac)
_LOGGER.debug("HCIdump thread: Connected")
btctrl.process = self.process_hci_events
btctrl.send_command(
aiobs.HCI_Cmd_LE_Set_Scan_Params(scan_type=self._active))
btctrl.send_scan_request()
_LOGGER.debug("HCIdump thread: start main event_loop")
try:
self._event_loop.run_forever()
finally:
_LOGGER.debug(
"HCIdump thread: main event_loop stopped, finishing", )
btctrl.stop_scan_request()
conn.close()
self._event_loop.run_until_complete(asyncio.sleep(0))
self._event_loop.close()
_LOGGER.debug("HCIdump thread: Run finished")
def main():
event_loop = asyncio.get_event_loop()
# First create and configure a raw socket
mysocket = aiobs.create_bt_socket(0)
# create a connection with the raw socket - This now requires a STREAM socket.
fac = event_loop._create_connection_transport(mysocket,
aiobs.BLEScanRequester, None,
None)
# Start it
conn, btctrl = event_loop.run_until_complete(fac)
# Attach Tilt processing
btctrl.process = tilt_process
# Probe for messages
btctrl.send_scan_request()
try:
print("Scanning for Tilts")
event_loop.run_forever()
except KeyboardInterrupt:
print("keyboard interrupt")
finally:
print("closing event loop")
btctrl.stop_scan_request()
command = aiobs.HCI_Cmd_LE_Advertise(enable=False)
btctrl.send_command(command)
conn.close()
event_loop.close()
def start(self, debug = False):
"""
Starts the BLE scanning thread
:return: None
"""
# Turn debug printing on or off
self.setDebug(debug)
self.event_loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.event_loop)
# First create and configure a raw socket
self.mysocket = aioblescan.create_bt_socket(self.dev_id)
# Create a connection with the STREAM socket
self.fac = self.event_loop._create_connection_transport(
self.mysocket, aioblescan.BLEScanRequester, None, None)
# Start it
self.conn, self.btctrl = self.event_loop.run_until_complete(self.fac)
# Attach your processing
self.btctrl.process = self.blecallback
# Probe
self.btctrl.send_scan_request()
thread = threading.Thread(target=self.event_loop.run_forever)
self.threads.append(thread)
thread.start()
return
def update_counters(call):
global scan_duration, current_event_loop
def my_process(data):
ev = aiobs.HCI_Event()
xx = ev.decode(data)
try:
mac = ev.retrieve("peer")[0].val
except:
return
if str(mac).find("b0:01:02") != -1:
_LOGGER.debug("SEE 1 tariff counter")
manufacturer_data = ev.retrieve("Manufacturer Specific Data")
payload = manufacturer_data[0].payload
payload = payload[1].val
c_num = int.from_bytes(payload[6:8], byteorder="little")
c_count = int.from_bytes(payload[9:12], byteorder="little")
if measurement == "m3":
inf[c_num] = c_count / 10000
else:
inf[c_num] = c_count / 10
if (str(mac).find("b0:03:02") != -1) or (str(mac).find("b0:04:02") != -1):
_LOGGER.debug("SEE 2 tariff counter")
manufacturer_data = ev.retrieve("Manufacturer Specific Data")
payload = manufacturer_data[0].payload
payload = payload[1].val
c_num = int.from_bytes(payload[6:8], byteorder="little")
if str(mac).find("b0:03:02") != -1:
c_num = str(c_num) + "_1"
else:
c_num = str(c_num) + "_2"
c_count = int.from_bytes(payload[9:12], byteorder="little")
c_temp = int.from_bytes(payload[14:16], byteorder="little") / 100
inf[c_num.split("_")[0]] = c_temp
if measurement == "m3":
inf[c_num] = c_count / 10000
else:
inf[c_num] = c_count / 10
if current_event_loop is None:
current_event_loop = asyncio.new_event_loop()
asyncio.set_event_loop(current_event_loop)
mysocket = aiobs.create_bt_socket(0)
fac = getattr(current_event_loop, "_create_connection_transport")(
mysocket, aiobs.BLEScanRequester, None, None
)
conn, btctrl = current_event_loop.run_until_complete(fac)
btctrl.process = my_process
current_event_loop.run_until_complete(btctrl.send_scan_request(scan_duration))
try:
current_event_loop.run_forever()
finally:
current_event_loop(btctrl.stop_scan_request())
conn.close()
current_event_loop.run_until_complete(asyncio.sleep(0))
current_event_loop.close()
def run(self):
"""Run HCIdump thread."""
while True:
_LOGGER.debug("HCIdump thread: Run")
mysocket = {}
fac = {}
conn = {}
btctrl = {}
if self._event_loop is None:
self._event_loop = asyncio.new_event_loop()
asyncio.set_event_loop(self._event_loop)
for hci in self._interfaces:
try:
mysocket[hci] = aiobs.create_bt_socket(hci)
except OSError as error:
_LOGGER.error("HCIdump thread: OS error (hci%i): %s", hci, error)
else:
fac[hci] = getattr(self._event_loop, "_create_connection_transport")(
mysocket[hci], aiobs.BLEScanRequester, None, None
)
conn[hci], btctrl[hci] = self._event_loop.run_until_complete(fac[hci])
_LOGGER.debug("HCIdump thread: connected to hci%i", hci)
btctrl[hci].process = self.process_hci_events
try:
self._event_loop.run_until_complete(btctrl[hci].send_scan_request(self._active))
except RuntimeError as error:
_LOGGER.error(
"HCIdump thread: Runtime error while sending scan request on hci%i: %s", hci, error
)
_LOGGER.debug("HCIdump thread: start main event_loop")
try:
self._event_loop.run_forever()
finally:
_LOGGER.debug("HCIdump thread: main event_loop stopped, finishing")
for hci in self._interfaces:
try:
self._event_loop.run_until_complete(btctrl[hci].stop_scan_request())
except RuntimeError as error:
_LOGGER.error("HCIdump thread: Runtime error while stop scan request on hci%i: %s", hci, error)
except KeyError:
_LOGGER.debug("HCIdump thread: Key error while stop scan request on hci%i", hci)
try:
conn[hci].close()
except KeyError:
_LOGGER.debug("HCIdump thread: Key error while closing connection on hci%i", hci)
self._event_loop.run_until_complete(asyncio.sleep(0))
if self._joining is True:
break
_LOGGER.debug("HCIdump thread: Scanning will be restarted")
_LOGGER.debug("%i HCI events processed for previous period.", self.evt_cnt)
self.evt_cnt = 0
self._event_loop.close()
_LOGGER.debug("HCIdump thread: Run finished")
def update_counters(call):
global scan_duration
def my_process(data):
if time.time() - start > int(scan_duration):
btctrl.stop_scan_request()
conn.close()
event_loop.stop()
ev = aiobs.HCI_Event()
xx = ev.decode(data)
try:
mac = ev.retrieve("peer")[0].val
except:
return
if str(mac).find('b0:01:02') != -1:
manufacturer_data = ev.retrieve("Manufacturer Specific Data")
payload = manufacturer_data[0].payload
payload = payload[1].val
c_num = int.from_bytes(payload[6:8], byteorder='little')
c_count = int.from_bytes(payload[9:12], byteorder='little')
if measurement == 'm3':
inf[c_num] = c_count / 10000
else:
inf[c_num] = c_count / 10
start = time.time()
event_loop = asyncio.new_event_loop()
asyncio.set_event_loop(event_loop)
mysocket = aiobs.create_bt_socket(0)
fac = event_loop._create_connection_transport(mysocket,
aiobs.BLEScanRequester, None,
None)
conn, btctrl = event_loop.run_until_complete(fac)
btctrl.process = my_process
btctrl.send_scan_request()
try:
event_loop.run_forever()
except KeyboardInterrupt:
print('keyboard interrupt')
finally:
print('closing event loop')
btctrl.stop_scan_request()
conn.close()
event_loop.close()
def __init__(self, mac_allowlist={}, debug=False):
logger.info(f"Initialising ThermoBeaconScanner - mac_allow_list = {mac_allowlist}, debug = {debug}")
if not mac_allowlist:
raise Exception('Missing arg mac_allowlist')
self.mac_allowlist = mac_allowlist
# Start event loop and open socket to bluetooth interface
logger.info("Starting event loop")
self.event_loop = asyncio.get_event_loop()
self.socket = aiobs.create_bt_socket(0)
fac = self.event_loop._create_connection_transport(self.socket, aiobs.BLEScanRequester, None, None)
self.conn, self.btctrl = self.event_loop.run_until_complete(fac)
# Create empty list for storing packets in debug mode
self.debug = debug
self.packets = []
# Set scan callback and start scanning for devices
logger.info("Sending BLE scan request")
self.btctrl.process = self.ble_scan_callback
self.btctrl.send_scan_request()
def scan(self, attempt=0):
print(tfs(), "Attempt Scanning")
self.eventReceived = False
event_loop = asyncio.new_event_loop()
bluetoothSocket = aioblescan.create_bt_socket(self.hciIndex)
transportProcess = event_loop._create_connection_transport(
bluetoothSocket, aioblescan.BLEScanRequester, None, None)
self.connection, self.bluetoothControl = event_loop.run_until_complete(
transportProcess)
print(tfs(), "Connection made!")
self.bluetoothControl.process = self.parsingProcess
self.timeRequestStart = time.time()
self.bluetoothControl.send_scan_request()
print(tfs(), "Scan command sent!")
alreadyCleanedUp = False
try:
event_loop.run_until_complete(self.awaitEventSleep(1))
if not self.eventReceived:
if attempt < 10:
print(tfs(), 'Retrying... Closing event loop', attempt)
self.cleanup(event_loop)
alreadyCleanedUp = True
self.scan(attempt + 1)
return
else:
pass
event_loop.run_until_complete(
self.awaitActiveSleep(self.scanDuration))
except KeyboardInterrupt:
print('keyboard interrupt')
finally:
print("")
if not alreadyCleanedUp:
print(tfs(), 'closing event loop', attempt)
self.cleanup(event_loop)
def scan_eddystone(on_data=None):
"""
Provide a callback for 'on_data'. The callback will be run whenever
an Eddystone packet is detected.
:param on_data: A function to be called on Eddystone packet
:return: None
"""
global packet_callback
mydev = 0
event_loop = asyncio.get_event_loop()
# First create and configure a raw socket
mysocket = aioblescan.create_bt_socket(mydev)
# create a connection with the raw socket
#fac = event_loop.create_connection(aioblescan.BLEScanRequester,
# sock=mysocket)
fac = event_loop._create_connection_transport(mysocket,
aioblescan.BLEScanRequester,
None, None)
# Start it
conn, btctrl = event_loop.run_until_complete(fac)
# Attach your processing
btctrl.process = _process_packet
packet_callback = on_data
# Probe
btctrl.send_scan_request()
try:
# event_loop.run_until_complete(coro)
event_loop.run_forever()
except KeyboardInterrupt:
print('keyboard interrupt')
finally:
print('closing event loop')
btctrl.stop_scan_request()
conn.close()
event_loop.close()
def scan_eddystone(on_data=None):
"""
Provide a callback for 'on_data'. The callback will be run whenever
an Eddystone packet is detected.
:param on_data: A function to be called on Eddystone packet
:return: None
"""
global packet_callback
mydev = 0
event_loop = asyncio.get_event_loop()
# First create and configure a raw socket
mysocket = aioblescan.create_bt_socket(mydev)
# create a connection with the raw socket
fac = event_loop.create_connection(aioblescan.BLEScanRequester,
sock=mysocket)
# Start it
conn, btctrl = event_loop.run_until_complete(fac)
# Attach your processing
btctrl.process = _process_packet
packet_callback = on_data
# Probe
btctrl.send_scan_request()
try:
# event_loop.run_until_complete(coro)
event_loop.run_forever()
except KeyboardInterrupt:
print('keyboard interrupt')
finally:
print('closing event loop')
btctrl.stop_scan_request()
conn.close()
event_loop.close()
def main(args=None):
global opts
parser = argparse.ArgumentParser(
description="Track BLE advertised packets")
parser.add_argument(
"-e",
"--eddy",
action="store_true",
default=False,
help="Look specificaly for Eddystone messages.",
)
parser.add_argument(
"-m",
"--mac",
type=check_mac,
action="append",
help="Look for these MAC addresses.",
)
parser.add_argument(
"-r",
"--ruuvi",
action="store_true",
default=False,
help="Look only for Ruuvi tag Weather station messages",
)
parser.add_argument(
"-p",
"--pebble",
action="store_true",
default=False,
help="Look only for Pebble Environment Monitor",
)
parser.add_argument(
"-A",
"--atcmi",
action="store_true",
default=False,
help="Look only for ATC_MiThermometer tag messages",
)
parser.add_argument(
"-R",
"--raw",
action="store_true",
default=False,
help="Also show the raw data.",
)
parser.add_argument(
"-a",
"--advertise",
type=int,
default=0,
help=
"Broadcast like an EddyStone Beacon. Set the interval between packet in millisec",
)
parser.add_argument(
"-u",
"--url",
type=str,
default="",
help="When broadcasting like an EddyStone Beacon, set the url.",
)
parser.add_argument(
"-t",
"--txpower",
type=int,
default=0,
help="When broadcasting like an EddyStone Beacon, set the Tx power",
)
parser.add_argument(
"-D",
"--device",
type=int,
default=0,
help="Select the hciX device to use (default 0, i.e. hci0).",
)
try:
opts = parser.parse_args()
except Exception as e:
parser.error("Error: " + str(e))
sys.exit()
event_loop = asyncio.get_event_loop()
# First create and configure a raw socket
mysocket = aiobs.create_bt_socket(opts.device)
# create a connection with the raw socket
# This used to work but now requires a STREAM socket.
# fac=event_loop.create_connection(aiobs.BLEScanRequester,sock=mysocket)
# Thanks to martensjacobs for this fix
fac = event_loop._create_connection_transport(mysocket,
aiobs.BLEScanRequester, None,
None)
# Start it
conn, btctrl = event_loop.run_until_complete(fac)
# Attach your processing
btctrl.process = my_process
if opts.advertise:
command = aiobs.HCI_Cmd_LE_Advertise(enable=False)
event_loop.run_until_complete(btctrl.send_command(command))
command = aiobs.HCI_Cmd_LE_Set_Advertised_Params(
interval_min=opts.advertise, interval_max=opts.advertise)
event_loop.run_until_complete(btctrl.send_command(command))
if opts.url:
myeddy = EddyStone(param=opts.url)
else:
myeddy = EddyStone()
if opts.txpower:
myeddy.power = opts.txpower
command = aiobs.HCI_Cmd_LE_Set_Advertised_Msg(msg=myeddy)
event_loop.run_until_complete(btctrl.send_command(command))
command = aiobs.HCI_Cmd_LE_Advertise(enable=True)
event_loop.run_until_complete(btctrl.send_command(command))
# Probe
event_loop.run_until_complete(btctrl.send_scan_request())
try:
# event_loop.run_until_complete(coro)
event_loop.run_forever()
except KeyboardInterrupt:
print("keyboard interrupt")
finally:
print("closing event loop")
event_loop.run_until_complete(btctrl.stop_scan_request())
command = aiobs.HCI_Cmd_LE_Advertise(enable=False)
event_loop.run_until_complete(btctrl.send_command(command))
conn.close()
event_loop.close()
def run_ble(hci_dev, QUIT_BLE_EVENT, decoder_q):
# TIMING
my_timer = helpers.StopWatch()
# ------------------------------
event_loop = asyncio.get_event_loop()
# Callback process to handle data received from BLE
# ---------------------------------------------------
def callback_data_handler(data):
# data = byte array of raw data received
# TIMING
my_timer.start()
# ------------------------------
if QUIT_BLE_EVENT.is_set():
event_loop.stop()
else:
# Add message to queue
decoder_q.put(data)
# TIMING
my_timer.split()
# ------------------------------
# ---------------------------------------------------
# EOF callback_data_handler
if int(hci_dev) < 0:
print("No device specified, exiting run_ble")
return 1
# First create and configure a raw socket
mysocket = aiobs.create_bt_socket(hci_dev)
# create a connection with the socket
fac = event_loop._create_connection_transport(
mysocket, aiobs.BLEScanRequester, None, None
)
# Start it
conn, btctrl = event_loop.run_until_complete(fac)
# Attach your processing (callback)
btctrl.process = callback_data_handler
# Start BLE probe
btctrl.send_scan_request()
try:
event_loop.run_forever()
except KeyboardInterrupt:
print("\nKeyboard interrupt!")
finally:
print("Closing ble event loop.")
btctrl.stop_scan_request()
command = aiobs.HCI_Cmd_LE_Advertise(enable=False)
btctrl.send_command(command)
conn.close()
event_loop.close()
# TIMING
print(my_timer.get_count(), "ble messages.")
print(
1000 * 1000 * my_timer.get_average(),
"usec in average per message in run_ble.callback_data_handler().",
)
# ------------------------------
print("Exiting run_ble.")
return 0
def run(self):
"""Run HCIdump thread."""
while True:
_LOGGER.debug("HCIdump thread: Run")
mysocket = {}
fac = {}
conn = {}
btctrl = {}
interface_is_ok = {}
interfaces_to_reset = []
initialized_evt = {}
if self._event_loop is None:
self._event_loop = asyncio.new_event_loop()
asyncio.set_event_loop(self._event_loop)
if "disable" not in self.config[CONF_BT_INTERFACE]:
for hci in self._interfaces:
interface_is_ok[hci] = False
try:
mysocket[hci] = aiobs.create_bt_socket(hci)
except OSError as error:
_LOGGER.error("HCIdump thread: OS error (hci%i): %s", hci, error)
else:
fac[hci] = getattr(
self._event_loop, "_create_connection_transport"
)(mysocket[hci], aiobs.BLEScanRequester, None, None)
conn[hci], btctrl[hci] = self._event_loop.run_until_complete(
fac[hci]
)
# Wait up to five seconds for aioblescan BLEScanRequester to initialize
initialized_evt[hci] = getattr(btctrl[hci], "_initialized")
_LOGGER.debug(
"HCIdump thread: BLEScanRequester._initialized is %s for hci%i, "
" waiting for connection...",
initialized_evt[hci].is_set(),
hci,
)
try:
self._event_loop.run_until_complete(asyncio.wait_for(initialized_evt[hci].wait(), 5))
except asyncio.TimeoutError:
_LOGGER.error(
"HCIdump thread: Something wrong - interface hci%i not ready,"
" and will be skipped for current scan period.",
hci,
)
conn[hci].close()
fac[hci].close()
mysocket[hci].close()
else:
btctrl[hci].process = self.process_hci_events
_LOGGER.debug("HCIdump thread: connected to hci%i", hci)
try:
self._event_loop.run_until_complete(
btctrl[hci].send_scan_request(self._active)
)
except RuntimeError as error:
_LOGGER.error(
"HCIdump thread: Runtime error while sending scan request on hci%i: %s.",
hci,
error,
)
conn[hci].close()
fac[hci].close()
mysocket[hci].close()
else:
interface_is_ok[hci] = True
_LOGGER.debug(
"HCIdump thread: BLEScanRequester._initialized is %s for hci%i, "
" connection established, send_scan_request succeeded.",
initialized_evt[hci].is_set(),
hci,
)
if (interface_is_ok[hci] is False) and (self.config[CONF_BT_AUTO_RESTART] is True):
interfaces_to_reset.append(hci)
if interfaces_to_reset:
ts_now = dt_util.now()
if (ts_now - self.last_bt_reset).seconds > 60:
for iface in interfaces_to_reset:
_LOGGER.error(
"HCIdump thread: Trying to power cycle Bluetooth adapter hci%i %s,"
" will try to use it next scan period.",
iface,
BT_INTERFACES[iface],
)
reset_bluetooth(iface)
self.last_bt_reset = ts_now
_LOGGER.debug("HCIdump thread: start main event_loop")
try:
self._event_loop.run_forever()
finally:
_LOGGER.debug("HCIdump thread: main event_loop stopped, finishing.")
if "disable" not in self.config[CONF_BT_INTERFACE]:
for hci in self._interfaces:
if interface_is_ok[hci] is True:
try:
self._event_loop.run_until_complete(
btctrl[hci].stop_scan_request()
)
except RuntimeError as error:
_LOGGER.error(
"HCIdump thread: Runtime error while stop scan request on hci%i: %s.",
hci,
error,
)
except KeyError:
_LOGGER.debug(
"HCIdump thread: Key error while stop scan request on hci%i",
hci,
)
try:
conn[hci].close()
fac[hci].close()
mysocket[hci].close()
except KeyError:
_LOGGER.debug(
"HCIdump thread: Key error while closing connection on hci%i",
hci,
)
self._event_loop.run_until_complete(asyncio.sleep(0))
if self._joining is True:
break
_LOGGER.debug("HCIdump thread: Scanning will be restarted")
_LOGGER.debug("%i HCI events processed for previous period", self.evt_cnt)
self.evt_cnt = 0
self._event_loop.close()
_LOGGER.debug("HCIdump thread: Run finished")
import mqtt
import kafka_producer
import fluke
import asyncio
import aioblescan
from config import *
event_loop = asyncio.get_event_loop()
#First create and configure a raw socket hci0
mysocket = aioblescan.create_bt_socket(0)
#create a connection with the raw socket
#fac=event_loop.create_connection(aioblescan.BLEScanRequester,sock=mysocket)
fac = event_loop._create_connection_transport(mysocket,aioblescan.BLEScanRequester,None,None)
#Start it
conn,btctrl = event_loop.run_until_complete(fac)
#Attach your processing
btctrl.process=fluke.process
btctrl.send_scan_request()
try:
mqtt.start()
kafka_producer.start()
event_loop.run_forever()
except KeyboardInterrupt:
print('keyboard interrupt')
finally:
mqtt.stop()
elif opts.pebble:
xx = BlueMaestro().decode(ev)
if xx:
print("Pebble info {}".format(xx))
elif opts.tilt:
xx = Tilt().decode(ev)
if xx:
print("{}".format(xx))
else:
ev.show(0)
event_loop = asyncio.get_event_loop()
#First create and configure a raw socket
mysocket = aiobs.create_bt_socket(opts.device)
#create a connection with the raw socket
#This used to work but now requires a STREAM socket.
#fac=event_loop.create_connection(aiobs.BLEScanRequester,sock=mysocket)
#Thanks to martensjacobs for this fix
fac = event_loop._create_connection_transport(mysocket, aiobs.BLEScanRequester,
None, None)
#Start it
conn, btctrl = event_loop.run_until_complete(fac)
#Attach your processing
btctrl.process = my_process
if opts.advertise:
command = aiobs.HCI_Cmd_LE_Advertise(enable=False)
btctrl.send_command(command)
command = aiobs.HCI_Cmd_LE_Set_Advertised_Params(
if current_y == y_dim:
print('ALL DONE')
np.savetxt("foo.csv", rssi_measurements, delimiter=",")
exit(0)
# #update_time = time.time() % 1000
#print("{0}, {1}".format(rssi, update_time))
#ev.show(0)
event_loop = asyncio.get_event_loop()
#First create and configure a raw socket
# 0th device by default -> in the case of RPi, that means the build-in bt antenna
mysocket = aiobs.create_bt_socket(0)
# create a connection with the raw socket
# This used to work but now requires a STREAM socket.
# fac=event_loop.create_connection(aiobs.BLEScanRequester,sock=mysocket)
# Thanks to martensjacobs for this fix
fac = event_loop._create_connection_transport(mysocket, aiobs.BLEScanRequester,
None, None)
#Start it
conn, btctrl = event_loop.run_until_complete(fac)
#Attach your processing
btctrl.process = scan_result_handler
#Probe
btctrl.send_scan_request()
def run(self):
"""Run HCIdump thread."""
while True:
_LOGGER.debug("HCIdump thread: Run")
mysocket = {}
fac = {}
conn = {}
btctrl = {}
if self._event_loop is None:
self._event_loop = asyncio.new_event_loop()
asyncio.set_event_loop(self._event_loop)
for hci in self._interfaces:
try:
mysocket[hci] = aiobs.create_bt_socket(hci)
except OSError as error:
_LOGGER.error("HCIdump thread: OS error (hci%i): %s", hci,
error)
else:
fac[hci] = getattr(self._event_loop,
"_create_connection_transport")(
mysocket[hci],
aiobs.BLEScanRequester, None, None)
conn[hci], btctrl[
hci] = self._event_loop.run_until_complete(fac[hci])
_LOGGER.debug("HCIdump thread: connected to hci%i", hci)
btctrl[hci].process = self.process_hci_events
try:
self._event_loop.run_until_complete(
btctrl[hci].send_scan_request(self._active))
except RuntimeError as error:
if self.config[CONF_BT_AUTO_RESTART] is True:
ts_now = dt_util.now()
if (ts_now - self.last_bt_reset).seconds > 60:
_LOGGER.error(
"HCIdump thread: Runtime error while sending scan request on hci%i: %s. Resetting Bluetooth adapter %s and trying again.",
hci,
error,
BT_INTERFACES[hci],
)
reset_bluetooth(hci)
self.last_bt_reset = ts_now
else:
_LOGGER.error(
"HCIdump thread: Runtime error while sending scan request on hci%i: %s.",
hci,
error,
)
_LOGGER.debug("HCIdump thread: start main event_loop")
try:
self._event_loop.run_forever()
finally:
_LOGGER.debug(
"HCIdump thread: main event_loop stopped, finishing")
for hci in self._interfaces:
try:
self._event_loop.run_until_complete(
btctrl[hci].stop_scan_request())
except RuntimeError as error:
if self.config[CONF_BT_AUTO_RESTART] is True:
ts_now = dt_util.now()
if (ts_now - self.last_bt_reset).seconds > 60:
_LOGGER.error(
"HCIdump thread: Runtime error while stop scan request on hci%i: %s Resetting Bluetooth adapter %s and trying again.",
hci,
error,
BT_INTERFACES[hci],
)
reset_bluetooth(hci)
self.last_bt_reset = ts_now
else:
_LOGGER.error(
"HCIdump thread: Runtime error while stop scan request on hci%i: %s.",
hci,
error,
)
except KeyError:
_LOGGER.debug(
"HCIdump thread: Key error while stop scan request on hci%i",
hci,
)
try:
conn[hci].close()
except KeyError:
_LOGGER.debug(
"HCIdump thread: Key error while closing connection on hci%i",
hci,
)
self._event_loop.run_until_complete(asyncio.sleep(0))
if self._joining is True:
break
_LOGGER.debug("HCIdump thread: Scanning will be restarted")
_LOGGER.debug("%i HCI events processed for previous period",
self.evt_cnt)
self.evt_cnt = 0
self._event_loop.close()
_LOGGER.debug("HCIdump thread: Run finished")
theta, cost = model.gradientDescent(np.array([inp][3]), steps)
return model.predict(np.array(inp[-3:]))
# today_steps = 0
# tmr_steps = 0
# for i in range(3):
# today_steps += weights[i] * inp[i]
# tmr_steps += weights[i] * inp[-3+i]
# return round(steps + offset), round(tmr_steps + offset)
if __name__ == '__main__':
mydev = 0
event_loop = asyncio.get_event_loop() # creates event loop to run async tasks
mysocket = aiobs.create_bt_socket(mydev) # creates a bt socket
fac = event_loop._create_connection_transport(mysocket, aiobs.BLEScanRequester, None, None) # create a transport level connection between the bluetooth and socket
conn, btctrl = event_loop.run_until_complete(fac) # runs the future to get the bluetooth and connection objects
btctrl.process = _process_packet # assigns our custom process packet function to the bluetooth processing
btctrl.send_scan_request() # start scanning via bluetooth
# create mqtt client
client = mqtt.Client('P2')
client.connect(broker_address)
client.on_message = _on_mqtt_message_received
client.loop_start()
client.subscribe(subscribe_topic)
client.subscribe(prompt_topic)
try:
print('Press Ctrl+C to send information to uBit and exit')
event_loop.run_forever() # runs our bluetooth scan until we send a keyboard interrupt signal
def get_tilt_readings(open_read_time):
readings = {}
def my_process(data):
ev = aiobs.HCI_Event()
xx = ev.decode(data)
xx = Tilt().decode(ev)
if xx:
# debug only, otherwise noisy
# print("{}".format(xx))
parsedData = json.loads(xx)
color = get_tilt_color(parsedData['uuid'])
# extra protection, if no color: that measured thing wasn't a tilt!
if color:
readings[parsedData['uuid']] = {'rssi': parsedData['rssi'], 'tx_power': parsedData['tx_power'], 'mac': parsedData['mac'],
'major': parsedData['major'], 'minor': parsedData['minor'], 'uuid': parsedData['uuid'], 'color': color}
# whoever reads that event_loop voodoo, please don't judge me too hard
asyncio.set_event_loop(asyncio.new_event_loop())
event_loop = asyncio.get_event_loop()
# First create and configure a raw socket
mysocket = aiobs.create_bt_socket(BLE_DEVICE)
# create a connection with the raw socket
# This used to work but now requires a STREAM socket.
# fac=event_loop.create_connection(aiobs.BLEScanRequester,sock=mysocket)
# Thanks to martensjacobs for this fix
fac = event_loop._create_connection_transport(
mysocket, aiobs.BLEScanRequester, None, None)
# Start it
conn, btctrl = event_loop.run_until_complete(fac)
# Attach your processing
btctrl.process = my_process
# print('Starting acquisition for ' + str(open_read_time) + ' s')
btctrl.send_scan_request()
async def wait_read_time(future):
await asyncio.sleep(open_read_time)
future.set_result('Open read time finished!')
def got_result(future):
event_loop.stop()
future = asyncio.Future()
asyncio.ensure_future(wait_read_time(future))
future.add_done_callback(got_result)
try:
event_loop.run_forever()
finally:
# stop: close event loop
# print('Stopping acquisition')
btctrl.stop_scan_request()
command = aiobs.HCI_Cmd_LE_Advertise(enable=False)
btctrl.send_command(command)
conn.close()
event_loop.close()
return readings
if not goon:
return
if opts.raw:
print("Raw data: {}".format(ev.raw_data))
else:
ev.show(0)
try:
mydev = int(sys.argv[1])
except:
mydev = 0
event_loop = asyncio.get_event_loop()
mysocket = aiobs.create_bt_socket(mydev)
fac = event_loop._create_connection_transport(mysocket, aiobs.BLEScanRequester,
None, None)
conn, btctrl = event_loop.run_until_complete(fac)
btctrl.process = my_process
if opts.advertise:
command = aiobs.HCI_Cmd_LE_Advertise(enable=False)
btctrl.send_command(command)
command = aiobs.HCI_Cmd_LE_Set_Advertised_Params(
interval_min=opts.advertise, interval_max=opts.advertise)
btctrl.send_command(command)
command = aiobs.HCI_Cmd_LE_Set_Advertised_Msg(msg=EddyStone())
btctrl.send_command(command)
command = aiobs.HCI_Cmd_LE_Advertise(enable=True)
btctrl.send_command(command)
yellow = 'a495bb70c5b14b44b5121370f02d74de'
pink = 'a495bb80c5b14b44b5121370f02d74de'
def my_process(data):
ev = aiobs.HCI_Event()
xx = ev.decode(data)
xx = Tilt().decode(ev)
if xx:
print("{}".format(xx))
event_loop = asyncio.get_event_loop()
# First create and configure a raw socket
mysocket = aiobs.create_bt_socket(BLE_DEVICE)
# create a connection with the raw socket
# This used to work but now requires a STREAM socket.
# fac=event_loop.create_connection(aiobs.BLEScanRequester,sock=mysocket)
# Thanks to martensjacobs for this fix
fac = event_loop._create_connection_transport(mysocket, aiobs.BLEScanRequester,
None, None)
# Start it
conn, btctrl = event_loop.run_until_complete(fac)
# Attach your processing
btctrl.process = my_process
# Probe
btctrl.send_scan_request()
try:
