juham-automation 0.0.29__tar.gz → 0.0.31__tar.gz

{juham_automation-0.0.29/juham_automation.egg-info → juham_automation-0.0.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: juham-automation
-Version: 0.0.29
+Version: 0.0.31
 Summary: Juha's Ultimate Home Automation Masterpiece
 Author-email: J Meskanen <juham.api@gmail.com>
 Maintainer-email: "J. Meskanen" <juham.api@gmail.com>

{juham_automation-0.0.29 → juham_automation-0.0.31}/juham_automation/automation/energybalancer.py

@@ -6,6 +6,27 @@ from juham_core import Juham, timestamp
 from masterpiece import MqttMsg
 
 
+class Consumer:
+    """Class representing a consumer.
+
+    This class is used to represent a consumer in the energy balancer.
+    It contains the name of the consumer and its power consumption.
+
+    """
+
+    def __init__(self, name: str, power) -> None:
+        """Initialize the consumer
+
+        Args:
+            name (str): name of the consumer
+            power (float): power of the consumer in watts
+        """
+        self.name = name
+        self.power: float = power
+        self.start: float = 0.0
+        self.stop: float = 0.0
+
+
 class EnergyBalancer(Juham):
     """The energy balancer monitors the balance between produced and consumed energy
     within the balancing interval to determine if there is enough energy available for
@@ -19,6 +40,8 @@ class EnergyBalancer(Juham):
 
     The energy balancer is used in conjunction with a power meter that reads
     the total power consumption of the house. The energy balancer uses the power meter
+
+
     """
 
     #: Description of the attribute
@@ -34,28 +57,29 @@ class EnergyBalancer(Juham):
         """
         super().__init__(name)
 
-        self.topic_in_consumers = self.make_topic_name("energybalance_consumers")
-        self.topic_in_net_energy_balance = self.make_topic_name("net_energy_balance")
-        self.topic_out_energybalance = self.make_topic_name("energybalance")
+        self.topic_in_consumers = self.make_topic_name("energybalance/consumers")
+        self.topic_out_status = self.make_topic_name("energybalance/status")
+        self.topic_out_diagnostics = self.make_topic_name("energybalance/diagnostics")
+        self.topic_in_power = self.make_topic_name("net_energy_balance")
+
         self.net_energy_balance: float = 0.0  # Energy balance in joules (watt-seconds)
         self.current_interval_ts: float = -1
         self.needed_energy: float = 0.0  # Energy needed in joules (watt-seconds)
         self.net_energy_balancing_mode: bool = False
-        self.consumers: dict[str, float] = {}
-        self.active_consumers: dict[str, dict[float, float]] = {}
+        self.consumers: dict[str, Consumer] = {}
 
     @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_net_energy_balance)
+            self.subscribe(self.topic_in_power)
             self.subscribe(self.topic_in_consumers)
 
     @override
     def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
         ts: float = timestamp()
 
-        if msg.topic == self.topic_in_net_energy_balance:
+        if msg.topic == self.topic_in_power:
             self.on_power(json.loads(msg.payload.decode()), ts)
         elif msg.topic == self.topic_in_consumers:
             self.on_consumer(json.loads(msg.payload.decode()))
@@ -78,7 +102,7 @@ class EnergyBalancer(Juham):
             m (dict[str, Any]): power consumer message
             ts (float): current time
         """
-        self.consumers[m["Unit"]] = m["Power"]
+        self.consumers[m["Unit"]] = Consumer(m["Unit"], m["Power"])
         self.info(f"Consumer {m['Unit']} added, power: {m['Power']}")
 
     def update_energy_balance(self, power: float, ts: float) -> None:
@@ -97,6 +121,7 @@ class EnergyBalancer(Juham):
         """
 
         # regardless of the mode, if we hit the end of the interval, reset the balance
+
         interval_ts: float = ts % self.energy_balancing_interval
         if self.current_interval_ts < 0 or interval_ts <= self.current_interval_ts:
             # time runs backwards, must be a new interval
@@ -117,7 +142,7 @@ class EnergyBalancer(Juham):
                 # if we have enough energy to power the radiator for the rest of the time slot
                 if self.net_energy_balance >= self.needed_energy:
                     self.net_energy_balancing_mode = True
-                    self.initialize_active_consumers(ts)
+                    self.initialize_consumer_timelines(ts)
         self.publish_energybalance(ts)
 
     def calculate_needed_energy(self, interval_ts: float) -> float:
@@ -131,16 +156,19 @@ class EnergyBalancer(Juham):
         Returns:
             float: energy needed in joules
         """
+
         required_power: float = 0.0
         num_consumers: int = len(self.consumers)
+        if num_consumers == 0:
+            return 0.0
         remaining_ts_consumer: float = (
             self.energy_balancing_interval - interval_ts
         ) / num_consumers
         for consumer in self.consumers.values():
-            required_power += consumer * remaining_ts_consumer
+            required_power += consumer.power * remaining_ts_consumer
         return required_power
 
-    def initialize_active_consumers(self, ts: float) -> None:
+    def initialize_consumer_timelines(self, ts: float) -> None:
         """Initialize the list of active consumers with their start and stop times.
 
         Args:
@@ -157,46 +185,59 @@ class EnergyBalancer(Juham):
             self.energy_balancing_interval - interval_ts
         ) / num_consumers
 
-        # Reset the active consumers dictionary
-        self.active_consumers.clear()
-
-        for consumer_name, consumer_data in self.consumers.items():
-            start: float = interval_ts
-            stop: float = start + secs_per_consumer
-
-            # Add the consumer to the active consumers dictionary with its start and stop times
-            self.active_consumers[consumer_name] = {start: stop}
-
-            # Update interval_ts to the stop time for the next consumer
-            interval_ts = stop
+        for consumer in self.consumers.values():
+            consumer.start = interval_ts
+            consumer.stop = interval_ts + secs_per_consumer
+            interval_ts += secs_per_consumer
 
-    def consider_net_energy_balance(self, unit: str, ts: float) -> bool:
-        """Check if there is enough energy available for the consumer to heat
-        the water in the remaining time within the balancing interval.
+    def publish_energybalance(self, ts: float) -> None:
+        """Publish  diagnostics and status.
 
         Args:
-            unit (str): name of the consumer
-            ts (float): current time
+            ts (float): current time.
 
         Returns:
-            bool: true if the given consumer is active
+            None
         """
-        # Check if the consumer exists in the active_consumers dictionary
-        if unit not in self.active_consumers:
-            return False  # The consumer is not found, so return False
 
-        # Get the start and stop time dictionary for the consumer
-        consumer_times = self.active_consumers[unit]
+        # publish diagnostics
+        m: dict[str, Any] = {
+            "EnergyBalancer": self.name,
+            "CurrentBalance": self.net_energy_balance,
+            "NeededBalance": self.needed_energy,
+            "Timestamp": ts,
+        }
+        self.publish(self.topic_out_diagnostics, json.dumps(m))
+
 
-        # map the current time to the balancing interval  time slot
-        interval_ts: float = ts % self.energy_balancing_interval
+        # publish consumer statuses to control consumers
+        num_consumers: int = len(self.consumers)
+        if num_consumers == 0:
+            return  # If there are no consumers, we simply do nothing
+        interval_ts = ts % self.energy_balancing_interval
+        for consumer in self.consumers.values():
+            m: dict[str, Any] = {
+                "EnergyBalancer": self.name,
+                "Unit": consumer.name,
+                "Power": consumer.power,
+                "Mode": consumer.start <= interval_ts < consumer.stop,
+                "Timestamp": ts,
+            }
+            self.publish(self.topic_out_status, json.dumps(m))
+
+    def detect_consumer_status(self, name: str, ts: float) -> bool:
+        """Detect consumer status
 
-        # Check if current time (ts) is within the active range
-        for start_ts, stop_ts in consumer_times.items():
-            if start_ts <= interval_ts < stop_ts:
-                return True  # If the current time is within the range, the consumer is active
+        Args:
+            name (str): name of the consumer
+            ts (float): current time.
 
-        return False  # If no matching time range was found, return False
+        Returns:
+            True if the consumer is active, False otherwise
+        """
+        consumer: Consumer = self.consumers[name]
+        interval_ts = ts % self.energy_balancing_interval
+        return consumer.start <= interval_ts < consumer.stop
 
     def reset_net_energy_balance(self, interval_ts: float) -> None:
         """Reset the net energy balance at the end of the interval."""
@@ -204,7 +245,10 @@ class EnergyBalancer(Juham):
         self.current_interval_ts = interval_ts
         self.needed_energy = self.calculate_needed_energy(interval_ts)
         self.net_energy_balancing_mode = False
-        self.active_consumers.clear()  # Clear the active consumers at the end of the interval
+        for consumer in self.consumers.values():
+            consumer.start = 0.0
+            consumer.stop = 0.0
+
         self.info("Energy balance reset, interval ended")
 
     def activate_balancing_mode(self, ts: float) -> None:
@@ -220,20 +264,3 @@ class EnergyBalancer(Juham):
         self.info("Balance used, or the end of the interval reached, disable")
         self.net_energy_balance = 0.0  # Reset the energy balance at the interval's end
 
-    def publish_energybalance(self, ts: float) -> None:
-        """Publish energy balance information.
-
-        Args:
-            ts (float): current time
-        Returns:
-            dict: diagnostics information
-        """
-        m: dict[str, Any] = {
-            "Unit": self.name,
-            "Mode": self.net_energy_balancing_mode,
-            "Rc": self.net_energy_balancing_mode,
-            "CurrentBalance": self.net_energy_balance,
-            "NeededBalance": self.needed_energy,
-            "Timestamp": ts,
-        }
-        self.publish(self.topic_out_energybalance, json.dumps(m))

{juham_automation-0.0.29 → juham_automation-0.0.31}/juham_automation/automation/heatingoptimizer.py

@@ -88,8 +88,8 @@ class HeatingOptimizer(Juham):
         self.topic_forecast = self.make_topic_name("forecast")
         self.topic_temperature = self.make_topic_name(temperature_sensor)
         self.topic_powerplan = self.make_topic_name("powerplan")
-        self.topic_in_energybalance = self.make_topic_name("energybalance")
-        self.topic_out_energybalance = self.make_topic_name("energybalance_consumers")
+        self.topic_in_energybalance = self.make_topic_name("energybalance/status")
+        self.topic_out_energybalance = self.make_topic_name("energybalance/consumers")
         self.topic_out_power = self.make_topic_name("power")
 
         self.current_temperature = 100
@@ -321,9 +321,7 @@ class HeatingOptimizer(Juham):
         """
         if m["Unit"] == self.name:
             self.net_energy_balance_mode = m["Mode"]
-            self.info(
-                "Net energy balance mode for {self.name} set to {m['Mode']}", str(m)
-            )
+
 
     def consider_heating(self, ts: float) -> int:
         """Consider whether the target boiler needs heating. Check first if the solar

juham_automation-0.0.31/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-0.0.29 → juham_automation-0.0.31/juham_automation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: juham-automation
-Version: 0.0.29
+Version: 0.0.31
 Summary: Juha's Ultimate Home Automation Masterpiece
 Author-email: J Meskanen <juham.api@gmail.com>
 Maintainer-email: "J. Meskanen" <juham.api@gmail.com>

{juham_automation-0.0.29 → juham_automation-0.0.31}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "juham-automation"
-version = "0.0.29"
+version = "0.0.31"
 description = "Juha's Ultimate Home Automation Masterpiece"
 readme = {file = "README.rst", content-type = "text/markdown"}
 requires-python = ">=3.8"

{juham_automation-0.0.29 → juham_automation-0.0.31}/tests/automation/test_energybalancer.py

@@ -82,8 +82,8 @@ class TestEnergyBalancing(unittest.TestCase):
             self.assertEqual(energy, self.optimizer.net_energy_balance)
 
             # Call the method to check if balancing mode should be activated
-            main_on: bool = self.optimizer.consider_net_energy_balance("main", ts)
-            sun_on: bool = self.optimizer.consider_net_energy_balance("sun", ts)
+            main_on: bool = self.optimizer.detect_consumer_status("main", ts)
+            sun_on: bool = self.optimizer.detect_consumer_status("sun", ts)
 
             if energy >= self.optimizer.needed_energy:
                 self.assertTrue(main_on or sun_on, "One of the consumers must be ON")

juham_automation-0.0.29/juham_automation/ts/energybalancer_ts.py

@@ -1,47 +0,0 @@
-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)