Load-profile learner: drop Zuhause, skip wallbox, median, heat pump per temperature band (v2.40.0)

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: xchillxx

README.md

@@ -76,6 +76,12 @@ cloud passes over or another appliance briefly kicks in.
   until a given combination has enough daily samples of its own.
   Diagnostic only for now — visible on the "Lastprofil Wochentag/Modus"
   sensor's attributes — doesn't yet feed into any switching decision.
+  Since v2.40.0: the daytime "Zuhause" mode is no longer learned (spike-
+  dominated, no pattern); samples are skipped while the wallbox charges
+  and for 10 minutes afterwards; per-hour and cross-day values use the
+  median. Optionally add a heat-pump power sensor and an outdoor
+  temperature sensor: the heat pump is then subtracted from the profile
+  and learned separately per temperature band (mean, since it cycles).
 - **Spike-resistant** — the battery-margin projection uses a 20-minute
   rolling median of the discharge rate, so a stove or kettle running for a
   few minutes doesn't get projected forward as if it continued all night.

custom_components/surplus_load_switch/config_flow.py

@@ -31,6 +31,8 @@
     CONF_DEVICE_WINDOW_START,
     CONF_EXPORT_POWER_SENSOR,
     CONF_HAUSMODUS_ENTITY,
+    CONF_HEATPUMP_POWER_SENSOR,
+    CONF_OUTDOOR_TEMP_SENSOR,
     CONF_LOAD_SENSOR,
     CONF_MIN_SOC,
     CONF_SOC_SENSOR,
@@ -80,6 +82,16 @@ def _global_settings_schema(defaults: dict | None = None) -> vol.Schema:
         ): selector.EntitySelector(
             selector.EntitySelectorConfig(domain=["input_select", "select"])
         ),
+        vol.Optional(
+            CONF_HEATPUMP_POWER_SENSOR, **_default(d, CONF_HEATPUMP_POWER_SENSOR)
+        ): selector.EntitySelector(
+            selector.EntitySelectorConfig(domain="sensor", device_class="power")
+        ),
+        vol.Optional(
+            CONF_OUTDOOR_TEMP_SENSOR, **_default(d, CONF_OUTDOOR_TEMP_SENSOR)
+        ): selector.EntitySelector(
+            selector.EntitySelectorConfig(domain="sensor", device_class="temperature")
+        ),
         vol.Optional(
             CONF_SOLAR_FORECAST_REMAINING_ENTITY, **_default(d, CONF_SOLAR_FORECAST_REMAINING_ENTITY)
         ): selector.EntitySelector(

custom_components/surplus_load_switch/const.py

@@ -33,6 +33,11 @@ def _minutes_to_cycles(minutes: float) -> int:
 # weekday/hour/mode load-profile learner (see load_profile.py). Left
 # unset, the learner and its diagnostic sensor simply don't run.
 CONF_HAUSMODUS_ENTITY = "hausmodus_entity"
+# Optional, load-profile learner only: the heat pump's electrical power
+# (subtracted from the learned house base and recorded separately per
+# outdoor-temperature band) and an outdoor temperature sensor.
+CONF_HEATPUMP_POWER_SENSOR = "heatpump_power_sensor"
+CONF_OUTDOOR_TEMP_SENSOR = "outdoor_temp_sensor"
 # Optional: a sensor reporting the forecast kWh still expected to arrive
 # today (e.g. Forecast.Solar's "Geschätzte Energieerzeugung – Resttag
 # heute" / sensor.energy_production_today_remaining) — lets
@@ -401,6 +406,15 @@ def _minutes_to_cycles(minutes: float) -> int:
 # load_profile.py's fallback hierarchy) — an average built from a single
 # day is just that one day, not a real pattern yet.
 LOAD_PROFILE_MIN_SAMPLES = 2
+# Modes whose load is not learned at all (and whose already-stored data is
+# dropped on load): daytime "Zuhause" is dominated by unpredictable spikes.
+LOAD_PROFILE_EXCLUDED_MODES = ("Zuhause",)
+# Wallbox draw above this (kW) keeps the sample out of the profile, and for
+# this many minutes afterwards (cross-source cloud polling lag).
+LOAD_PROFILE_WALLBOX_MIN_KW = 0.05
+LOAD_PROFILE_WALLBOX_COOLDOWN_MIN = 10
+# Outdoor-temperature band edges (°C) for the heat-pump profile.
+LOAD_PROFILE_TEMP_BANDS = (0.0, 5.0, 10.0, 15.0)
 
 # How long to keep using the pre-transition managed-power figure for
 # base_load AND battery-discharge attribution after a managed device's

custom_components/surplus_load_switch/coordinator.py

@@ -53,6 +53,8 @@
     CONF_DEVICE_WINDOW_START,
     CONF_EXPORT_POWER_SENSOR,
     CONF_HAUSMODUS_ENTITY,
+    CONF_HEATPUMP_POWER_SENSOR,
+    CONF_OUTDOOR_TEMP_SENSOR,
     CONF_LOAD_SENSOR,
     CONF_MIN_SOC,
     CONF_SOC_SENSOR,
@@ -2740,7 +2742,26 @@ async def _evaluate_devices(self, data: CoordinatorData) -> None:
             if hausmodus_state is not None and hausmodus_state.state not in ("unavailable", "unknown")
             else None
         )
-        self._load_profile_learner.record(base_load, hausmodus)
+        # base_load_excl_wallbox, not base_load: the latter adds the
+        # wallbox's draw back in while it is "starved", which would put
+        # charging sessions into the profile.
+        heatpump_entity = self._config.get(CONF_HEATPUMP_POWER_SENSOR)
+        heatpump_state = self.hass.states.get(heatpump_entity) if heatpump_entity else None
+        heatpump_kw = (
+            self._get_power_kw(heatpump_entity)
+            if heatpump_state is not None
+            and heatpump_state.state not in ("unavailable", "unknown", "")
+            else None
+        )
+        temp_entity = self._config.get(CONF_OUTDOOR_TEMP_SENSOR)
+        temp_state = self.hass.states.get(temp_entity) if temp_entity else None
+        try:
+            outdoor_temp_c = float(temp_state.state) if temp_state is not None else None
+        except ValueError:
+            outdoor_temp_c = None
+        self._load_profile_learner.record(
+            base_load_excl_wallbox, hausmodus, wallbox_power_kw, heatpump_kw, outdoor_temp_c
+        )
         data.load_profile = self._load_profile_learner.diagnostics
 
         # Computed once per cycle, not per dependent device — several

custom_components/surplus_load_switch/load_profile.py

@@ -1,6 +1,25 @@
 """Learns typical Grundlast (base_load) by weekday, hour of day, and house
-mode (e.g. Zuhause/Abwesend/Schlafen/Urlaub) — diagnostic only for now,
-does not feed any switching decision.
+mode (e.g. Abwesend/Schlafen/Urlaub) — diagnostic only for now, does not
+feed any switching decision.
+
+What gets learned, and what deliberately doesn't:
+- Modes listed in LOAD_PROFILE_EXCLUDED_MODES (the daytime "Zuhause"
+  mode) are neither recorded nor kept: their load is dominated by
+  unpredictable spikes (wallbox, oven, ...) and carries no pattern.
+- Wallbox charging is kept out entirely: samples are skipped while the
+  wallbox draws power and for LOAD_PROFILE_WALLBOX_COOLDOWN_MIN afterwards
+  (the wallbox reading and the house-load reading come from different
+  cloud-polled integrations and don't refresh in lockstep, so the
+  subtraction alone is noisy right at the ramp edges).
+- The heat pump is learned separately. If a heat-pump power sensor is
+  configured, its draw is subtracted from the profile above (which then
+  stays a stable, weather-independent house base) and instead recorded per
+  outdoor-temperature band and hour. Without that sensor the heat pump's
+  draw stays inside the profile, unseparated.
+- The house base uses the median per hour and across days (robust against
+  one-off spikes); the heat pump uses the mean, because it cycles on and
+  off within an hour and a median would report ~0 for a unit that really
+  averages a few hundred watts.
 
 Self-sampling from the coordinator's own cycles, not the recorder's
 history: this install's Grundlast entity_id isn't known generically (see
@@ -26,15 +45,20 @@
 from __future__ import annotations
 
 import logging
-from datetime import date
+import statistics
+from datetime import date, datetime, timedelta
 
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.storage import Store
 from homeassistant.util import dt as dt_util
 
 from .const import (
+    LOAD_PROFILE_EXCLUDED_MODES,
     LOAD_PROFILE_MIN_SAMPLES,
+    LOAD_PROFILE_TEMP_BANDS,
     LOAD_PROFILE_TRAILING_SAMPLES,
+    LOAD_PROFILE_WALLBOX_COOLDOWN_MIN,
+    LOAD_PROFILE_WALLBOX_MIN_KW,
     STORAGE_VERSION,
 )
 
@@ -47,6 +71,20 @@ def _bucket_key(weekday: str, hour: int, mode: str) -> str:
     return f"{weekday}_{hour}_{mode}"
 
 
+def _temp_band(temp_c: float) -> str:
+    """Label of the LOAD_PROFILE_TEMP_BANDS interval temp_c falls into."""
+    lower = None
+    for edge in LOAD_PROFILE_TEMP_BANDS:
+        if temp_c < edge:
+            return f"<{edge:g}" if lower is None else f"{lower:g}..{edge:g}"
+        lower = edge
+    return f">={lower:g}"
+
+
+def _wp_key(band: str, hour: int) -> str:
+    return f"{band}_{hour}"
+
+
 class WeekdayLoadProfileLearner:
     """Tracks, per (weekday, hour, house mode), a rolling window of daily
     average base_load readings."""
@@ -65,6 +103,16 @@ def __init__(self, hass: HomeAssistant, entry_id: str) -> None:
         # or a new day starts).
         self._current_key: tuple[str, int, str, date] | None = None
         self._current_samples: list[float] = []
+        # Heat-pump draw per (outdoor-temperature band, hour), same
+        # rolling-window shape as _buckets. Its own in-progress
+        # accumulator, since the band can change independently of the
+        # weekday/mode key above.
+        self._wp_buckets: dict[str, list[float]] = {}
+        self._wp_current_key: tuple[str, int, date] | None = None
+        self._wp_current_samples: list[float] = []
+        # No sample is taken before this moment (wallbox cooldown).
+        self._skip_until: datetime | None = None
+        self._wp_separated = False
         self._dirty = False
 
     async def async_load(self) -> None:
@@ -74,41 +122,107 @@ async def async_load(self) -> None:
         self._buckets = {
             k: list(v) for k, v in data.get("buckets", {}).items()
         }
+        self._wp_buckets = {
+            k: list(v) for k, v in data.get("wp_buckets", {}).items()
+        }
+        # Drop whatever an earlier version already learned for modes that
+        # are no longer tracked.
+        stale = [
+            k for k in self._buckets
+            if k.split("_", 2)[-1] in LOAD_PROFILE_EXCLUDED_MODES
+        ]
+        for k in stale:
+            del self._buckets[k]
+        if stale:
+            self._dirty = True
+            self._store.async_delay_save(self._payload, 60)
 
     async def async_save_now(self) -> None:
         """Force an immediate write — see coordinator.PVSurplusCoordinator.
         async_flush_stores for why this matters on unload/reload."""
         self._finalize_current(force=True)
+        self._wp_finalize_current(force=True)
         if self._dirty:
-            await self._store.async_save({"buckets": self._buckets})
+            await self._store.async_save(self._payload())
             self._dirty = False
 
-    def record(self, base_load_kw: float, mode: str | None) -> None:
-        """Call once per coordinator cycle with the current base_load and
-        house mode (None if the configured entity is unavailable — that
-        cycle is simply not sampled, nothing is finalized or lost)."""
+    def _payload(self) -> dict:
+        return {"buckets": self._buckets, "wp_buckets": self._wp_buckets}
+
+    def record(
+        self,
+        base_load_kw: float,
+        mode: str | None,
+        wallbox_kw: float = 0.0,
+        heatpump_kw: float | None = None,
+        outdoor_temp_c: float | None = None,
+    ) -> None:
+        """Call once per coordinator cycle. base_load_kw must already be
+        free of the wallbox and every managed device (the coordinator's
+        base_load_excl_wallbox). heatpump_kw / outdoor_temp_c are None
+        when the corresponding optional sensor isn't configured or
+        unavailable. mode is None if the house-mode entity is unavailable
+        — that cycle is simply not sampled, nothing is finalized or lost."""
         if mode is None:
             return
         now = dt_util.now()
+
+        # Wallbox: never sample while it charges or shortly afterwards.
+        if wallbox_kw > LOAD_PROFILE_WALLBOX_MIN_KW:
+            self._skip_until = now + timedelta(minutes=LOAD_PROFILE_WALLBOX_COOLDOWN_MIN)
+        if self._skip_until is not None and now < self._skip_until:
+            return
+
+        if heatpump_kw is not None:
+            self._wp_separated = True
+            if outdoor_temp_c is not None:
+                self._record_heatpump(now, heatpump_kw, outdoor_temp_c)
+            base_load_kw = max(base_load_kw - heatpump_kw, 0.0)
+        else:
+            self._wp_separated = False
+
+        if mode in LOAD_PROFILE_EXCLUDED_MODES:
+            return
         key = (WEEKDAYS[now.weekday()], now.hour, mode, now.date())
         if key != self._current_key:
             self._finalize_current()
             self._current_key = key
             self._current_samples = []
         self._current_samples.append(base_load_kw)
 
+    def _record_heatpump(self, now: datetime, heatpump_kw: float, temp_c: float) -> None:
+        key = (_temp_band(temp_c), now.hour, now.date())
+        if key != self._wp_current_key:
+            self._wp_finalize_current()
+            self._wp_current_key = key
+            self._wp_current_samples = []
+        self._wp_current_samples.append(heatpump_kw)
+
+    def _wp_finalize_current(self, force: bool = False) -> None:
+        if self._wp_current_key is None or not self._wp_current_samples:
+            return
+        band, hour, _day = self._wp_current_key
+        # Mean, not median: the unit cycles on/off within the hour.
+        avg = sum(self._wp_current_samples) / len(self._wp_current_samples)
+        history = self._wp_buckets.setdefault(_wp_key(band, hour), [])
+        history.append(round(avg, 3))
+        del history[:-LOAD_PROFILE_TRAILING_SAMPLES]
+        self._dirty = True
+        if not force:
+            self._store.async_delay_save(self._payload, 60)
+
     def _finalize_current(self, force: bool = False) -> None:
         if self._current_key is None or not self._current_samples:
             return
         weekday, hour, mode, _day = self._current_key
-        avg = sum(self._current_samples) / len(self._current_samples)
+        typical = statistics.median(self._current_samples)
         bucket_key = _bucket_key(weekday, hour, mode)
         history = self._buckets.setdefault(bucket_key, [])
-        history.append(round(avg, 3))
+        history.append(round(typical, 3))
         del history[:-LOAD_PROFILE_TRAILING_SAMPLES]
         self._dirty = True
         if not force:
-            self._store.async_delay_save(lambda: {"buckets": self._buckets}, 60)
+            self._store.async_delay_save(self._payload, 60)
 
     def effective_average(self, weekday: str, hour: int, mode: str) -> tuple[float | None, str]:
         """The learned average for (weekday, hour, mode), falling back to
@@ -118,7 +232,7 @@ def effective_average(self, weekday: str, hour: int, mode: str) -> tuple[float |
         hour, any weekday/mode), or "keine daten" (value is None)."""
         exact = self._buckets.get(_bucket_key(weekday, hour, mode), [])
         if len(exact) >= LOAD_PROFILE_MIN_SAMPLES:
-            return sum(exact) / len(exact), "genau"
+            return statistics.median(exact), "genau"
 
         by_hour_mode: list[float] = []
         by_hour: list[float] = []
@@ -127,7 +241,7 @@ def effective_average(self, weekday: str, hour: int, mode: str) -> tuple[float |
             if same_hour_mode:
                 by_hour_mode.extend(same_hour_mode)
         if len(by_hour_mode) >= LOAD_PROFILE_MIN_SAMPLES:
-            return sum(by_hour_mode) / len(by_hour_mode), "stunde+modus"
+            return statistics.median(by_hour_mode), "stunde+modus"
 
         for key, values in self._buckets.items():
             # bucket_key format is "<weekday>_<hour>_<mode>" — the mode
@@ -137,7 +251,7 @@ def effective_average(self, weekday: str, hour: int, mode: str) -> tuple[float |
             if len(parts) == 3 and parts[1] == str(hour):
                 by_hour.extend(values)
         if len(by_hour) >= LOAD_PROFILE_MIN_SAMPLES:
-            return sum(by_hour) / len(by_hour), "stunde"
+            return statistics.median(by_hour), "stunde"
 
         return None, "keine daten"
 
@@ -148,4 +262,27 @@ def diagnostics(self) -> dict:
             "erfasste_kombinationen": len(self._buckets),
             "gesamte_tages_messwerte": total_days,
             "profil": dict(self._buckets),
+            "nicht_erfasste_modi": list(LOAD_PROFILE_EXCLUDED_MODES),
+            "waermepumpe_herausgerechnet": self._wp_separated,
+            "waermepumpe_kw_je_temperaturband": self._wp_band_averages(),
+            "waermepumpe_profil": dict(self._wp_buckets),
+        }
+
+    def _wp_band_averages(self) -> dict[str, dict[str, float]]:
+        """Per temperature band: the mean heat-pump draw over all learned
+        hours ("alle_stunden") and over the night hours 0-6 ("nacht") —
+        the figure that matters for the overnight battery estimate."""
+        per_band: dict[str, dict[str, list[float]]] = {}
+        for key, values in self._wp_buckets.items():
+            band, _, hour = key.rpartition("_")
+            slot = per_band.setdefault(band, {"alle_stunden": [], "nacht": []})
+            slot["alle_stunden"].extend(values)
+            if hour.isdigit() and int(hour) <= 6:
+                slot["nacht"].extend(values)
+        return {
+            band: {
+                name: round(sum(v) / len(v), 3)
+                for name, v in slots.items() if v
+            }
+            for band, slots in per_band.items()
         }

custom_components/surplus_load_switch/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "local_polling",
   "issue_tracker": "https://github.com/xchillxx/surplus-load-switch/issues",
   "requirements": [],
-  "version": "2.39.0"
+  "version": "2.40.0"
 }

custom_components/surplus_load_switch/translations/de.json

@@ -12,6 +12,8 @@
           "battery_capacity_kwh": "Akku-Kapazität (kWh)",
           "min_soc": "Mindest-SOC (%)",
           "hausmodus_entity": "Hausmodus-Helfer (optional, z.B. ein input_select) — aktiviert den Wochentag/Stunde/Modus-Lastprofil-Lerner (nur Diagnose, beeinflusst noch keine Schaltentscheidung)",
+          "heatpump_power_sensor": "Wärmepumpen-Leistungssensor (optional, W/kW) — nur Lastprofil-Lerner (Diagnose): die WP-Last wird aus der gelernten Haus-Grundlast herausgerechnet und separat je Außentemperatur erfasst",
+          "outdoor_temp_sensor": "Außentemperatur-Sensor (optional, °C) — nur Lastprofil-Lerner: Temperaturbänder für das Wärmepumpen-Profil",
           "solar_forecast_remaining_entity": "PV-Prognose Resttag heute (optional, kWh, z.B. Forecast.Solar) — lässt die Wallbox-Reservierung dem tatsächlichen Tagesverlauf der Sonne folgen statt einem flachen Zeitdurchschnitt",
           "export_power_sensor": "Einspeise-Leistungssensor (optional, W/kW, z.B. Tibber Pulse) — der Akku-Pfad (Gerät läuft nur weil der Hausakku es sich leisten könnte) bleibt dann nur offen, solange wirklich ins Netz eingespeist wird"
         }
@@ -154,6 +156,8 @@
           "battery_capacity_kwh": "Akku-Kapazität (kWh)",
           "min_soc": "Mindest-SOC (%)",
           "hausmodus_entity": "Hausmodus-Helfer (optional, z.B. ein input_select) — aktiviert den Wochentag/Stunde/Modus-Lastprofil-Lerner (nur Diagnose, beeinflusst noch keine Schaltentscheidung)",
+          "heatpump_power_sensor": "Wärmepumpen-Leistungssensor (optional, W/kW) — nur Lastprofil-Lerner (Diagnose): die WP-Last wird aus der gelernten Haus-Grundlast herausgerechnet und separat je Außentemperatur erfasst",
+          "outdoor_temp_sensor": "Außentemperatur-Sensor (optional, °C) — nur Lastprofil-Lerner: Temperaturbänder für das Wärmepumpen-Profil",
           "solar_forecast_remaining_entity": "PV-Prognose Resttag heute (optional, kWh, z.B. Forecast.Solar) — lässt die Wallbox-Reservierung dem tatsächlichen Tagesverlauf der Sonne folgen statt einem flachen Zeitdurchschnitt",
           "export_power_sensor": "Einspeise-Leistungssensor (optional, W/kW, z.B. Tibber Pulse) — der Akku-Pfad (Gerät läuft nur weil der Hausakku es sich leisten könnte) bleibt dann nur offen, solange wirklich ins Netz eingespeist wird"
         }