Merge branch 'refs/heads/public-develop'

Author: Alexwijn

custom_components/sat/climate.py

@@ -40,7 +40,7 @@
 from .coordinator import SatDataUpdateCoordinator, DeviceState
 from .entity import SatEntity
 from .errors import Errors, Error
-from .helpers import convert_time_str_to_seconds
+from .helpers import convert_time_str_to_seconds, is_state_stale, state_age_seconds
 from .manufacturers.geminox import Geminox
 from .pwm import PWMState
 from .relative_modulation import RelativeModulation, RelativeModulationState
@@ -90,20 +90,6 @@ def __init__(self, coordinator: SatDataUpdateCoordinator, config_entry: ConfigEn
         self.inside_sensor_entity_id = config_entry.data.get(CONF_INSIDE_SENSOR_ENTITY_ID)
         self.humidity_sensor_entity_id = config_entry.data.get(CONF_HUMIDITY_SENSOR_ENTITY_ID)
 
-        # Get some sensor entity states
-        inside_sensor_entity = coordinator.hass.states.get(self.inside_sensor_entity_id)
-        humidity_sensor_entity = coordinator.hass.states.get(self.humidity_sensor_entity_id) if self.humidity_sensor_entity_id is not None else None
-
-        # Get current temperature
-        self._current_temperature = None
-        if inside_sensor_entity is not None and inside_sensor_entity.state not in [STATE_UNKNOWN, STATE_UNAVAILABLE]:
-            self._current_temperature = float(inside_sensor_entity.state)
-
-        # Get current temperature
-        self._current_humidity = None
-        if humidity_sensor_entity is not None and humidity_sensor_entity.state not in [STATE_UNKNOWN, STATE_UNAVAILABLE]:
-            self._current_humidity = float(humidity_sensor_entity.state)
-
         # Get outside sensor entity IDs
         self.outside_sensor_entities = config_entry.data.get(CONF_OUTSIDE_SENSOR_ENTITY_ID)
 
@@ -405,10 +391,10 @@ def extra_state_attributes(self):
 
             "rooms": self._rooms,
             "setpoint": self._setpoint,
-            "current_humidity": self._current_humidity,
+            "current_humidity": self.current_humidity,
 
-            "summer_simmer_index": SummerSimmer.index(self._current_temperature, self._current_humidity),
-            "summer_simmer_perception": SummerSimmer.perception(self._current_temperature, self._current_humidity),
+            "summer_simmer_index": SummerSimmer.index(self.current_temperature, self.current_humidity),
+            "summer_simmer_perception": SummerSimmer.perception(self.current_temperature, self.current_humidity),
 
             "valves_open": self.valves_open,
             "heating_curve": self.heating_curve.value,
@@ -428,23 +414,29 @@ def extra_state_attributes(self):
         }
 
     @property
-    def current_temperature(self):
+    def current_temperature(self) -> Optional[float]:
         """Return the sensor temperature."""
-        if self._thermal_comfort and self._current_humidity is not None:
-            return SummerSimmer.index(self._current_temperature, self._current_humidity)
+        if (current_temperature := self._get_entity_state_float(self.inside_sensor_entity_id)) is None:
+            return None
+
+        if self._thermal_comfort:
+            return SummerSimmer.index(current_temperature, self.current_humidity)
+
+        return current_temperature
 
-        return self._current_temperature
+    @property
+    def current_humidity(self) -> Optional[float]:
+        """Return the sensor humidity."""
+        if self.humidity_sensor_entity_id is None:
+            return None
+
+        return self._get_entity_state_float(self.humidity_sensor_entity_id)
 
     @property
     def target_temperature(self):
         """Return the temperature we try to reach."""
         return self._target_temperature
 
-    @property
-    def current_humidity(self):
-        """Return the sensor humidity."""
-        return self._current_humidity
-
     @property
     def error(self):
         """Return the error value."""
@@ -632,7 +624,6 @@ async def _async_inside_sensor_changed(self, event: Event[EventStateChangedData]
             return
 
         _LOGGER.debug("Inside Sensor Changed.")
-        self._current_temperature = float(new_state.state)
         self.async_write_ha_state()
 
         self._async_control_pid()
@@ -656,7 +647,6 @@ async def _async_humidity_sensor_changed(self, event: Event[EventStateChangedDat
             return
 
         _LOGGER.debug("Humidity Sensor Changed.")
-        self._current_humidity = float(new_state.state)
         self.async_write_ha_state()
 
         self._async_control_pid()
@@ -1135,3 +1125,22 @@ async def async_send_notification(self, title: str, message: str, service: str =
         """Send a notification to the user."""
         data = {"title": title, "message": message}
         await self.hass.services.async_call(notify.DOMAIN, service, data)
+
+    def _get_entity_state_float(self, entity_id: str) -> Optional[float]:
+        """Return state if available and valid."""
+        if entity_id is None:
+            return None
+
+        if (entity := self.hass.states.get(entity_id)) is None:
+            return None
+
+        sensor_max_value_age = self._sensor_max_value_age
+
+        if is_state_stale(entity, sensor_max_value_age):
+            _LOGGER.debug("Sensor %s stale for %s (age=%.1fs > %.1fs)", entity_id, self.entity_id, state_age_seconds(entity), sensor_max_value_age)
+            return None
+
+        if entity.state in [STATE_UNKNOWN, STATE_UNAVAILABLE]:
+            return None
+
+        return float(entity.state)

custom_components/sat/flame.py

@@ -172,8 +172,6 @@ def update(self, boiler_state: BoilerState, pwm_state: Optional[PWMState] = None
         self._last_boiler_state = boiler_state
         self._last_pulse_width_modulation_state = pwm_state or self._last_pulse_width_modulation_state
 
-        _LOGGER.debug("Flame active=%s->%s, last_update=%.1fs", previously_active, currently_active, elapsed)
-
         if previously_active and elapsed > 0.0:
             self._on_deltas_window.append((now, elapsed))
 
@@ -195,28 +193,13 @@ def update(self, boiler_state: BoilerState, pwm_state: Optional[PWMState] = None
             self._latest_on_time_seconds = now - self._flame_on_monotonic
 
             if self._has_completed_first_cycle:
-                alpha = self._smoothing_alpha
-                previous_average = self._average_on_time_seconds
-
                 self._average_on_time_seconds = (
                     self._latest_on_time_seconds
                     if self._average_on_time_seconds is None
-                    else (1.0 - alpha) * self._average_on_time_seconds + alpha * self._latest_on_time_seconds
+                    else (1.0 - self._smoothing_alpha) * self._average_on_time_seconds + self._smoothing_alpha * self._latest_on_time_seconds
                 )
-            else:
-                previous_average = self._average_on_time_seconds
 
             self._last_update_monotonic = now
-
-            _LOGGER.debug(
-                "Flame transition ON->ON: latest_on=%.1fs, average_on=%s->%s, cycles_last_hour=%.1f, duty_ratio_15m=%.2f",
-                self._latest_on_time_seconds,
-                previous_average,
-                self._average_on_time_seconds,
-                self._cycles_per_hour(now),
-                self._duty_ratio_last_window(now),
-            )
-
             self._recompute_health(now)
             return
 
@@ -252,14 +235,6 @@ def update(self, boiler_state: BoilerState, pwm_state: Optional[PWMState] = None
                 self._flame_off_monotonic = now
 
             self._last_update_monotonic = now
-
-            _LOGGER.debug(
-                "Flame transition OFF->OFF: off_since=%.1fs, cycles_last_hour=%.1f, duty_ratio_15m=%.2f",
-                None if self._flame_off_monotonic is None else now - self._flame_off_monotonic,
-                self._cycles_per_hour(now),
-                self._duty_ratio_last_window(now),
-            )
-
             self._recompute_health(now)
             return
 
@@ -293,8 +268,6 @@ def _recompute_health(self, now: float) -> None:
             timeout = self.MAX_DOMESTIC_HOT_WATER_IDLE_OFF_SECONDS if domestic_hot_water_active else self.STUCK_OFF_SECONDS
             if (not state.flame_active) and last_off_seconds > timeout and state.status not in self._TRANSIENT_STATUSES:
                 self._health_status = FlameStatus.STUCK_OFF
-            else:
-                self._health_status = FlameStatus.INSUFFICIENT_DATA
 
             return
 

custom_components/sat/helpers.py

@@ -3,6 +3,7 @@
 from time import monotonic
 from typing import Optional, Union
 
+from homeassistant.core import State
 from homeassistant.util import dt
 
 from .const import HEATING_SYSTEM_UNDERFLOOR
@@ -16,6 +17,19 @@ def seconds_since(start_time: float | None) -> float:
     return monotonic() - start_time
 
 
+def state_age_seconds(state: State) -> float:
+    """Return the age of a HA state in seconds."""
+    return (dt.utcnow() - state.last_updated).total_seconds()
+
+
+def is_state_stale(state: Optional[State], max_age_seconds: float) -> bool:
+    """Return True when the state is older than max_age_seconds."""
+    if state is None or max_age_seconds <= 0:
+        return False
+
+    return state_age_seconds(state) > max_age_seconds
+
+
 def convert_time_str_to_seconds(time_str: str) -> int:
     """Convert a time string in the format 'HH:MM:SS' to seconds."""
     try:

custom_components/sat/serial/__init__.py

@@ -31,8 +31,14 @@ def __init__(self, hass: HomeAssistant, port: str, config_data: Mapping[str, Any
         self.async_set_updated_data(DEFAULT_STATUS)
 
         self._port: str = port
+        self._hass_loop = hass.loop
         self._api: OpenThermGateway = OpenThermGateway()
-        self._api.subscribe(lambda data: self.async_set_updated_data(data))
+
+        async def _publish(data: dict) -> None:
+            self._hass_loop.call_soon_threadsafe(self.async_set_updated_data, data)
+
+        self._publish_callback = _publish
+        self._api.subscribe(self._publish_callback)
 
     @property
     def device_id(self) -> str:
@@ -137,7 +143,7 @@ def maximum_relative_modulation_value(self) -> Optional[float]:
         return super().maximum_relative_modulation_value
 
     @property
-    def member_id(self) -> int | None:
+    def member_id(self) -> Optional[int]:
         if (value := self.get(DATA_SLAVE_MEMBERID)) is not None:
             return int(value)
 
@@ -148,11 +154,7 @@ def flame_active(self) -> bool:
         return bool(self.get(DATA_SLAVE_FLAME_ON))
 
     def get(self, key: str) -> Optional[Any]:
-        """Get the value for the given `key` from the boiler data.
-
-        :param key: Key of the value to retrieve from the boiler data.
-        :return: Value for the given key from the boiler data, or None if the boiler data or the value are not available.
-        """
+        """Get the value for the given `key` from the boiler data."""
         return self.data[BOILER].get(key)
 
     async def async_connect(self) -> SatSerialCoordinator:
@@ -167,11 +169,15 @@ async def async_setup(self) -> None:
         await self.async_connect()
 
     async def async_will_remove_from_hass(self) -> None:
-        self._api.unsubscribe(self.async_set_updated_data)
+        if self._publish_callback is not None:
+            try:
+                self._api.unsubscribe(self._publish_callback)
+            except Exception:  # pragma: no cover - best effort cleanup
+                _LOGGER.debug("Failed to unsubscribe serial listener", exc_info=True)
+            finally:
+                self._publish_callback = None
 
-        await self._api.set_control_setpoint(0)
-        await self._api.set_max_relative_mod("-")
-        await self._api.disconnect()
+        await self._graceful_disconnect()
 
     async def async_set_control_setpoint(self, value: float) -> None:
         if not self._simulation:
@@ -183,7 +189,7 @@ async def async_set_control_hot_water_setpoint(self, value: float) -> None:
         if not self._simulation:
             await self._api.set_dhw_setpoint(value)
 
-        await super().async_set_control_thermostat_setpoint(value)
+        await super().async_set_control_hot_water_setpoint(value)
 
     async def async_set_control_thermostat_setpoint(self, value: float) -> None:
         if not self._simulation:
@@ -208,3 +214,15 @@ async def async_set_control_max_setpoint(self, value: float) -> None:
             await self._api.set_max_ch_setpoint(value)
 
         await super().async_set_control_max_setpoint(value)
+
+    async def _graceful_disconnect(self) -> None:
+        try:
+            await self._api.set_control_setpoint(0)
+            await self._api.set_max_relative_mod("-")
+        except Exception:  # pragma: no cover - best effort cleanup
+            _LOGGER.debug("Failed to reset serial gateway state before disconnect", exc_info=True)
+
+        try:
+            await self._api.disconnect()
+        except Exception:  # pragma: no cover - best effort cleanup
+            _LOGGER.debug("Error while disconnecting serial gateway", exc_info=True)