boneio 1.5.0.dev31__tar.gz → 1.5.0.dev33__tar.gz

{boneio-1.5.0.dev31/boneio.egg-info → boneio-1.5.0.dev33}/PKG-INFO

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

{boneio-1.5.0.dev31 → boneio-1.5.0.dev33}/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.dev31 → boneio-1.5.0.dev33}/boneio/core/config/migrations/__init__.py

@@ -98,6 +98,56 @@ def get_config_version(doc: dict) -> int:
     return 0
 
 
+def _has_legacy_fields(doc: dict) -> bool:
+    """Check if the config contains deprecated fields that need migration.
+
+    Used to distinguish between a truly old config (needs migrations)
+    and a fresh config that simply lacks config_version.
+
+    Args:
+        doc: Raw config dict.
+
+    Returns:
+        True if deprecated fields are found, False otherwise.
+    """
+    # v1: nginx_proxy_port or modbus_sensors
+    web = doc.get("web")
+    if isinstance(web, dict) and "nginx_proxy_port" in web:
+        return True
+    if "modbus_sensors" in doc:
+        return True
+
+    # v2: float transition values in events/binary_sensors
+    for section_key in ("event", "binary_sensor"):
+        items = doc.get(section_key)
+        if isinstance(items, list):
+            for item in items:
+                if not isinstance(item, dict):
+                    continue
+                actions = item.get("actions")
+                if isinstance(actions, dict):
+                    for action_list in actions.values():
+                        if isinstance(action_list, list):
+                            for action in action_list:
+                                if isinstance(action, dict):
+                                    val = action.get("transition")
+                                    if isinstance(val, (int, float)):
+                                        return True
+
+    # v4: inline WLED effects/palettes in remote_devices
+    remote_devices = doc.get("remote_devices")
+    if isinstance(remote_devices, list):
+        for dev in remote_devices:
+            if isinstance(dev, dict) and dev.get("protocol") == "wled":
+                wled = dev.get("wled")
+                if isinstance(wled, dict) and (
+                    "effects" in wled or "palettes" in wled
+                ):
+                    return True
+
+    return False
+
+
 def run_migrations(
     doc: dict,
     from_version: int | None = None,
@@ -120,6 +170,25 @@ def run_migrations(
     if from_version >= CURRENT_SCHEMA_VERSION:
         return doc, from_version
 
+    # Fresh config without config_version: check if it actually needs migration.
+    # If no deprecated fields exist, this is a new install — skip all migrations
+    # and stamp with CURRENT_SCHEMA_VERSION directly.
+    if from_version == 0 and not _has_legacy_fields(doc):
+        _LOGGER.debug(
+            "Fresh config detected (no legacy fields), "
+            "setting config_version to %d",
+            CURRENT_SCHEMA_VERSION,
+        )
+        if "boneio" not in doc or not isinstance(doc.get("boneio"), dict):
+            doc["boneio"] = {}
+        doc["boneio"]["config_version"] = CURRENT_SCHEMA_VERSION
+        if config_file:
+            try:
+                _persist_config_version(config_file, CURRENT_SCHEMA_VERSION)
+            except Exception as e:
+                _LOGGER.error("Failed to persist config_version: %s", e)
+        return doc, CURRENT_SCHEMA_VERSION
+
     applied: list[str] = []
 
     for migration in _MIGRATIONS:

{boneio-1.5.0.dev31 → boneio-1.5.0.dev33}/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.dev31 → boneio-1.5.0.dev33}/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.dev31 → boneio-1.5.0.dev33}/boneio/example_config/24x16/config.yaml

@@ -25,6 +25,7 @@ binary_sensor: !include binary_sensor.yaml
 output: !include output24x16A.yaml
 
 boneio:
+  config_version: 4
   name: "boneIO Black 24x16A"
   version: 0.8
   device_type: "24x16A"

{boneio-1.5.0.dev31 → boneio-1.5.0.dev33}/boneio/example_config/32x10/config.yaml

@@ -25,6 +25,7 @@ binary_sensor: !include binary_sensor.yaml
 output: !include output32x10A.yaml
 
 boneio:
+  config_version: 4
   name: "boneIO Black 32x10A"
   version: 0.8
   device_type: "32x10A"

{boneio-1.5.0.dev31 → boneio-1.5.0.dev33}/boneio/example_config/48x4/config.yaml

@@ -25,6 +25,7 @@ binary_sensor: !include binary_sensor.yaml
 output: !include output48x4A.yaml
 
 boneio:
+  config_version: 4
   name: "boneIO Black 48x4A"
   version: 0.8
   device_type: "48x4A"

{boneio-1.5.0.dev31 → boneio-1.5.0.dev33}/boneio/example_config/cover/config.yaml

@@ -26,6 +26,7 @@ output: !include outputCover.yaml
 cover: !include cover.yaml
 
 boneio:
+  config_version: 4
   name: "boneIO Black Cover"
   version: 0.8
   device_type: "cover"

{boneio-1.5.0.dev31 → boneio-1.5.0.dev33}/boneio/example_config/cover_mix/config.yaml

@@ -26,6 +26,7 @@ output: !include outputCoverMix.yaml
 cover: !include cover.yaml
 
 boneio:
+  config_version: 4
   name: "boneIO Black Cover Mix"
   version: 0.8
   device_type: "Cover Mix"

{boneio-1.5.0.dev31 → boneio-1.5.0.dev33}/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.dev33/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)