Cheap charging with PV below the battery value when the forecast fills it anyway (v3.1.18)

User 10.10.: the forecast still fills the battery in the afternoon, the house
draws little while the car charges. Below 'Cheap charging with PV from home
battery' PV slots are open when the forecast x0.7 after the car's block until
the PV end covers the battery gap plus the house (base + running devices)
until then; a running block doesn't stop for the battery while it does.
10.10. (13:03, 34 %): 12.7 kWh vs 19.7 kWh needed -> still blocked.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: xchillxx

README.md

@@ -72,7 +72,9 @@ it needs. With the option off (battery set not to discharge into the
 wallbox in the inverter app) every slot up to the departure counts, midday
 included, and the car charges PV plus grid there — slots with PV only while
 the home battery is at least *Cheap charging with PV from home battery* full
-(default 50 %, 0 = no limit). Many inverters (e.g. Huawei) give the PV to the
+(default 50 %, 0 = no limit) — or below it when the forecast (×0.7) after the
+car's block until the PV end still fills the battery and carries the house
+(measured base load + running devices) meanwhile. Many inverters (e.g. Huawei) give the PV to the
 wallbox first and let the battery carry the house, so a midday block still
 drains it; a running block goes on down to 5 % below that value, then stops
 and stays off in PV hours for the rest of the day. With a *home battery

custom_components/surplus_pilot/coordinator.py

@@ -905,7 +905,8 @@ def explain(self) -> list[str]:
                     txt += " — lädt aus dem Netz: günstigster Zeitraum bis zur Abfahrt"
                 if not cp.car_grid and getattr(self, "_cheap_pv_waits", False):
                     txt += (f" — Strom billig, aber mit PV erst ab Hausakku "
-                            f"{float(self.store.data['cheap_pv_battery_soc']):.0f} %"
+                            f"{float(self.store.data['cheap_pv_battery_soc']):.0f} % "
+                            f"oder wenn die Prognose ihn danach trotzdem füllt"
                             + (" (heute schon einmal abgebrochen)"
                                if self.store.data.get("cheap_pv_lock") == dt_util.now().date().isoformat() else ""))
                 if cp.car_block and not cp.car_grid and cp.car_block[1] > dt_util.now():

custom_components/surplus_pilot/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "local_polling",
   "issue_tracker": "https://github.com/xchillxx/surplus-pilot/issues",
   "requirements": [],
-  "version": "3.1.17"
+  "version": "3.1.18"
 }

custom_components/surplus_pilot/planner.py

@@ -561,23 +561,43 @@ def _cheap_topup_now(inp: Inputs, dep: Departure | None,
 
 
 def cheap_pv_battery_ok(inp: Inputs) -> bool:
-    """May cheap grid charging use slots with PV? Only with the home battery at
-    least `cheap_pv_battery_soc` full - a running block goes on down to
-    CHEAP_PV_SOC_HYSTERESIS below it, and once stopped for that it stays off
-    in PV for the day (no stop-and-go while PV refills the battery)."""
+    """May cheap grid charging use slots with PV? With the home battery at
+    least `cheap_pv_battery_soc` full, or below that if the cautious forecast
+    still fills it by the PV end anyway (`battery_fills_anyway`). A running
+    block goes on down to CHEAP_PV_SOC_HYSTERESIS below the value; once
+    stopped for the battery it stays off in PV for the day (no stop-and-go
+    while PV refills the battery)."""
     if inp.cheap_pv_battery_soc is None or inp.battery_soc is None:
         return True
     if inp.cheap_pv_locked:
         return False
     floor = inp.cheap_pv_battery_soc - (CHEAP_PV_SOC_HYSTERESIS if inp.grid_running else 0.0)
-    return inp.battery_soc >= floor
+    return inp.battery_soc >= floor or battery_fills_anyway(inp)
 
 
 def cheap_pv_battery_stop(inp: Inputs) -> bool:
     """A running cheap block with PV must stop for the battery (-> lock for today)."""
     return (inp.grid_running and inp.cheap_pv_battery_soc is not None and inp.battery_soc is not None
             and not inp.battery_feeds_car and inp.pv_kw > inp.base_kw + 0.3
-            and inp.battery_soc < inp.cheap_pv_battery_soc - CHEAP_PV_SOC_HYSTERESIS)
+            and inp.battery_soc < inp.cheap_pv_battery_soc - CHEAP_PV_SOC_HYSTERESIS
+            and not battery_fills_anyway(inp))
+
+
+def battery_fills_anyway(inp: Inputs) -> bool:
+    """Below the battery value cheap charging with PV is still fine when the
+    forecast (x0.7) after the car's block until the PV end fills the battery
+    and carries the house the whole time (during the block the inverter gives
+    the PV to the car and the battery carries the house)."""
+    car = inp.car
+    if (inp.battery_soc is None or car is None or car.soc is None or inp.cheap_target_soc is None
+            or inp.pv_end.date() != inp.now.date() or inp.pv_end <= inp.now):
+        return False
+    car_kwh = max(0.0, min(inp.cheap_target_soc, car.limit_soc) - car.soc) / 100.0 * car.capacity_kwh / car.efficiency
+    block_end = inp.now + timedelta(hours=car_kwh / max(car.max_kw, 0.1))
+    pv = forecast_kwh(inp.forecast, block_end, inp.pv_end) * FORECAST_SAFETY
+    house_kw = inp.base_kw + sum(d.decision_kw for d in inp.devices if d.is_on)
+    need = (100.0 - inp.battery_soc) / 100.0 * inp.battery_capacity_kwh + house_kw * _h(inp.now, inp.pv_end)
+    return pv >= need
 
 
 def _cheapest_free_slot_now(inp: Inputs, end: datetime, kwh: float,

tests/test_planner.py

@@ -440,7 +440,7 @@ def test_cheap_topup_with_pv_needs_a_full_enough_home_battery():
     def inp_at(t, pv, battery, running=False, locked=False):
         inp = _oct10(t, pv_kw=pv, battery_soc=battery, car_soc=53.0, prices=prices,
                      price_now=next(p.price for p in prices if p.start <= t < p.end), threshold=0.1904,
-                     cheap_target=80.0)
+                     cheap_target=80.0, scale=0.5)   # dull afternoon: the forecast won't fill the battery
         inp.battery_feeds_car = False
         inp.cheap_pv_battery_soc = 50.0
         inp.grid_running, inp.cheap_pv_locked = running, locked
@@ -460,3 +460,32 @@ def inp_at(t, pv, battery, running=False, locked=False):
     free = inp_at(now, 4.5, 34.0)
     free.cheap_pv_battery_soc = None
     assert P.make_plan(free).car_grid
+
+
+def test_cheap_topup_with_pv_below_the_battery_value_when_the_forecast_fills_it_anyway():
+    """User 10.10.: 'the battery gets nearly full by the forecast anyway'. Below
+    50 % cheap charging with PV is fine when the forecast x0.7 after the car's
+    block until the PV end fills the battery and carries the house meanwhile.
+    10.10. 13:03 (34 %, Forecast.Solar 18 kWh after the block, house ~2.2 kW)
+    that's not enough; on a sunny day it is."""
+    now = datetime(2026, 10, 10, 13, 0, tzinfo=TZ)
+    prices = [P.PriceSlot(now.replace(hour=0) + timedelta(minutes=15 * i),
+                          now.replace(hour=0) + timedelta(minutes=15 * (i + 1)), 0.1716) for i in range(96)]
+
+    def plan(scale, battery=34.0):
+        inp = _oct10(now, pv_kw=4.5, battery_soc=battery, car_soc=53.0, prices=prices, price_now=0.1716,
+                     threshold=0.1904, cheap_target=80.0, scale=scale)
+        inp.base_kw = 0.9
+        inp.devices = [P.DeviceInput(id="pump", name="Pumpe", priority=3, decision_kw=1.34, is_on=True)]
+        inp.battery_feeds_car = False
+        inp.cheap_pv_battery_soc = 50.0
+        inp.pv_end = now.replace(hour=17, minute=46)
+        return inp, P.make_plan(inp)
+
+    inp, p = plan(1.0)                      # 10.10.: ~9 kWh x0.7 after the block, ~19 kWh needed
+    assert not P.battery_fills_anyway(inp) and not p.car_grid
+    inp, p = plan(3.0)                      # sunny afternoon: PV slots open (the PV then brings the car anyway)
+    assert P.battery_fills_anyway(inp) and P.cheap_pv_battery_ok(inp)
+    inp, p = plan(3.0, battery=20.0)        # running block below 45 %: no stop while the forecast covers it
+    inp.grid_running = True
+    assert not P.cheap_pv_battery_stop(inp)