def test_eddystone(self):
adapter = get_provider().get_adapter()
beacon = EddystoneBeacon(adapter, 'https://www.google.com/')
beacon.start()
log.info("Starting beacon for {} seconds, url={}".format(BEACON_TIME, beacon.url))
sleep(BEACON_TIME)
beacon.stop()
def advertising(name):
adapter = get_provider().get_adapter()
advertiser = Advertiser(adapter)
advertisement = Advertisement()
deviceName = updateName(name)
#print("CHANGE >> "+deviceName)
change(deviceName)
advertisement.name = name
advertiser.advertisement = advertisement
color = deviceName[1]
advertiser.start()
#print("color >> "+color)
if (color == "1"):
lighting(LIGHT_GREEN)
elif (color == "2"):
lighting(LIGHT_YELLOW)
elif (color == "3"):
lighting(LIGHT_RED)
elif (color == "4"):
lighting(LIGHT_BLUE)
sleep(1)
advertiser.stop()
def update_gap_buffer(logger_state_dict):
try:
beacon = None
if 'beacon' in logger_state_dict:
beacon = logger_state_dict['beacon']
else:
adapter = bleson.get_provider().get_adapter()
beacon = edg_beacon.EcoDroidGPSBeacon(adapter)
logger_state_dict['beacon'] = beacon
gga = logger_state_dict['gga']
if gga is None:
raise Exception('gga is still None')
lat = gga.latitude
lon = gga.longitude
#print(logger_state_dict['last_rmc_datetime'])
ts = logger_state_dict['last_rmc_datetime'].timestamp()
#print("lat:", lat)
#print("lat:", lon)
#print("ts:", ts)
gap_buffer = gen_ecodroidgps_gap_broadcast_buffer(lat, lon, ts)
beacon.eid = gap_buffer
beacon.start()
except Exception:
type_, value_, traceback_ = sys.exc_info()
exstr = traceback.format_exception(type_, value_, traceback_)
print(("WARNING: update_gap_buffer exception:", exstr))
def __init__(self):
self._log = getLogger('xitherm.ble')
adapter = get_provider().get_adapter()
super().__init__(adapter)
self.on_advertising_data = self._handle_advertisement
self._channels: List[Deque] = list()
self._qlock = Lock()
def __init__(self, _):
super().__init__(_)
self.previous_log_level = set_level(DEBUG)
provider = get_provider()
self.adapter0 = provider.get_adapter(0) # Used for the Observer role
self.adapter1 = provider.get_adapter(1) # Used for the Advertiser role
def __init__(self, mqtt: MqttClient):
self._log = getLogger('xitherm.ble')
adapter = get_provider().get_adapter()
super().__init__(adapter)
self.on_advertising_data = self._handle_advertisement
self._mqtt = mqtt
self._publish: Set[str] = set()
host = gethostname()
self._source = f'xitherm/{host}'
self._last_packet: Optional[int] = None
def start():
adapter = get_provider().get_adapter()
q = Queue()
observer = Observer(adapter)
observer.on_advertising_data = q.put # Put advertisement to queue
observer.start()
return (observer, q)
def advertising(deviceName):
adapter = get_provider().get_adapter()
advertiser = Advertiser(adapter)
advertisement = Advertisement()
advertisement.name = deviceName
advertiser.advertisement = advertisement
advertiser.start()
sleep(5)
advertiser.stop()
def sensor_data(json):
print('sensor message:', json)
if(json['sensorStatus'] == 'True'):
adapter = get_provider().get_adapter()
observer = Observer(adapter)
observer.on_advertising_data = on_advertisement
observer.start()
time.sleep(5)
observer.stop()
emit('tempHumSensorUpdate', govee_devices)
else:
emit('tempHumSensorUpdate', {'data': 'data disabled'})
def test_advertiser(self):
adapter = get_provider().get_adapter()
advertisement = Advertisement()
advertisement.name = 'bleson'
advertiser = Advertiser(adapter)
advertiser.advertisement = advertisement
advertiser.start()
log.info("Starting Advertiser role for {} seconds, advertised name={}".
format(ADVERTISE_TIME, advertisement.name))
sleep(ADVERTISE_TIME)
advertiser.stop()
def __init__(self, publishers, params):
"""Initializes the listener and kicks off the listening thread."""
super().__init__(publishers, params)
self.dest_root = params("Destination")
self.log.info("Configuring Govee listener with destination %s",
self.dest_root)
self.adapter = get_provider().get_adapter()
self.observer = Observer(self.adapter)
self.observer.on_advertising_data = self.on_advertisement
self.observer.start()
# Store readings so they can be reported on demand.
self.devices = {}
def test():
i = 0
adapter = bleson.get_provider().get_adapter()
beacon = edg_beacon.EcoDroidGPSBeacon(adapter)
while True:
i += 1
lat = i * (1.0 / 10000000)
lon = lat
ba = edg_gps_parser.gen_ecodroidgps_gap_broadcast_buffer(
lat, lon, time.time())
beacon.eid = ba
beacon.start()
print("USE NRFCONNECT APP TO CHECK THIS ON PHONE NOW!")
time.sleep(1.0)
if i >= KEEP_RUNNING_DURATION_SECS:
break
def start_listen_ble():
try:
adapter = get_provider().get_adapter()
global receiver_mac
receiver_mac = adapter.get_device_info().address.address
observer = Observer(adapter)
observer.on_advertising_data = on_advertisement
observer.start()
except OSError:
print(
"Error listening for BLE advertisements, using fixed test data instead"
)
start_send_test_data()
def _start(self) -> None:
""" Internal start function that doesn't change user intent"""
if self._started:
return
# don't start unless there is a sensor list to filter for
if self._scanning_mode == ServiceScanningMode.FILTERED_MODE and len(
self.SensorMonitoredList) == 0:
return
# if adapter is none do initial setup before starting.
if self._adapter is None:
self._adapter = get_provider().get_adapter(self._hci_index)
self._adapter._handle_meta_event = handle_meta_event_override
self._adapter.start_scanning()
self._started = True
def __init__(self, publisher, logger, params, sensors, actuators):
"""Initializes the listener and kicks off the listening"""
self.logger = logger
self.dest_root = params("Destination")
self.publish = publisher
self.logger.info(
'----------Configuring Govee listener with destination {}'.format(
self.dest_root))
self.GOVEE_BT_MAC_PREFIX = "A4:C1:38"
self.H5075_UPDATE_UUID16 = UUID16(0xEC88)
self.adapter = get_provider().get_adapter()
self.observer = Observer(self.adapter)
self.observer.on_advertising_data = self.on_advertisement
self.observer.start()
self.poll = -1
self.devices = {}
def __init__(self, callback, bt_device=''):
'''
Arguments:
callback: Function that receives the data from BLE
device (string): BLE device (default 0)
'''
super().__init__(callback, bt_device)
self.observer = None
if not bt_device:
bt_device = 0
else:
# Old communication used hci0 etc.
bt_device = bt_device.replace('hci', '')
log.info('Observing broadcasts (device %s)', bt_device)
adapter = get_provider().get_adapter(int(bt_device))
self.observer = Observer(adapter)
self.observer.on_advertising_data = self.handle_callback
def __init__(self, url, tx_power=0x08):
"""
:param url: String containing URL e.g. ('http://camjam.me')
:param tx_power: Value of Tx Power of advertisement (Not implemented)
"""
# service_data = tools.url_to_advert(url, 0x10, tx_power)
# if len(service_data) > 20:
# raise Exception('URL too long')
# if (check_prefix(url) is False):
# raise Exception('URL domain prefix did not match')
# self.url_beacon = broadcaster.Beacon()
# self.url_beacon.add_service_data('FEAA', service_data)
self.adapter = get_provider().get_adapter()
self.beacon = EddystoneBeacon(self.adapter)
if (check_prefix(url) is False):
raise Exception('URL domain prefix did not match')
self.beacon.url = url
def start(bt_device=''):
'''
Attributes:
device (string): BLE device (default 0)
'''
if not bt_device:
bt_device = 0
else:
# Old communication used hci0 etc.
bt_device = bt_device.replace('hci', '')
log.info('Start receiving broadcasts (device %s)', bt_device)
q = Queue()
adapter = get_provider().get_adapter(int(bt_device))
observer = Observer(adapter)
observer.on_advertising_data = q.put
observer.start()
return (observer, q)
def run_observer():
with Observer(get_provider().get_adapter(), lambda advertisement_report: print(advertisement_report)):
sleep(5)
def run_beacon(url):
with EddystoneBeacon(get_provider().get_adapter(), url):
pause()
#!/usr/bin/env python3
import sys
from time import sleep
from bleson import get_provider, Advertiser, Advertisement
# Get the wait time from the first script argument or default it to 10 seconds
WAIT_TIME = int(sys.argv[1]) if len(sys.argv) > 1 else 10
with Advertiser(get_provider().get_adapter(),
Advertisement(name='bleson', raw_data=bytearray([0, 1]))):
sleep(WAIT_TIME)
args=parser.parse_args()
###### Define graceful exit
atexit.register(exit_handler)
###### Define output
if args.logfile=="" or args.logfile=="stdout":
_useStdOut = True
else:
_useStdOut = False
level=set_level(args.loglevel)
###### ibeacon adapter and observers
adapter = get_provider().get_adapter(args.hci)
observer = Observer(adapter)
observer.on_advertising_data = on_advertisement
observer.start(True) # filter duplicates
###### Sleep this thread while the observer thread does its magic
listentime = args.listentime
if listentime == -1:
###### TODO: Service Healthcheck and sleep???
while True:
sleep (10)
#TODO clean up files.
#TODO what other useful things could this thread do
def run_beacon(url):
with EddystoneBeacon(get_provider().get_adapter(), url):
while True:
sleep(1)
def setup_platform(hass, config, add_entities, discovery_info=None) -> None:
"""Set up the sensor platform."""
_LOGGER.debug("Starting Govee HCI Sensor")
if hasattr(config, "CONF_HCITOOL_ACTIVE"):
_LOGGER.warning("CONF_HCITOOL_ACTIVE has been deprecated "
"and will be removed in a future release.")
govee_devices: List[BLE_HT_data] = [] # Data objects of configured devices
sensors_by_mac = {} # HomeAssistant sensors by MAC address
adapter = None
def handle_meta_event(hci_packet) -> None:
"""Handle recieved BLE data."""
# If recieved BLE packet is of type ADVERTISING_REPORT
if hci_packet.subevent_code == EVT_LE_ADVERTISING_REPORT:
packet_mac = hci_packet.data[3:9]
for device in govee_devices:
# If recieved device data matches a configured govee device
if BDAddress(device.mac) == BDAddress(packet_mac):
_LOGGER.debug("Received packet data for {}: {}".format(
BDAddress(device.mac), hex_string(hci_packet.data)))
# parse packet data
ga = GoveeAdvertisement(hci_packet.data)
# If mfg data information is defined, update values
if ga.packet is not None:
device.update(ga.temperature, ga.humidity, ga.packet)
# Update RSSI and battery level
device.rssi = ga.rssi
device.battery = ga.battery
def init_configureed_devices() -> None:
"""Initialize configured Govee devices."""
for conf_dev in config[CONF_GOVEE_DEVICES]:
# Initialize BLE HT data objects
mac = conf_dev["mac"]
device = BLE_HT_data(mac, conf_dev.get("name", None))
device.log_spikes = config[CONF_LOG_SPIKES]
if config[CONF_ROUNDING]:
device.decimal_places = config[CONF_DECIMALS]
govee_devices.append(device)
# Initialize HA sensors
name = conf_dev.get("name", mac)
temp_sensor = TemperatureSensor(mac, name)
hum_sensor = HumiditySensor(mac, name)
sensors = [temp_sensor, hum_sensor]
sensors_by_mac[mac] = sensors
add_entities(sensors)
def update_ble_devices(config) -> None:
"""Discover Bluetooth LE devices."""
# _LOGGER.debug("Discovering Bluetooth LE devices")
use_median = config[CONF_USE_MEDIAN]
ATTR = "_device_state_attributes"
textattr = "last median of" if use_median else "last mean of"
for device in govee_devices:
sensors = sensors_by_mac[device.mac]
_LOGGER.debug("Last mfg data for {}: {}".format(
BDAddress(device.mac), device.last_packet))
if device.last_packet:
humstate_med = float(device.median_humidity)
humstate_mean = float(device.mean_humidity)
tempstate_med = float(device.median_temperature)
tempstate_mean = float(device.mean_temperature)
getattr(sensors[0], ATTR)["median"] = tempstate_med
getattr(sensors[0], ATTR)["mean"] = tempstate_mean
if use_median:
setattr(sensors[0], "_state", tempstate_med)
else:
setattr(sensors[0], "_state", tempstate_mean)
getattr(sensors[1], ATTR)["median"] = humstate_med
getattr(sensors[1], ATTR)["mean"] = humstate_mean
if use_median:
setattr(sensors[1], "_state", humstate_med)
else:
setattr(sensors[1], "_state", humstate_mean)
for sensor in sensors:
last_packet = device.last_packet
getattr(sensor, ATTR)["last packet id"] = last_packet
getattr(sensor, ATTR)["rssi"] = device.rssi
getattr(sensor, ATTR)[ATTR_BATTERY_LEVEL] = device.battery
getattr(sensor, ATTR)[textattr] = device.data_size
sensor.async_schedule_update_ha_state()
device.reset()
def update_ble_loop(now) -> None:
"""Lookup Bluetooth LE devices and update status."""
_LOGGER.debug("update_ble_loop called")
adapter.start_scanning()
try:
# Time to make the dounuts
update_ble_devices(config)
except RuntimeError as error:
_LOGGER.error("Error during Bluetooth LE scan: %s", error)
time_offset = dt_util.utcnow() + timedelta(seconds=config[CONF_PERIOD])
# update_ble_loop() will be called again after time_offset
track_point_in_utc_time(hass, update_ble_loop, time_offset)
###########################################################################
# Initalize bluetooth adapter and begin scanning
# XXX: will not work if there are more than 10 HCI devices
adapter = get_provider().get_adapter(int(config[CONF_HCI_DEVICE][-1]))
adapter._handle_meta_event = handle_meta_event
hass.bus.listen("homeassistant_stop", adapter.stop_scanning)
adapter.start_scanning()
# Initialize configured Govee devices
init_configureed_devices()
# Begin sensor update loop
update_ble_loop(dt_util.utcnow())
def handle_meta_event(hci_packet) -> None:
"""Handle recieved BLE data."""
# If recieved BLE packet is of type ADVERTISING_REPORT
if hci_packet.subevent_code == EVT_LE_ADVERTISING_REPORT:
ga = GoveeAdvertisement(hci_packet.data)
# If mfg data information is defined
if ga.packet is not None:
print_govee_data(ga)
else:
print_unknown_packet(ga)
# ###########################################################################
adapter = get_provider().get_adapter()
adapter._handle_meta_event = handle_meta_event
try:
while True:
adapter.start_scanning()
sleep(2)
adapter.stop_scanning()
except KeyboardInterrupt:
try:
adapter.stop_scanning()
sys.exit(0)
except SystemExit:
adapter.stop_scanning()
os._exit(0)
#!/usr/bin/env python3
import sys
from time import sleep
from bleson import get_provider, EddystoneBeacon
# Get the wait time from the first script argument or default it to 10 seconds
WAIT_TIME = int(sys.argv[1]) if len(sys.argv) > 1 else 10
with EddystoneBeacon(get_provider().get_adapter(),
'https://www.bluetooth.com/'):
sleep(WAIT_TIME)
#!/usr/bin/env python3
import sys
from time import sleep
from bleson import get_provider, Observer
from bleson.logger import log, set_level, DEBUG
#set_level(DEBUG)
# Get the wait time from the first script argument or default it to 10 seconds
WAIT_TIME = int(sys.argv[1]) if len(sys.argv) > 1 else 10
with Observer(get_provider().get_adapter(), lambda device: log.info(device)):
sleep(WAIT_TIME)
def __init__(self, _):
super().__init__(_)
self.adapter = get_provider().get_adapter()
# Turn on bleson DEBUG logging, keeping note of the previous setting.
self.previous_log_level = set_level(DEBUG)
def setup_platform(hass, config, add_entities, discovery_info=None) -> None:
"""Set up the sensor platform."""
_LOGGER.debug("Starting Govee HCI Sensor")
govee_devices: List[BLE_HT_data] = [] # Data objects of configured devices
sensors_by_mac = {} # HomeAssistant sensors by MAC address
adapter = None
def handle_meta_event(hci_packet) -> None:
"""Handle recieved BLE data."""
# If recieved BLE packet is of type ADVERTISING_REPORT
if hci_packet.subevent_code == EVT_LE_ADVERTISING_REPORT:
packet_mac = hci_packet.data[3:9]
for device in govee_devices:
# If recieved device data matches a configured govee device
if BDAddress(device.mac) == BDAddress(packet_mac):
_LOGGER.debug("Received packet data for {}: {}".format(
BDAddress(device.mac), hex_string(hci_packet.data)))
# parse packet data
ga = GoveeAdvertisement(hci_packet.data)
# If mfg data information is defined, update values
if ga.packet is not None:
device.update(ga.temperature, ga.humidity, ga.packet)
# Update RSSI and battery level
device.rssi = ga.rssi
device.battery = ga.battery
def init_configureed_devices() -> None:
"""Initialize configured Govee devices."""
for conf_dev in config[CONF_GOVEE_DEVICES]:
# Initialize BLE HT data objects
mac: str = conf_dev["mac"]
given_name = conf_dev.get("name", None)
device = BLE_HT_data(mac, given_name)
device.log_spikes = config[CONF_LOG_SPIKES]
device.maximum_temperature = config[CONF_TEMP_RANGE_MAX_CELSIUS]
device.minimum_temperature = config[CONF_TEMP_RANGE_MIN_CELSIUS]
if config[CONF_ROUNDING]:
device.decimal_places = config[CONF_DECIMALS]
govee_devices.append(device)
# Initialize HA sensors
name = conf_dev.get("name", mac)
temp_sensor = TemperatureSensor(mac, name)
hum_sensor = HumiditySensor(mac, name)
sensors = [temp_sensor, hum_sensor]
sensors_by_mac[mac] = sensors
add_entities(sensors)
def update_ble_devices(config) -> None:
"""Discover Bluetooth LE devices."""
# _LOGGER.debug("Discovering Bluetooth LE devices")
use_median = config[CONF_USE_MEDIAN]
ATTR = "_device_state_attributes"
textattr = "last median of" if use_median else "last mean of"
for device in govee_devices:
sensors = sensors_by_mac[device.mac]
_LOGGER.debug("Last mfg data for {}: {}".format(
BDAddress(device.mac), device.last_packet))
if device.last_packet:
if device.median_humidity is not None:
humstate_med = float(device.median_humidity)
getattr(sensors[1], ATTR)["median"] = humstate_med
if use_median:
setattr(sensors[1], "_state", humstate_med)
if device.mean_humidity is not None:
humstate_mean = float(device.mean_humidity)
getattr(sensors[1], ATTR)["mean"] = humstate_mean
if not use_median:
setattr(sensors[1], "_state", humstate_mean)
if device.median_temperature is not None:
tempstate_med = float(device.median_temperature)
getattr(sensors[0], ATTR)["median"] = tempstate_med
if use_median:
setattr(sensors[0], "_state", tempstate_med)
if device.mean_temperature is not None:
tempstate_mean = float(device.mean_temperature)
getattr(sensors[0], ATTR)["mean"] = tempstate_mean
if not use_median:
setattr(sensors[0], "_state", tempstate_mean)
for sensor in sensors:
last_packet = device.last_packet
getattr(sensor, ATTR)["last packet id"] = last_packet
getattr(sensor, ATTR)["rssi"] = device.rssi
getattr(sensor, ATTR)[ATTR_BATTERY_LEVEL] = device.battery
getattr(sensor, ATTR)[textattr] = device.data_size
sensor.async_schedule_update_ha_state()
device.reset()
def update_ble_loop(now) -> None:
"""Lookup Bluetooth LE devices and update status."""
_LOGGER.debug("update_ble_loop called")
adapter.start_scanning()
try:
# Time to make the dounuts
update_ble_devices(config)
except RuntimeError as error:
_LOGGER.error("Error during Bluetooth LE scan: %s", error)
time_offset = dt_util.utcnow() + timedelta(seconds=config[CONF_PERIOD])
# update_ble_loop() will be called again after time_offset
track_point_in_utc_time(hass, update_ble_loop, time_offset)
###########################################################################
# Initalize bluetooth adapter and begin scanning
# XXX: will not work if there are more than 10 HCI devices
try:
adapter = get_provider().get_adapter(int(config[CONF_HCI_DEVICE][-1]))
adapter._handle_meta_event = handle_meta_event
hass.bus.listen("homeassistant_stop", adapter.stop_scanning)
adapter.start_scanning()
except (RuntimeError, OSError, PermissionError) as error:
error_msg = "Error connecting to Bluetooth adapter: {}\n\n".format(
error)
error_msg += "Bluetooth adapter troubleshooting:\n"
error_msg += " -If running HASS, ensure the correct HCI device is being"
error_msg += " used. Check by logging into HA command line and execute:\n"
error_msg += " gdbus introspect --system --dest org.bluez --object-path /org/bluez | fgrep -i hci\n"
error_msg += " -If running Home Assistant in Docker, "
error_msg += "make sure it run with the --privileged flag.\n"
# _LOGGER.error(error_msg)
raise HomeAssistantError(error_msg) from error
# Initialize configured Govee devices
init_configureed_devices()
# Begin sensor update loop
update_ble_loop(dt_util.utcnow())
def stopadvertising():
adapter = get_provider().get_adapter()
advertiser = Advertiser(adapter)
advertisement = Advertisement()
advertiser.advertisement = advertisement
advertiser.stop()
