Improved area presets and weighting

Author: Alexwijn

custom_components/sat/area.py

@@ -297,8 +297,7 @@ def __init__(self, areas, percentile: float = 0.75, headroom: float = 5.0):
         @property
         def output(self) -> float:
             """Aggregate PID output + count for areas that are calling for heat."""
-            area_count = 0
-            outputs: list[float] = []
+            outputs: list[tuple[float, float]] = []
 
             for area in self._areas:
                 if not area.pid.available or not area.requires_heat:
@@ -310,18 +309,34 @@ def output(self) -> float:
                     _LOGGER.warning("Failed to compute PID output for area %s: %s", area.id, exception)
                     continue
 
-                area_count += 1
-                outputs.append(value)
+                weight = area.demand_weight
+                if weight is None or weight <= 0.0:
+                    weight = area.room_weight
+
+                outputs.append((value, weight))
 
             if not outputs:
                 return MINIMUM_SETPOINT
 
-            outputs.sort()
-            index = max(0, min(len(outputs) - 1, int(len(outputs) * self._percentile)))
-            baseline = outputs[index]
+            outputs.sort(key=lambda item: item[0])
+
+            total_weight = sum(weight for _, weight in outputs)
+            if total_weight <= 0.0:
+                baseline = outputs[-1][0]
+            else:
+                cumulative = 0.0
+                baseline = outputs[-1][0]
+                threshold = total_weight * self._percentile
 
+                for value, weight in outputs:
+                    cumulative += weight
+                    if cumulative >= threshold:
+                        baseline = value
+                        break
+
+            max_output = outputs[-1][0]
             allowed = baseline + self._headroom
-            chosen = min(outputs[-1], allowed)
+            chosen = min(max_output, allowed)
 
             return round(chosen, 1)
 
@@ -331,7 +346,7 @@ def overshoot_cap(self) -> Optional[float]:
             caps: list[float] = []
 
             for area in self._areas:
-                if not area.pid.available or not area.requires_heat:
+                if not area.pid.available:
                     continue
 
                 if (temperature_state := area.temperature_state) is None:

custom_components/sat/climate.py

@@ -43,7 +43,6 @@
 from .temperature.state import TemperatureState
 from .types import PWMStatus, HeatingMode
 
-ATTR_ROOMS = "rooms"
 ATTR_SETPOINT = "setpoint"
 ATTR_RELATIVE_MODULATION_VALUE = "relative_modulation_value"
 
@@ -81,7 +80,6 @@ def __init__(self, coordinator: SatDataUpdateCoordinator, heating_control: SatHe
 
         self._sensors: dict[str, str] = {}
 
-        self._rooms: Optional[dict[str, float]] = None
         self._presets: dict[str, float] = self._build_presets(config.presets.presets)
 
         self._target_temperature: Optional[float] = None
@@ -177,7 +175,6 @@ def extra_state_attributes(self) -> dict[str, Any]:
             "pre_custom_temperature": self._pre_custom_temperature,
             "pre_activity_temperature": self._pre_activity_temperature,
 
-            "rooms": self._rooms,
             "current_humidity": self.current_humidity,
             "setpoint": self._heating_control.control_setpoint,
 
@@ -541,10 +538,8 @@ async def async_set_preset_mode(self, preset_mode: str) -> None:
                     if state is None or state.state == HVACMode.OFF:
                         continue
 
-                    if preset_mode != PRESET_HOME:
-                        target_temperature = self._presets[preset_mode]
-                    else:
-                        target_temperature = self._rooms.get(entity_id, self._presets[preset_mode])
+                    if (target_temperature := self._room_preset_target(entity_id)) is None:
+                        continue
 
                     data = {ATTR_ENTITY_ID: entity_id, ATTR_TEMPERATURE: target_temperature}
                     await self.hass.services.async_call(CLIMATE_DOMAIN, SERVICE_SET_TEMPERATURE, data, blocking=True)
@@ -691,15 +686,7 @@ async def _restore_previous_state_or_set_defaults(self) -> None:
 
             if old_state.attributes.get(ATTR_PRE_CUSTOM_TEMPERATURE):
                 self._pre_custom_temperature = old_state.attributes.get(ATTR_PRE_CUSTOM_TEMPERATURE)
-
-            if old_state.attributes.get(ATTR_ROOMS):
-                self._rooms = old_state.attributes.get(ATTR_ROOMS)
-            else:
-                await self._async_update_rooms_from_climates()
         else:
-            if self._rooms is None:
-                await self._async_update_rooms_from_climates()
-
             if self._target_temperature is None:
                 self.pid.control_setpoint = self.min_temp
                 self._target_temperature = self.min_temp
@@ -747,27 +734,11 @@ async def _async_entity_changed(self, event: Event[EventStateChangedData]) -> No
 
     async def _async_climate_changed(self, event: Event[EventStateChangedData]) -> None:
         """Handle changes to a climate entity."""
-        new_state = event.data.get("new_state")
-
-        if not new_state or self._rooms is None:
-            return
-
-        # Get the attributes of the new state
-        new_attrs = new_state.attributes
-
-        if (target_temperature := new_attrs.get("temperature")) is None:
-            return
-
-        if float(target_temperature) == self._rooms.get(new_state.entity_id, target_temperature):
+        if not (new_state := event.data.get("new_state")) or new_state.attributes.get("temperature") is None:
             return
 
-        if new_state.entity_id not in self._rooms or self.preset_mode == PRESET_HOME:
-            self._rooms[new_state.entity_id] = float(target_temperature)
-            _LOGGER.debug(f"Updated area preset temperature for {new_state.entity_id} to {target_temperature}")
-
         self.areas.pids.reset(new_state.entity_id)
         self._update_heating_curves()
-
         self.async_write_ha_state()
 
     async def _async_window_sensor_changed(self, event: Event[EventStateChangedData]) -> None:
@@ -806,27 +777,20 @@ async def _async_window_sensor_changed(self, event: Event[EventStateChangedData]
 
             return
 
-    async def _async_update_rooms_from_climates(self) -> None:
-        """Update the temperature setpoint for each room based on their associated climate entity."""
-        self._rooms = {}
-
-        # Iterate through each climate entity
-        for entity_id in self.areas.ids():
-            state = self.hass.states.get(entity_id)
-
-            # Skip any entities that are unavailable or have an unknown state
-            if not state or state.state in [STATE_UNKNOWN, STATE_UNAVAILABLE]:
-                continue
-
-            # Retrieve the target temperature from the climate entity's attributes
-            target_temperature = state.attributes.get("temperature")
-
-            # If the target temperature exists, store it in the _rooms dictionary with the climate entity as the key
-            if target_temperature is not None:
-                self._rooms[entity_id] = float(target_temperature)
-
     @staticmethod
     def _build_presets(config_options: Mapping[str, float]) -> dict[str, float]:
         """Build preset temperature mapping from config options."""
         conf_presets = {p: f"{p}_temperature" for p in (PRESET_ACTIVITY, PRESET_AWAY, PRESET_HOME, PRESET_SLEEP, PRESET_COMFORT)}
         return {key: config_options[value] for key, value in conf_presets.items() if key in conf_presets}
+
+    def _room_preset_target(self, entity_id: str) -> Optional[float]:
+        preset_mode = self._attr_preset_mode
+        if preset_mode == PRESET_NONE:
+            return self._target_temperature
+
+        preset_temperature = self._presets.get(preset_mode)
+        overrides = self._config.presets.preset_room_overrides.get(preset_mode, {})
+        if (override := overrides.get(entity_id)) is not None:
+            return float(override)
+
+        return preset_temperature if preset_temperature is not None else self._target_temperature

custom_components/sat/config_flow.py

@@ -6,6 +6,13 @@
 import voluptuous as vol
 from homeassistant import config_entries
 from homeassistant.components import sensor, switch, valve, weather, binary_sensor, climate, input_boolean
+from homeassistant.components.climate import (
+    PRESET_ACTIVITY,
+    PRESET_AWAY,
+    PRESET_COMFORT,
+    PRESET_HOME,
+    PRESET_SLEEP,
+)
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import callback
 from homeassistant.helpers import selector, entity_registry
@@ -628,46 +635,96 @@ async def async_step_general(self, _user_input: Optional[dict[str, Any]] = None)
             )
         )
 
+        schema[vol.Required(CONF_SYNC_CLIMATES_WITH_PRESET, default=options[CONF_SYNC_CLIMATES_WITH_PRESET])] = bool
+        schema[vol.Required(CONF_PUSH_SETPOINT_TO_THERMOSTAT, default=options[CONF_PUSH_SETPOINT_TO_THERMOSTAT])] = bool
+
         return self.async_show_form(step_id="general", data_schema=vol.Schema(schema))
 
     async def async_step_presets(self, _user_input: Optional[dict[str, Any]] = None):
-        if _user_input is not None:
-            return await self.update_options(_user_input)
+        if len(self._config_entry.data.get(CONF_ROOMS, [])) > 0:
+            return self.async_show_menu(
+                step_id="presets",
+                menu_options=[
+                    "preset_home",
+                    "preset_comfort",
+                    "preset_sleep",
+                    "preset_away",
+                    "preset_activity",
+                ]
+            )
+
+        return await self.async_step_preset_home(_user_input)
+
+    async def async_step_preset_home(self, user_input: Optional[dict[str, Any]] = None):
+        return await self._async_step_preset_settings(PRESET_HOME, CONF_HOME_TEMPERATURE, user_input)
+
+    async def async_step_preset_comfort(self, user_input: Optional[dict[str, Any]] = None):
+        return await self._async_step_preset_settings(PRESET_COMFORT, CONF_COMFORT_TEMPERATURE, user_input)
+
+    async def async_step_preset_sleep(self, user_input: Optional[dict[str, Any]] = None):
+        return await self._async_step_preset_settings(PRESET_SLEEP, CONF_SLEEP_TEMPERATURE, user_input)
+
+    async def async_step_preset_away(self, user_input: Optional[dict[str, Any]] = None):
+        return await self._async_step_preset_settings(PRESET_AWAY, CONF_AWAY_TEMPERATURE, user_input)
+
+    async def async_step_preset_activity(self, user_input: Optional[dict[str, Any]] = None):
+        return await self._async_step_preset_settings(PRESET_ACTIVITY, CONF_ACTIVITY_TEMPERATURE, user_input)
+
+    async def _async_step_preset_settings(self, preset: str, preset_option_key: str, user_input: Optional[dict[str, Any]] = None):
+        primary_key = "primary_temperature"
+        if user_input is not None:
+            options = await self.get_options()
+            overrides = dict(options.get(CONF_PRESET_ROOM_OVERRIDES) or {})
+            room_overrides: dict[str, float] = {}
+
+            for entity_id in self._config_entry.data.get(CONF_ROOMS, []):
+                raw_value = user_input.get(entity_id)
+                if raw_value is None:
+                    continue
+
+                try:
+                    value = float(raw_value)
+                except (TypeError, ValueError):
+                    continue
+
+                if abs(value - float(user_input[primary_key])) > 0.001:
+                    room_overrides[entity_id] = value
+
+            if room_overrides:
+                overrides[preset] = room_overrides
+            else:
+                overrides.pop(preset, None)
+
+            update = {
+                preset_option_key: user_input[primary_key],
+                CONF_PRESET_ROOM_OVERRIDES: overrides,
+            }
+
+            return await self.update_options(update)
 
         options = await self.get_options()
-        schema_entries: list[tuple[Marker, Any]] = [
-            (
-                vol.Required(CONF_HOME_TEMPERATURE, default=options[CONF_HOME_TEMPERATURE]),
-                selector.NumberSelector(selector.NumberSelectorConfig(min=5, max=35, step=0.5, unit_of_measurement="°C")),
-            ),
-            (
-                vol.Required(CONF_COMFORT_TEMPERATURE, default=options[CONF_COMFORT_TEMPERATURE]),
-                selector.NumberSelector(selector.NumberSelectorConfig(min=5, max=35, step=0.5, unit_of_measurement="°C")),
-            ),
-            (
-                vol.Required(CONF_SLEEP_TEMPERATURE, default=options[CONF_SLEEP_TEMPERATURE]),
-                selector.NumberSelector(selector.NumberSelectorConfig(min=5, max=35, step=0.5, unit_of_measurement="°C")),
-            ),
-            (
-                vol.Required(CONF_AWAY_TEMPERATURE, default=options[CONF_AWAY_TEMPERATURE]),
-                selector.NumberSelector(selector.NumberSelectorConfig(min=5, max=35, step=0.5, unit_of_measurement="°C")),
-            ),
-            (
-                vol.Required(CONF_ACTIVITY_TEMPERATURE, default=options[CONF_ACTIVITY_TEMPERATURE]),
-                selector.NumberSelector(selector.NumberSelectorConfig(min=5, max=35, step=0.5, unit_of_measurement="°C")),
-            ),
-            (vol.Required(CONF_SYNC_CLIMATES_WITH_PRESET, default=options[CONF_SYNC_CLIMATES_WITH_PRESET]), bool),
-            (vol.Required(CONF_PUSH_SETPOINT_TO_THERMOSTAT, default=options[CONF_PUSH_SETPOINT_TO_THERMOSTAT]), bool),
-        ]
+        overrides = options.get(CONF_PRESET_ROOM_OVERRIDES) or {}
+
+        preset_overrides = overrides.get(preset, {})
+        preset_default = float(options[preset_option_key])
+
+        schema_fields: dict[Marker, Any] = {
+            vol.Required(primary_key, default=preset_default): selector.NumberSelector(
+                selector.NumberSelectorConfig(min=5, max=35, step=0.5, unit_of_measurement="°C")
+            )
+        }
+
+        for entity_id in self._config_entry.data.get(CONF_ROOMS, []):
+            default_value = preset_overrides.get(entity_id, preset_default)
+            schema_fields[vol.Required(entity_id, default=default_value)] = selector.NumberSelector(selector.NumberSelectorConfig(min=5, max=35, step=0.5, unit_of_measurement="°C"))
 
         return self.async_show_form(
-            step_id="presets",
-            data_schema=vol.Schema({key: value for key, value in schema_entries})
+            step_id=f"preset_{preset}",
+            data_schema=vol.Schema(schema_fields),
         )
 
     async def async_step_areas(self, user_input: Optional[dict[str, Any]] = None):
         room_weights: dict[str, float] = dict(self._options.get(CONF_ROOM_WEIGHTS, {}))
-
         room_entity_ids: list[str] = list(self._config_entry.data.get(CONF_ROOMS, []))
 
         # Build stable schema keys (entity_id) and friendly labels separately

custom_components/sat/const.py

@@ -74,6 +74,7 @@
 CONF_MODULATION_SUPPRESSION_DELAY_SECONDS = "modulation_suppression_delay_seconds"
 CONF_MODULATION_SUPPRESSION_OFFSET_CELSIUS = "modulation_suppression_offset_celsius"
 CONF_FLOW_SETPOINT_OFFSET_CELSIUS = "flow_setpoint_offset_celsius"
+CONF_PRESET_ROOM_OVERRIDES = "preset_room_overrides"
 CONF_MINIMUM_BOILER_PRESSURE = "minimum_boiler_pressure"
 CONF_MAXIMUM_BOILER_PRESSURE = "maximum_boiler_pressure"
 CONF_MAXIMUM_PRESSURE_DROP_RATE = "maximum_pressure_drop_rate"
@@ -136,6 +137,7 @@
     CONF_MODULATION_SUPPRESSION_DELAY_SECONDS: 20,
     CONF_MODULATION_SUPPRESSION_OFFSET_CELSIUS: 1.0,
     CONF_FLOW_SETPOINT_OFFSET_CELSIUS: 2.0,
+    CONF_PRESET_ROOM_OVERRIDES: {},
 
     # Pressure health thresholds.
     CONF_MINIMUM_BOILER_PRESSURE: 0.8,

custom_components/sat/entry_data.py

@@ -85,6 +85,7 @@ class PresetConfig:
 
     presets: Mapping[str, float]
     room_weights: Mapping[str, float]
+    preset_room_overrides: Mapping[str, Mapping[str, float]]
 
 
 @dataclass(frozen=True)
@@ -259,6 +260,22 @@ def presets(self) -> PresetConfig:
             CONF_ACTIVITY_TEMPERATURE: self.options.get(CONF_ACTIVITY_TEMPERATURE),
         }
 
+        room_overrides_raw = self.options.get(CONF_PRESET_ROOM_OVERRIDES) or {}
+        room_overrides: dict[str, dict[str, float]] = {}
+        for preset, values in room_overrides_raw.items():
+            if not isinstance(values, Mapping):
+                continue
+
+            overrides: dict[str, float] = {}
+            for entity_id, value in values.items():
+                try:
+                    overrides[entity_id] = float(value)
+                except (TypeError, ValueError):
+                    continue
+
+            if overrides:
+                room_overrides[str(preset)] = overrides
+
         return PresetConfig(
             heating_mode=heating_mode,
             thermal_comfort=bool(self.options.get(CONF_THERMAL_COMFORT)),
@@ -267,6 +284,7 @@ def presets(self) -> PresetConfig:
 
             presets={key: float(value) for key, value in preset_values.items()},
             room_weights=self.options.get(CONF_ROOM_WEIGHTS) or {},
+            preset_room_overrides=room_overrides,
         )
 
     @property