juham-automation 0.0.26__tar.gz → 0.0.28__tar.gz

{juham_automation-0.0.26/juham_automation.egg-info → juham_automation-0.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: juham-automation
-Version: 0.0.26
+Version: 0.0.28
 Summary: Juha's Ultimate Home Automation Masterpiece
 Author-email: J Meskanen <juham.api@gmail.com>
 Maintainer-email: "J. Meskanen" <juham.api@gmail.com>
@@ -44,7 +44,7 @@ Classifier: Programming Language :: Python :: 3.8
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.rst
-Requires-Dist: juham_core>=0.1.3
+Requires-Dist: juham_core>=0.1.5
 Provides-Extra: dev
 Requires-Dist: check-manifest; extra == "dev"
 Requires-Dist: types-pyz; extra == "dev"

juham_automation-0.0.28/juham_automation/automation/energybalancer.py

@@ -0,0 +1,239 @@
+import json
+from typing import Any
+from typing_extensions import override
+
+from juham_core import Juham, timestamp
+from masterpiece import MqttMsg
+
+
+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
+    a given energy-consuming device, such as heating radiators, to operate within the
+    remaining time of the interval.
+
+    Any number of energy-consuming devices can be connected to the energy balancer, with
+    without any restrictions on the power consumption. The energy balancer will monitor the
+    power consumption of the devices and determine if there is enough energy available for
+    the devices to operate within the remaining time of the balancing interval.
+
+    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
+    energy_balancing_interval: int = 3600
+    """The time interval in seconds for energy balancing."""
+
+    def __init__(self, name: str = "energybalancer") -> None:
+        """Initialize the energy balancer.
+
+        Args:
+            name (str): name of the heating radiator
+            power (float): power of the consumer in watts
+        """
+        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.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]] = {}
+
+    @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_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:
+            self.on_power(json.loads(msg.payload.decode()), ts)
+        elif msg.topic == self.topic_in_consumers:
+            self.on_consumer(json.loads(msg.payload.decode()))
+        else:
+            super().on_message(client, userdata, msg)
+
+    def on_power(self, m: dict[str, Any], ts: float) -> None:
+        """Handle the power consumption. Read the current power balance and accumulate
+        to the net energy balance to reflect the  energy produced (or consumed) within the
+        current time slot.
+        Args:
+            m (dict[str, Any]): power consumption message
+            ts (float): current time
+        """
+        self.update_energy_balance(m["power"], ts)
+
+    def on_consumer(self, m: dict[str, Any]) -> None:
+        """Add consumer, e.g. heating radiator to be controlled.
+        Args:
+            m (dict[str, Any]): power consumer message
+            ts (float): current time
+        """
+        self.consumers[m["Unit"]] = m["Power"]
+        self.info(f"Consumer {m['Unit']} added, power: {m['Power']}")
+
+    def update_energy_balance(self, power: float, ts: float) -> None:
+        """Update the current net net energy balance. The change in the balance is calculate the
+        energy balance, which the time elapsed since the last update, multiplied by the
+        power. Positive energy balance means we have produced energy that can be consumed
+        at the end of the interval. The target is to use all the energy produced during the
+        balancing interval. This method is called  by the powermeter reading the
+        total power consumption of the house.
+
+        Args:
+            power (float): power reading from the powermeter. Positive value means
+                energy produced, negative value means energy consumed. The value of 0 means
+                the house is not consuming or producing energy.
+            ts (float): current time in utc seconds
+        """
+
+        # 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
+            self.reset_net_energy_balance(interval_ts)
+        else:
+            # update the energy balance with the elapsed time and the power
+            elapsed_ts = interval_ts - self.current_interval_ts
+            balance: float = elapsed_ts * power  # joules i.e. watt-seconds
+            self.net_energy_balance = self.net_energy_balance + balance
+            self.current_interval_ts = interval_ts
+            self.needed_energy = self.calculate_needed_energy(interval_ts)
+            if self.net_energy_balancing_mode:
+                if self.net_energy_balance <= 0:
+                    # if we have used all the energy, disable the balancing mode
+                    self.reset_net_energy_balance(0.0)
+            else:
+                # consider enabling the balancing mode
+                # 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.publish_energybalance(ts)
+
+    def calculate_needed_energy(self, interval_ts: float) -> float:
+        """Calculate the energy needed to power the consumer for the rest of the time slot.
+        Assumes consumers run one at a time in serialized manner and are evenly distributed over the time slot
+        to minimze the power peak.
+
+        Args:
+            interval_ts (float): current elapsed seconds within the balancing interval.
+
+        Returns:
+            float: energy needed in joules
+        """
+        required_power: float = 0.0
+        num_consumers: int = len(self.consumers)
+        remaining_ts_consumer: float = (
+            self.energy_balancing_interval - interval_ts
+        ) / num_consumers
+        for consumer in self.consumers.values():
+            required_power += consumer * remaining_ts_consumer
+        return required_power
+
+    def initialize_active_consumers(self, ts: float) -> None:
+        """Initialize the list of active consumers with their start and stop times.
+
+        Args:
+            ts (float): current time.
+
+        Returns:
+            None
+        """
+        num_consumers: int = len(self.consumers)
+        if num_consumers == 0:
+            return  # If there are no consumers, we simply do nothing
+        interval_ts: float = ts % self.energy_balancing_interval
+        secs_per_consumer: float = (
+            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
+
+    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.
+
+        Args:
+            unit (str): name of the consumer
+            ts (float): current time
+
+        Returns:
+            bool: true if the given consumer is active
+        """
+        # 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]
+
+        # map the current time to the balancing interval  time slot
+        interval_ts: float = ts % self.energy_balancing_interval
+
+        # 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
+
+        return False  # If no matching time range was found, return False
+
+    def reset_net_energy_balance(self, interval_ts: float) -> None:
+        """Reset the net energy balance at the end of the interval."""
+        self.net_energy_balance = 0.0
+        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
+        self.info("Energy balance reset, interval ended")
+
+    def activate_balancing_mode(self, ts: float) -> None:
+        """Activate balancing mode when enough energy is available."""
+        self.net_energy_balancing_mode = True
+        self.info(
+            f"{int(self.net_energy_balance/3600)} Wh is enough to supply the radiator, enable"
+        )
+
+    def deactivate_balancing_mode(self) -> None:
+        """Deactivate balancing mode when energy is depleted or interval ends."""
+        self.net_energy_balancing_mode = False
+        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.26 → juham_automation-0.0.28}/juham_automation/automation/heatingoptimizer.py

@@ -90,7 +90,7 @@ class HeatingOptimizer(Juham):
         self.topic_powerplan = self.make_topic_name("powerplan")
         self.topic_in_powerconsumption = self.make_topic_name("powerconsumption")
         self.topic_in_net_energy_balance = self.make_topic_name("net_energy_balance")
-        self.topic_in_energybalance = self.make_topic_name("energybalance")
+        self.topic_out_energybalance = self.make_topic_name("energybalance_consumers")
         self.topic_out_power = self.make_topic_name("power")  # controls the relay
 
         self.current_temperature = 100
@@ -113,6 +113,18 @@ class HeatingOptimizer(Juham):
             self.subscribe(self.topic_temperature)
             self.subscribe(self.topic_in_powerconsumption)
             self.subscribe(self.topic_in_net_energy_balance)
+            self.register_as_consumer()
+
+    def register_as_consumer(self) -> None:
+        """Register this device as a consumer to the energy balancer. The energy balancer will then add this device
+        to its list of consumers and will tell the device when to heat."""
+
+        consumer: dict[str, Any] = {
+            "Unit": self.name,
+            "Power": self.radiator_power,
+        }
+        self.publish(self.topic_out_energybalance, json.dumps(consumer), 1, False)
+        self.info(f"Registered {self.name} as consumer with {self.radiator_power}W", "")
 
     def sort_by_rank(
         self, hours: list[dict[str, Any]], ts_utc_now: float
@@ -309,7 +321,11 @@ class HeatingOptimizer(Juham):
         Returns:
             bool: true if production exceeds the consumption
         """
-        self.net_energy_balance_mode = m["Mode"]
+        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.26 → juham_automation-0.0.28/juham_automation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: juham-automation
-Version: 0.0.26
+Version: 0.0.28
 Summary: Juha's Ultimate Home Automation Masterpiece
 Author-email: J Meskanen <juham.api@gmail.com>
 Maintainer-email: "J. Meskanen" <juham.api@gmail.com>
@@ -44,7 +44,7 @@ Classifier: Programming Language :: Python :: 3.8
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.rst
-Requires-Dist: juham_core>=0.1.3
+Requires-Dist: juham_core>=0.1.5
 Provides-Extra: dev
 Requires-Dist: check-manifest; extra == "dev"
 Requires-Dist: types-pyz; extra == "dev"

{juham_automation-0.0.26 → juham_automation-0.0.28}/juham_automation.egg-info/requires.txt

@@ -1,4 +1,4 @@
-juham_core>=0.1.3
+juham_core>=0.1.5
 
 [dev]
 check-manifest

{juham_automation-0.0.26 → juham_automation-0.0.28}/pyproject.toml

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

juham_automation-0.0.28/tests/automation/test_energybalancer.py

@@ -0,0 +1,107 @@
+import unittest
+from typing import List, Any
+from juham_automation.automation.energybalancer import EnergyBalancer
+from juham_core.timeutils import (
+    quantize,
+)
+from masterpiece.mqtt import MqttMsg
+
+
+class SimpleMqttMsg(MqttMsg):
+    def __init__(self, topic: str, payload: Any):
+        self._topic = topic
+        self._payload = payload
+
+    @property
+    def payload(self) -> Any:
+        return self._payload
+
+    @payload.setter
+    def payload(self, value: Any) -> None:
+        self._payload = value
+
+    @property
+    def topic(self) -> str:
+        return self._topic
+
+    @topic.setter
+    def topic(self, value: str) -> None:
+        self._topic = value
+
+
+class TestEnergyBalancing(unittest.TestCase):
+
+    balancing_interval: int = EnergyBalancer.energy_balancing_interval
+    power: int = 3000  # Power of the radiator (in watts )
+
+    def setUp(self) -> None:
+        """Create balancer with two consumers"""
+        self.optimizer = EnergyBalancer("test_optimizer")
+        self.optimizer.on_consumer({"Unit": "main", "Power": 2000})
+        self.optimizer.on_consumer({"Unit": "sun", "Power": 1000})
+
+    def test_initial_state(self) -> None:
+        self.assertEqual(
+            self.optimizer.net_energy_balance, 0, "Initial energy balance should be 0"
+        )
+        self.assertEqual(
+            self.balancing_interval, self.optimizer.energy_balancing_interval
+        )
+        self.assertFalse(self.optimizer.net_energy_balancing_mode)
+
+        self.assertEqual(self.optimizer.needed_energy, 0.0)
+
+        #  time within the interval should be zero
+        self.assertEqual(-1, self.optimizer.current_interval_ts)
+
+    def test_set_power(self) -> None:
+        """Test setting power consumption and check if the energy balance is updated."""
+        step: int = 60
+        for ts in range(0, self.balancing_interval, step):
+            self.optimizer.update_energy_balance(self.power, ts)
+            self.assertEqual(ts * self.power, self.optimizer.net_energy_balance)
+            self.assertEqual(ts, self.optimizer.current_interval_ts)
+
+        self.optimizer.update_energy_balance(self.power, ts + step)
+        self.assertEqual(0, self.optimizer.net_energy_balance)
+
+    def test_consider_net_energy_balance(self) -> None:
+        """Test case to simulate passing time and check energy balancing behavior.
+        Pass power consumption self.power, which should switch the heating on just
+        in the middle of the interval."""
+
+        balancing_interval: int = self.balancing_interval
+
+        step: int = balancing_interval // 10
+        for ts in range(0, self.balancing_interval * 10, step):
+            interval_ts: float = ts % balancing_interval  # quantized timestamp
+            energy: float = self.power * interval_ts  # in watt-seconds
+            self.optimizer.update_energy_balance(self.power, ts)
+
+            # make sure the optimizer is in the right state
+            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)
+
+            if energy >= self.optimizer.needed_energy:
+                self.assertTrue(main_on or sun_on, "One of the consumers must be ON")
+                self.assertFalse(sun_on and main_on, "Only one at a time")
+            else:
+                self.assertFalse(main_on, "Not enough energy, main should be OFF")
+                self.assertFalse(sun_on, "Not enough energy, sun should be OFF")
+
+    def test_quantization(self) -> None:
+        """Test that timestamps are quantized to the interval boundaries correctly."""
+        test_times: List[int] = [3601, 7200, 10800]  # Slightly over boundaries
+        for ts in test_times:
+            quantized_ts = quantize(self.optimizer.energy_balancing_interval, ts)
+            expected_quantized_ts = (
+                ts // self.optimizer.energy_balancing_interval
+            ) * self.optimizer.energy_balancing_interval
+            self.assertEqual(
+                quantized_ts,
+                expected_quantized_ts,
+                f"Timestamp {ts} should be quantized to {expected_quantized_ts}",
+            )

{juham_automation-0.0.26 → juham_automation-0.0.28}/tests/automation/test_heatingoptimizer.py

@@ -107,7 +107,7 @@ class TestHeatingOptimizer(unittest.TestCase):
 
     def test_consider_net_energy_balance(self) -> None:
         """Test case to simulate passing time and check energy balancing behavior."""
-        data: dict[str, Any] = {"Mode": False}
+        data: dict[str, Any] = {"Unit": "main", "Mode": False}
         mock_msg = SimpleMqttMsg(
             topic=self.optimizer.topic_in_net_energy_balance,
             payload=json.dumps(data).encode("utf-8"),
@@ -122,11 +122,12 @@ class TestHeatingOptimizer(unittest.TestCase):
             None,
             SimpleMqttMsg(
                 topic=self.optimizer.topic_in_net_energy_balance,
-                payload=json.dumps({"Mode": True}).encode("utf-8"),
+                payload=json.dumps({"Unit": "sun", "Mode": True}).encode("utf-8"),
             ),
         )
-        self.assertTrue(
-            self.optimizer.net_energy_balance_mode, f"At time {0}, heating should be ON"
+        self.assertFalse(
+            self.optimizer.net_energy_balance_mode,
+            f"At time {0}, heating should be OFF",
         )
 
 

juham_automation-0.0.26/juham_automation/automation/energybalancer.py

@@ -1,158 +0,0 @@
-import json
-from typing import Any, Dict
-from typing_extensions import override
-
-from juham_core import Juham, timestamp
-from juham_core.timeutils import timestampstr, quantize
-from masterpiece import MqttMsg
-
-
-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
-    a given energy-consuming device, such as heating radiators, to operate within the
-    remaining time of the interval.
-
-    Any number of energy-consuming devices can be connected to the energy balancer.
-    The energy balancer is typically 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
-    energy_balancing_interval: int = 3600
-    radiator_power: float = 3000
-    timezone: str = "Europe/Helsinki"
-
-    def __init__(self, name: str = "energybalancer") -> None:
-        """Initialize the energy balancer.
-
-        Args:
-            name (str): name of the heating radiator
-            power (float): power of the consumer in watts
-        """
-        super().__init__(name)
-
-        self.topic_in_powerconsumption = self.make_topic_name("powerconsumption")
-        self.topic_in_net_energy_balance = self.make_topic_name("net_energy_balance")
-        self.topic_out_energybalance = self.make_topic_name("energybalance")
-        self.net_energy_balance: float = 0.0  # Energy balance in joules (watt-seconds)
-        self.net_energy_balance_ts: float = -1
-        self.needed_energy: float = self.energy_balancing_interval * self.radiator_power
-        self.net_energy_balancing_mode: bool = 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.topic_in_net_energy_balance)
-
-    @override
-    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
-        ts: float = timestamp()
-
-        if msg.topic == self.topic_in_net_energy_balance:
-            self.on_power(json.loads(msg.payload.decode()), ts)
-        else:
-            super().on_message(client, userdata, msg)
-
-    def on_power(self, m: dict[str, Any], ts: float) -> None:
-        """Handle the power consumption. Read the current power balance and accumulate
-        to the net energy balance to reflect the  energy produced (or consumed) within the
-        current time slot.
-        Args:
-            m (dict[str, Any]): power consumption message
-            ts (float): current time
-        """
-        self.update_energy_balance(m["power"], ts)
-
-    def update_energy_balance(self, power: float, ts: float) -> None:
-        """Update the current net net energy balance. The change in the balance is calculate the
-        energy balance, which the time elapsed since the last update, multiplied by the
-        power. Positive energy balance means we have produced energy that can be consumed
-        at the end of the interval. The target is to use all the energy produced during the
-        balancing interval. This method is typically called  by the powermeter reading the
-        total power consumption of the house
-
-        Args:
-            power (float): power reading from the powermeter. Positive value means
-                energy produced, negative value means energy consumed. The value of 0 means
-                the house is not consuming or producing energy.
-            ts (float): current time in utc seconds
-        """
-
-        # regardless of the mode, if we hit the end of the interval, reset the balance
-        quantized_ts: float = ts % self.energy_balancing_interval
-        if self.net_energy_balance_ts < 0:
-            self.net_energy_balance_ts = quantized_ts
-            self.needed_energy = self.energy_balancing_interval - quantized_ts
-        elif quantized_ts <= self.net_energy_balance_ts:
-            self.reset_net_energy_balance()
-        else:
-            # update the energy balance with the elapsed time and the power
-            elapsed_ts = quantized_ts - self.net_energy_balance_ts
-            balance: float = elapsed_ts * power  # joules i.e. watt-seconds
-            self.net_energy_balance = self.net_energy_balance + balance
-            self.net_energy_balance_ts = quantized_ts
-            self.needed_energy = (
-                self.energy_balancing_interval - quantized_ts
-            ) * self.radiator_power
-
-            if self.net_energy_balancing_mode:
-                if self.net_energy_balance <= 0:
-                    # if we have used all the energy, disable the balancing mode
-                    self.reset_net_energy_balance()
-            else:
-                if self.net_energy_balance >= self.needed_energy:
-                    self.net_energy_balancing_mode = True
-        self.publish_energybalance(ts)
-
-    def consider_net_energy_balance(self, 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, and switch
-        the balancing mode on if sufficient.
-
-        Args:
-            ts (float): current time
-
-        Returns:
-            bool: true if production exceeds the consumption
-        """
-        return self.net_energy_balancing_mode
-
-    def reset_net_energy_balance(self) -> None:
-        """Reset the net energy balance at the end of the interval."""
-        self.net_energy_balance = 0.0
-        self.needed_energy = self.energy_balancing_interval * self.radiator_power
-        self.net_energy_balance_ts = 0
-        self.net_energy_balancing_mode = False
-
-    def activate_balancing_mode(self, ts: float) -> None:
-        """Activate balancing mode when enough energy is available."""
-        self.net_energy_balancing_mode = True
-        self.info(
-            f"{int(self.net_energy_balance/3600)} Wh is enough to supply the radiator, enable"
-        )
-
-    def deactivate_balancing_mode(self) -> None:
-        """Deactivate balancing mode when energy is depleted or interval ends."""
-        self.net_energy_balancing_mode = False
-        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.26/tests/automation/test_energybalancer.py

@@ -1,183 +0,0 @@
-import unittest
-from typing import List, Any
-from juham_automation.automation.energybalancer import EnergyBalancer
-from juham_core.timeutils import (
-    quantize,
-    timestamp,
-    timestamp_hour,
-    timestampstr,
-    is_hour_within_schedule,
-    timestamp_hour_local,
-)
-from masterpiece.mqtt import MqttMsg
-from juham_automation.automation.heatingoptimizer import HeatingOptimizer
-
-
-class SimpleMqttMsg(MqttMsg):
-    def __init__(self, topic: str, payload: Any):
-        self._topic = topic
-        self._payload = payload
-
-    @property
-    def payload(self) -> Any:
-        return self._payload
-
-    @payload.setter
-    def payload(self, value: Any) -> None:
-        self._payload = value
-
-    @property
-    def topic(self) -> str:
-        return self._topic
-
-    @topic.setter
-    def topic(self, value: str) -> None:
-        self._topic = value
-
-
-class TestEnergyBalancing(unittest.TestCase):
-
-    balancing_interval: int = EnergyBalancer.energy_balancing_interval
-    power: int = 3000  # Power of the radiator (in watts )
-
-    def setUp(self) -> None:
-        self.optimizer = EnergyBalancer("test_optimizer")
-        self.optimizer.radiator_power = 3000  # Set the radiator power
-
-    def test_initial_state(self) -> None:
-        self.assertEqual(
-            self.optimizer.net_energy_balance, 0, "Initial energy balance should be 0"
-        )
-        self.assertEqual(
-            self.balancing_interval, self.optimizer.energy_balancing_interval
-        )
-        self.assertFalse(self.optimizer.net_energy_balancing_mode)
-
-        self.assertEqual(
-            self.optimizer.needed_energy, self.balancing_interval * self.power
-        )
-
-        #  time within the interval should be zero
-        self.assertEqual(-1, self.optimizer.net_energy_balance_ts)
-
-    def test_set_power(self) -> None:
-        """Test setting power consumption and check if the energy balance is updated."""
-        step: int = 60
-        for ts in range(0, self.balancing_interval, step):
-            self.optimizer.update_energy_balance(self.power, ts)
-            self.assertEqual(ts * self.power, self.optimizer.net_energy_balance)
-            self.assertEqual(ts, self.optimizer.net_energy_balance_ts)
-
-        self.optimizer.update_energy_balance(self.power, ts + step)
-        self.assertEqual(0, self.optimizer.net_energy_balance)
-
-    def test_consider_net_energy_balance(self) -> None:
-        """Test case to simulate passing time and check energy balancing behavior.
-        Pass power consumption self.power, which should switch the heating on just
-        in the middle of the interval."""
-
-        balancing_interval: int = self.balancing_interval
-        energy: float = 0
-        step: int = balancing_interval // 10
-        for ts in range(0, self.balancing_interval, step):
-            energy = self.power * ts  # in watt-seconds
-            self.optimizer.update_energy_balance(self.power, ts)
-
-            # make sure the optimizer is in the right state
-            self.assertEqual(energy, self.optimizer.net_energy_balance)
-
-            # Call the method to check if balancing mode should be activated
-            heating_on: bool = self.optimizer.consider_net_energy_balance(ts)
-
-            # Calculate the remaining energy needed to power the radiator for the rest of the time slot
-            remaining_time: float = self.optimizer.energy_balancing_interval - ts
-            required_energy: float = self.optimizer.radiator_power * remaining_time
-
-            # Check if heating was enabled or not based on energy balance
-            if energy >= required_energy and remaining_time > 0:
-                self.assertTrue(heating_on, f"At time {ts}, heating should be ON")
-            else:
-                self.assertFalse(heating_on, f"At time {ts}, heating should be OFF")
-
-            # Ensure heating state is correct
-            if energy >= required_energy and remaining_time > 0:
-                self.assertTrue(self.optimizer.net_energy_balancing_mode)
-            else:
-                self.assertFalse(self.optimizer.net_energy_balancing_mode)
-
-        # Step 2: Testing energy balancing reset at the end of the interval
-        # self.optimizer.net_energy_balance = 0  # Reset energy before boundary test
-        self.optimizer.update_energy_balance(self.power, self.balancing_interval)
-        heating_on = self.optimizer.consider_net_energy_balance(ts)
-        self.assertFalse(heating_on, "Heating should be OFF after interval reset")
-        self.assertEqual(
-            self.optimizer.net_energy_balance,
-            0,
-            "Energy balance should be reset to 0 at the end of the interval",
-        )
-        self.assertFalse(
-            self.optimizer.net_energy_balancing_mode,
-            "Balancing mode should be OFF after interval reset",
-        )
-
-        # Step 3: Testing activation when energy is sufficient
-        self.optimizer.update_energy_balance(
-            self.power * 1800, self.balancing_interval // 10
-        )
-
-        ts = 3600 + 60  # Start of a new interval
-        heating_on = self.optimizer.consider_net_energy_balance(ts)
-        self.assertTrue(
-            heating_on, "Heating should be ON when enough energy is available"
-        )
-        self.assertTrue(
-            self.optimizer.net_energy_balancing_mode,
-            "Balancing mode should be ON when enough energy is available",
-        )
-
-    def test_consider_net_energy_balance_start_middle(self) -> None:
-        """Start from the middle of the interval."""
-
-        balancing_interval: int = self.balancing_interval
-        energy: float = 0
-        step: int = balancing_interval // 10
-        for ts in range(self.balancing_interval // 2, self.balancing_interval, step):
-
-            self.optimizer.update_energy_balance(self.power, ts)
-
-            # make sure the optimizer is in the right state
-            self.assertEqual(energy, self.optimizer.net_energy_balance)
-
-            # Call the method to check if balancing mode should be activated
-            heating_on: bool = self.optimizer.consider_net_energy_balance(ts)
-
-            # Calculate the remaining energy needed to power the radiator for the rest of the time slot
-            remaining_time: float = self.optimizer.energy_balancing_interval - ts
-            required_energy: float = self.optimizer.radiator_power * remaining_time
-
-            # Check if heating was enabled or not based on energy balance
-            if energy >= required_energy and remaining_time > 0:
-                self.assertTrue(heating_on, f"At time {ts}, heating should be ON")
-            else:
-                self.assertFalse(heating_on, f"At time {ts}, heating should be OFF")
-
-            # Ensure heating state is correct
-            if energy >= required_energy and remaining_time > 0:
-                self.assertTrue(self.optimizer.net_energy_balancing_mode)
-            else:
-                self.assertFalse(self.optimizer.net_energy_balancing_mode)
-            energy = energy + self.power * step  # in watt-seconds
-
-    def test_quantization(self) -> None:
-        """Test that timestamps are quantized to the interval boundaries correctly."""
-        test_times: List[int] = [3601, 7200, 10800]  # Slightly over boundaries
-        for ts in test_times:
-            quantized_ts = quantize(self.optimizer.energy_balancing_interval, ts)
-            expected_quantized_ts = (
-                ts // self.optimizer.energy_balancing_interval
-            ) * self.optimizer.energy_balancing_interval
-            self.assertEqual(
-                quantized_ts,
-                expected_quantized_ts,
-                f"Timestamp {ts} should be quantized to {expected_quantized_ts}",
-            )