circuitpython-adxl36x 0.1.0__py3-none-any.whl

adxl36x/__init__.py

@@ -0,0 +1,747 @@
+"""CircuitPython driver for the Analog Devices ADXL366/ADXL367 accelerometers."""
+
+import time
+from typing import TYPE_CHECKING
+
+from adafruit_bus_device.i2c_device import I2CDevice
+from adafruit_bus_device.spi_device import SPIDevice
+from micropython import const
+
+if TYPE_CHECKING:
+    from busio import I2C, SPI
+    from digitalio import DigitalInOut
+    from typing_extensions import Self
+
+_STANDARD_GRAVITY = 9.80665
+
+# -- I2C addresses (ASEL pin low/high) --
+_DEFAULT_I2C_ADDRESS = const(0x53)
+_ALT_I2C_ADDRESS = const(0x1D)
+
+# -- SPI protocol commands --
+_SPI_WRITE_REG = const(0x0A)
+_SPI_READ_REG = const(0x0B)
+_SPI_READ_FIFO = const(0x0D)
+
+# -- Register addresses --
+_REG_DEVID_AD = const(0x00)
+_REG_DEVID_MST = const(0x01)
+_REG_PARTID = const(0x02)
+_REG_REVID = const(0x03)
+_REG_SERIAL_NUMBER_3 = const(0x04)
+_REG_XDATA = const(0x08)
+_REG_STATUS = const(0x0B)
+_REG_FIFO_ENTRIES_L = const(0x0C)
+_REG_FIFO_ENTRIES_H = const(0x0D)
+_REG_XDATA_H = const(0x0E)
+_REG_TEMP_H = const(0x14)
+_REG_EX_ADC_H = const(0x16)
+_REG_I2C_FIFO_DATA = const(0x18)
+_REG_SOFT_RESET = const(0x1F)
+_REG_THRESH_ACT_H = const(0x20)
+_REG_THRESH_ACT_L = const(0x21)
+_REG_TIME_ACT = const(0x22)
+_REG_THRESH_INACT_H = const(0x23)
+_REG_THRESH_INACT_L = const(0x24)
+_REG_TIME_INACT_H = const(0x25)
+_REG_TIME_INACT_L = const(0x26)
+_REG_ACT_INACT_CTL = const(0x27)
+_REG_FIFO_CONTROL = const(0x28)
+_REG_FIFO_SAMPLES = const(0x29)
+_REG_INTMAP1_LWR = const(0x2A)
+_REG_INTMAP2_LWR = const(0x2B)
+_REG_FILTER_CTL = const(0x2C)
+_REG_POWER_CTL = const(0x2D)
+_REG_SELF_TEST = const(0x2E)
+_REG_TAP_THRESH = const(0x2F)
+_REG_TAP_DUR = const(0x30)
+_REG_TAP_LATENT = const(0x31)
+_REG_TAP_WINDOW = const(0x32)
+_REG_X_OFFSET = const(0x33)
+_REG_Y_OFFSET = const(0x34)
+_REG_Z_OFFSET = const(0x35)
+_REG_TIMER_CTL = const(0x39)
+_REG_INTMAP1_UPPER = const(0x3A)
+_REG_INTMAP2_UPPER = const(0x3B)
+_REG_ADC_CTL = const(0x3C)
+_REG_TEMP_CTL = const(0x3D)
+_REG_AXIS_MASK = const(0x43)
+_REG_PEDOMETER_STEP_CNT_H = const(0x47)
+_REG_PEDOMETER_CTL = const(0x49)
+
+# -- Device/part identification --
+_DEVID_AD = const(0xAD)
+_DEVID_MST = const(0x1D)
+_PART_ID = const(0xF7)
+_REVID_ADXL367 = const(0x3)
+_REVID_ADXL366 = const(0x5)
+_RESET_KEY = const(0x52)
+
+# -- POWER_CTL (0x2D) --
+_POWER_CTL_MODE_MASK = const(0x03)
+
+
+class OpMode:
+    """Values for `ADXL367.power_mode`."""
+
+    STANDBY = const(0x00)
+    MEASURE = const(0x02)
+
+
+# -- FILTER_CTL (0x2C) --
+_FILTER_CTL_RANGE_MASK = const(0xC0)
+_FILTER_CTL_RANGE_SHIFT = const(6)
+_FILTER_CTL_ODR_MASK = const(0x07)
+
+
+class Range:
+    """Values for `ADXL367.g_range`.
+
+    Unlike the ADXL34x family, ±16g isn't supported.
+    """
+
+    RANGE_2_G = const(0x00)
+    RANGE_4_G = const(0x01)
+    RANGE_8_G = const(0x02)
+
+
+_RANGE_SCALE_MULTIPLIER = (1, 2, 4)  # indexed by Range value
+
+
+class DataRate:
+    """Values for `ADXL367.data_rate`."""
+
+    RATE_12_5_HZ = const(0x00)
+    RATE_25_HZ = const(0x01)
+    RATE_50_HZ = const(0x02)
+    RATE_100_HZ = const(0x03)
+    RATE_200_HZ = const(0x04)
+    RATE_400_HZ = const(0x05)
+
+
+_DATA_RATE_HZ = (12.5, 25.0, 50.0, 100.0, 200.0, 400.0)  # indexed by DataRate value
+
+# -- Acceleration/temperature scaling --
+_ACCEL_SCALE_MUL = const(245166)
+_ACCEL_SCALE_DIV = const(1_000_000_000)
+_TEMP_OFFSET = const(1185)
+_TEMP_SCALE_MUL = const(18518518)
+_TEMP_SCALE_DIV = const(1_000_000_000)
+
+# -- ACT_INACT_CTL (0x27) --
+_ACT_INACT_CTL_ACT_MASK = const(0x03)
+_ACT_INACT_CTL_INACT_MASK = const(0x0C)
+_ACT_INACT_CTL_INACT_SHIFT = const(2)
+_ACT_INACT_CTL_REF_READBACK_MASK = const(0xC0)
+_ACTIVITY_ENABLE = const(0x01)
+_REFERENCED_ACTIVITY_ENABLE = const(0x03)
+_THRESHOLD_MAX = const(0x1FFF)
+
+# -- SELF_TEST (0x2E) --
+_SELF_TEST_ST = const(0x01)
+_SELF_TEST_ST_FORCE = const(0x02)
+_SELF_TEST_MIN = const(360)  # 90 * 100 / 25
+_SELF_TEST_MAX = const(1080)  # 270 * 100 / 25
+
+# -- TEMP_CTL (0x3D) / ADC_CTL (0x3C) --
+_TEMP_CTL_EN = const(0x01)
+_TEMP_CTL_NL_COMP_EN = const(0x80)
+_ADC_CTL_EN = const(0x01)
+
+# -- Per-axis offset trim (0x33-0x35) --
+_OFFSET_MAX = const(0x1F)
+
+# -- FIFO --
+_FIFO_CONTROL_MODE_MASK = const(0x03)
+_FIFO_CONTROL_FORMAT_MASK = const(0x78)
+_FIFO_CONTROL_FORMAT_SHIFT = const(3)
+_FIFO_CONTROL_SAMPLES_MSB = const(0x04)
+_FIFO_ENTRIES_H_MASK = const(0x03)
+_FIFO_SAMPLE_SETS_MAX = const(0x1FF)
+
+
+class FIFOMode:
+    """Values for `ADXL367.configure_fifo(mode=...)`."""
+
+    DISABLED = const(0x00)
+    OLDEST_SAVED = const(0x01)
+    STREAM = const(0x02)
+    TRIGGERED = const(0x03)
+
+
+class FIFOFormat:
+    """Values for `ADXL367.configure_fifo(fifo_format=...)`.
+
+    T/A suffixes add a temperature-or-ADC sample (whichever is enabled via
+    `temperature`/`adc_value`) to each sample set.
+    """
+
+    XYZ = const(0x00)
+    X = const(0x01)
+    Y = const(0x02)
+    Z = const(0x03)
+    XYZT = const(0x04)
+    XT = const(0x05)
+    YT = const(0x06)
+    ZT = const(0x07)
+    XYZA = const(0x08)
+    XA = const(0x09)
+    YA = const(0x0A)
+    ZA = const(0x0B)
+
+
+_FIFO_CHANNEL_NAMES = ("x", "y", "z", "temp_or_adc")  # indexed by FIFO channel ID
+
+# -- Interrupt mapping (INTMAP1/2 LWR + UPPER) --
+_INTMAPX_UPPER_MASK = const(0xDF)
+# name -> (is_upper_byte, bit_index)
+_INTERRUPT_EVENTS = {
+    "data_ready": (False, 0),
+    "fifo_ready": (False, 1),
+    "fifo_watermark": (False, 2),
+    "fifo_overrun": (False, 3),
+    "activity": (False, 4),
+    "inactivity": (False, 5),
+    "awake": (False, 6),
+    "active_low": (False, 7),
+    "single_tap": (True, 0),
+    "double_tap": (True, 1),
+    "temp_adc_low": (True, 2),
+    "temp_adc_high": (True, 3),
+    "keep_alive_timer": (True, 4),
+    "user_register_error": (True, 6),
+    "fuse_error": (True, 7),
+}
+
+# -- STATUS (0x0B) bits --
+_STATUS_DATA_RDY = const(0x01)
+_STATUS_FIFO_RDY = const(0x02)
+_STATUS_FIFO_WATERMARK = const(0x04)
+_STATUS_FIFO_OVERRUN = const(0x08)
+_STATUS_ACT = const(0x10)
+_STATUS_INACT = const(0x20)
+_STATUS_AWAKE = const(0x40)
+_STATUS_ERR_USER_REGS = const(0x80)
+
+
+def _decode_s14(msb: int, lsb: int) -> int:
+    """Decode a signed 14-bit value from an H/L register pair."""
+    value = ((msb << 6) | (lsb >> 2)) & 0x3FFF
+    if value & 0x2000:
+        value -= 0x4000
+    return value
+
+
+# -- bus transport --
+
+
+class _I2CDevice(I2CDevice):
+    """`I2CDevice` with a correctly-typed `__exit__`.
+
+    `adafruit_bus_device-stubs` declares `__exit__(self) -> None` (zero
+    args), which doesn't match the real 3-argument context-manager protocol
+    and makes every `with I2CDevice(...) as ...:` a type error. The real
+    `__exit__` only unlocks the bus and always returns a falsy value, so we
+    reimplement it directly here instead of delegating to the mistyped
+    parent method.
+    """
+
+    i2c: "I2C"
+
+    def __exit__(self, *exc_info: object) -> None:
+        self.i2c.unlock()
+
+
+class I2CBus:
+    """Register-level access to a device over I2C."""
+
+    def __init__(self, i2c_bus: "I2C", address: int) -> None:
+        self._device = _I2CDevice(i2c_bus, address)
+
+    def read_into(self, register: int, buffer: bytearray) -> None:
+        with self._device as i2c:
+            i2c.write_then_readinto(bytes((register,)), buffer)
+
+    def write(self, register: int, value: int) -> None:
+        with self._device as i2c:
+            i2c.write(bytes((register, value & 0xFF)))
+
+    def read_fifo_into(self, buffer: bytearray) -> None:
+        with self._device as i2c:
+            i2c.write_then_readinto(bytes((_REG_I2C_FIFO_DATA,)), buffer)
+
+
+class _SPIDevice(SPIDevice):
+    """`SPIDevice` with a correctly-typed `__exit__`. See `_I2CDevice`."""
+
+    spi: "SPI"
+    chip_select: "DigitalInOut | None"
+    cs_active_value: bool
+
+    def __exit__(self, *exc_info: object) -> None:
+        # extra_clocks handling is intentionally omitted: we never construct
+        # this with a nonzero extra_clocks, so upstream's post-CS clock-out
+        # step would always be a no-op here.
+        if self.chip_select:
+            self.chip_select.value = not self.cs_active_value
+        self.spi.unlock()
+
+
+class _SPIBus:
+    """Register-level access to a device over SPI."""
+
+    def __init__(self, spi_bus: "SPI", cs: "DigitalInOut", *, baudrate: int) -> None:
+        self._device = _SPIDevice(spi_bus, cs, baudrate=baudrate, polarity=0, phase=0)
+
+    def read_into(self, register: int, buffer: bytearray) -> None:
+        with self._device as spi:
+            spi.write(bytes((_SPI_READ_REG, register)))
+            spi.readinto(buffer)
+
+    def write(self, register: int, value: int) -> None:
+        with self._device as spi:
+            spi.write(bytes((_SPI_WRITE_REG, register, value & 0xFF)))
+
+    def read_fifo_into(self, buffer: bytearray) -> None:
+        with self._device as spi:
+            spi.write(bytes((_SPI_READ_FIFO,)))
+            spi.readinto(buffer)
+
+
+class ADXL367:
+    """Driver for the Analog Devices ADXL367 accelerometer.
+
+    Also the base class for `ADXL366`, which shares this entire register map
+    and adds a few extra features. Connect over I2C with the constructor
+    (mirroring `adafruit_adxl34x.ADXL345`) or over SPI with `from_spi()`.
+    """
+
+    _revid = _REVID_ADXL367
+
+    def __init__(self, i2c_bus: "I2C", *, address: int = _DEFAULT_I2C_ADDRESS) -> None:
+        self._bus: I2CBus | _SPIBus = I2CBus(i2c_bus, address)
+        self._range = Range.RANGE_2_G
+        self._data_rate = DataRate.RATE_100_HZ
+        self._initialize()
+
+    @classmethod
+    def from_spi(
+        cls,
+        spi_bus: "SPI",
+        cs: "DigitalInOut",
+        *,
+        baudrate: int = 1_000_000,
+    ) -> "Self":
+        """Construct a driver instance over SPI instead of I2C."""
+        self = cls.__new__(cls)
+        self._bus = _SPIBus(spi_bus, cs, baudrate=baudrate)
+        self._range = Range.RANGE_2_G
+        self._data_rate = DataRate.RATE_100_HZ
+        self._initialize()
+        return self
+
+    # -- low-level bus access --
+
+    def _read_into(self, register: int, buffer: bytearray) -> None:
+        self._bus.read_into(register, buffer)
+
+    def _read_u8(self, register: int) -> int:
+        buffer = bytearray(1)
+        self._read_into(register, buffer)
+        return buffer[0]
+
+    def _write_u8(self, register: int, value: int) -> None:
+        self._bus.write(register, value)
+
+    def _write_masked(self, register: int, value: int, mask: int) -> None:
+        current = self._read_u8(register)
+        self._write_u8(register, (current & ~mask) | (value & mask))
+
+    def _read_fifo_into(self, buffer: bytearray) -> None:
+        self._bus.read_fifo_into(buffer)
+
+    def _set_threshold(
+        self,
+        high_register: int,
+        low_register: int,
+        threshold: int,
+    ) -> None:
+        if not 0 <= threshold <= _THRESHOLD_MAX:
+            msg = f"threshold must be in range 0-{_THRESHOLD_MAX}, got {threshold!r}"
+            raise ValueError(msg)
+        self._write_u8(high_register, (threshold >> 6) & 0x7F)
+        self._write_u8(low_register, (threshold & 0x3F) << 2)
+
+    # -- initialization --
+
+    def reset(self) -> None:
+        """Perform a software reset, returning all registers to power-on defaults."""
+        self._write_u8(_REG_SOFT_RESET, _RESET_KEY)
+        time.sleep(0.02)
+
+    def _initialize(self) -> None:
+        self.reset()
+        seen = (
+            self._read_u8(_REG_DEVID_AD),
+            self._read_u8(_REG_DEVID_MST),
+            self._read_u8(_REG_PARTID),
+            self._read_u8(_REG_REVID),
+        )
+        expected = (_DEVID_AD, _DEVID_MST, _PART_ID, self._revid)
+        if seen != expected:
+            msg = f"{type(self).__name__}: unexpected device ID bytes {seen!r} (expected {expected!r})"
+            raise RuntimeError(msg)
+        self.power_mode = OpMode.MEASURE
+
+    # -- identification --
+
+    @property
+    def serial_number(self) -> int:
+        """This chip's factory-programmed 32-bit unique serial number."""
+        buffer = bytearray(4)
+        self._read_into(_REG_SERIAL_NUMBER_3, buffer)
+        return int.from_bytes(bytes(buffer), "big")
+
+    # -- power/range/rate --
+
+    @property
+    def power_mode(self) -> int:
+        """The current `OpMode` (standby or measure)."""
+        return self._read_u8(_REG_POWER_CTL) & _POWER_CTL_MODE_MASK
+
+    @power_mode.setter
+    def power_mode(self, mode: int) -> None:
+        self._write_masked(_REG_POWER_CTL, mode, _POWER_CTL_MODE_MASK)
+
+    @property
+    def g_range(self) -> int:
+        """The measurement range, a `Range` value (tops out at ±8g, unlike ADXL34x)."""
+        return self._range
+
+    @g_range.setter
+    def g_range(self, value: int) -> None:
+        if value not in (Range.RANGE_2_G, Range.RANGE_4_G, Range.RANGE_8_G):
+            msg = f"invalid Range value: {value!r}"
+            raise ValueError(msg)
+        self._write_masked(
+            _REG_FILTER_CTL,
+            value << _FILTER_CTL_RANGE_SHIFT,
+            _FILTER_CTL_RANGE_MASK,
+        )
+        self._range = value
+
+    @property
+    def data_rate(self) -> int:
+        """The output data rate, a `DataRate` value."""
+        return self._data_rate
+
+    @data_rate.setter
+    def data_rate(self, value: int) -> None:
+        if not 0 <= value <= DataRate.RATE_400_HZ:
+            msg = f"invalid DataRate value: {value!r}"
+            raise ValueError(msg)
+        self._write_masked(_REG_FILTER_CTL, value, _FILTER_CTL_ODR_MASK)
+        self._data_rate = value
+
+    # -- acceleration --
+
+    @property
+    def raw_x(self) -> int:
+        """Raw, signed 14-bit X-axis acceleration code."""
+        return self._read_raw_axis(_REG_XDATA_H)
+
+    @property
+    def raw_y(self) -> int:
+        """Raw, signed 14-bit Y-axis acceleration code."""
+        return self._read_raw_axis(_REG_XDATA_H + 2)
+
+    @property
+    def raw_z(self) -> int:
+        """Raw, signed 14-bit Z-axis acceleration code."""
+        return self._read_raw_axis(_REG_XDATA_H + 4)
+
+    def _read_raw_axis(self, high_register: int) -> int:
+        buffer = bytearray(2)
+        self._read_into(high_register, buffer)
+        return _decode_s14(buffer[0], buffer[1])
+
+    @property
+    def raw_acceleration(self) -> tuple[int, int, int]:
+        """Raw, signed 14-bit (x, y, z) codes, read in a single bus transaction."""
+        buffer = bytearray(6)
+        self._read_into(_REG_XDATA_H, buffer)
+        return (
+            _decode_s14(buffer[0], buffer[1]),
+            _decode_s14(buffer[2], buffer[3]),
+            _decode_s14(buffer[4], buffer[5]),
+        )
+
+    @property
+    def acceleration(self) -> tuple[float, float, float]:
+        """(x, y, z) acceleration in m/s^2."""
+        scale = _RANGE_SCALE_MULTIPLIER[self._range] * _ACCEL_SCALE_MUL / _ACCEL_SCALE_DIV * _STANDARD_GRAVITY
+        x, y, z = self.raw_acceleration
+        return (x * scale, y * scale, z * scale)
+
+    # -- offsets --
+
+    @property
+    def offset(self) -> tuple[int, int, int]:
+        """Per-axis trim offsets: raw 5-bit codes (0-31); units unconfirmed."""
+        return (
+            self._read_u8(_REG_X_OFFSET) & _OFFSET_MAX,
+            self._read_u8(_REG_Y_OFFSET) & _OFFSET_MAX,
+            self._read_u8(_REG_Z_OFFSET) & _OFFSET_MAX,
+        )
+
+    @offset.setter
+    def offset(self, value: tuple[int, int, int]) -> None:
+        x, y, z = value
+        for axis_value in (x, y, z):
+            if not 0 <= axis_value <= _OFFSET_MAX:
+                msg = f"offset values must be in range 0-{_OFFSET_MAX}, got {value!r}"
+                raise ValueError(msg)
+        self._write_u8(_REG_X_OFFSET, x)
+        self._write_u8(_REG_Y_OFFSET, y)
+        self._write_u8(_REG_Z_OFFSET, z)
+
+    # -- activity/inactivity detection --
+
+    def enable_motion_detection(
+        self,
+        *,
+        threshold: int = 100,
+        time_: int = 1,
+        referenced: bool = False,
+    ) -> None:
+        """Enable activity (motion) detection.
+
+        `threshold` is a raw accelerometer-code magnitude (same units as
+        `raw_acceleration`, i.e. scaled by `range`) rather than the ADXL34x's
+        fixed 62.5 mg/LSB - the exact mg/LSB figure for this threshold field
+        is not confirmed against the datasheet. `time_` is in seconds
+        (unconfirmed exact LSB scale; treat as approximate).
+        """
+        self._set_threshold(_REG_THRESH_ACT_H, _REG_THRESH_ACT_L, threshold)
+        self._write_u8(_REG_TIME_ACT, time_ & 0xFF)
+        mode = _REFERENCED_ACTIVITY_ENABLE if referenced else _ACTIVITY_ENABLE
+        self._write_masked(_REG_ACT_INACT_CTL, mode, _ACT_INACT_CTL_ACT_MASK)
+
+    def disable_motion_detection(self) -> None:
+        """Disable activity (motion) detection."""
+        self._write_masked(_REG_ACT_INACT_CTL, 0, _ACT_INACT_CTL_ACT_MASK)
+
+    def enable_inactivity_detection(
+        self,
+        *,
+        threshold: int = 50,
+        time_: int = 3,
+        referenced: bool = False,
+    ) -> None:
+        """Enable inactivity detection.
+
+        See `enable_motion_detection` for unit caveats.
+        """
+        self._set_threshold(_REG_THRESH_INACT_H, _REG_THRESH_INACT_L, threshold)
+        self._write_u8(_REG_TIME_INACT_H, (time_ >> 8) & 0xFF)
+        self._write_u8(_REG_TIME_INACT_L, time_ & 0xFF)
+        mode = _REFERENCED_ACTIVITY_ENABLE if referenced else _ACTIVITY_ENABLE
+        shifted = mode << _ACT_INACT_CTL_INACT_SHIFT
+        self._write_masked(_REG_ACT_INACT_CTL, shifted, _ACT_INACT_CTL_INACT_MASK)
+
+    def disable_inactivity_detection(self) -> None:
+        """Disable inactivity detection."""
+        self._write_masked(_REG_ACT_INACT_CTL, 0, _ACT_INACT_CTL_INACT_MASK)
+
+    @property
+    def events(self) -> dict[str, bool]:
+        """Currently-set event flags from STATUS (0x0B).
+
+        Does not yet include tap, pedometer-overflow, or ADC/temperature
+        threshold events - their status-register bit positions
+        (STATUS_COPY/STATUS_2/STATUS_3) aren't confirmed against the
+        datasheet yet.
+        """
+        status = self._read_u8(_REG_STATUS)
+        return {
+            "data_ready": bool(status & _STATUS_DATA_RDY),
+            "fifo_ready": bool(status & _STATUS_FIFO_RDY),
+            "fifo_watermark": bool(status & _STATUS_FIFO_WATERMARK),
+            "fifo_overrun": bool(status & _STATUS_FIFO_OVERRUN),
+            "motion": bool(status & _STATUS_ACT),
+            "inactivity": bool(status & _STATUS_INACT),
+            "awake": bool(status & _STATUS_AWAKE),
+            "error": bool(status & _STATUS_ERR_USER_REGS),
+        }
+
+    # -- interrupt routing --
+
+    def map_interrupt(self, pin: int, events: "set[str] | frozenset[str]") -> None:
+        """Route the named events (keys of `_INTERRUPT_EVENTS`) to INT1 or INT2."""
+        if pin not in (1, 2):
+            msg = f"pin must be 1 or 2, got {pin!r}"
+            raise ValueError(msg)
+        lower = upper = 0
+        for name in events:
+            if name not in _INTERRUPT_EVENTS:
+                msg = f"unknown interrupt event: {name!r}"
+                raise ValueError(msg)
+            is_upper, bit = _INTERRUPT_EVENTS[name]
+            if is_upper:
+                upper |= 1 << bit
+            else:
+                lower |= 1 << bit
+        lwr_register = _REG_INTMAP1_LWR if pin == 1 else _REG_INTMAP2_LWR
+        upper_register = _REG_INTMAP1_UPPER if pin == 1 else _REG_INTMAP2_UPPER
+        self._write_u8(lwr_register, lower)
+        self._write_u8(upper_register, upper & _INTMAPX_UPPER_MASK)
+
+    # -- temperature / external ADC --
+
+    @property
+    def temperature(self) -> float:
+        """On-chip temperature in Celsius. Mutually exclusive with `adc_value`."""
+        self._write_masked(_REG_TEMP_CTL, _TEMP_CTL_EN, _TEMP_CTL_EN)
+        self._write_masked(_REG_ADC_CTL, 0, _ADC_CTL_EN)
+        buffer = bytearray(2)
+        self._read_into(_REG_TEMP_H, buffer)
+        raw = _decode_s14(buffer[0], buffer[1])
+        return (raw + _TEMP_OFFSET) * _TEMP_SCALE_MUL / _TEMP_SCALE_DIV
+
+    @property
+    def adc_value(self) -> int:
+        """Raw signed 14-bit ADC code. Mutually exclusive with `temperature`."""
+        self._write_masked(_REG_ADC_CTL, _ADC_CTL_EN, _ADC_CTL_EN)
+        self._write_masked(_REG_TEMP_CTL, 0, _TEMP_CTL_EN)
+        buffer = bytearray(2)
+        self._read_into(_REG_EX_ADC_H, buffer)
+        return _decode_s14(buffer[0], buffer[1])
+
+    # -- FIFO --
+
+    def configure_fifo(
+        self,
+        *,
+        mode: int = FIFOMode.STREAM,
+        fifo_format: int = FIFOFormat.XYZ,
+        sample_sets: int = 128,
+    ) -> None:
+        """Configure the FIFO.
+
+        `sample_sets` (0-511) is the total number of sample sets to store.
+        """
+        if not 0 <= sample_sets <= _FIFO_SAMPLE_SETS_MAX:
+            msg = f"sample_sets must be in range 0-{_FIFO_SAMPLE_SETS_MAX}, got {sample_sets!r}"
+            raise ValueError(msg)
+        control = mode & _FIFO_CONTROL_MODE_MASK
+        control |= (fifo_format << _FIFO_CONTROL_FORMAT_SHIFT) & _FIFO_CONTROL_FORMAT_MASK
+        if sample_sets & 0x100:
+            control |= _FIFO_CONTROL_SAMPLES_MSB
+        self._write_u8(_REG_FIFO_CONTROL, control)
+        self._write_u8(_REG_FIFO_SAMPLES, sample_sets & 0xFF)
+
+    @property
+    def fifo_entries(self) -> int:
+        """Number of 16-bit words currently stored in the FIFO."""
+        low = self._read_u8(_REG_FIFO_ENTRIES_L)
+        high = self._read_u8(_REG_FIFO_ENTRIES_H) & _FIFO_ENTRIES_H_MASK
+        return (high << 8) | low
+
+    def read_fifo(self) -> list[tuple[str, int]]:
+        """Read and drain all available FIFO entries.
+
+        Returns a list of (channel_name, raw_signed_code) pairs, where
+        channel_name is one of "x", "y", "z", "temp_or_adc". Accel-channel
+        values use the same raw-code scale as `raw_acceleration`.
+        """
+        entries = self.fifo_entries
+        buffer = bytearray(entries * 2)
+        self._read_fifo_into(buffer)
+        result = []
+        for i in range(entries):
+            high, low = buffer[2 * i], buffer[2 * i + 1]
+            channel = high >> 6
+            raw = ((high & 0x3F) << 8) | low
+            if raw & 0x2000:
+                raw -= 0x4000
+            result.append((_FIFO_CHANNEL_NAMES[channel], raw))
+        return result
+
+    # -- self-test --
+
+    def self_test(self) -> bool:
+        """Run the built-in electrostatic self-test. Returns True if it passes."""
+        previous_mode = self.power_mode
+        self.power_mode = OpMode.MEASURE
+        delay = 4.0 / _DATA_RATE_HZ[self._data_rate]
+        both_bits = _SELF_TEST_ST | _SELF_TEST_ST_FORCE
+        try:
+            self._write_masked(_REG_SELF_TEST, _SELF_TEST_ST, both_bits)
+            time.sleep(delay)
+            before = self.raw_x
+            self._write_masked(_REG_SELF_TEST, both_bits, both_bits)
+            time.sleep(delay)
+            after = self.raw_x
+        finally:
+            self._write_u8(_REG_SELF_TEST, 0)
+            self.power_mode = previous_mode
+        diff = after - before
+        scale = _RANGE_SCALE_MULTIPLIER[self._range]
+        return _SELF_TEST_MIN * scale <= diff <= _SELF_TEST_MAX * scale
+
+
+class ADXL366(ADXL367):
+    """Driver for the Analog Devices ADXL366 accelerometer.
+
+    Adds Z-axis nonlinearity compensation, activity/inactivity reference
+    readback, and a step-counting pedometer on top of everything `ADXL367`
+    provides - the ADXL367 silicon doesn't implement these three features.
+    """
+
+    _revid = _REVID_ADXL366
+
+    @property
+    def z_nonlinearity_compensation(self) -> bool:
+        """Z-axis temperature-informed nonlinearity compensation state."""
+        return bool(self._read_u8(_REG_TEMP_CTL) & _TEMP_CTL_NL_COMP_EN)
+
+    @z_nonlinearity_compensation.setter
+    def z_nonlinearity_compensation(self, enable: bool) -> None:
+        value = _TEMP_CTL_NL_COMP_EN if enable else 0
+        self._write_masked(_REG_TEMP_CTL, value, _TEMP_CTL_NL_COMP_EN)
+
+    def reference_readback(self, *, inactivity: bool = False) -> tuple[int, int, int]:
+        """Read back the activity/inactivity reference point.
+
+        Only meaningful when the corresponding detector is in referenced mode.
+        """
+        select = 0x02 if inactivity else 0x01
+        self._write_masked(
+            _REG_ACT_INACT_CTL,
+            select << 6,
+            _ACT_INACT_CTL_REF_READBACK_MASK,
+        )
+        try:
+            return self.raw_acceleration
+        finally:
+            self._write_masked(_REG_ACT_INACT_CTL, 0, _ACT_INACT_CTL_REF_READBACK_MASK)
+
+    @property
+    def pedometer_enabled(self) -> bool:
+        """Whether the step-counting pedometer is enabled."""
+        return bool(self._read_u8(_REG_PEDOMETER_CTL) & 0x01)
+
+    @pedometer_enabled.setter
+    def pedometer_enabled(self, enable: bool) -> None:
+        self._write_masked(_REG_PEDOMETER_CTL, 0x01 if enable else 0x00, 0x01)
+
+    @property
+    def steps(self) -> int:
+        """Cumulative pedometer step count."""
+        buffer = bytearray(2)
+        self._read_into(_REG_PEDOMETER_STEP_CNT_H, buffer)
+        return (buffer[0] << 8) | buffer[1]
+
+    def reset_steps(self) -> None:
+        """Reset the pedometer step count to zero."""
+        self._write_masked(_REG_PEDOMETER_CTL, 0x04, 0x04)

circuitpython_adxl36x-0.1.0.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: circuitpython-adxl36x
+Version: 0.1.0
+Summary: CircuitPython driver for the Analog Devices ADXL366/ADXL367 accelerometers
+Keywords: adxl366,adxl367,accelerometer,blinka,circuitpython,hardware,i2c,micropython,spi
+Author: Mike Mabey
+Author-email: Mike Mabey <email@mikemabey.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Embedded Systems
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Hardware
+Requires-Dist: adafruit-circuitpython-busdevice>=5.2.11
+Requires-Dist: circuitpython-stubs>=10.2.1
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/mmabey/circuitpython-adxl36x
+Project-URL: Repository, https://github.com/mmabey/circuitpython-adxl36x
+Project-URL: Issues, https://github.com/mmabey/circuitpython-adxl36x/issues
+Description-Content-Type: text/markdown
+
+# circuitpython-adxl36x
+
+[![PyPI](https://img.shields.io/pypi/v/circuitpython-adxl36x)](https://pypi.org/project/circuitpython-adxl36x/)
+[![Python versions](https://img.shields.io/pypi/pyversions/circuitpython-adxl36x)](https://pypi.org/project/circuitpython-adxl36x/)
+[![License: MIT](https://img.shields.io/pypi/l/circuitpython-adxl36x)](LICENSE)
+[![CI](https://github.com/mmabey/circuitpython-adxl36x/actions/workflows/ci.yml/badge.svg)](https://github.com/mmabey/circuitpython-adxl36x/actions/workflows/ci.yml)
+[![Downloads](https://img.shields.io/pypi/dm/circuitpython-adxl36x)](https://pypi.org/project/circuitpython-adxl36x/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+CircuitPython driver for the Analog Devices [ADXL366](https://www.analog.com/en/products/adxl366.html) and
+[ADXL367](https://www.analog.com/en/products/adxl367.html) ultra-low-power 3-axis MEMS accelerometers.
+
+`ADXL367` implements the full shared register map and is the base class. `ADXL366` subclasses it, adding the pedometer,
+Z-axis nonlinearity compensation, and activity/inactivity reference readback - the three features the ADXL367 silicon
+doesn't implement. Both support SPI and I2C.
+
+## Relationship to `adafruit_adxl34x`
+
+This library's public API deliberately mirrors the shape of [Adafruit's
+`adafruit_adxl34x`](https://github.com/adafruit/Adafruit_CircuitPython_ADXL34x) driver for the ADXL34x family
+(`.acceleration`, `.events`, `enable_tap_detection()`, `enable_motion_detection()`, `data_rate`) so that code written
+against a 34x-family chip needs minimal changes to run against a 366/367. The two chip families are **not**
+register-compatible — only the driver's Python API shape is shared. Notable differences:
+
+- `range` is named `g_range` here instead — `range` shadows the Python builtin, and compatibility with the ADXL34x API
+  takes a back seat to that on this one property.
+- No `enable_freefall_detection()` — the 366/367 has no freefall-detection hardware.
+- `Range` tops out at `RANGE_8_G` — the 366/367 doesn't support ±16g.
+- `DataRate` only has 6 discrete rates (12.5 Hz-400 Hz) vs. the 34x's 16.
+- `.events` includes many more keys (FIFO, pedometer, ADC/temperature thresholds) since the 366/367 exposes far more
+  interrupt sources.
+
+## Installation
+
+On a CircuitPython board, copy `src/adxl36x/` into `CIRCUITPY/lib/adxl36x/`, along with the `adafruit_bus_device` bundle
+library.
+
+For host-side development (type checking, tests) in another project:
+
+```bash
+uv add --editable ~/src/circuitpython-adxl36x
+```
+
+## Development
+
+```bash
+uv sync
+uv run ruff check --fix
+uv run ruff format
+uv run ty check
+uv run pytest
+```

circuitpython_adxl36x-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+adxl36x/__init__.py,sha256=9fRNYWiTk-0KtlFIajzUFUpvdGkityVJil30pTatRxA,24919
+adxl36x/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+circuitpython_adxl36x-0.1.0.dist-info/licenses/LICENSE,sha256=y6Dkapl6bO30fL3Dv-RKQnxT73xuLBeGTmiZdUljU5A,1067
+circuitpython_adxl36x-0.1.0.dist-info/WHEEL,sha256=EmLkUISDECbcUx3FMCYOqokNOJqNp2r0d4mJzjErvvs,80
+circuitpython_adxl36x-0.1.0.dist-info/METADATA,sha256=eZBVKMt-PTAEHthZTAxrYSJ9iocSAkuK8R2YLskkOHk,3783
+circuitpython_adxl36x-0.1.0.dist-info/RECORD,,

circuitpython_adxl36x-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.3
+Root-Is-Purelib: true
+Tag: py3-none-any

circuitpython_adxl36x-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mike Mabey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.