boneio 1.6.0.dev33__tar.gz → 1.6.0.dev35__tar.gz

boneio-1.6.0.dev35/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: boneio
+Version: 1.6.0.dev35
+Summary: Python App for BoneIO
+Author-email: Paweł Szafer <pszafer@gmail.com>
+License: GNU General Public License v3.0
+Project-URL: Homepage, https://boneio.eu
+Project-URL: Repository, https://github.com/boneIO-eu/app_black
+Project-URL: Documentation, https://boneio.eu/docs/intro/
+Project-URL: Changelog, https://github.com/boneIO-eu/app_black/releases
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: smbus2==0.4.3
+Requires-Dist: aiomqtt==2.4.0
+Requires-Dist: aiohttp==3.14.3
+Requires-Dist: Cerberus==1.3.7
+Requires-Dist: colorlog==6.9.0
+Requires-Dist: luma-core==2.5.1
+Requires-Dist: luma-oled==3.14.0
+Requires-Dist: pymodbus==3.11.3
+Requires-Dist: pyserial-asyncio-fast==0.16
+Requires-Dist: PyYAML==6.0.3
+Requires-Dist: psutil==7.2.2
+Requires-Dist: w1thermsensor[async]==2.3.0
+Requires-Dist: fastapi==0.141.1
+Requires-Dist: starlette>=1.3.1
+Requires-Dist: pydantic==2.11.9
+Requires-Dist: hypercorn==0.18.0
+Requires-Dist: websockets==15.0.1
+Requires-Dist: PyJWT==2.14.0
+Requires-Dist: python-multipart==0.0.31
+Requires-Dist: qrcode==8.2
+Requires-Dist: gpiod==2.3.0
+Requires-Dist: requests==2.33.0
+Requires-Dist: packaging==25.0
+Requires-Dist: aioesphomeapi>=45.0.0
+Requires-Dist: zeroconf>=0.148.0
+Requires-Dist: canopen-asyncio>=2.4.1
+Requires-Dist: anyio>=4.14.2
+Requires-Dist: cryptography>=50.0.0; platform_system == "Linux"
+Dynamic: license-file
+
+# boneIO Black
+
+**boneIO Black** is a DIN-rail home automation controller: relays, inputs and
+sensors in one box, ready to wire into a switchboard. This repository is the
+software that runs on it — configured from the browser, integrated with
+Home Assistant over MQTT, and working on its own when the network or the
+server is down.
+
+[boneio.eu](https://boneio.eu) · [Documentation](https://boneio.eu/docs/intro/) · [Releases](https://github.com/boneIO-eu/app_black/releases)
+
+## The controller
+
+- **32x10A** — 32 relay outputs, 10 A each, plus inputs for wall switches.
+- **24x16A** — 24 relay outputs, 16 A each, for heavier loads.
+- **Cover** and **Cover Mix** — boards made for roller blinds, venetian blinds
+  and gates.
+
+Every board has an OLED status screen, a temperature sensor, power
+monitoring and RS-485 for Modbus devices. It comes with the system image
+installed: power it up, open the panel, pick the board type, done.
+
+## What the software does
+
+- **Web panel** — configure outputs, inputs, covers and devices from the
+  browser, with no YAML editing needed (YAML stays available for those who
+  want it). Accounts with roles, HTTPS, works as a phone app (PWA).
+- **Home Assistant** — every output, input and sensor appears in Home
+  Assistant by itself through MQTT discovery. MQTT over TLS is supported.
+- **Local logic** — inputs drive outputs directly on the controller, with
+  click / double click / long press actions and conditions. Lights still work
+  when Home Assistant or the network does not.
+- **Covers** — time-based roller blinds, venetian blinds with tilt, gates.
+- **Modbus** — ready definitions for energy meters, inverters, HVAC units and
+  sensors (SDM630, ORNO, Socomec, Sofar, SHT30, PT100 and more).
+- **Templates** — thermostats, alarm panel, irrigation, schedules, presence
+  simulation, sunrise / sunset triggers, virtual switches and energy sensors.
+- **Remote devices** — ESPHome, WLED and other controllers over MQTT or CAN,
+  used as inputs and outputs as if they were local.
+- **Updates from the panel** — application and system updates, backups and
+  configuration restore without SSH.
+
+## Getting started
+
+The controller ships ready to use. Connect it to the network and open
+`https://<controller-ip>:8443`, or plug in USB and open
+`http://192.168.7.2:8090`. The first-run wizard creates the administrator
+account and asks which board this is.
+
+Full guide: [boneio.eu/docs](https://boneio.eu/docs/intro/).
+
+The supported way to run this software is the boneIO system image on boneIO
+hardware. Installing the Python package by hand on another system is not
+supported.
+
+## Development
+
+```bash
+uv sync
+uv run boneio run -c ~/boneio/config.yaml -dd
+```
+
+Python 3.13 or newer. Frontend sources are in `frontend/`.
+
+## License
+
+GNU General Public License v3.0.

boneio-1.6.0.dev35/README.md

@@ -0,0 +1,66 @@
+# boneIO Black
+
+**boneIO Black** is a DIN-rail home automation controller: relays, inputs and
+sensors in one box, ready to wire into a switchboard. This repository is the
+software that runs on it — configured from the browser, integrated with
+Home Assistant over MQTT, and working on its own when the network or the
+server is down.
+
+[boneio.eu](https://boneio.eu) · [Documentation](https://boneio.eu/docs/intro/) · [Releases](https://github.com/boneIO-eu/app_black/releases)
+
+## The controller
+
+- **32x10A** — 32 relay outputs, 10 A each, plus inputs for wall switches.
+- **24x16A** — 24 relay outputs, 16 A each, for heavier loads.
+- **Cover** and **Cover Mix** — boards made for roller blinds, venetian blinds
+  and gates.
+
+Every board has an OLED status screen, a temperature sensor, power
+monitoring and RS-485 for Modbus devices. It comes with the system image
+installed: power it up, open the panel, pick the board type, done.
+
+## What the software does
+
+- **Web panel** — configure outputs, inputs, covers and devices from the
+  browser, with no YAML editing needed (YAML stays available for those who
+  want it). Accounts with roles, HTTPS, works as a phone app (PWA).
+- **Home Assistant** — every output, input and sensor appears in Home
+  Assistant by itself through MQTT discovery. MQTT over TLS is supported.
+- **Local logic** — inputs drive outputs directly on the controller, with
+  click / double click / long press actions and conditions. Lights still work
+  when Home Assistant or the network does not.
+- **Covers** — time-based roller blinds, venetian blinds with tilt, gates.
+- **Modbus** — ready definitions for energy meters, inverters, HVAC units and
+  sensors (SDM630, ORNO, Socomec, Sofar, SHT30, PT100 and more).
+- **Templates** — thermostats, alarm panel, irrigation, schedules, presence
+  simulation, sunrise / sunset triggers, virtual switches and energy sensors.
+- **Remote devices** — ESPHome, WLED and other controllers over MQTT or CAN,
+  used as inputs and outputs as if they were local.
+- **Updates from the panel** — application and system updates, backups and
+  configuration restore without SSH.
+
+## Getting started
+
+The controller ships ready to use. Connect it to the network and open
+`https://<controller-ip>:8443`, or plug in USB and open
+`http://192.168.7.2:8090`. The first-run wizard creates the administrator
+account and asks which board this is.
+
+Full guide: [boneio.eu/docs](https://boneio.eu/docs/intro/).
+
+The supported way to run this software is the boneIO system image on boneIO
+hardware. Installing the Python package by hand on another system is not
+supported.
+
+## Development
+
+```bash
+uv sync
+uv run boneio run -c ~/boneio/config.yaml -dd
+```
+
+Python 3.13 or newer. Frontend sources are in `frontend/`.
+
+## License
+
+GNU General Public License v3.0.

boneio-1.6.0.dev35/boneio/components/sensor/virtual_energy.py

@@ -0,0 +1,337 @@
+"""Virtual Energy Sensor module.
+
+Creates virtual power/energy or water flow sensors linked to outputs.
+When the linked output is ON, the sensor calculates consumption based on
+configured power_usage or flow_rate.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import time
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from boneio.const import ON
+from boneio.models import SensorState
+from boneio.models.events import SensorEvent
+
+if TYPE_CHECKING:
+    from boneio.components.output.basic import BasicOutput
+    from boneio.core.events.bus import EventBus
+    from boneio.core.messaging.basic import MessageBus
+
+_LOGGER = logging.getLogger(__name__)
+
+# How long to wait, once the broker has the subscription, for a stored total.
+# None arriving means the counter has never been published.
+RESTORE_GRACE_SECONDS = 15.0
+
+
+class VirtualEnergySensor:
+    """Virtual energy/water sensor linked to an output.
+
+    Tracks energy consumption (Wh) or water consumption (L) based on
+    configured power_usage (W) or flow_rate (L/h) when the linked output is ON.
+
+    Args:
+        id: Unique sensor identifier
+        name: Display name for Home Assistant
+        output: The output to track
+        message_bus: MessageBus for MQTT communication
+        loop: Event loop
+        topic_prefix: MQTT topic prefix
+        sensor_type: 'power' or 'water'
+        power_usage: Power consumption in Watts (for sensor_type='power')
+        flow_rate: Flow rate in L/h (for sensor_type='water')
+        area: Optional area ID for HA sub-device
+    """
+
+    def __init__(
+        self,
+        id: str,
+        name: str,
+        output: BasicOutput,
+        message_bus: MessageBus,
+        event_bus: EventBus,
+        loop: asyncio.AbstractEventLoop,
+        topic_prefix: str,
+        sensor_type: str,
+        power_usage: float | None = None,
+        flow_rate: float | None = None,
+        area: str | None = None,
+    ):
+        self._id = id
+        self._name = name
+        self._output = output
+        self._loop = loop or asyncio.get_running_loop()
+        self._message_bus = message_bus
+        self._event_bus = event_bus
+        self._topic_prefix = topic_prefix
+        self._sensor_type = sensor_type
+        self._power_usage = power_usage
+        self._flow_rate = flow_rate
+        self._area = area
+
+        self._virtual_sensors_task = None
+        self._restore_task: asyncio.Task | None = None
+
+        # Counters
+        self._energy_consumed_Wh = 0.0
+        self._water_consumed_L = 0.0
+        self._last_on_timestamp = None
+
+        # State restore gate — prevents sending state=0 before
+        # the retained MQTT message with the real value is received.
+        self._restore_done = asyncio.Event()
+
+        # MQTT topic for this sensor
+        self._sensor_topic = f"{topic_prefix}/energy/{id}"
+
+        # Subscribe to restore state from MQTT
+        self._subscribe_restore_state()
+
+        _LOGGER.info(
+            "Initialized VirtualEnergySensor: id=%s, name=%s, output=%s, type=%s", id, name, output.id, sensor_type
+        )
+
+    @property
+    def id(self) -> str:
+        """Get sensor ID."""
+        return self._id
+
+    @property
+    def name(self) -> str:
+        """Get sensor name."""
+        return self._name
+
+    @property
+    def output_id(self) -> str:
+        """Get linked output ID."""
+        return self._output.id
+
+    @property
+    def sensor_type(self) -> str:
+        """Get sensor type ('power' or 'water')."""
+        return self._sensor_type
+
+    @property
+    def area(self) -> str | None:
+        """Get area ID."""
+        return self._area
+
+    @property
+    def power_usage(self) -> float | None:
+        """Get power usage in Watts."""
+        return self._power_usage
+
+    @property
+    def flow_rate(self) -> float | None:
+        """Get flow rate in L/h."""
+        return self._flow_rate
+
+    @property
+    def last_on_timestamp(self) -> float | None:
+        """Get timestamp when output was last turned ON."""
+        return self._last_on_timestamp
+
+    def rebind_output(self, resolve: Callable[[BasicOutput], BasicOutput]) -> None:
+        """Swap the tracked output for the one registered now under its id.
+
+        Tracking reads the output's state; after an output reload the old
+        object's state no longer changes, so nothing was counted.
+
+        Args:
+            resolve: Maps the held output to the current one.
+        """
+        self._output = resolve(self._output)
+
+    def start_tracking(self):
+        """Start tracking consumption (called when output turns ON)."""
+        if self._last_on_timestamp is None:  # ON while already on keeps the stretch
+            self._last_on_timestamp = time.time()
+        if self._virtual_sensors_task is not None and not self._virtual_sensors_task.done():
+            return  # Already running
+        self._virtual_sensors_task = self._loop.create_task(self._tracking_loop())
+        _LOGGER.debug("Started tracking for virtual sensor %s", self._id)
+
+    def stop_tracking(self):
+        """Stop tracking consumption (called when output turns OFF)."""
+        # Update one last time before stopping
+        self._update_consumption()
+        self._last_on_timestamp = None
+
+        if self._virtual_sensors_task is not None:
+            self._virtual_sensors_task.cancel()
+            self._virtual_sensors_task = None
+
+        # Send final state (only if restore is done)
+        if self._restore_done.is_set():
+            self._send_state()
+        _LOGGER.debug("Stopped tracking for virtual sensor %s", self._id)
+
+    async def _tracking_loop(self):
+        """Periodically update and send state every 30 seconds while output is ON."""
+        try:
+            # Publishing before the stored total is known would replace it
+            # with what was counted since boot.
+            await self._restore_done.wait()
+
+            while self._output.state == ON:
+                self._update_consumption()
+                self._send_state()
+                await asyncio.sleep(30)
+        except asyncio.CancelledError:
+            pass
+
+    def _update_consumption(self):
+        """Update consumption counters based on elapsed time."""
+        now = time.time()
+        # Not the output's state: by the time OFF is handled it is already
+        # off, and the stretch since the last update would be lost.
+        if self._last_on_timestamp is not None:
+            elapsed = now - self._last_on_timestamp
+
+            if self._sensor_type == "power" and self._power_usage is not None:
+                self._energy_consumed_Wh += (self._power_usage * elapsed) / 3600.0
+                _LOGGER.debug("Energy updated for %s: %.4f Wh", self._id, self._energy_consumed_Wh)
+            elif self._sensor_type == "water" and self._flow_rate is not None:
+                self._water_consumed_L += (self._flow_rate * elapsed) / 3600.0
+                _LOGGER.debug("Water updated for %s: %.4f L", self._id, self._water_consumed_L)
+
+            self._last_on_timestamp = now
+
+    def _subscribe_restore_state(self):
+        """Subscribe to retained MQTT topic to restore state on startup.
+
+        Sets _restore_done event when restore is complete (or if no retained
+        message is available). This gates _send_state() to prevent overwriting
+        the retained value with 0.
+        """
+
+        async def on_message(_topic, payload):
+            if self._restore_done.is_set():
+                return  # Late, after giving up: the counter is already published.
+            try:
+                data = json.loads(payload)
+                if isinstance(data, dict):
+                    # Added, not assigned: the output may have been on since boot.
+                    if "energy" in data:
+                        self._energy_consumed_Wh += float(data["energy"])
+                        _LOGGER.info("Restored energy state for %s: %.4f Wh", self._id, self._energy_consumed_Wh)
+                    if "water" in data:
+                        self._water_consumed_L += float(data["water"])
+                        _LOGGER.info("Restored water state for %s: %.4f L", self._id, self._water_consumed_L)
+            except Exception as e:
+                _LOGGER.warning("Failed to restore state for %s: %s", self._id, e)
+            finally:
+                self._restore_done.set()
+                await self._message_bus.unsubscribe_and_stop_listen(self._sensor_topic)
+
+        async def restore():
+            await self._message_bus.subscribe_and_listen(self._sensor_topic, on_message)
+            # The grace starts once the broker has the subscription, not at
+            # boot: connecting can take longer than any fixed timeout.
+            await self._message_bus.wait_until_subscribed()
+            try:
+                await asyncio.wait_for(self._restore_done.wait(), timeout=RESTORE_GRACE_SECONDS)
+            except TimeoutError:
+                _LOGGER.info("No stored state for %s, counting from boot", self._id)
+                self._restore_done.set()
+                await self._message_bus.unsubscribe_and_stop_listen(self._sensor_topic)
+
+        if self._message_bus is not None:
+            self._restore_task = asyncio.create_task(restore())
+
+    def get_current_power(self) -> float:
+        """Get current power usage in W (0 if output is OFF)."""
+        if self._sensor_type != "power":
+            return 0.0
+        return (self._power_usage or 0.0) if self._output.state == ON else 0.0
+
+    def get_total_energy(self) -> float:
+        """Get total energy consumed in Wh."""
+        return round(self._energy_consumed_Wh, 3)
+
+    def get_current_flow_rate(self) -> float:
+        """Get current flow rate in L/h (0 if output is OFF)."""
+        if self._sensor_type != "water":
+            return 0.0
+        return (self._flow_rate or 0.0) if self._output.state == ON else 0.0
+
+    def get_total_water(self) -> float:
+        """Get total water consumed in L."""
+        return round(self._water_consumed_L, 3)
+
+    def _send_state(self):
+        """Send current state to MQTT and EventBus (for WebSocket/frontend)."""
+        payload = {}
+        timestamp = int(time.time())
+
+        if self._sensor_type == "power":
+            payload["power"] = self.get_current_power()
+            payload["energy"] = self.get_total_energy()
+
+            # Send SensorEvents to frontend via EventBus
+            self._event_bus.trigger_event(
+                SensorEvent(
+                    entity_id=f"{self._id}_power",
+                    state=SensorState(
+                        id=f"{self._id}_power",
+                        name=f"{self._name} Power",
+                        state=self.get_current_power(),
+                        unit="W",
+                        timestamp=timestamp,
+                    ),
+                )
+            )
+            self._event_bus.trigger_event(
+                SensorEvent(
+                    entity_id=f"{self._id}_energy",
+                    state=SensorState(
+                        id=f"{self._id}_energy",
+                        name=f"{self._name} Energy",
+                        state=self.get_total_energy(),
+                        unit="Wh",
+                        timestamp=timestamp,
+                    ),
+                )
+            )
+        elif self._sensor_type == "water":
+            payload["volume_flow_rate"] = self.get_current_flow_rate()
+            payload["water"] = self.get_total_water()
+
+            # Send SensorEvents to frontend via EventBus
+            self._event_bus.trigger_event(
+                SensorEvent(
+                    entity_id=f"{self._id}_flow",
+                    state=SensorState(
+                        id=f"{self._id}_flow",
+                        name=f"{self._name} Flow Rate",
+                        state=self.get_current_flow_rate(),
+                        unit="L/h",
+                        timestamp=timestamp,
+                    ),
+                )
+            )
+            self._event_bus.trigger_event(
+                SensorEvent(
+                    entity_id=f"{self._id}_water",
+                    state=SensorState(
+                        id=f"{self._id}_water",
+                        name=f"{self._name} Water",
+                        state=self.get_total_water(),
+                        unit="L",
+                        timestamp=timestamp,
+                    ),
+                )
+            )
+
+        self._message_bus.send_message(
+            topic=self._sensor_topic,
+            payload=payload,
+            retain=True,
+        )
+        _LOGGER.debug("Sent state for %s: %s", self._id, payload)