manually enable reports

Author: ladyada

adafruit_bno080/__init__.py

@@ -67,18 +67,18 @@
 
 
 # Calibrated Acceleration (m/s2)
-_BNO_REPORT_ACCELEROMETER = const(0x01)
+BNO_REPORT_ACCELEROMETER = const(0x01)
 # Calibrated gyroscope (rad/s).
-_BNO_REPORT_GYROSCOPE = const(0x02)
+BNO_REPORT_GYROSCOPE = const(0x02)
 # Magnetic field calibrated (in µTesla). The fully calibrated magnetic field measurement.
-_BNO_REPORT_MAGNETIC_FIELD = const(0x03)
+BNO_REPORT_MAGNETIC_FIELD = const(0x03)
 # Linear acceleration (m/s2). Acceleration of the device with gravity removed
-_BNO_REPORT_LINEAR_ACCELERATION = const(0x04)
+BNO_REPORT_LINEAR_ACCELERATION = const(0x04)
 # Rotation Vector
-_BNO_REPORT_ROTATION_VECTOR = const(0x05)
-_BNO_REPORT_GEOMAGNETIC_ROTATION_VECTOR = const(0x09)
-_BNO_REPORT_STEP_COUNTER = const(0x11)
-_BNO_REPORT_SHAKE_DETECTOR = const(0x19)
+BNO_REPORT_ROTATION_VECTOR = const(0x05)
+BNO_REPORT_GEOMAGNETIC_ROTATION_VECTOR = const(0x09)
+BNO_REPORT_STEP_COUNTER = const(0x11)
+BNO_REPORT_SHAKE_DETECTOR = const(0x19)
 
 
 _DEFAULT_REPORT_INTERVAL = const(50000)  # in microseconds = 50ms
@@ -112,15 +112,15 @@
     _BNO_CMD_TIMESTAMP_REBASE: 5,
 }
 # length is probably deterministic, like axes * 2 +4
-_ENABLED_SENSOR_REPORTS = {
-    _BNO_REPORT_ACCELEROMETER: (_Q_POINT_8_SCALAR, 3, 10),
-    _BNO_REPORT_GYROSCOPE: (_Q_POINT_9_SCALAR, 3, 10),
-    _BNO_REPORT_MAGNETIC_FIELD: (_Q_POINT_4_SCALAR, 3, 10),
-    _BNO_REPORT_LINEAR_ACCELERATION: (_Q_POINT_8_SCALAR, 3, 10),
-    _BNO_REPORT_ROTATION_VECTOR: (_Q_POINT_14_SCALAR, 4, 14,),
-    _BNO_REPORT_GEOMAGNETIC_ROTATION_VECTOR: (_Q_POINT_12_SCALAR, 4, 14),
-    _BNO_REPORT_STEP_COUNTER: (1, 1, 12),
-    _BNO_REPORT_SHAKE_DETECTOR: (1, 1, 6),
+_AVAIL_SENSOR_REPORTS = {
+    BNO_REPORT_ACCELEROMETER: (_Q_POINT_8_SCALAR, 3, 10),
+    BNO_REPORT_GYROSCOPE: (_Q_POINT_9_SCALAR, 3, 10),
+    BNO_REPORT_MAGNETIC_FIELD: (_Q_POINT_4_SCALAR, 3, 10),
+    BNO_REPORT_LINEAR_ACCELERATION: (_Q_POINT_8_SCALAR, 3, 10),
+    BNO_REPORT_ROTATION_VECTOR: (_Q_POINT_14_SCALAR, 4, 14,),
+    BNO_REPORT_GEOMAGNETIC_ROTATION_VECTOR: (_Q_POINT_12_SCALAR, 4, 14),
+    BNO_REPORT_STEP_COUNTER: (1, 1, 12),
+    BNO_REPORT_SHAKE_DETECTOR: (1, 1, 6),
 }
 
 DATA_BUFFER_SIZE = const(512)  # data buffer size. obviously eats ram
@@ -158,7 +158,7 @@ def wrapper_timer(*args, **kwargs):
 def _parse_sensor_report_data(report_bytes):
     data_offset = 4  # this may not always be true
     report_id = report_bytes[0]
-    scalar, count, _report_length = _ENABLED_SENSOR_REPORTS[report_id]
+    scalar, count, _report_length = _AVAIL_SENSOR_REPORTS[report_id]
 
     results = []
 
@@ -204,7 +204,7 @@ def parse_sensor_id(buffer):
 
 def _report_length(report_id):
     if report_id < 0xF0:  # it's a sensor report
-        return _ENABLED_SENSOR_REPORTS[report_id][2]
+        return _AVAIL_SENSOR_REPORTS[report_id][2]
 
     return _REPORT_LENGTHS[report_id]
 
@@ -362,53 +362,62 @@ def initialize(self):
         self.soft_reset()
         if not self._check_id():
             raise RuntimeError("Could not read ID")
-        for report_type in _ENABLED_SENSOR_REPORTS:
-            self._enable_feature(report_type)
 
     @property
     def magnetic(self):
         """A tuple of the current magnetic field measurements on the X, Y, and Z axes"""
         self._process_available_packets()  # decorator?
-        return self._readings[_BNO_REPORT_MAGNETIC_FIELD]
-
+        try:
+            return self._readings[BNO_REPORT_MAGNETIC_FIELD]
+        except KeyError:
+            raise RuntimeError("No magfield report found, is it enabled?") from None
     @property
     def quaternion(self):
         """A quaternion representing the current rotation vector"""
         self._process_available_packets()
-        return self._readings[_BNO_REPORT_ROTATION_VECTOR]
+        return self._readings[BNO_REPORT_ROTATION_VECTOR]
 
     @property
     def geomagnetic_quaternion(self):
         """A quaternion representing the current geomagnetic rotation vector"""
         self._process_available_packets()
-        return self._readings[_BNO_REPORT_GEOMAGNETIC_ROTATION_VECTOR]
+        return self._readings[BNO_REPORT_GEOMAGNETIC_ROTATION_VECTOR]
 
     @property
     def steps(self):
         """The number of steps detected since the sensor was initialized"""
         self._process_available_packets()
-        return self._readings[_BNO_REPORT_STEP_COUNTER]
+        return self._readings[BNO_REPORT_STEP_COUNTER]
 
     @property
     def linear_acceleration(self):
         """A tuple representing the current linear acceleration values on the X, Y, and Z
         axes in meters per second squared"""
         self._process_available_packets()
-        return self._readings[_BNO_REPORT_LINEAR_ACCELERATION]
+        try:
+            return self._readings[BNO_REPORT_LINEAR_ACCELERATION]
+        except KeyError:
+            raise RuntimeError("No lin. accel report found, is it enabled?") from None
 
     @property
     def acceleration(self):
         """A tuple representing the acceleration measurements on the X, Y, and Z
         axes in meters per second squared"""
         self._process_available_packets()
-        return self._readings[_BNO_REPORT_ACCELEROMETER]
+        try:
+            return self._readings[BNO_REPORT_ACCELEROMETER]
+        except KeyError:
+            raise RuntimeError("No accel report found, is it enabled?") from None
 
     @property
     def gyro(self):
         """A tuple representing Gyro's rotation measurements on the X, Y, and Z
         axes in radians per second"""
         self._process_available_packets()
-        return self._readings[_BNO_REPORT_GYROSCOPE]
+        try:
+            return self._readings[BNO_REPORT_GYROSCOPE]
+        except KeyError:
+            raise RuntimeError("No gyro report found, is it enabled?") from None
 
     @property
     def shake(self):
@@ -419,20 +428,24 @@ def shake(self):
         this property is not guaranteed to reflect the shake state at the moment it is read
         """
         self._process_available_packets()
-        shake_detected = self._readings[_BNO_REPORT_SHAKE_DETECTOR]
+        shake_detected = self._readings[BNO_REPORT_SHAKE_DETECTOR]
         # clear on read
         if shake_detected:
-            self._readings[_BNO_REPORT_SHAKE_DETECTOR] = False
+            self._readings[BNO_REPORT_SHAKE_DETECTOR] = False
 
     # # decorator?
     def _process_available_packets(self):
         processed_count = 0
         while self._data_ready:
-            new_packet = self._read_packet()
+            print("reading a packet")
+            try:
+                new_packet = self._read_packet()
+            except PacketError:
+                continue
             self._handle_packet(new_packet)
             processed_count += 1
             self._dbg("")
-            self._dbg("Processesd", processed_count, "packets")
+            #print("Processed", processed_count, "packets")
             self._dbg("")
             # we'll probably need an exit here for fast sensor rates
         self._dbg("")
@@ -511,14 +524,14 @@ def _process_report(self, report_id, report_bytes):
                 print(outstr)
                 self._dbg("")
 
-            if report_id == _BNO_REPORT_STEP_COUNTER:
+            if report_id == BNO_REPORT_STEP_COUNTER:
                 self._readings[report_id] = _parse_step_couter_report(report_bytes)
                 return
-            if report_id == _BNO_REPORT_SHAKE_DETECTOR:
+            if report_id == BNO_REPORT_SHAKE_DETECTOR:
                 shake_detected = _parse_shake_report(report_bytes)
                 # shake not previously detected - auto cleared by 'shake' property
-                if not self._readings[_BNO_REPORT_SHAKE_DETECTOR]:
-                    self._readings[_BNO_REPORT_SHAKE_DETECTOR] = shake_detected
+                if not self._readings[BNO_REPORT_SHAKE_DETECTOR]:
+                    self._readings[BNO_REPORT_SHAKE_DETECTOR] = shake_detected
                 return
 
             sensor_data = _parse_sensor_report_data(report_bytes)
@@ -541,10 +554,11 @@ def _get_feature_enable_report(
         pack_into("<I", set_feature_report, 5, report_interval)
         return set_feature_report
 
-    def _enable_feature(self, feature_id):
+    def enable_feature(self, feature_id):
         self._dbg("\n********** Enabling feature id:", feature_id, "**********")
 
         set_feature_report = self._get_feature_enable_report(feature_id)
+        print("Enabling", feature_id)
         self._send_packet(_BNO_CHANNEL_CONTROL, set_feature_report)
         while True:
             packet = self._wait_for_packet_type(
@@ -553,15 +567,16 @@ def _enable_feature(self, feature_id):
 
             if packet.data[1] == feature_id:
                 if (
-                    feature_id == _BNO_REPORT_ROTATION_VECTOR
+                    feature_id == BNO_REPORT_ROTATION_VECTOR
                 ):  # check for other vector types as well
                     self._readings[feature_id] = (0.0, 0.0, 0.0, 0.0)
                 else:
                     self._readings[feature_id] = (0.0, 0.0, 0.0)
-                self._dbg("Enabled")
-                return True
+                print("Enabled", feature_id)
+                break
+            else:
+                raise RuntimeError("Was not able to enable feature", feature_id)
 
-        return False
 
     def _check_id(self):
         self._dbg("\n********** READ ID **********")
@@ -613,13 +628,6 @@ def _get_data(self, index, fmt_string):
         data_index = index + 4
         return unpack_from(fmt_string, self._data_buffer, offset=data_index)[0]
 
-    def _read_header(self):
-        """Reads the first 4 bytes available as a header"""
-        with self.bus_device_obj as bus_dev:  # pylint:disable=no-member
-            bus_dev.readinto(self._data_buffer, end=4)
-        packet_header = Packet.header_from_buffer(self._data_buffer)
-        self._dbg(packet_header)
-        return packet_header
 
     # pylint:disable=no-self-use
     @property

adafruit_bno080/i2c.py

@@ -49,15 +49,27 @@ def _send_packet(self, channel, data):
     # returns true if available data was read
     # the sensor will always tell us how much there is, so no need to track it ourselves
 
+    def _read_header(self):
+        """Reads the first 4 bytes available as a header"""
+        while True:
+            with self.bus_device_obj as i2c:
+                try:
+                    i2c.readinto(self._data_buffer, end=4)  # this is expecting a header
+                    break
+                except RuntimeError:
+                    time.sleep(0.1)
+                    pass
+        packet_header = Packet.header_from_buffer(self._data_buffer)
+        self._dbg(packet_header)
+        return packet_header
+
     def _read_packet(self):
         # TODO: MAGIC NUMBER?
-
-        time.sleep(0.001)  #
         # TODO: this can be `_read_header` or know it's done by `_data_ready`
         with self.bus_device_obj as i2c:
             i2c.readinto(self._data_buffer, end=4)  # this is expecting a header?
         self._dbg("")
-        self._dbg("SHTP READ packet header: ", [hex(x) for x in self._data_buffer[0:4]])
+        #print("SHTP READ packet header: ", [hex(x) for x in self._data_buffer[0:4]])
 
         header = Packet.header_from_buffer(self._data_buffer)
         packet_byte_count = header.packet_byte_count
@@ -105,6 +117,7 @@ def _read(self, requested_read_length):
     @property
     def _data_ready(self):
         header = self._read_header()
+
         if header.channel_number > 5:
             self._dbg("channel number out of range:", header.channel_number)
         #  data_length, packet_byte_count)

examples/bno080_simpletest.py

@@ -4,21 +4,27 @@
 import time
 import board
 import busio
+import adafruit_bno080
 from adafruit_bno080.i2c import BNO080_I2C
 from digitalio import DigitalInOut
 
-i2c = busio.I2C(board.SCL, board.SDA)
+i2c = busio.I2C(board.SCL, board.SDA, frequency=400000)
 reset_pin = DigitalInOut(board.G0)
 bno = BNO080_I2C(i2c, reset=reset_pin)
 
+bno.enable_feature(adafruit_bno080.BNO_REPORT_ACCELEROMETER)
+#bno.enable_feature(adafruit_bno080.BNO_REPORT_GYROSCOPE)
+#bno.enable_feature(adafruit_bno080.BNO_REPORT_MAGNETIC_FIELD)
+
 while True:
 
-    # print("Acceleration:")
+    print("Acceleration:")
     accel_x, accel_y, accel_z = bno.acceleration  # pylint:disable=no-member
     print("X: %0.6f  Y: %0.6f Z: %0.6f  m/s^2" % (accel_x, accel_y, accel_z))
     print("")
 
-    # print("Gyro:")
+    """
+    print("Gyro:")
     gyro_x, gyro_y, gyro_z = bno.gyro  # pylint:disable=no-member
     print("X: %0.6f  Y: %0.6f Z: %0.6f rads/s" % (gyro_x, gyro_y, gyro_z))
     print("")
@@ -65,3 +71,4 @@
         print("")
 
     sleep(0.5)
+    """