fixes missing type definitions for new style SPI.

Also adds the start of an IMU sensor framework and fusion math.

Author: kdschlosser

api_drivers/common_api_drivers/frozen/other/auto_rotation.py

@@ -0,0 +1,119 @@
+# Copyright (c) 2024 - 2025 Kevin G. Schlosser
+
+import lvgl as lv
+
+
+class AutoRotation:
+
+    def __init__(self, device, delay, lock_rotation=False, adjustment=0.0):
+
+        if adjustment > 180 or adjustment < -180:
+            raise ValueError('adjustment range is -180.0 to +180.0')
+
+        scrn = lv.screen_active()
+        disp = scrn.get_display()
+
+        self._device = device
+
+        self._timer = lv.timer_create(self._timer_cb, delay)
+        self._timer.set_repeat_count(-1)
+
+        self._fusion = fusion.Fusion()
+        self._lock_rotation = lock_rotation
+
+        self._last_rotation = disp.get_rotation()
+        self._last_free_rotation = 0
+        self._adjustment = adjustment
+
+    @property
+    def adjustment(self):
+        return self._adjustment
+
+    @adjustment.setter
+    def adjustment(self, value):
+        self._adjustment = value
+        self._timer_cb(None)
+
+    @property
+    def lock_rotation(self):
+        return self._lock_rotation
+
+    @lock_rotation.setter
+    def lock_rotation(self, value):
+        self._lock_rotation = value
+        self._timer_cb(None)
+
+    def __del__(self):
+        if self._timer is not None:
+            self._timer.delete()
+
+    def _timer_cb(self, _):
+        roll, pitch, yaw = self._device.read()
+
+        roll += self._adjustment
+
+        if roll > 180.00:
+            roll -= 360.0
+
+        if roll < -180.0:
+            roll += 360.0
+
+        if roll < 0.0:
+            roll += 360.0
+
+        scrn = lv.screen_active()
+        disp = scrn.get_display()
+
+        if self._lock_rotation:
+
+            if 45 <= roll < 135:
+                new_rotation = lv.DISPLAY_ROTATION._90
+
+            elif 135 <= roll < 225:
+                new_rotation = lv.DISPLAY_ROTATION._180
+
+            elif 225 <= roll < 315:
+                new_rotation = lv.DISPLAY_ROTATION._270
+
+            else:
+                new_rotation = lv.DISPLAY_ROTATION._0
+
+            if new_rotation != self._last_rotation:
+                self._last_rotation = new_rotation
+                disp.set_rotation(new_rotation)
+        else:
+            roll = int(roll * 10.0)
+
+            if self._last_rotation != lv.DISPLAY_ROTATION._0:
+                self._last_rotation = lv.DISPLAY_ROTATION._0
+                disp.set_rotation(lv.DISPLAY_ROTATION._0)
+
+            if roll != self._last_free_rotation:
+                self._last_free_rotation = roll
+                top_layer = disp.get_layer_top()
+                sys_layer = disp.get_layer_sys()
+                bottom_layer = disp.get_layer_bottom()
+
+                top_layer_pivot_x = int(top_layer.get_width() / 2)
+                top_layer_pivot_y = int(top_layer.get_height() / 2)
+                top_layer.set_style_transform_pivot_x(top_layer_pivot_x, lv.PART.ANY)
+                top_layer.set_style_transform_pivot_y(top_layer_pivot_y, lv.PART.ANY)
+                top_layer.set_style_transform_rotation(roll, lv.PART.ANY)
+
+                sys_layer_pivot_x = int(sys_layer.get_width() / 2)
+                sys_layer_pivot_y = int(sys_layer.get_height() / 2)
+                sys_layer.set_style_transform_pivot_x(sys_layer_pivot_x, lv.PART.ANY)
+                sys_layer.set_style_transform_pivot_y(sys_layer_pivot_y, lv.PART.ANY)
+                sys_layer.set_style_transform_rotation(roll, lv.PART.ANY)
+
+                bottom_layer_pivot_x = int(bottom_layer.get_width() / 2)
+                bottom_layer_pivot_y = int(bottom_layer.get_height() / 2)
+                bottom_layer.set_style_transform_pivot_x(bottom_layer_pivot_x, lv.PART.ANY)
+                bottom_layer.set_style_transform_pivot_y(bottom_layer_pivot_y, lv.PART.ANY)
+                bottom_layer.set_style_transform_rotation(roll, lv.PART.ANY)
+
+                scrn_pivot_x = int(scrn.get_width() / 2)
+                scrn_pivot_y = int(scrn.get_height() / 2)
+                scrn.set_style_transform_pivot_x(scrn_pivot_x, lv.PART.ANY)
+                scrn.set_style_transform_pivot_y(scrn_pivot_y, lv.PART.ANY)
+                scrn.set_style_transform_rotation(roll, lv.PART.ANY)

api_drivers/common_api_drivers/imu_sensor/qmi8658c.py

@@ -0,0 +1,186 @@
+from micropython import const  # NOQA
+import imu_sensor_framework  # NOQA
+
+
+_VERSION_REG = const(0x0)
+_REVISION_REG = const(0x1)
+
+_TIME_REG = const(0x30)
+_TEMP_REG = const(0x33)
+_ACCEL_REG = const(0x35)
+_GYRO_REG = const(0x3B)
+
+_CONFIG2_REG = const(0x02)
+_CONFIG5_REG = const(0x05)
+_CONFIG6_REG = const(0x06)
+_CONFIG7_REG = const(0x07)
+
+_ACCEL_SETTING_REG = const(0x03)
+_GYRO_SETTING_REG = const(0x04)
+_ENABLE_REG = const(0x08)
+
+# STANDARD_GRAVITY = 9.80665
+
+
+def _decode_settings(value):
+    rnge = value >> 4
+    rate = value & 0xF
+
+    return rnge, rate
+
+
+def _encode_setting(rnge, rate):
+    return ((rnge & 0x7) << 4) | (rate & 0xF)
+
+
+ACCEL_RANGE_2 = const(0)  # +/- 2g
+ACCEL_RANGE_4 = const(0x10)  # +/- 4g
+ACCEL_RANGE_8 = const(0x20)  # +/- 8g (default value)
+ACCEL_RANGE_16 = const(0x30)  # +/- 16g
+
+GYRO_RANGE_16 = const(0)  # +/- 16 deg/s
+GYRO_RANGE_32 = const(0x10)  # +/- 32 deg/s
+GYRO_RANGE_64 = const(0x20)  # +/- 64 deg/s
+GYRO_RANGE_128 = const(0x30)  # +/- 128 deg/s
+GYRO_RANGE_256 = const(0x40)  # +/- 256 deg/s (default value)
+GYRO_RANGE_512 = const(0x50)  # +/- 512 deg/s
+GYRO_RANGE_1024 = const(0x60)  # +/- 1024 deg/s
+GYRO_RANGE_2048 = const(0x70)  # +/- 2048 deg/s
+
+ACCEL_RATE_8000_HZ = const(0)
+ACCEL_RATE_4000_HZ = const(1)
+ACCEL_RATE_2000_HZ = const(2)
+ACCEL_RATE_1000_HZ = const(3)
+ACCEL_RATE_500_HZ = const(4)
+ACCEL_RATE_250_HZ = const(5)
+ACCEL_RATE_125_HZ = const(6)  # (default value)
+ACCEL_RATE_62_HZ = const(7)
+ACCEL_RATE_31_HZ = const(8)
+ACCEL_RATE_LP_128_HZ = const(12)
+ACCEL_RATE_LP_21_HZ = const(13)
+ACCEL_RATE_LP_11_HZ = const(14)
+ACCEL_RATE_LP_3_HZ = const(15)
+
+
+GYRO_RATE_8000_HZ = const(0)
+GYRO_RATE_4000_HZ = const(1)
+GYRO_RATE_2000_HZ = const(2)
+GYRO_RATE_1000_HZ = const(3)
+GYRO_RATE_500_HZ = const(4)
+GYRO_RATE_250_HZ = const(5)
+GYRO_RATE_125_HZ = const(6)  # (default value)
+GYRO_RATE_62_HZ = const(7)
+GYRO_RATE_31_HZ = const(8)
+
+I2C_ADDR = 0x6B
+BITS = 8
+
+
+class QMI8658C(imu_sensor_framework.IMUSensorFramework):
+
+    def _read_reg(self, reg):
+        self._device.read_mem(reg, self._rx_mv[:1])
+        return self._rx_buf[0]
+
+    def _write_reg(self, reg, data):
+        self._tx_buf[0] = data
+        self._device.write_mem(reg, self._tx_mv[:1])
+
+    def __init__(self, device, delay_between_samples=100):
+
+        super().__init__(device, 0.0, delay_between_samples)
+        self._device = device
+        self._tx_buf = bytearray(1)
+        self._tx_mv = memoryview(self._tx_buf)
+        self._rx_buf = bytearray(6)
+        self._rx_mv = memoryview(self._rx_buf)
+
+        if self._read_reg(_VERSION_REG) != 0x05:
+            raise RuntimeError("Failed to find QMI8658C")
+
+        self._accel_range = ACCEL_RANGE_8
+        self._accel_rate = ACCEL_RATE_125_HZ
+
+        self._gyro_range = GYRO_RANGE_256
+        self._gyro_rate = GYRO_RATE_125_HZ
+
+        self._write_reg(_CONFIG2_REG, 0x60)
+        self._write_reg(_ACCEL_SETTING_REG, _encode_setting(ACCEL_RANGE_8, ACCEL_RATE_125_HZ))
+        self._write_reg(_GYRO_SETTING_REG, _encode_setting(GYRO_RANGE_256, GYRO_RATE_125_HZ))
+
+        self._write_reg(_CONFIG5_REG, 0x00)  # No magnetometer
+        self._write_reg(_CONFIG6_REG, 0x00)  # Disables Gyroscope And Accelerometer Low-Pass Filter
+        self._write_reg(_CONFIG7_REG, 0x00)  # Disables Motion on Demand.
+        self._write_reg(_ENABLE_REG, 0x03)  # enable accel and gyro
+
+    @property
+    def accel_range(self):
+        return self._accel_range
+
+    @accel_range.setter
+    def accel_range(self, value):
+        self._accel_range = value
+        self._write_reg(_ACCEL_SETTING_REG, _encode_setting(value, self._accel_rate))
+
+    @property
+    def accel_rate(self):
+        return self._accel_rate
+
+    @accel_rate.setter
+    def accel_rate(self, value):
+        self._accel_rate = value
+        self._write_reg(_ACCEL_SETTING_REG, _encode_setting(self._accel_range, value))
+
+    @property
+    def gyro_range(self):
+        return self._gyro_range
+
+    @gyro_range.setter
+    def gyro_range(self, value):
+        self._gyro_range = value
+        self._write_reg(_ACCEL_SETTING_REG, _encode_setting(value, self._gyro_rate))
+
+    @property
+    def gyro_rate(self):
+        return self._gyro_rate
+
+    @gyro_rate.setter
+    def gyro_rate(self, value):
+        self._gyro_rate = value
+        self._write_reg(_ACCEL_SETTING_REG, _encode_setting(self._gyro_range, value))
+
+    @property
+    def timestamp(self) -> int:
+        self._device.read_mem(_TIME_REG, self._rx_mv[:3])
+        return self._rx_buf[0] + (self._rx_buf[1] << 8) + (self._rx_buf[2] << 16)
+
+    @property
+    def temperature(self) -> float:
+        """Chip temperature"""
+        self._device.read_mem(_TEMP_REG, self._rx_mv[:2])
+        temp = self._rx_buf[0] / 256 + self._rx_buf[1]
+        return temp
+
+    def _get_accelerometer(self):
+        self._device.read_mem(_ACCEL_REG, self._rx_mv[:6])
+
+        buf = self._rx_buf
+
+        x = buf[0] << 8 | buf[1]
+        y = buf[2] << 8 | buf[3]
+        z = buf[4] << 8 | buf[5]
+
+        return x, y, z
+
+    def _get_gyrometer(self):
+        self._device.read_mem(_GYRO_REG, self._rx_mv[:6])
+        buf = self._rx_buf
+
+        x = buf[0] << 8 | buf[1]
+        y = buf[2] << 8 | buf[3]
+        z = buf[4] << 8 | buf[5]
+
+        return x, y, z
+
+    def _get_magnetometer(self):  # NOQA
+        return None

api_drivers/py_api_drivers/frozen/imu_sensor/imu_sensor_framework.py

@@ -0,0 +1,68 @@
+import fusion
+import time
+
+
+class IMUSensorFramework:
+    # delay between samples is nanosecond resolution. 1000 nanoseconds = 1 millisecond
+
+    def __init__(self, device, declination_adjustment=0.0, delay_between_samples=100):
+        self._device = device
+        self._fusion = fusion.Fusion(declination=declination_adjustment)
+        self._delay_between_samples = delay_between_samples
+        self._roll = 0.0
+        self._pitch = 0.0
+        self._yaw = 0.0
+
+    @property
+    def roll(self):
+        return self._roll
+
+    @property
+    def pitch(self):
+        return self._pitch
+
+    @property
+    def yaw(self):
+        return self._yaw
+
+    def _get_gyrometer(self):
+        raise NotImplementedError
+
+    def _get_accelerometer(self):
+        raise NotImplementedError
+
+    def _get_magnetometer(self):
+        raise NotImplementedError
+
+    def calibrate(self, sample_count=5):
+        ts = [time.ticks_ns()]
+        count = [0]
+
+        def _stop_func():
+            if count[0] == sample_count:
+                return True
+
+            now_ts = time.ticks_ns()
+            diff = time.ticks_diff(now_ts, ts[0])
+            remaining = self._delay_between_samples - diff
+            if remaining > 0:
+                time.sleep_ns(remaining)
+
+            ts[0] = time.ticks_ns()
+            count[0] += 1
+            return False
+
+        self._fusion.calibrate(self._get_magnetometer, _stop_func)
+
+    def read(self):
+        accel = self._get_accelerometer()
+        gyro = self._get_gyrometer()
+
+        try:
+            mag = self._get_magnetometer()
+        except NotImplementedError:
+            mag = None
+
+        self._roll, self._pitch, self._yaw = self._fusion.update(accel, gyro, mag)
+
+        return self._roll, self._pitch, self._yaw