juham-automation 0.0.17__py3-none-any.whl → 0.0.26__py3-none-any.whl

juham_automation/automation/watercirculator.py

@@ -1,159 +1,159 @@
-from typing import Any
-from typing_extensions import override
-import json
-
-from masterpiece.mqtt import MqttMsg
-from juham_core import Juham
-from juham_core.timeutils import timestamp
-
-
-class WaterCirculator(Juham):
-    """Hot Water Circulation Automation
-
-    This system monitors motion sensor data to detect home occupancy.
-
-    - **When motion is detected**: The water circulator pump is activated, ensuring hot water is
-        instantly available when the tap is turned on.
-    - **When no motion is detected for a specified period (in seconds)**: The pump automatically
-        switches off to conserve energy.
-
-    Future improvement idea
-    ------------------------
-
-    In cold countries, such as Finland, energy conservation during the winter season may not be a priority.
-    In this case, an additional temperature sensor measuring the outside temperature could be used to determine whether
-    the circulator should be switched off at all. The circulating water could potentially act as an additional heating radiator.
-
-    Points to consider
-    ------------------
-
-    - Switching the pump on and off may affect its lifetime.
-    - Keeping the pump running with hot water could impact the lifespan of the pipes, potentially causing
-      corrosion due to constant hot water flow.
-
-    """
-
-    uptime = 60 * 60  # one hour
-    min_temperature = 37
-
-    def __init__(self, name: str, temperature_sensor: str) -> None:
-        super().__init__(name)
-
-        # input topics
-        self.motion_topic = self.make_topic_name("motion")  # motion detection
-        self.temperature_topic = self.make_topic_name(temperature_sensor)
-
-        # relay to be controlled
-        self.topic_power = self.make_topic_name("power")
-
-        # for the pump controlling logic
-        self.current_motion: bool = False
-        self.relay_started_ts: float = 0
-        self.water_temperature: float = 0
-        self.water_temperature_updated: float = 0
-        self.initialized = False
-
-    @override
-    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
-        super().on_connect(client, userdata, flags, rc)
-        if rc == 0:
-            self.subscribe(self.motion_topic)
-            self.subscribe(self.temperature_topic)
-            # reset the relay to make sure the initial state matches the state of us
-            self.publish_relay_state(0)
-
-    @override
-    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
-        if msg.topic == self.temperature_topic:
-            m = json.loads(msg.payload.decode())
-            self.on_temperature_sensor(m, timestamp())
-        elif msg.topic == self.motion_topic:
-            m = json.loads(msg.payload.decode())
-            self.on_motion_sensor(m, timestamp())
-        else:
-            super().on_message(client, userdata, msg)
-
-    def on_temperature_sensor(self, m: dict[str, Any], ts_utc_now: float) -> None:
-        """Handle message from the hot water pipe temperature sensor.
-        Records the temperature and updates the water_temperature_updated attribute.
-
-        Args:
-            m (dict): temperature reading from the hot water blump sensor
-            ts_utc_now (float): _current utc time
-        """
-
-        self.water_temperature = m["temperature"]
-        self.water_temperature_updated = ts_utc_now
-        # self.info(
-        #    f"Temperature of circulating water updated to {self.water_temperature} C"
-        # )
-
-    def on_motion_sensor(self, m: dict[str, dict[str, Any]], ts_utc_now: float) -> None:
-        """Control the water cirulator bump.
-
-        Given message from the motion sensor consider switching the
-        circulator bump on.
-
-        Args:
-            msg (dict): directionary holding motion sensor data
-            ts_utc_now (float): current time stamp
-        """
-        sensor = m["sensor"]
-        vibration: bool = bool(m["vibration"])
-        motion: bool = bool(m["motion"])
-
-        if motion or vibration:
-            # self.debug(f"Life form detected in {sensor}")
-            # honey I'm home
-            if not self.current_motion:
-                if self.water_temperature > self.min_temperature:
-                    self.publish_relay_state(0)
-                    # self.debug(
-                    #    f"Circulator: motion detected but water warm already {self.water_temperature} > {self.min_temperature} C"
-                    # )
-                else:
-                    self.current_motion = True
-                    self.relay_started_ts = ts_utc_now
-                    self.publish_relay_state(1)
-                    self.initialized = True
-                    self.info(
-                        f"Circulator pump started, will run for {int(self.uptime / 60)} minutes "
-                    )
-            else:
-                self.publish_relay_state(1)
-                self.relay_started_ts = ts_utc_now
-                # self.debug(
-                #    f"Circulator pump has been running for {int(ts_utc_now - self.relay_started_ts)/60} minutes",
-                #    " ",
-                # )
-        else:
-            if self.current_motion or not self.initialized:
-                elapsed: float = ts_utc_now - self.relay_started_ts
-                if elapsed > self.uptime:
-                    self.publish_relay_state(0)
-                    self.info(
-                        f"Circulator  pump stopped, no motion in {int(elapsed/60)} minutes detected",
-                        "",
-                    )
-                    self.current_motion = False
-                    self.initialized = True
-                else:
-                    self.publish_relay_state(1)
-                    # self.debug(
-                    #    f"Circulator bump stop countdown {int(self.uptime - (ts_utc_now - self.relay_started_ts ))/60} min"
-                    # )
-            else:
-                self.publish_relay_state(0)
-                # self.debug(
-                #    f"Circulator bump off already, temperature {self.water_temperature} C",
-                #    "",
-                # )
-
-    def publish_relay_state(self, state: int) -> None:
-        """Publish power status.
-
-        Args:
-            state (int): 1 for on, 0 for off, as defined by Juham 'power' topic
-        """
-        heat = {"Unit": self.name, "Timestamp": timestamp(), "State": state}
-        self.publish(self.topic_power, json.dumps(heat), 1, False)
+from typing import Any
+from typing_extensions import override
+import json
+
+from masterpiece.mqtt import MqttMsg
+from juham_core import Juham
+from juham_core.timeutils import timestamp
+
+
+class WaterCirculator(Juham):
+    """Hot Water Circulation Automation
+
+    This system monitors motion sensor data to detect home occupancy.
+
+    - **When motion is detected**: The water circulator pump is activated, ensuring hot water is
+        instantly available when the tap is turned on.
+    - **When no motion is detected for a specified period (in seconds)**: The pump automatically
+        switches off to conserve energy.
+
+    Future improvement idea
+    ------------------------
+
+    In cold countries, such as Finland, energy conservation during the winter season may not be a priority.
+    In this case, an additional temperature sensor measuring the outside temperature could be used to determine whether
+    the circulator should be switched off at all. The circulating water could potentially act as an additional heating radiator.
+
+    Points to consider
+    ------------------
+
+    - Switching the pump on and off may affect its lifetime.
+    - Keeping the pump running with hot water could impact the lifespan of the pipes, potentially causing
+      corrosion due to constant hot water flow.
+
+    """
+
+    uptime = 60 * 60  # one hour
+    min_temperature = 37
+
+    def __init__(self, name: str, temperature_sensor: str) -> None:
+        super().__init__(name)
+
+        # input topics
+        self.motion_topic = self.make_topic_name("motion")  # motion detection
+        self.temperature_topic = self.make_topic_name(temperature_sensor)
+
+        # relay to be controlled
+        self.topic_power = self.make_topic_name("power")
+
+        # for the pump controlling logic
+        self.current_motion: bool = False
+        self.relay_started_ts: float = 0
+        self.water_temperature: float = 0
+        self.water_temperature_updated: float = 0
+        self.initialized = False
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        super().on_connect(client, userdata, flags, rc)
+        if rc == 0:
+            self.subscribe(self.motion_topic)
+            self.subscribe(self.temperature_topic)
+            # reset the relay to make sure the initial state matches the state of us
+            self.publish_relay_state(0)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        if msg.topic == self.temperature_topic:
+            m = json.loads(msg.payload.decode())
+            self.on_temperature_sensor(m, timestamp())
+        elif msg.topic == self.motion_topic:
+            m = json.loads(msg.payload.decode())
+            self.on_motion_sensor(m, timestamp())
+        else:
+            super().on_message(client, userdata, msg)
+
+    def on_temperature_sensor(self, m: dict[str, Any], ts_utc_now: float) -> None:
+        """Handle message from the hot water pipe temperature sensor.
+        Records the temperature and updates the water_temperature_updated attribute.
+
+        Args:
+            m (dict): temperature reading from the hot water blump sensor
+            ts_utc_now (float): _current utc time
+        """
+
+        self.water_temperature = m["temperature"]
+        self.water_temperature_updated = ts_utc_now
+        # self.info(
+        #    f"Temperature of circulating water updated to {self.water_temperature} C"
+        # )
+
+    def on_motion_sensor(self, m: dict[str, dict[str, Any]], ts_utc_now: float) -> None:
+        """Control the water cirulator bump.
+
+        Given message from the motion sensor consider switching the
+        circulator bump on.
+
+        Args:
+            msg (dict): directionary holding motion sensor data
+            ts_utc_now (float): current time stamp
+        """
+        sensor = m["sensor"]
+        vibration: bool = bool(m["vibration"])
+        motion: bool = bool(m["motion"])
+
+        if motion or vibration:
+            # self.debug(f"Life form detected in {sensor}")
+            # honey I'm home
+            if not self.current_motion:
+                if self.water_temperature > self.min_temperature:
+                    self.publish_relay_state(0)
+                    # self.debug(
+                    #    f"Circulator: motion detected but water warm already {self.water_temperature} > {self.min_temperature} C"
+                    # )
+                else:
+                    self.current_motion = True
+                    self.relay_started_ts = ts_utc_now
+                    self.publish_relay_state(1)
+                    self.initialized = True
+                    self.info(
+                        f"Circulator pump started, will run for {int(self.uptime / 60)} minutes "
+                    )
+            else:
+                self.publish_relay_state(1)
+                self.relay_started_ts = ts_utc_now
+                # self.debug(
+                #    f"Circulator pump has been running for {int(ts_utc_now - self.relay_started_ts)/60} minutes",
+                #    " ",
+                # )
+        else:
+            if self.current_motion or not self.initialized:
+                elapsed: float = ts_utc_now - self.relay_started_ts
+                if elapsed > self.uptime:
+                    self.publish_relay_state(0)
+                    self.info(
+                        f"Circulator  pump stopped, no motion in {int(elapsed/60)} minutes detected",
+                        "",
+                    )
+                    self.current_motion = False
+                    self.initialized = True
+                else:
+                    self.publish_relay_state(1)
+                    # self.debug(
+                    #    f"Circulator bump stop countdown {int(self.uptime - (ts_utc_now - self.relay_started_ts ))/60} min"
+                    # )
+            else:
+                self.publish_relay_state(0)
+                # self.debug(
+                #    f"Circulator bump off already, temperature {self.water_temperature} C",
+                #    "",
+                # )
+
+    def publish_relay_state(self, state: int) -> None:
+        """Publish power status.
+
+        Args:
+            state (int): 1 for on, 0 for off, as defined by Juham 'power' topic
+        """
+        heat = {"Unit": self.name, "Timestamp": timestamp(), "State": state}
+        self.publish(self.topic_power, json.dumps(heat), 1, False)

juham_automation/japp.py

@@ -1,49 +1,53 @@
-from masterpiece import Application
-from juham_core import Juham
-
-from .ts import ForecastTs
-from .ts import PowerTs
-from .ts import PowerPlanTs
-from .ts import PowerMeterTs
-from .ts import LogTs
-from .ts import EnergyCostCalculatorTs
-from .ts import ElectricityPriceTs
-from .automation import SpotHintaFi
-from .automation import EnergyCostCalculator
-
-
-class JApp(Application):
-    """Juham home automation application base class. Registers new plugin
-    group 'juham' on which general purpose Juham plugins can be written on.
-    """
-
-    def __init__(self, name: str) -> None:
-        """Creates home automation application with the given name.
-        If --enable_plugins is False create hard coded configuration
-        by calling instantiate_classes() method.
-
-        Args:
-            name (str): name for the application
-        """
-        super().__init__(name, Juham(name))
-
-    def instantiate_classes(self) -> None:
-        """Instantiate automation classes .
-
-        Returns:
-            None
-        """
-        self.add(ForecastTs())
-        self.add(PowerTs())
-        self.add(PowerPlanTs())
-        self.add(PowerMeterTs())
-        self.add(LogTs())
-        self.add(SpotHintaFi())
-        self.add(EnergyCostCalculator())
-        self.add(EnergyCostCalculatorTs())
-        self.add(ElectricityPriceTs())
-
-    @classmethod
-    def register(cls) -> None:
-        """Register plugin group `juham`."""
-        Application.register_plugin_group("juham")
+from juham_automation.automation.energybalancer import EnergyBalancer
+from masterpiece import Application
+from juham_core import Juham
+
+from .ts import ForecastTs
+from .ts import PowerTs
+from .ts import PowerPlanTs
+from .ts import PowerMeterTs
+from .ts import EnergyBalancerTs
+from .ts import LogTs
+from .ts import EnergyCostCalculatorTs
+from .ts import ElectricityPriceTs
+from .automation import SpotHintaFi
+from .automation import EnergyCostCalculator
+
+
+class JApp(Application):
+    """Juham home automation application base class. Registers new plugin
+    group 'juham' on which general purpose Juham plugins can be written on.
+    """
+
+    def __init__(self, name: str) -> None:
+        """Creates home automation application with the given name.
+        If --enable_plugins is False create hard coded configuration
+        by calling instantiate_classes() method.
+
+        Args:
+            name (str): name for the application
+        """
+        super().__init__(name, Juham(name))
+
+    def instantiate_classes(self) -> None:
+        """Instantiate automation classes .
+
+        Returns:
+            None
+        """
+        self.add(ForecastTs())
+        self.add(PowerTs())
+        self.add(PowerPlanTs())
+        self.add(PowerMeterTs())
+        self.add(LogTs())
+        self.add(SpotHintaFi())
+        self.add(EnergyCostCalculator())
+        self.add(EnergyCostCalculatorTs())
+        self.add(ElectricityPriceTs())
+        self.add(EnergyBalancer())
+        self.add(EnergyBalancerTs())
+
+    @classmethod
+    def register(cls) -> None:
+        """Register plugin group `juham`."""
+        Application.register_plugin_group("juham")

juham_automation/ts/__init__.py

@@ -1,25 +1,27 @@
-"""
-Description
-===========
-
-Juham - Juha's Ultimate Home Automation Timeseries 
-
-"""
-
-from .energycostcalculator_ts import EnergyCostCalculatorTs
-from .log_ts import LogTs
-from .power_ts import PowerTs
-from .powerplan_ts import PowerPlanTs
-from .powermeter_ts import PowerMeterTs
-from .electricityprice_ts import ElectricityPriceTs
-from .forecast_ts import ForecastTs
-
-__all__ = [
-    "EnergyCostCalculatorTs",
-    "ForecastTs",
-    "LogTs",
-    "PowerTs",
-    "PowerPlanTs",
-    "PowerMeterTs",
-    "ElectricityPriceTs",
-]
+"""
+Description
+===========
+
+Time series recorders for Juha's Ultimate Home Automation classes.
+
+"""
+
+from .energycostcalculator_ts import EnergyCostCalculatorTs
+from .log_ts import LogTs
+from .power_ts import PowerTs
+from .powerplan_ts import PowerPlanTs
+from .powermeter_ts import PowerMeterTs
+from .electricityprice_ts import ElectricityPriceTs
+from .forecast_ts import ForecastTs
+from .energybalancer_ts import EnergyBalancerTs
+
+__all__ = [
+    "EnergyCostCalculatorTs",
+    "ForecastTs",
+    "LogTs",
+    "PowerTs",
+    "PowerPlanTs",
+    "PowerMeterTs",
+    "ElectricityPriceTs",
+    "EnergyBalancerTs",
+]

juham_automation/ts/electricityprice_ts.py

@@ -1,51 +1,51 @@
-from datetime import datetime
-import time
-import json
-from typing import Any, Dict, Optional, cast
-from typing_extensions import override
-
-from masterpiece.mqtt import Mqtt, MqttMsg
-from juham_core.timeutils import epoc2utc
-from juham_core import JuhamTs
-
-
-class ElectricityPriceTs(JuhamTs):
-    """Spot electricity price for reading hourly electricity prices from"""
-
-    def __init__(self, name: str = "electricityprice_ts") -> None:
-        super().__init__(name)
-
-        self.spot_topic = self.make_topic_name("spot")
-
-    @override
-    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
-        super().on_connect(client, userdata, flags, rc)
-        if rc == 0:
-            self.subscribe(self.spot_topic)
-
-    @override
-    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
-        if msg.topic == self.spot_topic:
-            em = json.loads(msg.payload.decode())
-            self.on_spot(em)
-        else:
-            super().on_message(client, userdata, msg)
-
-    def on_spot(self, m: dict[Any, Any]) -> None:
-        """Write hourly spot electricity prices to time series database.
-
-        Args:
-            m (dict): holding hourlys spot electricity prices
-        """
-        grid_cost : float
-        for h in m:
-            if "GridCost" in h:
-                grid_cost = h["GridCost"]
-                point = (
-                    self.measurement("spot")
-                    .tag("hour", h["Timestamp"])
-                    .field("value", h["PriceWithTax"])
-                    .field("grid", grid_cost)
-                    .time(epoc2utc(h["Timestamp"]))
-                )
-                self.write(point)
+from datetime import datetime
+import time
+import json
+from typing import Any, Dict, Optional, cast
+from typing_extensions import override
+
+from masterpiece.mqtt import Mqtt, MqttMsg
+from juham_core.timeutils import epoc2utc
+from juham_core import JuhamTs
+
+
+class ElectricityPriceTs(JuhamTs):
+    """Spot electricity price for reading hourly electricity prices from"""
+
+    def __init__(self, name: str = "electricityprice_ts") -> None:
+        super().__init__(name)
+
+        self.spot_topic = self.make_topic_name("spot")
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        super().on_connect(client, userdata, flags, rc)
+        if rc == 0:
+            self.subscribe(self.spot_topic)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        if msg.topic == self.spot_topic:
+            em = json.loads(msg.payload.decode())
+            self.on_spot(em)
+        else:
+            super().on_message(client, userdata, msg)
+
+    def on_spot(self, m: dict[Any, Any]) -> None:
+        """Write hourly spot electricity prices to time series database.
+
+        Args:
+            m (dict): holding hourlys spot electricity prices
+        """
+        grid_cost : float
+        for h in m:
+            if "GridCost" in h:
+                grid_cost = h["GridCost"]
+                point = (
+                    self.measurement("spot")
+                    .tag("hour", h["Timestamp"])
+                    .field("value", h["PriceWithTax"])
+                    .field("grid", grid_cost)
+                    .time(epoc2utc(h["Timestamp"]))
+                )
+                self.write(point)

juham_automation/ts/energybalancer_ts.py

@@ -0,0 +1,47 @@
+import json
+from typing import Any
+from typing_extensions import override
+
+from masterpiece.mqtt import MqttMsg
+
+from juham_core import JuhamTs
+from juham_core.timeutils import epoc2utc
+
+
+class EnergyBalancerTs(JuhamTs):
+    """Heating optimizer diagnosis.
+
+    This class listens the "energybalance" MQTT topic and records the
+    messages to time series database.
+    """
+
+    def __init__(self, name: str = "energybalancer_ts") -> None:
+        """Construct record object with the given name."""
+
+        super().__init__(name)
+        self.topic_name = self.make_topic_name("energybalance")
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        super().on_connect(client, userdata, flags, rc)
+        self.subscribe(self.topic_name)
+        self.debug(f"Subscribed to {self.topic_name}")
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        """Standard mqtt message notification method.
+
+        This method is called upon new arrived message.
+        """
+
+        m = json.loads(msg.payload.decode())
+        point = (
+            self.measurement("energybalance")
+            .tag("Unit", m["Unit"])
+            .field("Mode", m["Mode"])
+            .field("Rc", m["Rc"])
+            .field("CurrentBalance", m["CurrentBalance"])
+            .field("NeededBalance", m["NeededBalance"])
+            .time(epoc2utc(m["Timestamp"]))
+        )
+        self.write(point)