Add support for multiple values per sensor type.

tannewt · tannewt · commit 5c4aeb2787c6 · 2020-02-06T17:30:57.000-08:00
diff --git a/adafruit_ble_broadcastnet.py b/adafruit_ble_broadcastnet.py
@@ -43,13 +43,27 @@
 * Adafruit's BLE library: https://github.com/adafruit/Adafruit_CircuitPython_BLE
 """
 
+import adafruit_ble
 from adafruit_ble.advertising import Advertisement, LazyObjectField
 from adafruit_ble.advertising.standard import ManufacturerData, ManufacturerDataField
 import struct
+import time
 
 __version__ = "0.0.0-auto.0"
 __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_BLE_BroadcastNet.git"
 
+_ble = adafruit_ble.BLERadio()
+_sequence_number = 0
+def broadcast(measurement, *, broadcast_time=0.1):
+    global _sequence_number
+    measurement.sequence_number = _sequence_number
+    _ble.start_advertising(measurement, scan_response=None)
+    time.sleep(broadcast_time)
+    _ble.stop_advertising()
+    _sequence_number = (_sequence_number + 1) % 256
+
+device_address = "{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}".format(*_ble._adapter.address.address_bytes)
+
 _MANUFACTURING_DATA_ADT = const(0xff)
 _ADAFRUIT_COMPANY_ID = const(0x0822)
 _SENSOR_DATA_ID = const(0x0002)
@@ -71,16 +85,16 @@ class AdafruitSensorMeasurement(Advertisement):
     sequence_number = ManufacturerDataField(0x0003, "<B")
     """Sequence number of the measurement. Used to detect missed packets."""
 
-    acceleration = ManufacturerDataField(0x0a00, "<fff")
+    acceleration = ManufacturerDataField(0x0a00, "<fff", ("x", "y", "z"))
     """Acceleration as (x, y, z) tuple of floats in meters per second per second."""
 
-    magnetic = ManufacturerDataField(0x0a01, "<fff")
+    magnetic = ManufacturerDataField(0x0a01, "<fff", ("x", "y", "z"))
     """Magnetism as (x, y, z) tuple of floats in micro-Tesla."""
 
-    orientation = ManufacturerDataField(0x0a02, "<fff")
+    orientation = ManufacturerDataField(0x0a02, "<fff", ("x", "y", "z"))
     """Absolution orientation as (x, y, z) tuple of floats in degrees."""
 
-    gyro = ManufacturerDataField(0x0a03, "<fff")
+    gyro = ManufacturerDataField(0x0a03, "<fff", ("x", "y", "z"))
     """Gyro motion as (x, y, z) tuple of floats in radians per second."""
 
     temperature = ManufacturerDataField(0x0a04, "<f")
diff --git a/examples/ble_broadcastnet_multisensor.py b/examples/ble_broadcastnet_multisensor.py
@@ -0,0 +1,81 @@
+"""This is a complex sensor node that uses the sensors on a Clue and Feather Bluefruit Sense."""
+
+import board
+import adafruit_bmp280
+import adafruit_sht31d
+import adafruit_apds9960.apds9960
+import adafruit_lis3mdl
+import adafruit_lsm6ds
+import adafruit_ble_broadcastnet
+import time
+
+print("This is BroadcastNet sensor:", adafruit_ble_broadcastnet.device_address)
+
+i2c = board.I2C()
+
+# Define sensors:
+# Accelerometer/gyroscope:
+lsm6ds = adafruit_lsm6ds.LSM6DS33(i2c)
+
+# Magnetometer:
+lis3mdl = adafruit_lis3mdl.LIS3MDL(i2c)
+
+# DGesture/proximity/color/light sensor:
+# TODO: How do we get the light level?
+# apds9960 = adafruit_apds9960.apds9960.APDS9960(i2c)
+# apds9960.enable_color = True
+
+# Humidity sensor:
+sht31d = adafruit_sht31d.SHT31D(i2c)
+
+# Barometric pressure sensor:
+bmp280 = adafruit_bmp280.Adafruit_BMP280_I2C(i2c)
+
+last_sht31d_temperature = None
+last_sht31d_relative_humidity = None
+last_bmp280_temperature = None
+last_bmp280_pressure = None
+last_lsm6ds_acceleration = None
+last_lis3mdl_magnetic = None
+
+while True:
+    measurement = adafruit_ble_broadcastnet.AdafruitSensorMeasurement()
+
+    # Handle the two temperature measurements. We must always provide both because they split into
+    # feeds based on the position in the field.
+    sht31d_temperature = round(sht31d.temperature, 0)
+    bmp280_temperature = round(bmp280.temperature, 0)
+    if (sht31d_temperature != last_sht31d_temperature or
+        bmp280_temperature != last_bmp280_temperature):
+        measurement.temperature = (sht31d_temperature, bmp280_temperature)
+        last_sht31d_temperature = sht31d_temperature
+        last_bmp280_temperature = bmp280_temperature
+
+    # Relative humidity, rounded to the nearest whole integer.
+    sht31d_relative_humidity = round(sht31d.relative_humidity, 0)
+    if sht31d_relative_humidity != last_sht31d_relative_humidity:
+        measurement.relative_humidity = sht31d_relative_humidity
+        last_sht31d_relative_humidity = sht31d_relative_humidity
+
+    # Pressure, round to one decimal place.
+    bmp280_pressure = round(bmp280.pressure, 1)
+    if bmp280_pressure != last_bmp280_pressure:
+        measurement.pressure = bmp280_pressure
+        last_bmp280_pressure = bmp280_pressure
+
+    # Acceleration, each axis rounded to one decimal place.
+    lsm6ds_acceleration = tuple([round(axis, 1) for axis in lsm6ds.acceleration])
+    if lsm6ds_acceleration != last_lsm6ds_acceleration:
+        measurement.acceleration = lsm6ds_acceleration
+        last_lsm6ds_acceleration = lsm6ds_acceleration
+
+    # Magnetic, each axis rounded to two decimal places.
+    lis3mdl_magnetic = tuple([round(axis, 2) for axis in lis3mdl.magnetic])
+    if lis3mdl_magnetic != last_lis3mdl_magnetic:
+        measurement.magnetic = lis3mdl_magnetic
+        last_lis3mdl_magnetic = lis3mdl_magnetic
+
+    if measurement:
+        print(measurement)
+        adafruit_ble_broadcastnet.broadcast(measurement)
+    time.sleep(10)
diff --git a/examples/ble_broadcastnet_simpletest.py b/examples/ble_broadcastnet_simpletest.py
@@ -0,0 +1,21 @@
+"""This is a basic sensor node that uses the internal temperature sensor."""
+
+import adafruit_ble_broadcastnet
+import microcontroller
+import time
+
+print("This is BroadcastNet sensor:", adafruit_ble_broadcastnet.device_address)
+
+last_temperature = None
+while True:
+    temp = microcontroller.cpu.temperature
+    # Round the temperature to the nearest degree to reduce how often it is
+    # broadcast.
+    temp = round(temp, 0)
+    if temp != last_temperature:
+        measurement = adafruit_ble_broadcastnet.AdafruitSensorMeasurement()
+        measurement.temperature = temp
+        print(measurement)
+        adafruit_ble_broadcastnet.broadcast(measurement)
+    last_temperature = temp
+    time.sleep(10)
diff --git a/examples/ble_broadcastnet_wifi_bridge.py b/examples/ble_broadcastnet_wifi_bridge.py
@@ -6,51 +6,9 @@
 from adafruit_esp32spi import adafruit_esp32spi
 from adafruit_esp32spi import adafruit_esp32spi_wifimanager
 from secrets import secrets
-from adafruit_ble import BLERadio
-
-from adafruit_ble.advertising import Advertisement, LazyObjectField
-from adafruit_ble.advertising.standard import ManufacturerData, ManufacturerDataField
-import struct
-import collections
-
-_MANUFACTURING_DATA_ADT = const(0xff)
-_ADAFRUIT_COMPANY_ID = const(0x0822)
-_SENSOR_DATA_ID = const(0x0002)
-
-class AdafruitSensorMeasurement(Advertisement):
-    """Broadcast a single RGB color."""
-    # This prefix matches all
-    prefix = struct.pack("<BBH",
-                         3,
-                         _MANUFACTURING_DATA_ADT,
-                         _ADAFRUIT_COMPANY_ID)
-
-    manufacturer_data = LazyObjectField(ManufacturerData,
-                                        "manufacturer_data",
-                                        advertising_data_type=_MANUFACTURING_DATA_ADT,
-                                        company_id=_ADAFRUIT_COMPANY_ID,
-                                        key_encoding="<H")
-
-    sequence_number = ManufacturerDataField(0x0003, "<B")
-    """Color to broadcast as RGB integer."""
-
-    temperature = ManufacturerDataField(0x0a00, "<f")
-    """Color to broadcast as RGB integer."""
-
-    def __init__(self, *, sensor_device_id=0xff, sequence_number=0xff):
-        super().__init__()
-        # self.sensor_device_id = sensor_device_id
-        # self.sequence_number = sequence_number
-
-    def __str__(self):
-        parts = []
-        for attr in dir(self.__class__):
-            attribute_instance = getattr(self.__class__, attr)
-            if issubclass(attribute_instance.__class__, ManufacturerDataField):
-                value = getattr(self, attr)
-                if value is not None:
-                    parts.append("{}={}".format(attr, str(value)))
-        return "<{} {} >".format(self.__class__.__name__, " ".join(parts))
+from adafruit_ble.advertising.standard import ManufacturerDataField
+import adafruit_ble
+import adafruit_ble_broadcastnet
 
 esp32_cs = DigitalInOut(board.D13)
 esp32_ready = DigitalInOut(board.D11)
@@ -84,6 +42,8 @@ def create_group(name):
 def create_feed(group_key, name):
     response = aio_post("/groups/{}/feeds".format(group_key), json={"feed": {"name": name}})
     if response.status_code != 201:
+        print(name)
+        print(response.content)
         print(response.status_code)
         raise RuntimeError("unable to create new feed")
     return response.json()["key"]
@@ -99,20 +59,22 @@ def create_data(group_key, data):
         raise RuntimeError("unable to create new data")
     response.close()
 
-def convert_to_feed_data(values, attribute_name):
+def convert_to_feed_data(values, attribute_name, attribute_instance):
     feed_data = []
-    if not isinstance(values, tuple) or hasattr(values, "_fields"):
+    # Wrap single value entries for enumeration.
+    if (not isinstance(values, tuple) or
+        (attribute_instance.element_count > 1 and not isinstance(values[0], tuple))):
         values = (values, )
     for i, value in enumerate(values):
-        key = attribute_name + str(i)
+        key = attribute_name.replace("_", "-") + "-" + str(i)
         if isinstance(value, tuple):
-            for field in value._fields:
-                feed_data.append({"key": key + field, "value": getattr(value, field)})
+            for j in range(attribute_instance.element_count):
+                feed_data.append({"key": key + "-" + attribute_instance.field_names[j], "value": value[j]})
         else:
             feed_data.append({"key": key, "value": value})
     return feed_data
 
-ble = BLERadio()
+ble = adafruit_ble.BLERadio()
 address = ble._adapter.address
 bridge_address = "{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}".format(*address.address_bytes)
 print("This is BroadcastNet bridge:", bridge_address)
@@ -132,17 +94,17 @@ def convert_to_feed_data(values, attribute_name):
 
 print(existing_feeds)
 
-counter = 0
-
-ble = BLERadio()
 print("scanning")
 sequence_numbers = {}
 # By providing Advertisement as well we include everything, not just specific advertisements.
-for measurement in ble.start_scan(AdafruitSensorMeasurement):
+for measurement in ble.start_scan(adafruit_ble_broadcastnet.AdafruitSensorMeasurement):
     sensor_address = "{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}".format(*measurement.address.address_bytes)
-    print(sensor_address, measurement)
     if sensor_address not in sequence_numbers:
         sequence_numbers[sensor_address] = measurement.sequence_number - 1 % 256
+    # Skip if we are getting the same broadcast more than once.
+    if measurement.sequence_number == sequence_numbers[sensor_address]:
+        continue
+    print(sensor_address, measurement)
     number_missed = measurement.sequence_number - sequence_numbers[sensor_address] - 1
     if number_missed < 0:
         number_missed += 256
@@ -161,8 +123,8 @@ def convert_to_feed_data(values, attribute_name):
         if issubclass(attribute_instance.__class__, ManufacturerDataField):
             if attribute != "sequence_number":
                 values = getattr(measurement, attribute)
-
-                data.extend(convert_to_feed_data(values, attribute))
+                if values is not None:
+                    data.extend(convert_to_feed_data(values, attribute, attribute_instance))
 
     for feed_data in data:
         if feed_data["key"] not in existing_feeds[sensor_address]:
@@ -177,3 +139,22 @@ def convert_to_feed_data(values, attribute_name):
     print()
 
 print("scan done")
+
+# while True:
+#     try:
+#         print("Posting data...", end='')
+#         data = counter
+#         response = aio_post("/feeds/test/data", json={'value':data})
+#         if response.status_code == 404:
+#             response = aio_post("/feeds", json={'feed': {"name": "test"}})
+#             print("error", response.status_code)
+#             print(dir(response), response.socket)
+#         json = response.json()
+#         counter = counter + 1
+#         print("OK")
+#     except (ValueError, RuntimeError) as e:
+#         print("Failed to get data, retrying\n", e)
+#         wifi.reset()
+#         continue
+#     response = None
+#     time.sleep(15)
