plexus-python 0.1.0__py3-none-any.whl

plexus/sensors/ina219.py

@@ -0,0 +1,149 @@
+"""
+INA219 current/power monitor sensor driver.
+
+The INA219 measures bus voltage, shunt voltage, current, and power.
+Communicates via I2C at address 0x40–0x4F (configurable via A0/A1 pins).
+
+Usage:
+    from plexus.sensors import INA219
+
+    sensor = INA219()
+    for reading in sensor.read():
+        print(f"{reading.metric}: {reading.value}")
+"""
+
+from typing import List, Optional
+from .base import BaseSensor, SensorReading
+
+# Default I2C address
+INA219_ADDR = 0x40
+
+# Register addresses
+REG_CONFIG = 0x00
+REG_SHUNT_VOLTAGE = 0x01
+REG_BUS_VOLTAGE = 0x02
+REG_POWER = 0x03
+REG_CURRENT = 0x04
+REG_CALIBRATION = 0x05
+
+# Configuration: 32V range, 320mV shunt range, 12-bit, continuous
+CONFIG_DEFAULT = 0x399F
+
+# Calibration for 0.1 ohm shunt resistor, max expected current 3.2A
+# Cal = trunc(0.04096 / (current_lsb * r_shunt))
+# current_lsb = max_expected / 2^15 = 3.2 / 32768 ≈ 0.0001
+SHUNT_RESISTOR_OHMS = 0.1
+CURRENT_LSB = 0.0001  # 100uA per bit
+CAL_VALUE = int(0.04096 / (CURRENT_LSB * SHUNT_RESISTOR_OHMS))
+
+
+class INA219(BaseSensor):
+    """
+    INA219 current/power monitor driver.
+
+    Provides:
+    - bus_voltage: Bus voltage in volts
+    - shunt_voltage: Shunt voltage in millivolts
+    - current_ma: Current in milliamps
+    - power_mw: Power in milliwatts
+    """
+
+    name = "INA219"
+    description = "Current/power monitor (voltage, current, power)"
+    metrics = ["bus_voltage", "shunt_voltage", "current_ma", "power_mw"]
+    i2c_addresses = [0x40, 0x41, 0x44, 0x45]
+
+    def __init__(
+        self,
+        address: int = INA219_ADDR,
+        bus: int = 1,
+        shunt_ohms: float = SHUNT_RESISTOR_OHMS,
+        max_current: float = 3.2,
+        sample_rate: float = 10.0,
+        prefix: str = "",
+        tags: Optional[dict] = None,
+    ):
+        super().__init__(sample_rate=sample_rate, prefix=prefix, tags=tags)
+        self.address = address
+        self.bus_num = bus
+        self.shunt_ohms = shunt_ohms
+        self.max_current = max_current
+        self._bus = None
+        self._current_lsb = max_current / 32768.0
+        self._cal_value = int(0.04096 / (self._current_lsb * shunt_ohms))
+
+    def setup(self) -> None:
+        try:
+            from smbus2 import SMBus
+        except ImportError:
+            raise ImportError(
+                "smbus2 is required for INA219. Install with: pip install smbus2"
+            )
+
+        self._bus = SMBus(self.bus_num)
+
+        # Write configuration
+        self._write_register(REG_CONFIG, CONFIG_DEFAULT)
+        # Write calibration
+        self._write_register(REG_CALIBRATION, self._cal_value)
+
+    def cleanup(self) -> None:
+        if self._bus:
+            self._bus.close()
+            self._bus = None
+
+    def _write_register(self, reg: int, value: int) -> None:
+        high = (value >> 8) & 0xFF
+        low = value & 0xFF
+        self._bus.write_i2c_block_data(self.address, reg, [high, low])
+
+    def _read_register(self, reg: int) -> int:
+        data = self._bus.read_i2c_block_data(self.address, reg, 2)
+        value = (data[0] << 8) | data[1]
+        return value
+
+    def _read_signed(self, reg: int) -> int:
+        value = self._read_register(reg)
+        if value > 32767:
+            value -= 65536
+        return value
+
+    def read(self) -> List[SensorReading]:
+        if self._bus is None:
+            self.setup()
+
+        # Bus voltage: bits [15:3] * 4mV, bit 1 = conversion ready
+        raw_bus = self._read_register(REG_BUS_VOLTAGE)
+        bus_voltage = (raw_bus >> 3) * 0.004  # 4mV per LSB
+
+        # Shunt voltage: signed 16-bit, 10uV per LSB
+        raw_shunt = self._read_signed(REG_SHUNT_VOLTAGE)
+        shunt_voltage_mv = raw_shunt * 0.01  # 10uV = 0.01mV
+
+        # Current: signed 16-bit * current_lsb
+        raw_current = self._read_signed(REG_CURRENT)
+        current_ma = raw_current * self._current_lsb * 1000.0
+
+        # Power: unsigned 16-bit * 20 * current_lsb
+        raw_power = self._read_register(REG_POWER)
+        power_mw = raw_power * 20.0 * self._current_lsb * 1000.0
+
+        return [
+            SensorReading("bus_voltage", round(bus_voltage, 3)),
+            SensorReading("shunt_voltage", round(shunt_voltage_mv, 3)),
+            SensorReading("current_ma", round(current_ma, 2)),
+            SensorReading("power_mw", round(power_mw, 2)),
+        ]
+
+    def is_available(self) -> bool:
+        try:
+            from smbus2 import SMBus
+
+            bus = SMBus(self.bus_num)
+            # Read config register — should return non-zero default
+            data = bus.read_i2c_block_data(self.address, REG_CONFIG, 2)
+            bus.close()
+            config = (data[0] << 8) | data[1]
+            return config != 0x0000 and config != 0xFFFF
+        except Exception:
+            return False

plexus/sensors/magnetometer.py

@@ -0,0 +1,239 @@
+"""
+Magnetometer sensor drivers: QMC5883L and HMC5883L.
+
+These sensors measure magnetic field strength in 3 axes.
+Used for compass heading, metal detection, and orientation.
+
+QMC5883L: Common Chinese replacement, address 0x0D
+HMC5883L: Original Honeywell sensor, address 0x1E
+
+Usage:
+    from plexus.sensors import QMC5883L, HMC5883L
+
+    mag = QMC5883L()
+    for reading in mag.read():
+        print(f"{reading.metric}: {reading.value}")
+"""
+
+import time
+from typing import List, Optional
+from .base import BaseSensor, SensorReading
+
+# ─── QMC5883L ────────────────────────────────────────────────────────────────
+
+QMC5883L_ADDR = 0x0D
+
+QMC_REG_DATA = 0x00       # X LSB, X MSB, Y LSB, Y MSB, Z LSB, Z MSB
+QMC_REG_STATUS = 0x06
+QMC_REG_CONFIG1 = 0x09    # Mode, ODR, Range, OSR
+QMC_REG_CONFIG2 = 0x0A    # Soft reset, pointer roll-over
+QMC_REG_CHIP_ID = 0x0D
+
+# Config1: Continuous mode, 200Hz ODR, 8 Gauss range, 512 oversampling
+QMC_CONFIG1_DEFAULT = 0x1D
+# Config2: Pointer roll-over enabled
+QMC_CONFIG2_DEFAULT = 0x40
+
+
+class QMC5883L(BaseSensor):
+    """
+    QMC5883L 3-axis magnetometer driver.
+
+    Provides:
+    - mag_x, mag_y, mag_z: Magnetic field in microtesla (µT)
+    """
+
+    name = "QMC5883L"
+    description = "3-axis magnetometer (compass)"
+    metrics = ["mag_x", "mag_y", "mag_z"]
+    i2c_addresses = [QMC5883L_ADDR]
+
+    def __init__(
+        self,
+        address: int = QMC5883L_ADDR,
+        bus: int = 1,
+        sample_rate: float = 10.0,
+        prefix: str = "",
+        tags: Optional[dict] = None,
+    ):
+        super().__init__(sample_rate=sample_rate, prefix=prefix, tags=tags)
+        self.address = address
+        self.bus_num = bus
+        self._bus = None
+
+    def setup(self) -> None:
+        try:
+            from smbus2 import SMBus
+        except ImportError:
+            raise ImportError(
+                "smbus2 is required for QMC5883L. Install with: pip install smbus2"
+            )
+
+        self._bus = SMBus(self.bus_num)
+
+        # Soft reset
+        self._bus.write_byte_data(self.address, QMC_REG_CONFIG2, 0x80)
+        time.sleep(0.01)
+
+        # Configure: continuous mode, 200Hz, 8G range, 512x oversampling
+        self._bus.write_byte_data(self.address, QMC_REG_CONFIG1, QMC_CONFIG1_DEFAULT)
+        self._bus.write_byte_data(self.address, QMC_REG_CONFIG2, QMC_CONFIG2_DEFAULT)
+        time.sleep(0.01)
+
+    def cleanup(self) -> None:
+        if self._bus:
+            self._bus.close()
+            self._bus = None
+
+    def read(self) -> List[SensorReading]:
+        if self._bus is None:
+            self.setup()
+
+        # Check data ready
+        status = self._bus.read_byte_data(self.address, QMC_REG_STATUS)
+        if not (status & 0x01):
+            return []  # Data not ready
+
+        # Read 6 bytes: X_LSB, X_MSB, Y_LSB, Y_MSB, Z_LSB, Z_MSB
+        data = self._bus.read_i2c_block_data(self.address, QMC_REG_DATA, 6)
+
+        x = (data[1] << 8) | data[0]
+        y = (data[3] << 8) | data[2]
+        z = (data[5] << 8) | data[4]
+
+        # Convert to signed
+        if x > 32767:
+            x -= 65536
+        if y > 32767:
+            y -= 65536
+        if z > 32767:
+            z -= 65536
+
+        # At 8 Gauss range: 3000 LSB/Gauss, 1 Gauss = 100 µT
+        # So LSB = 100/3000 µT ≈ 0.0333 µT
+        scale = 100.0 / 3000.0
+
+        return [
+            SensorReading("mag_x", round(x * scale, 2)),
+            SensorReading("mag_y", round(y * scale, 2)),
+            SensorReading("mag_z", round(z * scale, 2)),
+        ]
+
+    def is_available(self) -> bool:
+        try:
+            from smbus2 import SMBus
+
+            bus = SMBus(self.bus_num)
+            chip_id = bus.read_byte_data(self.address, QMC_REG_CHIP_ID)
+            bus.close()
+            return chip_id == 0xFF  # QMC5883L returns 0xFF for chip ID register
+        except Exception:
+            return False
+
+
+# ─── HMC5883L ────────────────────────────────────────────────────────────────
+
+HMC5883L_ADDR = 0x1E
+
+HMC_REG_CONFIG_A = 0x00
+HMC_REG_CONFIG_B = 0x01
+HMC_REG_MODE = 0x02
+HMC_REG_DATA = 0x03  # X MSB, X LSB, Z MSB, Z LSB, Y MSB, Y LSB
+HMC_REG_ID_A = 0x0A
+
+# Config A: 8 samples averaged, 15Hz output, normal measurement
+HMC_CONFIG_A_DEFAULT = 0x70
+# Config B: Gain = 1.3 Gauss (1090 LSB/Gauss)
+HMC_CONFIG_B_DEFAULT = 0x20
+# Mode: Continuous measurement
+HMC_MODE_CONTINUOUS = 0x00
+
+
+class HMC5883L(BaseSensor):
+    """
+    HMC5883L 3-axis magnetometer driver.
+
+    Provides:
+    - mag_x, mag_y, mag_z: Magnetic field in microtesla (µT)
+    """
+
+    name = "HMC5883L"
+    description = "3-axis magnetometer (compass)"
+    metrics = ["mag_x", "mag_y", "mag_z"]
+    i2c_addresses = [HMC5883L_ADDR]
+
+    def __init__(
+        self,
+        address: int = HMC5883L_ADDR,
+        bus: int = 1,
+        sample_rate: float = 10.0,
+        prefix: str = "",
+        tags: Optional[dict] = None,
+    ):
+        super().__init__(sample_rate=sample_rate, prefix=prefix, tags=tags)
+        self.address = address
+        self.bus_num = bus
+        self._bus = None
+
+    def setup(self) -> None:
+        try:
+            from smbus2 import SMBus
+        except ImportError:
+            raise ImportError(
+                "smbus2 is required for HMC5883L. Install with: pip install smbus2"
+            )
+
+        self._bus = SMBus(self.bus_num)
+
+        self._bus.write_byte_data(self.address, HMC_REG_CONFIG_A, HMC_CONFIG_A_DEFAULT)
+        self._bus.write_byte_data(self.address, HMC_REG_CONFIG_B, HMC_CONFIG_B_DEFAULT)
+        self._bus.write_byte_data(self.address, HMC_REG_MODE, HMC_MODE_CONTINUOUS)
+        time.sleep(0.01)
+
+    def cleanup(self) -> None:
+        if self._bus:
+            self._bus.close()
+            self._bus = None
+
+    def read(self) -> List[SensorReading]:
+        if self._bus is None:
+            self.setup()
+
+        # Read 6 bytes: X MSB, X LSB, Z MSB, Z LSB, Y MSB, Y LSB
+        # Note: HMC5883L register order is X, Z, Y (not X, Y, Z)
+        data = self._bus.read_i2c_block_data(self.address, HMC_REG_DATA, 6)
+
+        x = (data[0] << 8) | data[1]
+        z = (data[2] << 8) | data[3]
+        y = (data[4] << 8) | data[5]
+
+        # Convert to signed
+        if x > 32767:
+            x -= 65536
+        if y > 32767:
+            y -= 65536
+        if z > 32767:
+            z -= 65536
+
+        # At 1.3 Gauss gain: 1090 LSB/Gauss, 1 Gauss = 100 µT
+        scale = 100.0 / 1090.0
+
+        return [
+            SensorReading("mag_x", round(x * scale, 2)),
+            SensorReading("mag_y", round(y * scale, 2)),
+            SensorReading("mag_z", round(z * scale, 2)),
+        ]
+
+    def is_available(self) -> bool:
+        try:
+            from smbus2 import SMBus
+
+            bus = SMBus(self.bus_num)
+            # Read identification registers (should be 'H', '4', '3')
+            id_a = bus.read_byte_data(self.address, HMC_REG_ID_A)
+            id_b = bus.read_byte_data(self.address, HMC_REG_ID_A + 1)
+            id_c = bus.read_byte_data(self.address, HMC_REG_ID_A + 2)
+            bus.close()
+            return id_a == 0x48 and id_b == 0x34 and id_c == 0x33  # "H43"
+        except Exception:
+            return False

plexus/sensors/mpu6050.py

@@ -0,0 +1,162 @@
+"""
+MPU6050 6-axis IMU sensor driver.
+
+The MPU6050 provides 3-axis accelerometer and 3-axis gyroscope data.
+Communicates via I2C at address 0x68 (or 0x69 if AD0 pin is high).
+
+Usage:
+    from plexus import Plexus
+    from plexus.sensors import MPU6050
+
+    px = Plexus()
+    imu = MPU6050()
+
+    while True:
+        for reading in imu.read():
+            px.send(reading.metric, reading.value)
+        time.sleep(0.01)  # 100 Hz
+
+Or with SensorHub:
+    from plexus.sensors import SensorHub, MPU6050
+
+    hub = SensorHub()
+    hub.add(MPU6050(sample_rate=100))
+    hub.run(Plexus())
+"""
+
+from typing import List, Optional
+from .base import BaseSensor, SensorReading
+
+# I2C constants
+MPU6050_ADDR = 0x68
+MPU6050_ADDR_ALT = 0x69
+
+# Register addresses
+PWR_MGMT_1 = 0x6B
+ACCEL_XOUT_H = 0x3B
+GYRO_XOUT_H = 0x43
+WHO_AM_I = 0x75
+
+# Scale factors for default ranges
+ACCEL_SCALE_2G = 16384.0  # LSB/g for ±2g
+GYRO_SCALE_250 = 131.0    # LSB/(°/s) for ±250°/s
+
+
+class MPU6050(BaseSensor):
+    """
+    MPU6050 6-axis IMU sensor driver.
+
+    Provides:
+    - accel_x, accel_y, accel_z: Acceleration in g (±2g range)
+    - gyro_x, gyro_y, gyro_z: Angular velocity in °/s (±250°/s range)
+    """
+
+    name = "MPU6050"
+    description = "6-axis IMU (accelerometer + gyroscope)"
+    metrics = ["accel_x", "accel_y", "accel_z", "gyro_x", "gyro_y", "gyro_z"]
+    i2c_addresses = [MPU6050_ADDR, MPU6050_ADDR_ALT]
+
+    def __init__(
+        self,
+        address: int = MPU6050_ADDR,
+        bus: int = 1,
+        sample_rate: float = 100.0,
+        prefix: str = "",
+        tags: Optional[dict] = None,
+    ):
+        """
+        Initialize MPU6050 driver.
+
+        Args:
+            address: I2C address (0x68 or 0x69)
+            bus: I2C bus number (usually 1 on Raspberry Pi)
+            sample_rate: Readings per second
+            prefix: Prefix for metric names
+            tags: Tags to add to all readings
+        """
+        super().__init__(sample_rate=sample_rate, prefix=prefix, tags=tags)
+        self.address = address
+        self.bus_num = bus
+        self._bus = None
+
+    def setup(self) -> None:
+        """Initialize the MPU6050."""
+        try:
+            from smbus2 import SMBus
+        except ImportError:
+            raise ImportError(
+                "smbus2 is required for MPU6050. Install with: pip install smbus2"
+            )
+
+        self._bus = SMBus(self.bus_num)
+
+        # Wake up the sensor (clear sleep bit)
+        self._bus.write_byte_data(self.address, PWR_MGMT_1, 0x00)
+
+    def cleanup(self) -> None:
+        """Close I2C bus."""
+        if self._bus:
+            self._bus.close()
+            self._bus = None
+
+    def _read_raw(self, register: int) -> int:
+        """Read 16-bit signed value from register pair."""
+        high = self._bus.read_byte_data(self.address, register)
+        low = self._bus.read_byte_data(self.address, register + 1)
+        value = (high << 8) | low
+        if value > 32767:
+            value -= 65536
+        return value
+
+    def read(self) -> List[SensorReading]:
+        """Read accelerometer and gyroscope data."""
+        if self._bus is None:
+            self.setup()
+
+        # Read accelerometer (g)
+        accel_x = self._read_raw(ACCEL_XOUT_H) / ACCEL_SCALE_2G
+        accel_y = self._read_raw(ACCEL_XOUT_H + 2) / ACCEL_SCALE_2G
+        accel_z = self._read_raw(ACCEL_XOUT_H + 4) / ACCEL_SCALE_2G
+
+        # Read gyroscope (°/s)
+        gyro_x = self._read_raw(GYRO_XOUT_H) / GYRO_SCALE_250
+        gyro_y = self._read_raw(GYRO_XOUT_H + 2) / GYRO_SCALE_250
+        gyro_z = self._read_raw(GYRO_XOUT_H + 4) / GYRO_SCALE_250
+
+        return [
+            SensorReading("accel_x", round(accel_x, 4)),
+            SensorReading("accel_y", round(accel_y, 4)),
+            SensorReading("accel_z", round(accel_z, 4)),
+            SensorReading("gyro_x", round(gyro_x, 2)),
+            SensorReading("gyro_y", round(gyro_y, 2)),
+            SensorReading("gyro_z", round(gyro_z, 2)),
+        ]
+
+    def is_available(self) -> bool:
+        """Check if MPU6050 is connected."""
+        try:
+            from smbus2 import SMBus
+
+            bus = SMBus(self.bus_num)
+            who_am_i = bus.read_byte_data(self.address, WHO_AM_I)
+            bus.close()
+            # Accept various MPU variants:
+            # 0x68 = MPU6050, 0x70 = MPU6500, 0x71 = MPU9250, 0x73 = MPU9255
+            return who_am_i in (0x68, 0x70, 0x71, 0x73)
+        except Exception:
+            return False
+
+
+class MPU9250(MPU6050):
+    """
+    MPU9250 IMU sensor driver.
+
+    The MPU9250 contains an MPU6500 (accel + gyro) and an AK8963 magnetometer
+    on an auxiliary I2C bus. This driver currently reads the 6-axis accel/gyro
+    data. Magnetometer support requires enabling the AK8963 pass-through mode
+    and is not yet implemented.
+    """
+
+    name = "MPU9250"
+    description = "6-axis IMU (accelerometer + gyroscope) — magnetometer not yet supported"
+    metrics = ["accel_x", "accel_y", "accel_z", "gyro_x", "gyro_y", "gyro_z"]

plexus/sensors/sht3x.py

@@ -0,0 +1,139 @@
+"""
+SHT3x precision temperature and humidity sensor driver.
+
+The SHT31/SHT35 provides high-accuracy temperature (±0.2°C) and
+humidity (±2%) readings. Communicates via I2C at address 0x44 or 0x45.
+
+Usage:
+    from plexus.sensors import SHT3x
+
+    sensor = SHT3x()
+    for reading in sensor.read():
+        print(f"{reading.metric}: {reading.value}")
+"""
+
+import time
+from typing import List, Optional
+from .base import BaseSensor, SensorReading
+
+SHT3X_ADDR = 0x44
+SHT3X_ADDR_ALT = 0x45
+
+# Single-shot measurement commands (clock stretching disabled)
+CMD_MEAS_HIGH = [0x24, 0x00]    # High repeatability
+CMD_MEAS_MEDIUM = [0x24, 0x0B]  # Medium repeatability
+CMD_MEAS_LOW = [0x24, 0x16]     # Low repeatability
+
+# Status register
+CMD_STATUS = [0xF3, 0x2D]
+
+# Soft reset
+CMD_RESET = [0x30, 0xA2]
+
+
+def _crc8(data: bytes) -> int:
+    """CRC-8 check per SHT3x datasheet (polynomial 0x31)."""
+    crc = 0xFF
+    for byte in data:
+        crc ^= byte
+        for _ in range(8):
+            if crc & 0x80:
+                crc = (crc << 1) ^ 0x31
+            else:
+                crc = crc << 1
+            crc &= 0xFF
+    return crc
+
+
+class SHT3x(BaseSensor):
+    """
+    SHT3x (SHT31/SHT35) precision humidity and temperature sensor.
+
+    Provides:
+    - sht_temperature: Temperature in °C (±0.2°C accuracy)
+    - sht_humidity: Relative humidity in % (±2% accuracy)
+    """
+
+    name = "SHT3x"
+    description = "Precision temperature and humidity (±0.2°C, ±2% RH)"
+    metrics = ["sht_temperature", "sht_humidity"]
+    i2c_addresses = [SHT3X_ADDR, SHT3X_ADDR_ALT]
+
+    def __init__(
+        self,
+        address: int = SHT3X_ADDR,
+        bus: int = 1,
+        sample_rate: float = 1.0,
+        prefix: str = "",
+        tags: Optional[dict] = None,
+    ):
+        super().__init__(sample_rate=sample_rate, prefix=prefix, tags=tags)
+        self.address = address
+        self.bus_num = bus
+        self._bus = None
+
+    def setup(self) -> None:
+        try:
+            from smbus2 import SMBus
+        except ImportError:
+            raise ImportError(
+                "smbus2 is required for SHT3x. Install with: pip install smbus2"
+            )
+
+        self._bus = SMBus(self.bus_num)
+
+        # Soft reset
+        self._bus.write_i2c_block_data(self.address, CMD_RESET[0], [CMD_RESET[1]])
+        time.sleep(0.002)  # 1.5ms reset time
+
+    def cleanup(self) -> None:
+        if self._bus:
+            self._bus.close()
+            self._bus = None
+
+    def read(self) -> List[SensorReading]:
+        if self._bus is None:
+            self.setup()
+
+        # Trigger single-shot measurement (high repeatability)
+        self._bus.write_i2c_block_data(self.address, CMD_MEAS_HIGH[0], [CMD_MEAS_HIGH[1]])
+        time.sleep(0.016)  # 15.5ms max for high repeatability
+
+        # Read 6 bytes: temp_msb, temp_lsb, temp_crc, hum_msb, hum_lsb, hum_crc
+        data = self._bus.read_i2c_block_data(self.address, 0x00, 6)
+
+        # Verify CRCs
+        if _crc8(bytes(data[0:2])) != data[2]:
+            return []  # Temperature CRC mismatch
+        if _crc8(bytes(data[3:5])) != data[5]:
+            return []  # Humidity CRC mismatch
+
+        # Convert raw values
+        raw_temp = (data[0] << 8) | data[1]
+        raw_hum = (data[3] << 8) | data[4]
+
+        temperature = -45.0 + 175.0 * (raw_temp / 65535.0)
+        humidity = 100.0 * (raw_hum / 65535.0)
+
+        # Clamp humidity to valid range
+        humidity = max(0.0, min(100.0, humidity))
+
+        return [
+            SensorReading("sht_temperature", round(temperature, 2)),
+            SensorReading("sht_humidity", round(humidity, 1)),
+        ]
+
+    def is_available(self) -> bool:
+        try:
+            from smbus2 import SMBus
+
+            bus = SMBus(self.bus_num)
+            # Read status register
+            bus.write_i2c_block_data(self.address, CMD_STATUS[0], [CMD_STATUS[1]])
+            time.sleep(0.001)
+            data = bus.read_i2c_block_data(self.address, 0x00, 3)
+            bus.close()
+            # Check CRC of status
+            return _crc8(bytes(data[0:2])) == data[2]
+        except Exception:
+            return False