boneio 1.5.0.dev32__tar.gz → 1.5.0.dev34__tar.gz

{boneio-1.5.0.dev32/boneio.egg-info → boneio-1.5.0.dev34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.5.0.dev32
+Version: 1.5.0.dev34
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0

{boneio-1.5.0.dev32 → boneio-1.5.0.dev34}/boneio/boards/1.0/output_24_16.yaml

@@ -1,8 +1,10 @@
 mcp23017:
 - id: mcp_left
   address: 35
+  inverted: true
 - id: mcp_right
   address: 36
+  inverted: true
 output_mapping:
   out_01:
     kind: mcp

{boneio-1.5.0.dev32 → boneio-1.5.0.dev34}/boneio/boards/1.0/output_32_10.yaml

@@ -1,8 +1,10 @@
 mcp23017:
 - id: mcp_left
   address: 35
+  inverted: true
 - id: mcp_right
   address: 36
+  inverted: true
 output_mapping:
   out_01:
     kind: mcp

{boneio-1.5.0.dev32 → boneio-1.5.0.dev34}/boneio/const.py

@@ -219,6 +219,7 @@ def filter_cover_extra_data(action_name: str, extra_data: dict) -> dict:
 
 
 INA219 = "ina219"
+INA226 = "ina226"
 VIRTUAL_ENERGY_SENSOR = "virtual_energy_sensor"
 
 # IRRIGATION CONSTS

{boneio-1.5.0.dev32 → boneio-1.5.0.dev34}/boneio/core/manager/display.py

@@ -153,8 +153,8 @@ class DisplayManager:
                     else None
                 ),
                 ina219=(
-                    self._manager.sensors.get_ina219_sensors()[0]
-                    if self._manager.sensors.get_ina219_sensors()
+                    (self._manager.sensors.get_ina219_sensors() or self._manager.sensors.get_ina226_sensors())[0]
+                    if (self._manager.sensors.get_ina219_sensors() or self._manager.sensors.get_ina226_sensors())
                     else None
                 ),
                 extra_sensors=extra_sensors,

{boneio-1.5.0.dev32 → boneio-1.5.0.dev34}/boneio/core/manager/outputs.py

@@ -185,9 +185,11 @@ class OutputManager:
             id = expander[ID] or expander[ADDRESS]
             address = expander[ADDRESS]
             try:
-                expander_dict[id] = _EXPANDER_CLASS[exp_type](
-                    i2c=self._manager._i2cbusio, address=address, reset=False
-                )
+                kwargs = {"i2c": self._manager._i2cbusio, "address": address, "reset": False}
+                if exp_type == MCP:
+                    kwargs["inverted"] = expander.get("inverted", None)
+                    kwargs["state_manager"] = getattr(self._manager, "_state_manager", None)
+                expander_dict[id] = _EXPANDER_CLASS[exp_type](**kwargs)
                 sleep_time = expander.get(INIT_SLEEP, TimePeriod(seconds=0))
                 if sleep_time.total_seconds > 0:
                     _LOGGER.debug(

{boneio-1.5.0.dev32 → boneio-1.5.0.dev34}/boneio/core/manager/sensors.py

@@ -19,6 +19,7 @@ from boneio.const import (
     FILTERS,
     ID,
     INA219,
+    INA226,
     LM75,
     MCP_TEMP_9808,
     ON,
@@ -79,6 +80,7 @@ class SensorManager:
         self._manager = manager
         self._temp_sensors: list[PCT2075 | MCP9808 | DallasSensor] = []
         self._ina219_sensors = []
+        self._ina226_sensors = []
         self._adc_sensors = []
         self._dallas_sensors: list[DallasSensor] = []
         self._system_sensors = []
@@ -88,15 +90,17 @@ class SensorManager:
         # Configure all sensor types
         self._configure_temp_sensors(sensors=sensors)
         self._configure_ina219_sensors(sensors=sensors)
+        self._configure_ina226_sensors(sensors=sensors)
         self._configure_dallas_sensors(dallas=dallas, sensors=sensors.get(ONEWIRE))
         self._configure_adc(adc_list=adc)
         self._configure_system_sensors()
         # Note: virtual_energy_sensors are configured after outputs are ready
 
         _LOGGER.info(
-            "SensorManager initialized with %d temp sensors, %d INA219, %d ADC, %d Dallas, %d system",
+            "SensorManager initialized with %d temp sensors, %d INA219, %d INA226, %d ADC, %d Dallas, %d system",
             len(self._temp_sensors),
             len(self._ina219_sensors),
+            len(self._ina226_sensors),
             len(self._adc_sensors),
             len(self._dallas_sensors),
             len(self._system_sensors),
@@ -251,6 +255,76 @@ class SensorManager:
             )
             return None
 
+    # -------------------------------------------------------------------------
+    # INA226 Power Sensors (boneIO v1.0)
+    # -------------------------------------------------------------------------
+
+    def _configure_ina226_sensors(self, sensors: dict) -> None:
+        """Configure INA226 power monitoring sensors.
+
+        Args:
+            sensors: Dictionary of sensor configurations
+        """
+        if not sensors.get(INA226):
+            return
+
+        for sensor_config in sensors[INA226]:
+            ina226 = self._create_ina226_sensor(config=sensor_config)
+            if ina226:
+                self._ina226_sensors.append(ina226)
+
+    def _create_ina226_sensor(self, config: dict):
+        """Create INA226 sensor instance.
+
+        Args:
+            config: Sensor configuration dictionary
+
+        Returns:
+            INA226 sensor instance or None on error
+        """
+        from boneio.hardware.i2c import INA226
+
+        address = config[ADDRESS]
+        id = config.get(ID, str(address)).replace(" ", "")
+
+        try:
+            ina226 = INA226(
+                id=id,
+                address=address,
+                sensors=config.get("sensors", []),
+                r_shunt=config.get("r_shunt", 0.05),
+                max_current=config.get("max_current", 1.5),
+                manager=self._manager,
+                message_bus=self._manager._message_bus,
+                topic_prefix=self._manager._topic_prefix,
+                update_interval=config.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
+            )
+            # Send HA autodiscovery for each sub-sensor
+            for sensor in ina226.sensors.values():
+                payload = ha_sensor_ina_availabilty_message(
+                    id=sensor.id,
+                    name=sensor.name,
+                    config_helper=self._manager._config_helper,
+                    unit_of_measurement=sensor.unit_of_measurement,
+                    device_class=sensor.device_class,
+                )
+                self._manager.publish_ha_discovery(id=sensor.id, ha_type=SENSOR, payload=payload)
+            return ina226
+        except I2CError as err:
+            _LOGGER.error("Can't configure INA226 sensor: %s", err)
+            self._manager._hardware_errors.append(
+                {
+                    "type": "sensor",
+                    "sensor_type": "ina226",
+                    "id": id,
+                    "name": id,
+                    "address": address,
+                    "error": str(err),
+                    "message": f"INA226 sensor at address 0x{address:02X}: {err}",
+                }
+            )
+            return None
+
     # -------------------------------------------------------------------------
     # Dallas 1-Wire Sensors
     # -------------------------------------------------------------------------
@@ -808,6 +882,14 @@ class SensorManager:
         """
         return self._ina219_sensors
 
+    def get_ina226_sensors(self) -> list:
+        """Get all INA226 sensors.
+
+        Returns:
+            List of INA226 sensors
+        """
+        return self._ina226_sensors
+
     def get_adc_sensors(self) -> list:
         """Get all ADC sensors.
 
@@ -1361,6 +1443,18 @@ class SensorManager:
                 )
                 self._manager.publish_ha_discovery(id=sub.id, ha_type=SENSOR, payload=payload)
 
+        # INA226 power sensors
+        for ina in self._ina226_sensors:
+            for sub in ina.sensors.values():
+                payload = ha_sensor_ina_availabilty_message(
+                    id=sub.id,
+                    name=sub.name,
+                    config_helper=self._manager._config_helper,
+                    unit_of_measurement=sub.unit_of_measurement,
+                    device_class=sub.device_class,
+                )
+                self._manager.publish_ha_discovery(id=sub.id, ha_type=SENSOR, payload=payload)
+
         # Dallas 1-Wire sensors
         for sensor in self._dallas_sensors:
             payload = ha_sensor_temp_availabilty_message(

{boneio-1.5.0.dev32 → boneio-1.5.0.dev34}/boneio/hardware/gpio/expanders/mcp23017.py

@@ -49,13 +49,22 @@ class MCP23017:
         pin0.switch_to_output(value=True)
     """
 
-    def __init__(self, i2c: SMBus2I2C, address: int = 0x20, reset: bool = False):
+    def __init__(
+        self,
+        i2c: SMBus2I2C,
+        address: int = 0x20,
+        reset: bool = False,
+        inverted: bool | None = None,
+        state_manager: Any = None,
+    ):
         """Initialize MCP23017.
         
         Args:
             i2c: I2C bus instance (SMBus2I2C)
             address: I2C address of the device (default 0x20)
             reset: Reset flag (unused, for API compatibility with Adafruit library)
+            inverted: Active-LOW relay board flag (True=active-LOW, False=active-HIGH, None=auto-detect)
+            state_manager: Optional StateManager instance to persist/read auto-detected logic
         
         Raises:
             ValueError: If address is not in valid range (0x20-0x27)
@@ -67,6 +76,7 @@ class MCP23017:
         
         self._i2c = i2c
         self._address = address
+        self._state_manager = state_manager
         
         # Lock for thread-safe pin operations
         # This prevents race conditions when multiple outputs are switched simultaneously
@@ -89,13 +99,55 @@ class MCP23017:
             # Write to both registers for robustness in case of dirty startup
             self._write_register_unlocked(0x0A, 0x20)  # SEQOP=1 (disabled), BANK=0
             self._write_register_unlocked(0x0B, 0x20)  # Mirror register
+
+            # Read IODIR to check if this is cold boot (all inputs = 0xFF)
+            iodir_a = self._read_register_unlocked(IODIRA)
+            iodir_b = self._read_register_unlocked(IODIRB)
+            is_cold_boot = (iodir_a == 0xFF and iodir_b == 0xFF)
+
+            # Determine inverted state:
+            # 1. Config override
+            # 2. State manager persisted value
+            # 3. Auto-detection on cold boot (GPIO read)
+            # 4. Fallback (False)
+            state_key = f"mcp_0x{address:02x}_inverted"
+            if inverted is not None:
+                self._inverted = bool(inverted)
+                _LOGGER.info("MCP23017@0x%02X inverted set from config: %s", address, self._inverted)
+            elif state_manager and state_manager.get("hardware", state_key) is not None:
+                self._inverted = bool(state_manager.get("hardware", state_key))
+                _LOGGER.info("MCP23017@0x%02X inverted loaded from state: %s", address, self._inverted)
+            elif is_cold_boot:
+                gpio_a = self._read_register_unlocked(GPIOA)
+                gpio_b = self._read_register_unlocked(GPIOB)
+                self._inverted = (gpio_a == 0xFF and gpio_b == 0xFF)
+                _LOGGER.info(
+                    "MCP23017@0x%02X auto-detected relay board logic: %s (GPIOA=0x%02X, GPIOB=0x%02X)",
+                    address,
+                    "active-LOW (inverted)" if self._inverted else "active-HIGH",
+                    gpio_a,
+                    gpio_b,
+                )
+                if state_manager:
+                    state_manager.save_attribute("hardware", state_key, self._inverted)
+            else:
+                self._inverted = False
+                _LOGGER.info("MCP23017@0x%02X inverted fallback: False", address)
             
             # Read current output latch states from hardware to preserve relay states
-            # This prevents momentary OFF state during application restart
-            self._port_a_state = self._read_register_unlocked(OLATA)
-            self._port_b_state = self._read_register_unlocked(OLATB)
+            if is_cold_boot and self._inverted:
+                # Cold boot with active-LOW relays: set all pins to HIGH (0xFF) before setting IODIR=0x00
+                # so relays stay OFF during initial output configuration
+                self._port_a_state = 0xFF
+                self._port_b_state = 0xFF
+                self._write_register_unlocked(OLATA, 0xFF)
+                self._write_register_unlocked(OLATB, 0xFF)
+            else:
+                self._port_a_state = self._read_register_unlocked(OLATA)
+                self._port_b_state = self._read_register_unlocked(OLATB)
+
             _LOGGER.debug(
-                f"MCP23017@0x{address:02X} preserved states: "
+                f"MCP23017@0x{address:02X} preserved states (inverted={self._inverted}): "
                 f"A=0b{self._port_a_state:08b}, B=0b{self._port_b_state:08b}"
             )
             
@@ -104,7 +156,7 @@ class MCP23017:
             self._write_register_unlocked(IODIRA, 0x00)
             self._write_register_unlocked(IODIRB, 0x00)
             
-            _LOGGER.info(f"Initialized MCP23017 at address 0x{address:02X}")
+            _LOGGER.info(f"Initialized MCP23017 at address 0x{address:02X} (inverted={self._inverted})")
         finally:
             self._i2c.unlock()
 
@@ -191,6 +243,11 @@ class MCP23017:
                 iodir &= ~(1 << pin_bit)  # Clear bit = output
                 self._write_register_unlocked(IODIRB, iodir)
 
+    @property
+    def inverted(self) -> bool:
+        """Check whether expander operates in inverted (active-LOW) mode."""
+        return self._inverted
+
     def _write_pin(self, pin_number: int, value: bool) -> None:
         """Write value to a pin using ATOMIC hardware Read-Modify-Write.
         
@@ -199,7 +256,7 @@ class MCP23017:
         
         Args:
             pin_number: Pin number (0-15)
-            value: Output state (True=HIGH, False=LOW)
+            value: Output state (True=ON/HIGH logical, False=OFF/LOW logical)
         """
         with self._lock:
             # Rate limiting: ensure minimum delay between I2C operations
@@ -223,8 +280,11 @@ class MCP23017:
                     # Read current state from hardware
                     current_state = self._read_register_unlocked(reg)
                     
+                    # Account for active-LOW inverted logic
+                    effective_value = not value if self._inverted else value
+
                     # Calculate new state
-                    if value:
+                    if effective_value:
                         new_state = current_state | (1 << bit)
                     else:
                         new_state = current_state & ~(1 << bit)
@@ -232,7 +292,7 @@ class MCP23017:
                     # Only write if state changed
                     if new_state != current_state:
                         _LOGGER.debug(
-                            f"MCP23017@0x{self._address:02X} pin {pin_number} -> {value}: "
+                            f"MCP23017@0x{self._address:02X} pin {pin_number} -> {value} (phys={effective_value}): "
                             f"{'OLATA' if pin_number < 8 else 'OLATB'} "
                             f"0b{current_state:08b} -> 0b{new_state:08b}"
                         )
@@ -277,23 +337,24 @@ class MCP23017:
         self._write_pin(pin_number, value)
 
     def get_pin_value(self, pin_number: int) -> bool:
-        """Get current pin value.
+        """Get current logical pin value.
         
         Args:
             pin_number: Pin number (0-15)
             
         Returns:
-            Current pin state
+            Current logical pin state (accounting for active-LOW inverted logic)
         """
         if not 0 <= pin_number <= 15:
             raise ValueError(f"Pin number must be 0-15, got {pin_number}")
         
         with self._lock:
             if pin_number < 8:
-                return bool(self._port_a_state & (1 << pin_number))
+                raw_state = bool(self._port_a_state & (1 << pin_number))
             else:
                 pin_bit = pin_number - 8
-                return bool(self._port_b_state & (1 << pin_bit))
+                raw_state = bool(self._port_b_state & (1 << pin_bit))
+            return not raw_state if self._inverted else raw_state
 
     def verify_port_state(self) -> tuple[int, int]:
         """Read actual port states from hardware and compare with cached state.

{boneio-1.5.0.dev32 → boneio-1.5.0.dev34}/boneio/hardware/i2c/__init__.py

@@ -3,11 +3,12 @@
 This module provides I2C bus support and I2C-based sensors:
 - SMBus2I2C wrapper for I2C communication
 - Temperature sensors (PCT2075/LM75, MCP9808)
-- Power monitoring (INA219)
+- Power monitoring (INA219 for v0.8, INA226 for v1.0)
 """
 
 from boneio.hardware.i2c.bus import SMBus2I2C
 from boneio.hardware.i2c.ina219 import INA219, INA219Sensor
+from boneio.hardware.i2c.ina226 import INA226, INA226Sensor
 from boneio.hardware.i2c.mcp9808 import MCP9808
 from boneio.hardware.i2c.pct2075 import PCT2075
 
@@ -20,4 +21,6 @@ __all__ = [
     # Power monitoring
     "INA219",
     "INA219Sensor",
+    "INA226",
+    "INA226Sensor",
 ]

boneio-1.5.0.dev34/boneio/hardware/i2c/ina226.py

@@ -0,0 +1,260 @@
+"""INA226 power monitoring sensor driver.
+
+This module provides support for INA226 current/voltage/power monitoring sensor.
+The INA226 is a high-side/low-side current shunt and power monitor with I2C
+interface, used on boneIO Black v1.0 boards (replacing INA219 from v0.8).
+
+Key improvements over INA219:
+- Bus voltage range: 0–36V (vs 0–26V)
+- Bus voltage resolution: 1.25 mV (vs 4 mV)
+- Internal power register (no need for V×I computation)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from datetime import datetime
+
+from boneio.const import SENSOR, STATE
+from boneio.core.messaging import BasicMqtt
+from boneio.core.utils import AsyncUpdater, Filter
+from boneio.exceptions import I2CError
+from boneio.hardware.i2c.ina226_driver import INA226_I2C
+from boneio.models import SensorState
+from boneio.models.events import SensorEvent
+
+_LOGGER = logging.getLogger(__name__)
+
+# Unit conversion for different measurement types
+UNIT_CONVERTER = {"current": "A", "power": "W", "voltage": "V"}
+
+
+class INA226Sensor(BasicMqtt, Filter):
+    """Single measurement from INA226 sensor.
+
+    This class represents one measurement type (current, voltage, or power)
+    from an INA226 sensor. Multiple INA226Sensor instances are typically
+    managed by a single INA226 coordinator.
+
+    Args:
+        device_class: Type of measurement ('current', 'voltage', or 'power')
+        filters: List of filter expressions to apply
+        state: Initial state value
+        **kwargs: Additional arguments (name, id, message_bus, etc.)
+    """
+
+    def __init__(
+        self, device_class: str, filters: list, state: float | None, **kwargs
+    ) -> None:
+        """Initialize INA226 sensor."""
+        super().__init__(topic_type=SENSOR, **kwargs)
+        self._unit_of_measurement = UNIT_CONVERTER[device_class]
+        self._device_class = device_class
+        self._filters = filters
+        self._raw_state = state
+        self._timestamp = time.time()
+        self._state = (
+            self._apply_filters(value=self._raw_state) if self._raw_state else None
+        )
+
+    @property
+    def raw_state(self) -> float | None:
+        """Get raw unfiltered state value.
+
+        Returns:
+            Raw measurement value or None
+        """
+        return self._raw_state
+
+    @raw_state.setter
+    def raw_state(self, value: float) -> None:
+        """Set raw state value.
+
+        Args:
+            value: New raw measurement value
+        """
+        self._raw_state = value
+
+    @property
+    def state(self) -> float | None:
+        """Get filtered state value.
+
+        Returns:
+            Filtered measurement value or None
+        """
+        return self._state
+
+    @property
+    def device_class(self) -> str:
+        """Get device class (measurement type).
+
+        Returns:
+            Device class string ('current', 'voltage', or 'power')
+        """
+        return self._device_class
+
+    @property
+    def unit_of_measurement(self) -> str:
+        """Get unit of measurement.
+
+        Returns:
+            Unit string ('A', 'V', or 'W')
+        """
+        return self._unit_of_measurement
+
+    @property
+    def last_timestamp(self) -> float:
+        """Get timestamp of last update.
+
+        Returns:
+            Unix timestamp
+        """
+        return self._timestamp
+
+    def update(self, timestamp: float) -> None:
+        """Update sensor state and publish to MQTT.
+
+        Args:
+            timestamp: Current timestamp
+        """
+        _state = self._apply_filters(value=self._raw_state) if self._raw_state else None
+        if not _state:
+            return
+        self._state = _state
+        self._timestamp = timestamp
+        self._message_bus.send_message(
+            topic=self._send_topic,
+            payload={STATE: self.state},
+        )
+
+
+class INA226(AsyncUpdater):
+    """INA226 power monitoring sensor coordinator.
+
+    This class manages an INA226 sensor and its multiple measurement types
+    (current, voltage, power). It periodically reads values from the sensor
+    and updates individual INA226Sensor instances.
+
+    Features:
+    - High-side/low-side current sensing
+    - 0–36V bus voltage measurement (1.25 mV resolution)
+    - Internal power calculation (more accurate than V×I)
+    - I2C interface (address: 0x40–0x4F)
+    - 16-bit ADC with configurable averaging
+
+    Args:
+        address: I2C address of the sensor (default: 0x40)
+        id: Sensor identifier
+        sensors: List of sensor configurations (device_class, id, filters)
+        r_shunt: Shunt resistor value in Ohms (default: 0.05 for boneIO v1.0)
+        max_current: Maximum expected current in A (default: 1.5)
+        **kwargs: Additional arguments (manager, update_interval, etc.)
+    """
+
+    def __init__(
+        self,
+        address: int,
+        id: str,
+        sensors: list[dict] | None = None,
+        r_shunt: float = 0.05,
+        max_current: float = 1.5,
+        **kwargs,
+    ) -> None:
+        """Initialize INA226 sensor coordinator.
+
+        Raises:
+            I2CError: If sensor is not found or communication fails
+        """
+        if sensors is None:
+            sensors = []
+        self._loop = asyncio.get_event_loop()
+        self._sensors: dict[str, INA226Sensor] = {}
+        self._id = id
+
+        # Initialize hardware sensor with error handling
+        try:
+            self._ina = INA226_I2C(
+                address=address,
+                r_shunt=r_shunt,
+                max_current=max_current,
+            )
+        except OSError as err:
+            raise I2CError(
+                f"Failed to initialize INA226 at address 0x{address:02X}: {err}"
+            ) from err
+
+        # Create individual sensor instances for each measurement type
+        for sensor in sensors:
+            _name = sensor["id"]
+            _id = f"{id}{_name.replace(' ', '')}"
+            self._sensors[sensor["device_class"]] = INA226Sensor(
+                device_class=sensor["device_class"],
+                filters=sensor.get("filters", []),
+                state=None,
+                name=_name,
+                id=_id,
+                **kwargs,
+            )
+
+        AsyncUpdater.__init__(self, **kwargs)
+        _LOGGER.info(
+            "Configured INA226 on address 0x%02X with %d sensors "
+            "(R_SHUNT=%.3fΩ, I_max=%.1fA)",
+            address, len(self._sensors), r_shunt, max_current,
+        )
+
+    @property
+    def id(self) -> str:
+        """Get sensor coordinator ID.
+
+        Returns:
+            Coordinator identifier string
+        """
+        return self._id
+
+    @property
+    def sensors(self) -> dict[str, INA226Sensor]:
+        """Get dictionary of managed sensors.
+
+        Returns:
+            Dictionary mapping device_class to INA226Sensor instances
+        """
+        return self._sensors
+
+    async def async_update(self, timestamp: datetime) -> None:
+        """Read sensor values and update all managed sensors.
+
+        This method is called periodically by AsyncUpdater. It reads
+        current, voltage, and power from the INA226 and updates the
+        corresponding sensor instances.
+
+        Args:
+            timestamp: Current timestamp
+        """
+        for k, sensor in self._sensors.items():
+            try:
+                value = getattr(self._ina, k)
+                _LOGGER.debug(
+                    "Fetched INA226 value: %s = %s %s",
+                    k, value, sensor.unit_of_measurement,
+                )
+
+                if sensor.raw_state != value:
+                    sensor.raw_state = value
+                    sensor.update(timestamp=timestamp)
+
+                    # Trigger event on EventBus
+                    self.manager.event_bus.trigger_event(SensorEvent(
+                        entity_id=sensor.id,
+                        state=SensorState(
+                            id=sensor.id,
+                            name=sensor.name,
+                            state=sensor.state,
+                            unit=sensor.unit_of_measurement,
+                            timestamp=sensor.last_timestamp,
+                        ),
+                    ))
+            except Exception as err:
+                _LOGGER.error("Error reading INA226 %s: %s", k, err)