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

juham_automation/automation/energybalancer.py

@@ -14,7 +14,7 @@ class Consumer:
 
     """
 
-    def __init__(self, name: str, power) -> None:
+    def __init__(self, name: str, power: float) -> None:
         """Initialize the consumer
 
         Args:
@@ -209,14 +209,13 @@ class EnergyBalancer(Juham):
         }
         self.publish(self.topic_out_diagnostics, json.dumps(m))
 
-
         # 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] = {
+            m = {
                 "EnergyBalancer": self.name,
                 "Unit": consumer.name,
                 "Power": consumer.power,
@@ -263,4 +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
-

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
@@ -322,7 +376,6 @@ class HeatingOptimizer(Juham):
         if m["Unit"] == self.name:
             self.net_energy_balance_mode = m["Mode"]
 
-
     def consider_heating(self, ts: float) -> int:
         """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.
@@ -337,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 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
+        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
+
+        return state  # 1 = heating, 0 = not heating
 
     # compute utilization optimization index
     def compute_uoi(
@@ -425,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",
             "",
         )
 
@@ -438,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",
             "",
@@ -497,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(
@@ -547,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-0.0.31.dist-info → juham_automation-0.0.33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: juham-automation
-Version: 0.0.31
+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.31.dist-info → juham_automation-0.0.33.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=_08KikTDO3zHsRCV0oI7xyRpMyk594Q1C0acalRQoQs,10855
+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=LMZ4Cr1CTsk1HI9D0P27l1bPFDepylhDh87dTd204r0,21367
+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
@@ -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.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.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.31.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