juham-automation 0.0.12__py3-none-any.whl → 0.2.11__py3-none-any.whl

juham_automation/automation/leakdetector.py

@@ -0,0 +1,162 @@
+"""
+Leak Detector based on Motion Detection and Water Meter Monitoring.
+
+This class listens to water meter and motion sensor topics to detect potential water leaks.
+If a leak is detected, the system triggers a leak alarm.
+"""
+import json
+from datetime import datetime
+from typing import Any
+from typing_extensions import override
+from masterpiece.mqtt import MqttMsg
+from juham_core.timeutils import timestamp
+from juham_core import Juham
+
+
+class LeakDetector(Juham):
+    """
+    Water Leak Detector Class
+
+    Listens to water meter and motion sensor topics to identify potential water leaks.
+    If water consumption is detected without corresponding motion, or if water usage
+    remains constant for prolonged periods, a leak alarm is triggered.
+
+    Detection considers the time since the last motion detection and compares it to
+    the configured leak detection period, which is the maximum runtime of water-consuming
+    appliances.
+    """
+
+    _LEAKDETECTOR: str = "leakdetector"
+    _LEAKDETECTOR_ATTRS: list[str] = [
+        "watermeter_topic",
+        "motion_topic",
+        "motion_last_detected_ts",
+    ]
+
+    watermeter_topic: str = "watermeter"
+    motion_topic: str = "motion"
+    leak_detection_period: float = (
+        3 * 3600.0
+    )  # Maximum runtime for appliances, in seconds
+    location: str = "home"
+    conseq_zero_periods: int = (
+        60  # this many subsequent zero flow reports imply no leak
+    )
+
+    def __init__(self, name: str = "leakdetector") -> None:
+        """
+        Initialize the leak detector.
+
+        Args:
+            name (str, optional): Name of the detector instance. Defaults to "leakdetector".
+        """
+        super().__init__(name)
+        self.motion_last_detected_ts: float = timestamp()
+        self.watermeter_full_topic: str = self.make_topic_name(self.watermeter_topic)
+        self.motion_full_topic: str = self.make_topic_name(self.motion_topic)
+        self.leak_detected: bool = False
+        self.zero_usage_periods_count: int = 0
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        """
+        Handle MQTT connection. Subscribe to water meter and motion topics.
+        """
+        super().on_connect(client, userdata, flags, rc)
+        if rc == 0:
+            self.subscribe(self.watermeter_full_topic)
+            self.subscribe(self.motion_full_topic)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        """
+        Process incoming MQTT messages for water meter and motion topics.
+        """
+        payload = json.loads(msg.payload.decode())
+        if msg.topic == self.watermeter_full_topic:
+            self.process_water_meter_data(payload)
+        elif msg.topic == self.motion_full_topic:
+            self.process_motion_data(payload)
+        else:
+            super().on_message(client, userdata, msg)
+
+    def detect_activity(self, current_ts: float) -> bool:
+        """
+        Check if activity (motion) has been detected within the leak detection period.
+
+        Args:
+            current_ts (float): Current timestamp.
+
+        Returns:
+            bool: True if activity detected within the period, False otherwise.
+        """
+        elapsed_time = current_ts - self.motion_last_detected_ts
+        return elapsed_time < self.leak_detection_period
+
+    def publish_leak_status(self, current_ts: float, leak_suspected: bool) -> None:
+        """
+        Publish the leak detection status.
+
+        Args:
+            current_ts (float): Current timestamp.
+            leak_suspected (bool): Whether a leak is suspected.
+        """
+        status : dict[str, Any] = {
+            "location": self.location,
+            "sensor": self.name,
+            "leak_suspected": leak_suspected,
+            "ts": current_ts,
+        }
+        payload = json.dumps(status)
+        self.publish(self.watermeter_full_topic, payload, qos=1, retain=False)
+
+    def process_water_meter_data(self, data: dict[str, float]) -> None:
+        """
+        Handle water meter data and apply leak detection logic.
+
+        Args:
+            data (dict): Water meter data containing flow rate and timestamp.
+        """
+        if "active_lpm" in data and "ts" in data:
+            flow_rate = data["active_lpm"]
+            current_ts = data["ts"]
+
+            if flow_rate > 0.0:
+                if not self.detect_activity(current_ts):
+                    if not self.leak_detected:
+                        self.leak_detected = True
+                        readable :str = datetime.fromtimestamp(self.motion_last_detected_ts).strftime("%Y-%m-%d %H:%M:%S")
+                        self.warning(f"LEAK SUSPECT", f"Flow {flow_rate} lpm, last detected motion {readable}")
+
+                self.zero_usage_periods_count = 0
+            else:
+                self.zero_usage_periods_count += 1
+                if self.zero_usage_periods_count > self.conseq_zero_periods:
+                    self.leak_detected = False
+                    self.motion_last_detected_ts = current_ts
+            self.publish_leak_status(current_ts, self.leak_detected)
+
+    def process_motion_data(self, data: dict[str, float]) -> None:
+        """
+        Update the last detected motion timestamp.
+
+        Args:
+            data (dict): Motion sensor data containing timestamp.
+        """
+        if "motion" in data and data["motion"]:
+            self.motion_last_detected_ts = data["ts"]
+
+    @override
+    def to_dict(self) -> dict[str, Any]:
+        data = super().to_dict()
+        attributes = {attr: getattr(self, attr) for attr in self._LEAKDETECTOR_ATTRS}
+        data[self._LEAKDETECTOR] = attributes
+        return data
+
+    @override
+    def from_dict(self, data: dict[str, Any]) -> None:
+        super().from_dict(data)
+        if self._LEAKDETECTOR in data:
+            attributes = data[self._LEAKDETECTOR]
+            for attr in self._LEAKDETECTOR_ATTRS:
+                setattr(self, attr, attributes.get(attr, None))

juham_automation/automation/watercirculator.py

@@ -33,7 +33,7 @@ class WaterCirculator(Juham):
 
     """
 
-    uptime = 60 * 60  # one hour
+    uptime = 1800  # half an hour
     min_temperature = 37
 
     def __init__(self, name: str, temperature_sensor: str) -> None:
@@ -84,9 +84,6 @@ class WaterCirculator(Juham):
 
         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.
@@ -103,14 +100,9 @@ class WaterCirculator(Juham):
         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
@@ -122,10 +114,6 @@ class WaterCirculator(Juham):
             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
@@ -139,15 +127,8 @@ class WaterCirculator(Juham):
                     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.

juham_automation/japp.py

@@ -1,3 +1,4 @@
+from juham_automation.automation.energybalancer import EnergyBalancer
 from masterpiece import Application
 from juham_core import Juham
 
@@ -5,10 +6,10 @@ 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
 
 
@@ -38,10 +39,11 @@ class JApp(Application):
         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:

juham_automation/ts/__init__.py

@@ -2,7 +2,7 @@
 Description
 ===========
 
-Juham - Juha's Ultimate Home Automation Timeseries 
+Time series recorders for Juha's Ultimate Home Automation classes.
 
 """
 
@@ -13,6 +13,7 @@ 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",
@@ -22,4 +23,5 @@ __all__ = [
     "PowerPlanTs",
     "PowerMeterTs",
     "ElectricityPriceTs",
+    "EnergyBalancerTs",
 ]

juham_automation/ts/electricityprice_ts.py

@@ -32,7 +32,7 @@ class ElectricityPriceTs(JuhamTs):
             super().on_message(client, userdata, msg)
 
     def on_spot(self, m: dict[Any, Any]) -> None:
-        """Write hourly spot electricity prices to time series database.
+        """Write spot electricity prices to time series database.
 
         Args:
             m (dict): holding hourlys spot electricity prices

juham_automation/ts/energybalancer_ts.py

@@ -0,0 +1,73 @@
+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):
+    """Record energy balance data to time series database.
+
+    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_in_status = self.make_topic_name("energybalance/status")
+        self.topic_in_diagnostics = self.make_topic_name("energybalance/diagnostics")
+
+    @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.topic_in_status)
+            self.subscribe(self.topic_in_diagnostics)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        if msg.topic == self.topic_in_status:
+            self.on_status(json.loads(msg.payload.decode()))
+        elif msg.topic == self.topic_in_diagnostics:
+            self.on_diagnostics(json.loads(msg.payload.decode()))
+        else:
+            super().on_message(client, userdata, msg)
+
+    def on_status(self, m: dict[str, Any]) -> None:
+        """Handle energybalance message.
+        Args:
+            m (dict[str, Any]): Message from energybalance topic.
+        """
+        if not "Power" in m or not "Timestamp" in m:
+            self.error(f"INVALID STATUS msg {m}")            
+            return
+        point = (
+            self.measurement("energybalance")
+            .tag("Unit", m["Unit"])
+            .field("Mode", m["Mode"])
+            .field("Power", float(m["Power"]))
+            .time(epoc2utc(m["Timestamp"]))
+        )
+        self.write(point)
+
+    def on_diagnostics(self, m: dict[str, Any]) -> None:
+        """Handle energybalance diagnostics.
+        Args:
+            m (dict[str, Any]): Message from energybalance topic.
+        """
+        if not "Timestamp" in m:
+            self.error(f"INVALID DIAGNOSTICS msg {m}")
+            return
+        point = (
+            self.measurement("energybalance")
+            .tag("EnergyBalancer", m["EnergyBalancer"])
+            .field("CurrentBalance", m["CurrentBalance"])
+            .field("NeededBalance", m["NeededBalance"])
+            .time(epoc2utc(m["Timestamp"]))
+        )
+        self.write(point)

juham_automation/ts/energycostcalculator_ts.py

@@ -26,10 +26,12 @@ class EnergyCostCalculatorTs(JuhamTs):
 
     @override
     def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
-        super().on_message(client, userdata, msg)
         if msg.topic == self.topic_net_energy_balance:
             m = json.loads(msg.payload.decode())
             self.record_powerconsumption(m)
+        else:
+            super().on_message(client, userdata, msg)
+
 
     def record_powerconsumption(self, m: dict[str, Any]) -> None:
         """Record powerconsumption

juham_automation/ts/log_ts.py

@@ -39,19 +39,22 @@ class LogTs(JuhamTs):
 
     @override
     def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
-        m = json.loads(msg.payload.decode())
-        ts = epoc2utc(m["Timestamp"])
-
-        point = (
-            self.measurement("log")
-            .tag("class", m["Class"])
-            .field("source", m["Source"])
-            .field("msg", m["Msg"])
-            .field("details", m["Details"])
-            .field("Timestamp", m["Timestamp"])
-            .time(ts)
-        )
-        try:
-            self.write(point)
-        except Exception as e:
-            self.log_message("Error", f"Cannot write log event {m['Msg']}", str(e))
+        if msg.topic == self.topic_name:
+            m = json.loads(msg.payload.decode())
+            ts = epoc2utc(m["Timestamp"])
+
+            point = (
+                self.measurement("log")
+                .tag("class", m["Class"])
+                .field("source", m["Source"])
+                .field("msg", m["Msg"])
+                .field("details", m["Details"])
+                .field("Timestamp", m["Timestamp"])
+                .time(ts)
+            )
+            try:
+                self.write(point)
+            except Exception as e:
+                print(f"ERROR: Cannot write log event {m['Msg']} {e}")
+        else:
+            super().on_message(client, userdata, msg)

juham_automation/ts/power_ts.py

@@ -33,17 +33,20 @@ class PowerTs(JuhamTs):
 
         This method is called upon new arrived message.
         """
-
-        m = json.loads(msg.payload.decode())
-        if not "Unit" in m:
-            return
-        unit = m["Unit"]
-        ts = m["Timestamp"]
-        state = m["State"]
-        point = (
-            self.measurement("power")
-            .tag("unit", unit)
-            .field("state", state)
-            .time(epoc2utc(ts))
-        )
-        self.write(point)
+        if msg.topic == self.topic_name:
+            m = json.loads(msg.payload.decode())
+            if not "Unit" in m:
+                return
+            unit = m["Unit"]
+            ts = m["Timestamp"]
+            state = m["State"]
+            point = (
+                self.measurement("power")
+                .tag("unit", unit)
+                .field("state", state)
+                .time(epoc2utc(ts))
+            )
+            self.write(point)
+        else:
+            super().on_message(client, userdata, msg)
+            

juham_automation/ts/powermeter_ts.py

@@ -26,11 +26,12 @@ class PowerMeterTs(JuhamTs):
 
     @override
     def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
-        super().on_message(client, userdata, msg)
         if msg.topic == self.power_topic:
             m = json.loads(msg.payload.decode())
             self.record_power(m)
-
+        else:
+            super().on_message(client, userdata, msg)
+            
     def record_power(self, em: dict[str, Any]) -> None:
         """Write from the power (energy) meter to the time
         series database accordingly.
@@ -50,9 +51,6 @@ class PowerMeterTs(JuhamTs):
         )
         try:
             self.write(point)
-            # self.debug(
-            #    f"PowerMeter event recorded {epoc2utc(em['timestamp'])} - {em['real_a']} {em['real_b']} {em['real_c']}"
-            # )
         except Exception as e:
             self.error(f"Writing to influx failed {str(e)}")
 

juham_automation/ts/powerplan_ts.py

@@ -25,21 +25,40 @@ class PowerPlanTs(JuhamTs):
 
     @override
     def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
-        super().on_message(client, userdata, msg)
-        m = json.loads(msg.payload.decode())
-        schedule = m["Schedule"]
-        uoi = m["UOI"]
-        ts = m["Timestamp"]
-
-        point = (
-            self.measurement("powerplan")
-            .tag("unit", m["Unit"])
-            .field("state", m["State"])  # 1 on, 0 off
-            .field("name", m["Unit"])  # e.g main_boiler
-            .field("type", "C")  # C=consumption, S = supply
-            .field("power", 16.0)  # kW
-            .field("Schedule", schedule)  # figures of merit
-            .field("UOI", float(uoi))  # Utilitzation Optimizing Index
-            .time(epoc2utc(ts))
-        )
-        self.write(point)
+        if msg.topic == self.powerplan_topic:
+            m = json.loads(msg.payload.decode())
+            schedule = m["Schedule"]
+            uoi = m["UOI"]
+            ts = m["Timestamp"]
+            
+            # optional fields
+            tempForecast = m.get("NextDayTemperature")
+            solarForecast = m.get("NextDaySolarpower")
+            minTemp  = m.get("MinTempLimit")
+            maxTemp  = m.get("MaxTempLimit")
+
+            point = (
+                self.measurement("powerplan")
+                .tag("unit", m["Unit"])
+                .field("state", m["State"])  # 1 on, 0 off
+                .field("name", m["Unit"])  # e.g main_boiler
+                .field("type", "C")  # C=consumption, S = supply
+                .field("power", 16.0)  # kW
+                .field("Schedule", schedule)  # figures of merit
+                .field("UOI", float(uoi))  # Utilitzation Optimizing Index
+                .time(epoc2utc(ts))
+            )
+
+            # Add optional fields only if they are present in the message
+            if minTemp is not None:
+                point = point.field("MinTemp", float(minTemp))
+            if maxTemp is not None:
+                point = point.field("MaxTemp", float(maxTemp))
+            if tempForecast is not None:
+                point = point.field("TempForecast", float(tempForecast))
+            if solarForecast is not None:
+                point = point.field("SolarForecast", float(solarForecast))
+
+            self.write(point)
+        else:
+            super().on_message(client, userdata, msg)