Make sure the integral update every minute

Author: Alexwijn

custom_components/sat/area.py

@@ -18,7 +18,7 @@
 from .entry_data import SatConfig
 from .heating_curve import HeatingCurve
 from .helpers import float_value, is_state_stale, state_age_seconds
-from .pid import PID
+from .pid import PID, PID_UPDATE_INTERVAL
 from .temperature.state import TemperatureStates, TemperatureState
 
 _LOGGER = logging.getLogger(__name__)
@@ -208,15 +208,12 @@ async def async_added_to_hass(self, hass: HomeAssistant, device_id) -> None:
         await self.pid.async_added_to_hass(hass, self._entity_id, device_id)
 
         if hass.state is CoreState.running:
-            self.update()
+            self.control_pid()
         else:
-            hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STARTED, self.update)
+            hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STARTED, self.control_pid)
 
         self._time_interval = async_track_time_interval(
-            self._hass,
-            self.update,
-            timedelta(seconds=30),
-            cancel_on_shutdown=True,
+            self._hass, self.control_pid, timedelta(seconds=PID_UPDATE_INTERVAL), cancel_on_shutdown=True
         )
 
     async def async_will_remove_from_hass(self) -> None:
@@ -229,7 +226,7 @@ async def async_outside_entity_changed(self, _event: Event[EventStateChangedData
         """Handle changes to the outside entity."""
         self.heating_curve.update(self.target_temperature, self.current_temperature)
 
-    def update(self, _time: Optional[datetime] = None) -> None:
+    def control_pid(self, _time: Optional[datetime] = None) -> None:
         """Update the PID controller with the current error and heating curve."""
         if (error := self.error) is None:
             _LOGGER.debug("Skipping control loop for %s because error could not be computed", self._entity_id)

custom_components/sat/climate.py

@@ -36,7 +36,7 @@
 from .heating_control import HeatingDemand, SatHeatingControl
 from .heating_curve import HeatingCurve
 from .helpers import is_state_stale, state_age_seconds, clamp, ensure_list, event_timestamp
-from .pid import PID
+from .pid import PID, PID_UPDATE_INTERVAL
 from .summer_simmer import SummerSimmer
 from .temperature.history import TemperatureHistory
 from .temperature.history import TemperatureStatistics
@@ -629,7 +629,7 @@ def _register_event_listeners(self) -> None:
 
         self.async_on_remove(
             async_track_time_interval(
-                self.hass, self.control_pid, timedelta(seconds=30)
+                self.hass, self.control_pid, timedelta(seconds=PID_UPDATE_INTERVAL), cancel_on_shutdown=True
             )
         )
 

custom_components/sat/pid.py

@@ -10,23 +10,23 @@
 from .const import *
 from .entry_data import PidConfig, SatConfig
 from .heating_curve import HeatingCurve
-from .helpers import float_value, timestamp as _timestamp, clamp_to_range
+from .helpers import float_value, clamp_to_range
 from .temperature.state import TemperatureState
 from .types import HeatingSystem
 
 _LOGGER = logging.getLogger(__name__)
-timestamp = _timestamp  # keep public name for tests
 
 DERIVATIVE_ALPHA1 = 0.8
 DERIVATIVE_ALPHA2 = 0.6
 DERIVATIVE_RAW_CAP = 5.0
 
+PID_UPDATE_INTERVAL = 60
+
 STORAGE_VERSION = 1
 STORAGE_KEY_INTEGRAL = "integral"
 STORAGE_KEY_LAST_ERROR = "last_error"
 STORAGE_KEY_RAW_DERIVATIVE = "raw_derivative"
 STORAGE_KEY_LAST_TEMPERATURE = "last_temperature"
-STORAGE_KEY_LAST_INTEGRAL_UPDATED = "last_integral_updated"
 STORAGE_KEY_LAST_DERIVATIVE_UPDATED = "last_derivative_updated"
 
 
@@ -40,7 +40,6 @@ def __init__(self, heating_system: HeatingSystem, heating_curve: HeatingCurve, c
 
         self._integral: float = 0.0
         self._last_error: Optional[float] = None
-        self._last_integral_updated: Optional[float] = None
 
         self._raw_derivative: float = 0.0
         self._last_temperature: Optional[float] = None
@@ -139,7 +138,6 @@ def reset(self) -> None:
         """Reset the PID controller to a clean state."""
         self._integral = 0.0
         self._last_error = None
-        self._last_integral_updated = None
 
     async def async_added_to_hass(self, hass: HomeAssistant, entity_id: str, device_id: str) -> None:
         """Restore PID controller state from storage when the integration loads."""
@@ -155,7 +153,6 @@ async def async_added_to_hass(self, hass: HomeAssistant, entity_id: str, device_
         self._last_derivative_updated = float_value(data.get(STORAGE_KEY_LAST_DERIVATIVE_UPDATED))
 
         self._integral = float(data.get(STORAGE_KEY_INTEGRAL, self._integral))
-        self._last_integral_updated = float_value(data.get(STORAGE_KEY_LAST_INTEGRAL_UPDATED))
         self._raw_derivative = float(data.get(STORAGE_KEY_RAW_DERIVATIVE, self._raw_derivative))
 
         _LOGGER.debug("Loaded PID state from storage for entity=%s", self._entity_id)
@@ -188,35 +185,13 @@ def _update_integral(self, state: TemperatureState) -> None:
         """Update the integral value in the PID controller."""
         if abs(state.error) > DEADBAND:
             self._integral = 0.0
-            self._last_integral_updated = None
-            return
-
-        if self._last_integral_updated is None:
-            self._last_integral_updated = state.last_changed.timestamp()
-            return
-
-        delta_time = state.last_changed.timestamp() - self._last_integral_updated
-
-        # Ignore non-forward timestamps.
-        if delta_time <= 0:
-            self._last_integral_updated = state.last_changed.timestamp()
             return
 
-        # Skip integration when integral gain is disabled.
-        if self.ki is None:
-            return
-
-        self._integral += self.ki * state.error * delta_time
+        self._integral += self.ki * state.error * PID_UPDATE_INTERVAL
         self._integral = clamp_to_range(self._integral, self._heating_curve.value)
 
-        # Record the timestamp used for this integration step.
-        self._last_integral_updated = state.last_changed.timestamp()
-
     def _update_derivative(self, state: TemperatureState) -> None:
         """Update the derivative term of the PID controller based on temperature slope."""
-        if self.kd is None:
-            return
-
         if self._last_temperature is None or self._last_derivative_updated is None:
             self._last_temperature = state.current
             self._last_derivative_updated = state.last_changed.timestamp()
@@ -228,6 +203,7 @@ def _update_derivative(self, state: TemperatureState) -> None:
             return
 
         temperature_delta = state.current - self._last_temperature
+
         if temperature_delta == 0.0:
             self._last_temperature = state.current
             self._last_derivative_updated = state.last_changed.timestamp()
@@ -265,7 +241,6 @@ async def _async_save_state(self) -> None:
             STORAGE_KEY_LAST_ERROR: self._last_error,
             STORAGE_KEY_RAW_DERIVATIVE: self._raw_derivative,
             STORAGE_KEY_LAST_TEMPERATURE: self._last_temperature,
-            STORAGE_KEY_LAST_INTEGRAL_UPDATED: self._last_integral_updated,
             STORAGE_KEY_LAST_DERIVATIVE_UPDATED: self._last_derivative_updated,
         }
 

tests/test_pid.py

@@ -11,7 +11,7 @@
     DERIVATIVE_ALPHA1,
     DERIVATIVE_ALPHA2,
     DERIVATIVE_RAW_CAP,
-    PID,
+    PID, PID_UPDATE_INTERVAL,
 )
 from custom_components.sat.temperature.state import TemperatureState
 from custom_components.sat.types import HeatingSystem
@@ -98,9 +98,9 @@ def test_manual_gains_output_and_availability():
     assert pid.ki == 1.0
     assert pid.kd == 0.5
     assert pid.proportional == 0.1
-    assert pid.integral == 0.5
+    assert pid.integral == 6.0
     assert pid.derivative == 0.0
-    assert pid.output == 30.6
+    assert pid.output == 36.1
 
 
 def test_automatic_gains_calculation():
@@ -136,10 +136,13 @@ def test_integral_timebase_reset_and_accumulation():
     assert pid.integral == 0.0
 
     pid.update(_state_for_error(DEADBAND / 2, 20.0))
-    assert pid.integral == 0.0
+    assert pid.integral == 3.0
 
     pid.update(_state_for_error(DEADBAND / 2, 30.0))
-    assert pid.integral == 0.5
+    assert pid.integral == 6.0
+
+    pid.update(_state_for_error(DEADBAND / 2, 20.0 + PID_UPDATE_INTERVAL))
+    assert pid.integral == 9.0
 
 
 def test_integral_clamped_to_heating_curve():