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

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/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/ts/energybalancer_ts.py

@@ -9,7 +9,7 @@ from juham_core.timeutils import epoc2utc
 
 
 class EnergyBalancerTs(JuhamTs):
-    """Heating optimizer diagnosis.
+    """Record energy balance data to time series database.
 
     This class listens the "energybalance" MQTT topic and records the
     messages to time series database.
@@ -19,27 +19,53 @@ class EnergyBalancerTs(JuhamTs):
         """Construct record object with the given name."""
 
         super().__init__(name)
-        self.topic_name = self.make_topic_name("energybalance")
+        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)
-        self.subscribe(self.topic_name)
-        self.debug(f"Subscribed to {self.topic_name}")
+        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:
-        """Standard mqtt message notification method.
+        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)
 
-        This method is called upon new arrived message.
+    def on_status(self, m: dict[str, Any]) -> None:
+        """Handle energybalance message.
+        Args:
+            m (dict[str, Any]): Message from energybalance topic.
         """
-
-        m = json.loads(msg.payload.decode())
+        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("Rc", m["Rc"])
+            .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"]))

{juham_automation-0.0.29.dist-info → juham_automation-0.0.31.dist-info}/METADATA

@@ -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.dist-info → juham_automation-0.0.31.dist-info}/RECORD

@@ -2,24 +2,24 @@ 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=V_2t6hkRWf0--o9njfa8G-AtHPYcPVNY2rDrO5WRqsc,10698
+juham_automation/automation/energybalancer.py,sha256=_08KikTDO3zHsRCV0oI7xyRpMyk594Q1C0acalRQoQs,10855
 juham_automation/automation/energycostcalculator.py,sha256=v30wxRpuY2gGBSMJifrFRTjsRU9t-iCiq33Vds7s3O8,10877
-juham_automation/automation/heatingoptimizer.py,sha256=UYvffqQDk96oEvNBmu7R0W3Qq6kMmfW92Xzejlr7Le8,21481
+juham_automation/automation/heatingoptimizer.py,sha256=LMZ4Cr1CTsk1HI9D0P27l1bPFDepylhDh87dTd204r0,21367
 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
 juham_automation/ts/__init__.py,sha256=kTEzVkDi6ednH4-fxKxrY6enlTuTXmSw09pPAQX3CMc,612
 juham_automation/ts/electricityprice_ts.py,sha256=BYs120V4teVjSqPc8PpPDjOTc5dOrVM9Maqse7E8cvk,1684
-juham_automation/ts/energybalancer_ts.py,sha256=KpMYnyzAKghPEMHAVHrh_aplorn9TeSvZr-DVpfir3c,1476
+juham_automation/ts/energybalancer_ts.py,sha256=XHl56G5fBjJOCSIJtdjzGpSTMAQN1xsnXpC4Ipl7ynw,2585
 juham_automation/ts/energycostcalculator_ts.py,sha256=MbeYEGlziVgq4zI40Tk71zxeDPeKafEG3s0LqDRiz0g,1277
 juham_automation/ts/forecast_ts.py,sha256=Gk46hIlS8ijxs-zyy8fBvXrhI7J-8e5Gt2QEe6gFB6s,3158
 juham_automation/ts/log_ts.py,sha256=XsNaazuPmRUZLUqxU0DZae_frtT6kAFcXJTc598CtOA,1750
 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.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.31.dist-info/licenses/LICENSE.rst,sha256=QVHD5V5_HSys2PdPdig_xKggDj8cGX33ALKqRsYyjtI,1089
+juham_automation-0.0.31.dist-info/METADATA,sha256=6PmgwoKzNtP2ZHHr_L_fhCcavtvkCOfL4COQcCje2A8,6837
+juham_automation-0.0.31.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+juham_automation-0.0.31.dist-info/entry_points.txt,sha256=h-KzuKjmGPd4_iX_oiGvxx4IEc97dVbGGlhdh5ctbpI,605
+juham_automation-0.0.31.dist-info/top_level.txt,sha256=jfohvtocvX_gfT21AhJk7Iay5ZiQsS3HzrDjF7S4Qp0,17
+juham_automation-0.0.31.dist-info/RECORD,,

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

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