juham-automation 0.0.16__tar.gz → 0.0.19__tar.gz

{juham_automation-0.0.16/juham_automation.egg-info → juham_automation-0.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: juham-automation
-Version: 0.0.16
+Version: 0.0.19
 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.16 → juham_automation-0.0.19}/juham_automation/automation/hotwateroptimizer.py

@@ -16,13 +16,17 @@ from juham_core.timeutils import (
 
 class HotWaterOptimizer(Juham):
     """Automation class for optimized control of temperature driven home energy consumers e.g hot
-    water radiators. Reads spot prices, electricity forecast and temperatures to minimize electricity bill.
-    Additional control over heating is provided by the following attributes
+    water radiators. Reads spot prices, electricity forecast, power meter and temperatures to minimize electricity bill.
 
-    Computes UOI - optimization utilization index for each hour, based on the spot price and the solar power forecast.
-    Value of 0 means the hour is expensive, value of 1 means the hour is free. The UOI threshold determines the slots
-    that are allowed to be consumed.
+    Represents a heating system that knows the power rating of its radiator (e.g., 3kW).
+    The system subscribes to the 'power' topic to track the current power balance. If the solar panels
+    generate more energy than is being consumed, the optimizer activates a relay to ensure that all excess energy
+    produced within that hour is used for heating. The goal is to achieve a net zero energy balance for each hour,
+    ensuring that any surplus energy from the solar panels is fully utilized.
 
+    Computes also UOI - optimization utilization index for each hour, based on the spot price and the solar power forecast.
+    For negative energy balance this determines when energy is consumed. Value of 0 means the hour is expensive, value of 1 means
+    the hour is free. The UOI threshold determines the slots that are allowed to be consumed.
 
     """
 
@@ -172,41 +176,64 @@ class HotWaterOptimizer(Juham):
         self.debug(f"Forecast sorted for the next {str(len(ranked_hours))} hours")
         return ranked_hours
 
+    def on_spot(self, m: list[dict[str, Any]], ts_quantized: float) -> None:
+        """Handle the spot prices.
+
+        Args:
+            list[dict[str, Any]]: list of spot prices
+            ts_quantized (float): current time
+        """
+        self.ranked_spot_prices = self.sort_by_rank(m, ts_quantized)
+
+    def on_forecast(
+        self, forecast: list[dict[str, Any]], ts_utc_quantized: float
+    ) -> None:
+        """Handle the solar forecast.
+
+        Args:
+            m (list[dict[str, Any]]): list of forecast prices
+            ts_quantized (float): current time
+        """
+        # reject forecasts that don't have solarenergy key
+        for f in forecast:
+            if not "solarenergy" in f:
+                return
+
+        self.ranked_solarpower = self.sort_by_power(forecast, ts_utc_quantized)
+        self.debug(
+            f"Solar energy forecast received and ranked for {len(self.ranked_solarpower)} hours"
+        )
+        self.power_plan = []  # reset power plan, it depends on forecast
+
+    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.net_energy_power = m["power"]
+        balance: float = (ts - self.net_energy_balance_ts) * self.net_energy_power
+        self.net_energy_balance = self.net_energy_balance + balance
+        self.net_energy_balance_ts = ts
+
     @override
     def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
         m = None
         ts: float = timestamp()
         ts_utc_quantized: float = quantize(3600, ts - 3600)
         if msg.topic == self.topic_spot:
-            self.ranked_spot_prices = self.sort_by_rank(
-                json.loads(msg.payload.decode()), ts_utc_quantized
-            )
-            self.debug(
-                f"Spot prices received and ranked for {len(self.ranked_spot_prices)} hours"
-            )
-            self.power_plan = []  # reset power plan, it depends on spot prices
+            self.on_spot(json.loads(msg.payload.decode()), ts_utc_quantized)
             return
         elif msg.topic == self.topic_forecast:
-            forecast = json.loads(msg.payload.decode())
-            # reject messages that don't have  solarenergy forecast
-
-            for f in forecast:
-                if not "solarenergy" in f:
-                    return
-
-            self.ranked_solarpower = self.sort_by_power(forecast, ts_utc_quantized)
-            self.debug(
-                f"Solar energy forecast received and ranked for {len(self.ranked_solarpower)} hours"
-            )
-            self.power_plan = []  # reset power plan, it depends on forecast
+            self.on_forecast(json.loads(msg.payload.decode()), ts_utc_quantized)
             return
         elif msg.topic == self.topic_temperature:
             m = json.loads(msg.payload.decode())
             self.current_temperature = m["temperature"]
         elif msg.topic == self.topic_in_net_energy_balance:
-            m = json.loads(msg.payload.decode())
-            self.net_energy_balance = m["energy"]
-            self.net_energy_power = m["power"]
+            self.on_power(json.loads(msg.payload.decode()), ts)
         elif msg.topic == self.topic_in_powerconsumption:
             m = json.loads(msg.payload.decode())
             self.current_power = m["real_total"]
@@ -216,7 +243,10 @@ class HotWaterOptimizer(Juham):
         self.on_powerplan(ts)
 
     def on_powerplan(self, ts_utc_now: float) -> None:
-        """Apply power plan.
+        """Apply the power plan. Check if the relay needs to be switched on or off.
+        The relay is switched on if the current temperature is below the maximum
+        temperature and the current time is within the heating plan. The relay is switched off
+        if the current temperature is above the maximum temperature or the current time is outside.
 
         Args:
             ts_utc_now (float): utc time
@@ -299,28 +329,43 @@ class HotWaterOptimizer(Juham):
             bool: true if production exceeds the consumption
         """
 
+        # if net energy balance is negative, then we are not in balancing mode
+        if self.net_energy_balance < 0:
+            return False
+
         # elapsed and remaining time within the current balancing slot
         elapsed_ts = ts - quantize(self.energy_balancing_interval, ts)
         remaining_ts = self.energy_balancing_interval - elapsed_ts
 
         # don't bother to switch the relay on for small intervals, to avoid
         # wearing contactors out
-        if remaining_ts < self.operation_threshold:
+        if (
+            not self.net_energy_balancing_mode
+            and remaining_ts < self.operation_threshold
+        ):
             print(
                 f"Skipping balance, remaining time {remaining_ts}s < {self.operation_threshold}s"
             )
             return False
+        elif remaining_ts <= 0:
+            self.net_energy_balancing_rc = False  # heating off
+            self.info(
+                f"End of the balancing interval reached, disabled with {self.net_energy_balance/3600}kWh left"
+            )
+            self.net_energy_balance = 0.0
+            self.net_energy_balance_ts = ts
+            return False
 
-        # check if the balance is sufficient for heating the next half of the energy balancing interval
-        # if yes then switch heating on for the next half an hour
-        needed_energy = 0.5 * self.radiator_power * remaining_ts
+        # check if the balance is sufficient for heating the remainin interval
+        # if yes then switch heating on
+        needed_energy = self.radiator_power * remaining_ts
         elapsed_interval = ts - self.net_energy_balance_ts
         print(
-            f"Needed energy {needed_energy}Wh, current balance {self.net_energy_balance}Wh"
+            f"Needed energy {int(needed_energy)/3600}kWh, current balance {int(self.net_energy_balance/3600)}kWh"
         )
 
         if (
-            self.net_energy_balance > needed_energy
+            self.net_energy_balance >= needed_energy
         ) and not self.net_energy_balancing_rc:
             self.net_energy_balance_ts = ts
             self.net_energy_balancing_rc = True  # heat
@@ -330,7 +375,7 @@ class HotWaterOptimizer(Juham):
             # check if we have reach the end of the interval, or consumed all the energy
             # of the current slot. If so switch the energy balancer mode off
             if (
-                elapsed_interval > self.energy_balancing_interval / 2.0
+                elapsed_interval > self.energy_balancing_interval
                 or self.net_energy_balance < 0
             ):
                 self.net_energy_balancing_rc = False  # heating off
@@ -338,7 +383,9 @@ class HotWaterOptimizer(Juham):
         return self.net_energy_balancing_rc
 
     def consider_heating(self, ts: float) -> int:
-        """Consider whether the target boiler needs heating.
+        """Consider whether the target boiler needs heating. Check first if the solar
+        energy is enough to heat the water the remaining time in the current slot.
+        If not, follow the predefined heating plan computed earlier based on the cheapest spot prices.
 
         Args:
             ts (float): current UTC time
@@ -349,7 +396,7 @@ class HotWaterOptimizer(Juham):
 
         # check if we have energy to consume, if so return 1
         if self.consider_net_energy_balance(ts):
-            self.warning("Net energy balance positive")
+            self.info("Net energy balance positive")
             return 1
         elif self.net_energy_balancing_mode:
             balancing_slot_start_ts = quantize(self.energy_balancing_interval, ts)

{juham_automation-0.0.16 → juham_automation-0.0.19/juham_automation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: juham-automation
-Version: 0.0.16
+Version: 0.0.19
 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.16 → juham_automation-0.0.19}/juham_automation.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ juham_automation/ts/powermeter_ts.py
 juham_automation/ts/powerplan_ts.py
 tests/__init__.py
 tests/test_japp.py
+tests/__pycache__/__init__.cpython-312.pyc
 tests/__pycache__/test_japp.cpython-312.pyc
 tests/automation/__init__.py
 tests/automation/test_energycostcalculator.py

{juham_automation-0.0.16 → juham_automation-0.0.19}/pyproject.toml

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

{juham_automation-0.0.16 → juham_automation-0.0.19}/tests/automation/test_hotwateroptimizer.py

@@ -104,6 +104,50 @@ class TestHotWaterOptimizer(unittest.TestCase):
         self.optimizer.on_message(None, None, mock_msg)
         self.assertEqual(self.optimizer.current_temperature, 55)
 
+    def test_consider_net_energy_balance(self):
+        # Test: Simulate passing time and accumulate energy
+        time_steps = [
+            0,
+            600,
+            1200,
+            1800,
+            2400,
+            3000,
+            3300,
+            3500,
+            3600,
+        ]  # Time steps in seconds
+        accumulated_power = 0
+
+        # Loop through the time steps and accumulate power
+        for ts in time_steps:
+            accumulated_power += 500000
+            self.optimizer.net_energy_balance = accumulated_power
+
+            # Call the method to check if balancing mode should be activated
+            heating_on = 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 = self.optimizer.energy_balancing_interval - ts
+            required_energy = self.optimizer.radiator_power * remaining_time
+
+            # Check if heating was enabled or not based on energy balance
+            if accumulated_power >= required_energy:
+                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 accumulated_power >= required_energy:
+                self.assertTrue(self.optimizer.net_energy_balancing_rc)
+            else:
+                self.assertFalse(self.optimizer.net_energy_balancing_rc)
+
+        # Check if the correct state transitions happen during the process
+        self.assertTrue(
+            self.optimizer.net_energy_balancing_rc
+        )  # At the end of the test, it should be on
+
 
 if __name__ == "__main__":
     unittest.main()