juham-automation 0.0.30__py3-none-any.whl → 0.0.33__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: float) -> 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
@@ -35,15 +58,15 @@ class EnergyBalancer(Juham):
         super().__init__(name)
 
         self.topic_in_consumers = self.make_topic_name("energybalance/consumers")
-        self.topic_out_energybalance = self.make_topic_name("energybalance/status")
+        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:
@@ -79,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:
@@ -98,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
@@ -118,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:
@@ -141,10 +165,10 @@ class EnergyBalancer(Juham):
             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:
@@ -161,46 +185,58 @@ 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 = {
+                "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."""
@@ -208,7 +244,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:
@@ -223,21 +262,3 @@ class EnergyBalancer(Juham):
         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/automation/heatingoptimizer.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 import json
 from typing import Any
 from typing_extensions import override
@@ -16,31 +17,63 @@ from juham_core.timeutils import (
 
 class HeatingOptimizer(Juham):
     """Automation class for optimized control of temperature driven home energy consumers e.g hot
-    water radiators. Reads spot prices, electricity forecast, power meter and temperatures to minimize electricity bill.
+    water radiators. Reads spot prices, solar electricity forecast,  power meter and
+    temperature to minimize electricity bill.
 
     Represents a heating system that knows the power rating of its radiator (e.g., 3kW).
+    Any number of heating devices can be controlled, each with its own temperature, schedule and electricity price ratings
+
     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,
+    produced within that balancing interval 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.
-
     """
 
-    maximum_boiler_temperature: float = 70
-    minimum_boiler_temperature: float = 40
     energy_balancing_interval: float = 3600
-    radiator_power: float = 6000  #
-    operation_threshold: float = 5 * 60
+    """Energy balancing interval, as regulated by the  industry/converment. In seconds"""
+
+    radiator_power: float = 6000  # W
+    """Radiator power in Watts. This is the maximum power that the radiator can consume."""
+
     heating_hours_per_day: float = 4
+    """ Number of hours per day the radiator is allowed to heat."""
+
     schedule_start_hour: float = 0
+    """Start hour of the heating schedule."""
+
     schedule_stop_hour: float = 0
+    """Stop hour of the heating schedule. Heating is allowed only between these two hours."""
+
     timezone: str = "Europe/Helsinki"
+    """ Timezone of the heating system. This is used to convert UTC timestamps to local time."""
+
     expected_average_price: float = 0.2
+    """Expected average price of electricity, beyond which the heating is avoided."""
+
     uoi_threshold: float = 0.8
+    """Utilization Optimization Index threshold. This is the minimum UOI value that is allowed for the heating to be activated."""
+
+    temperature_limits: dict[int, tuple[float, float]] = {
+        1: (20.0, 60.0),  # January
+        2: (20.0, 60.0),  # February
+        3: (20.0, 60.0),  # March
+        4: (20.0, 50.0),  # April
+        5: (20.0, 40.0),  # May
+        6: (20.0, 22.0),  # June
+        7: (20.0, 22.0),  # July
+        8: (20.0, 22.0),  # August
+        9: (20.0, 50.0),  # September
+        10: (20.0, 60.0),  # October
+        11: (20.0, 60.0),  # November
+        12: (20.0, 60.0),  # December
+    }
+    """Temperature limits for each month. The minimum temperature is maintained regardless of the cost.
+    The limits are defined as a dictionary where the keys are month numbers (1-12)
+    and the values are tuples of (min_temp, max_temp). The min_temp and max_temp values are in degrees Celsius."""
 
     def __init__(
         self,
@@ -84,9 +117,9 @@ class HeatingOptimizer(Juham):
         self.start_hour = start_hour
         self.spot_limit = spot_limit
 
-        self.topic_spot = self.make_topic_name("spot")
-        self.topic_forecast = self.make_topic_name("forecast")
-        self.topic_temperature = self.make_topic_name(temperature_sensor)
+        self.topic_in_spot = self.make_topic_name("spot")
+        self.topic_in_forecast = self.make_topic_name("forecast")
+        self.topic_in_temperature = self.make_topic_name(temperature_sensor)
         self.topic_powerplan = self.make_topic_name("powerplan")
         self.topic_in_energybalance = self.make_topic_name("energybalance/status")
         self.topic_out_energybalance = self.make_topic_name("energybalance/consumers")
@@ -107,9 +140,9 @@ class HeatingOptimizer(Juham):
     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_spot)
-            self.subscribe(self.topic_forecast)
-            self.subscribe(self.topic_temperature)
+            self.subscribe(self.topic_in_spot)
+            self.subscribe(self.topic_in_forecast)
+            self.subscribe(self.topic_in_temperature)
             self.subscribe(self.topic_in_energybalance)
             self.register_as_consumer()
 
@@ -122,7 +155,22 @@ class HeatingOptimizer(Juham):
             "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", "")
+        self.info(
+            f"Registered {self.name} as consumer with {self.radiator_power}W power",
+            "",
+        )
+
+    # Function to get the temperature limits based on the current month
+    def get_temperature_limits_for_current_month(self) -> tuple[float, float]:
+        """Get the temperature limits for the current month.
+        The limits are defined in a dictionary where the keys are month numbers (1-12)
+        and the values are tuples of (min_temp, max_temp).
+        Returns: tuple: (min_temp, max_temp)
+        """
+        current_month: int = datetime.now().month
+        # Get the min and max temperatures for the current month
+        min_temp, max_temp = self.temperature_limits[current_month]
+        return min_temp, max_temp
 
     def sort_by_rank(
         self, hours: list[dict[str, Any]], ts_utc_now: float
@@ -170,7 +218,7 @@ class HeatingOptimizer(Juham):
             reverse=True,
         )
         self.debug(
-            f"Sorted {len(sh)} days of forecast starting at {timestampstr(ts_utc)}"
+            f"{self.name} sorted {len(sh)} days of forecast starting at {timestampstr(ts_utc)}"
         )
         ranked_hours: list[dict[str, Any]] = []
 
@@ -178,7 +226,9 @@ class HeatingOptimizer(Juham):
             utc_ts: float = float(h["ts"])
             if utc_ts >= ts_utc:
                 ranked_hours.append(h)
-        self.debug(f"Forecast sorted for the next {str(len(ranked_hours))} hours")
+        self.debug(
+            f"{self.name} 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:
@@ -206,7 +256,7 @@ class HeatingOptimizer(Juham):
 
         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"
+            f"{self.name} solar energy forecast received and ranked for {len(self.ranked_solarpower)} hours"
         )
         self.power_plan = []  # reset power plan, it depends on forecast
 
@@ -215,13 +265,13 @@ class HeatingOptimizer(Juham):
         m = None
         ts: float = timestamp()
         ts_utc_quantized: float = quantize(3600, ts - 3600)
-        if msg.topic == self.topic_spot:
+        if msg.topic == self.topic_in_spot:
             self.on_spot(json.loads(msg.payload.decode()), ts_utc_quantized)
             return
-        elif msg.topic == self.topic_forecast:
+        elif msg.topic == self.topic_in_forecast:
             self.on_forecast(json.loads(msg.payload.decode()), ts_utc_quantized)
             return
-        elif msg.topic == self.topic_temperature:
+        elif msg.topic == self.topic_in_temperature:
             m = json.loads(msg.payload.decode())
             self.current_temperature = m["temperature"]
         elif msg.topic == self.topic_in_energybalance:
@@ -250,24 +300,24 @@ class HeatingOptimizer(Juham):
         self.relay_started_ts = ts_utc_now
 
         if not self.ranked_spot_prices:
-            self.debug("Waiting  spot prices...", "")
+            self.debug("{self.name} waiting  spot prices...", "")
             return
 
         if not self.power_plan:
             self.power_plan = self.create_power_plan()
             self.heating_plan = []
             self.info(
-                f"Power plan of length {len(self.power_plan)} created",
+                f"{self.name} power plan of length {len(self.power_plan)} created",
                 str(self.power_plan),
             )
 
         if not self.power_plan:
-            self.error("Failed to create a power plan", "")
+            self.error("{self.name} failed to create a power plan", "")
             return
 
         if len(self.power_plan) < 3:
             self.warning(
-                f"Suspiciously short {len(self.power_plan)}  power plan, wait more data ..",
+                f"{self.name} has suspiciously short {len(self.power_plan)}  power plan, waiting for more data ..",
                 "",
             )
             self.heating_plan = []
@@ -276,21 +326,25 @@ class HeatingOptimizer(Juham):
 
         if not self.ranked_solarpower or len(self.ranked_solarpower) < 4:
             self.warning(
-                f"Short of forecast {len(self.ranked_solarpower)}, optimization compromised..",
+                f"{self.name} short of forecast {len(self.ranked_solarpower)}, optimization compromised..",
                 "",
             )
 
         if not self.heating_plan:
             self.heating_plan = self.create_heating_plan()
             if not self.heating_plan:
-                self.error("Failed to create heating plan")
+                self.error("{self.name} failed to create heating plan")
                 return
             else:
                 self.info(
-                    f"Heating plan of length {len(self.heating_plan)} created", ""
+                    f"{self.name} heating plan of length {len(self.heating_plan)} created",
+                    "",
                 )
         if len(self.heating_plan) < 3:
-            self.info(f"Short heating plan {len(self.heating_plan)}, no can do", "")
+            self.warning(
+                f"{self.name} has too short heating plan {len(self.heating_plan)}, no can do",
+                "",
+            )
             self.heating_plan = []
             self.power_plan = []
             return
@@ -304,7 +358,7 @@ class HeatingOptimizer(Juham):
             }
             self.publish(self.topic_out_power, json.dumps(heat), 1, False)
             self.info(
-                f"Relay state {self.name} changed to {relay} at {timestampstr(ts_utc_now)}",
+                f"{self.name} relay changed to {relay} at {timestampstr(ts_utc_now)}",
                 "",
             )
             self.current_relay_state = relay
@@ -321,9 +375,6 @@ 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
@@ -339,28 +390,45 @@ class HeatingOptimizer(Juham):
 
         # check if we have excess energy to spent within the current slot
         if self.net_energy_balance_mode:
-            self.info("Positive net energy balance, spend it for heating")
+            self.debug(
+                "{self.name} with positive net energy balance, spend it for heating"
+            )
             return 1
 
-        # no free energy available, don't spend if the current temperature is already high enough
-        if self.current_temperature > self.maximum_boiler_temperature:
-            self.info(
-                f"Current temperature {self.current_temperature}C already beyond max {self.maximum_boiler_temperature}C"
-            )
-            return 0
         hour = timestamp_hour(ts)
+        state: int = -1
 
         # check if we are within the heating plan and see what the plan says
         for pp in self.heating_plan:
             ppts: float = pp["Timestamp"]
             h: float = timestamp_hour(ppts)
             if h == hour:
-                return pp["State"]
+                state = pp["State"]
+                break
+
+        if state == -1:
+            self.error(f"{self.name} cannot find heating plan for hour {hour}")
+            return 0
+
+        min_temp, max_temp = self.get_temperature_limits_for_current_month()
+        self.debug(
+            f"{self.name} month's temperature limits: Min = {min_temp}°C, Max = {max_temp}°C"
+        )
+
+        # don't heat if the current temperature is already high enough
+        if self.current_temperature > max_temp:
+            self.debug(
+                f"{self.name} plan {state}, temp {self.current_temperature}°C already beyond max {max_temp}°C"
+            )
+            return 0
+        #  heat if the current temperature is below the required minimum
+        if self.current_temperature < min_temp:
+            self.debug(
+                f"{self.name} plan {state}, temp {self.current_temperature}°C below min {min_temp}°C"
+            )
+            return 1
 
-        # if we are not within the heating plan, then we are not heating
-        # this should not happen, but just in case
-        self.error(f"Cannot find heating plan for hour {hour}")
-        return 0
+        return state  # 1 = heating, 0 = not heating
 
     # compute utilization optimization index
     def compute_uoi(
@@ -427,7 +495,7 @@ class HeatingOptimizer(Juham):
         ts_utc_quantized = quantize(3600, timestamp() - 3600)
         starts: str = timestampstr(ts_utc_quantized)
         self.info(
-            f"Trying to create power plan starting at {starts} with {len(self.ranked_spot_prices)}  hourly spot prices",
+            f"{self.name} created power plan starting at {starts} with {len(self.ranked_spot_prices)} hours of spot prices",
             "",
         )
 
@@ -440,10 +508,11 @@ class HeatingOptimizer(Juham):
                 )
 
         if len(spots) == 0:
-            self.debug(
+            self.info(
                 f"No spot prices initialized yet, can't proceed",
                 "",
             )
+            return []
         self.info(
             f"Have spot prices for the next {len(spots)} hours",
             "",
@@ -499,7 +568,7 @@ class HeatingOptimizer(Juham):
 
         shplan = sorted(hplan, key=lambda x: x["FOM"], reverse=True)
 
-        self.debug(f"Powerplan starts {starts} up to {len(shplan)} hours")
+        self.debug(f"{self.name} powerplan starts {starts} up to {len(shplan)} hours")
         return shplan
 
     def enable_relay(
@@ -549,5 +618,5 @@ class HeatingOptimizer(Juham):
             heating_plan.append(heat)
             hour = hour + 1
 
-        self.info(f"Heating plan of {len(heating_plan)} hours created", "")
+        self.info(f"{self.name} heating plan of {len(heating_plan)} hours created", "")
         return heating_plan

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.30.dist-info → juham_automation-0.0.33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: juham-automation
-Version: 0.0.30
+Version: 0.0.33
 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.30.dist-info → juham_automation-0.0.33.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=HcBTCI4eS429Up2-lx5zkAZQmZGn2ZCVTwGCavsjGg4,10722
+juham_automation/automation/energybalancer.py,sha256=2WnnajZdZZjHqUT9onCQCdkAIy_1nom8-y3u_pv2GM0,10844
 juham_automation/automation/energycostcalculator.py,sha256=v30wxRpuY2gGBSMJifrFRTjsRU9t-iCiq33Vds7s3O8,10877
-juham_automation/automation/heatingoptimizer.py,sha256=V56gZEsjJOf4veZCZYT1JUv8Tv8lmZ-65zLEb6T7q8s,21488
+juham_automation/automation/heatingoptimizer.py,sha256=DU-VvEHEZAj3C6CkT6K-7f-LhkAXRBYdf6RoxKbgydc,24412
 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.30.dist-info/licenses/LICENSE.rst,sha256=QVHD5V5_HSys2PdPdig_xKggDj8cGX33ALKqRsYyjtI,1089
-juham_automation-0.0.30.dist-info/METADATA,sha256=Be-9u_ReioR9XS4Z4U8jtaQBxrSbdGfoJPQHx9OkaXg,6837
-juham_automation-0.0.30.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-juham_automation-0.0.30.dist-info/entry_points.txt,sha256=h-KzuKjmGPd4_iX_oiGvxx4IEc97dVbGGlhdh5ctbpI,605
-juham_automation-0.0.30.dist-info/top_level.txt,sha256=jfohvtocvX_gfT21AhJk7Iay5ZiQsS3HzrDjF7S4Qp0,17
-juham_automation-0.0.30.dist-info/RECORD,,
+juham_automation-0.0.33.dist-info/licenses/LICENSE.rst,sha256=QVHD5V5_HSys2PdPdig_xKggDj8cGX33ALKqRsYyjtI,1089
+juham_automation-0.0.33.dist-info/METADATA,sha256=paKzowab6A0iDnu5qduBVXOWofockK1LhXp2KzcSnX4,6837
+juham_automation-0.0.33.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+juham_automation-0.0.33.dist-info/entry_points.txt,sha256=h-KzuKjmGPd4_iX_oiGvxx4IEc97dVbGGlhdh5ctbpI,605
+juham_automation-0.0.33.dist-info/top_level.txt,sha256=jfohvtocvX_gfT21AhJk7Iay5ZiQsS3HzrDjF7S4Qp0,17
+juham_automation-0.0.33.dist-info/RECORD,,

{juham_automation-0.0.30.dist-info → juham_automation-0.0.33.dist-info}/WHEEL

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