juham-automation 0.0.27__py3-none-any.whl → 0.0.29__py3-none-any.whl

juham_automation/automation/energybalancer.py

@@ -1,9 +1,8 @@
 import json
-from typing import Any, Dict
+from typing import Any
 from typing_extensions import override
 
 from juham_core import Juham, timestamp
-from juham_core.timeutils import timestampstr, quantize
 from masterpiece import MqttMsg
 
 
@@ -13,15 +12,18 @@ class EnergyBalancer(Juham):
     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
+    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
-    radiator_power: float = 3000
-    timezone: str = "Europe/Helsinki"
+    """The time interval in seconds for energy balancing."""
 
     def __init__(self, name: str = "energybalancer") -> None:
         """Initialize the energy balancer.
@@ -32,19 +34,22 @@ class EnergyBalancer(Juham):
         """
         super().__init__(name)
 
-        self.topic_in_powerconsumption = self.make_topic_name("powerconsumption")
+        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.net_energy_balance_ts: float = -1
-        self.needed_energy: float = self.energy_balancing_interval * self.radiator_power
+        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:
@@ -52,6 +57,8 @@ class EnergyBalancer(Juham):
 
         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)
 
@@ -65,13 +72,22 @@ class EnergyBalancer(Juham):
         """
         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 typically called  by the powermeter reading the
-        total power consumption of the house
+        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
@@ -81,50 +97,115 @@ class EnergyBalancer(Juham):
         """
 
         # 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()
+        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 = quantized_ts - self.net_energy_balance_ts
+            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.net_energy_balance_ts = quantized_ts
-            self.needed_energy = (
-                self.energy_balancing_interval - quantized_ts
-            ) * self.radiator_power
-
+            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()
+                    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 consider_net_energy_balance(self, ts: float) -> bool:
+    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, and switch
-        the balancing mode on if sufficient.
+        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 production exceeds the consumption
+            bool: true if the given consumer is active
         """
-        return self.net_energy_balancing_mode
+        # 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) -> None:
+    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.needed_energy = self.energy_balancing_interval * self.radiator_power
-        self.net_energy_balance_ts = 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."""

juham_automation/automation/heatingoptimizer.py

@@ -88,10 +88,9 @@ 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_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_power = self.make_topic_name("power")  # controls the relay
+        self.topic_out_energybalance = self.make_topic_name("energybalance_consumers")
+        self.topic_out_power = self.make_topic_name("power")
 
         self.current_temperature = 100
         self.current_heating_plan = 0
@@ -111,8 +110,19 @@ class HeatingOptimizer(Juham):
             self.subscribe(self.topic_spot)
             self.subscribe(self.topic_forecast)
             self.subscribe(self.topic_temperature)
-            self.subscribe(self.topic_in_powerconsumption)
-            self.subscribe(self.topic_in_net_energy_balance)
+            self.subscribe(self.topic_in_energybalance)
+            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
@@ -214,7 +224,7 @@ class HeatingOptimizer(Juham):
         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:
+        elif msg.topic == self.topic_in_energybalance:
             decoded_payload = msg.payload.decode()
             m = json.loads(decoded_payload)
             self.on_netenergy_balance(m)
@@ -309,7 +319,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.27.dist-info → juham_automation-0.0.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: juham-automation
-Version: 0.0.27
+Version: 0.0.29
 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.27.dist-info → juham_automation-0.0.29.dist-info}/RECORD

@@ -2,9 +2,9 @@ juham_automation/__init__.py,sha256=32BL36bhT7OaSw22H7st-7-3IXcFM2Pf5js80hNA8W0,
 juham_automation/japp.py,sha256=L2u1mfKvun2fiXhB3AEJD9zMDcdFZ3_doXZYJJzu9tg,1646
 juham_automation/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 juham_automation/automation/__init__.py,sha256=uxkIrcRSp1cFikn-oBRtQ8XiT9cSf7xjm3CS1RN7lAQ,522
-juham_automation/automation/energybalancer.py,sha256=Y8l3ARnLn1HPIR3IwNPOH69ky_JAI8lFgkXYO8oTUXY,6998
+juham_automation/automation/energybalancer.py,sha256=V_2t6hkRWf0--o9njfa8G-AtHPYcPVNY2rDrO5WRqsc,10698
 juham_automation/automation/energycostcalculator.py,sha256=v30wxRpuY2gGBSMJifrFRTjsRU9t-iCiq33Vds7s3O8,10877
-juham_automation/automation/heatingoptimizer.py,sha256=X9M2Z0jzneJCHtsh3lXmGqct0GwF_sm2Zwcv-26ZPdU,20923
+juham_automation/automation/heatingoptimizer.py,sha256=UYvffqQDk96oEvNBmu7R0W3Qq6kMmfW92Xzejlr7Le8,21481
 juham_automation/automation/powermeter_simulator.py,sha256=3WZcjByRTdqnC77l7LjP-TEjmZ8XBEO4hClYsrjxmBE,4549
 juham_automation/automation/spothintafi.py,sha256=cZbi7w2fVweHX_fh1r5MTjGdesX9wDQta2mfVjtiwvw,4331
 juham_automation/automation/watercirculator.py,sha256=a8meMNaONbHcIH3y0vP0UulJc1-gZiLZpw7H8kAOreY,6410
@@ -17,9 +17,9 @@ juham_automation/ts/log_ts.py,sha256=XsNaazuPmRUZLUqxU0DZae_frtT6kAFcXJTc598CtOA
 juham_automation/ts/power_ts.py,sha256=e7bSeZjitY4C_gLup9L0NjvU_WnQsl3ayDhVShj32KY,1399
 juham_automation/ts/powermeter_ts.py,sha256=gXzfK2S4SzrQ9GqM0tsLaV6z_vYmTkBatTcaivASSXs,2188
 juham_automation/ts/powerplan_ts.py,sha256=LZeE7TnzPCDaugggKlaV-K48lDwwnC1ZNum50JYAWaY,1482
-juham_automation-0.0.27.dist-info/licenses/LICENSE.rst,sha256=QVHD5V5_HSys2PdPdig_xKggDj8cGX33ALKqRsYyjtI,1089
-juham_automation-0.0.27.dist-info/METADATA,sha256=uQ3JKEJNyZgW0dgOXU2VcDRiEuORpAAUMz9IZoCKMTE,6837
-juham_automation-0.0.27.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-juham_automation-0.0.27.dist-info/entry_points.txt,sha256=h-KzuKjmGPd4_iX_oiGvxx4IEc97dVbGGlhdh5ctbpI,605
-juham_automation-0.0.27.dist-info/top_level.txt,sha256=jfohvtocvX_gfT21AhJk7Iay5ZiQsS3HzrDjF7S4Qp0,17
-juham_automation-0.0.27.dist-info/RECORD,,
+juham_automation-0.0.29.dist-info/licenses/LICENSE.rst,sha256=QVHD5V5_HSys2PdPdig_xKggDj8cGX33ALKqRsYyjtI,1089
+juham_automation-0.0.29.dist-info/METADATA,sha256=oowx8jK8iXbNZL2EDQJ7VfNZNEdO5Z0TXyn20jhBgg8,6837
+juham_automation-0.0.29.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+juham_automation-0.0.29.dist-info/entry_points.txt,sha256=h-KzuKjmGPd4_iX_oiGvxx4IEc97dVbGGlhdh5ctbpI,605
+juham_automation-0.0.29.dist-info/top_level.txt,sha256=jfohvtocvX_gfT21AhJk7Iay5ZiQsS3HzrDjF7S4Qp0,17
+juham_automation-0.0.29.dist-info/RECORD,,

{juham_automation-0.0.27.dist-info → juham_automation-0.0.29.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (78.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any