Grid charging as one block, no stop-and-go (v3.1.15)

10.10. live: cheap charging started at 11:45 (17.16 ct); the cheapest
single quarter hours would have stopped it at 12:00 (17.40) and started it
again at 12:30 - every stop/start is a billed car command and stresses the
charging hardware. Cheap and obligation grid charging now take the
cheapest block of consecutive slots (planner._best_block; cheap: earlier
on ties, obligation: later), and a running grid charge (last decision or
car near max power) continues while the price stays within 0.5 ct of the
best block's mean.

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

Author: xchillxx

README.md

@@ -59,7 +59,8 @@ help), and once there is just enough time left it charges regardless.
 (default: the cheapest 10 % of the last 8 days) the car is topped up from the
 grid up to a target (default 80 %) — but only by the energy the PV forecast
 won't bring before the next departure anyway, so a sunny tomorrow isn't
-wasted. It charges in the cheapest *published* slots before the departure.
+wasted. It charges in the cheapest *block* of consecutive published slots before
+the departure (one block, no stop-and-go).
 If your home battery discharges into the car (option *Home battery
 discharges into the car*, default on), only slots without PV count and only
 while the battery is at its minimum SoC — otherwise the battery would just

custom_components/surplus_pilot/coordinator.py

@@ -649,6 +649,8 @@ def inputs(pv_kw: float, base_kw: float, car_fixed: float | None) -> P.Inputs:
                 forecast=self._forecast, prices=self._prices, departures=deps, car=car_in, devices=dev_inputs,
                 allow_grid_for_car=bool(self.car_cfg.get(CONF_CAR_ALLOW_GRID, True)) if self.car_cfg else False,
                 battery_feeds_car=feeds_car,
+                grid_running=bool(self.car and ((self.car.decision is not None and self.car.decision.grid)
+                                                 or car_kw >= 0.9 * self.car.max_kw)),
                 car_fixed_kw=car_fixed, price_profile=ps["profile"], price_now=ps["now"],
                 cheap_threshold=ps["threshold"], cheap_target_soc=cheap_target)
 

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.14"
+  "version": "3.1.15"
 }

custom_components/surplus_pilot/planner.py

@@ -48,6 +48,7 @@
 MIN_LIFT_PV_SHARE = 0.5        # obligation at minimum current only while PV carries half of it ...
 MIN_LIFT_PV_SHARE_KEEP = 0.4   # ... (0.4 to keep an already charging car going)
 CHEAP_BATTERY_MARGIN = 3.0     # cheap grid top-up only with the home battery at most this far above its min SoC
+GRID_BLOCK_TOLERANCE = 0.005   # a running grid block continues while the price is within 0.5 ct of the block's mean
 FEED_CAR_MIN_KW = 1.0          # battery-feeds-car detection: car must draw at least this ...
 FEED_DEFICIT_KW = 0.5          # ... with at least this much missing beyond the PV ...
 FEED_SOC_MARGIN = 5.0          # ... and the battery this far above its min SoC (it could discharge)
@@ -124,6 +125,9 @@ class Inputs:
     # False: the home battery is set not to discharge into the car (e.g. in
     # the inverter app) - grid charging then leaves it alone, also at midday
     battery_feeds_car: bool = True
+    # the car is grid charging right now (last decision, or drawing near its
+    # maximum): a started grid block runs through instead of stop-and-go
+    grid_running: bool = False
     # Price knowledge for grid charging: published prices (`prices`), an
     # estimate per hour of day for the not yet published ones (median of the
     # last days), the current price and the "cheap" threshold (percentile of
@@ -433,13 +437,47 @@ def _floor_slot(t: datetime) -> datetime:
     return t.replace(minute=t.minute - t.minute % 15, second=0, microsecond=0)
 
 
+def _best_block(slots: list[tuple[datetime, float | None]], n: int, prefer_late: bool) -> tuple[datetime, int, float] | None:
+    """Cheapest run of n consecutive 15-min slots (None = not usable, it
+    breaks a run): (start, length, mean price). Charging is one block, not
+    scattered quarter hours - every stop and start costs a (possibly
+    billed) car command and stresses the charging hardware. When no run is
+    n long, the longest possible one counts."""
+    n = max(1, min(n, len(slots)))
+    while n >= 1:
+        best = None
+        for i in range(len(slots) - n + 1):
+            win = slots[i:i + n]
+            if any(p is None for _, p in win) or any(win[k + 1][0] - win[k][0] != SLOT for k in range(n - 1)):
+                continue
+            cost = sum(p for _, p in win)
+            if (best is None or cost < best[2] * n - 1e-9
+                    or (prefer_late and abs(cost - best[2] * n) <= 1e-9)):
+                best = (win[0][0], n, cost / n)
+        if best is not None:
+            return best
+        n -= 1
+    return None
+
+
+def _in_block(inp: Inputs, block: tuple[datetime, int, float] | None) -> bool:
+    if block is None:
+        return False
+    start, n, mean = block
+    if start <= inp.now < start + n * SLOT:
+        return True
+    # a running block goes on while the price stays close to the best block
+    price = inp.price_now if inp.price_now is not None else _price_at(inp, _floor_slot(inp.now))[0]
+    return inp.grid_running and price is not None and price <= mean + GRID_BLOCK_TOLERANCE
+
+
 def _grid_slot_now(inp: Inputs, dep: Departure, uncovered_kwh: float, max_kw: float) -> bool:
     """Grid fallback for a departure target the PV forecast can't reach:
-    charge in the cheapest 15-min slots between now and the departure
-    (unpublished prices estimated per hour of day — so a cheap midday today
-    can win over a night whose prices aren't out yet). Ties go to the later
-    slot (a sunnier hour than forecast may still help). Once there is just
-    enough time left, charge regardless of price."""
+    charge in the cheapest block of consecutive 15-min slots between now and
+    the departure (unpublished prices estimated per hour of day — so a cheap
+    midday today can win over a night whose prices aren't out yet). Ties go
+    to the later block (a sunnier hour than forecast may still help). Once
+    there is just enough time left, charge regardless of price."""
     need_slots = max(1, math.ceil(uncovered_kwh / max(max_kw, 0.1) / 0.25))
     now_slot = _floor_slot(inp.now)
     slots: list[tuple[datetime, float | None]] = []
@@ -450,12 +488,10 @@ def _grid_slot_now(inp: Inputs, dep: Departure, uncovered_kwh: float, max_kw: fl
     left_h = (dep.start - inp.now).total_seconds() / 3600.0
     if len(slots) <= need_slots or left_h <= need_slots * 0.25 + GRID_SAFETY_H:
         return True
-    priced = [x for x in slots if x[1] is not None]
-    if not priced:
+    if not any(x[1] is not None for x in slots):
         return False  # no price idea at all: wait for the safety start above
-    priced.sort(key=lambda x: (x[1], -x[0].timestamp()))
-    chosen = {x[0] for x in priced[:need_slots]}
-    return now_slot in chosen
+    # one block, equally cheap -> the later one (a sunnier hour may still help)
+    return _in_block(inp, _best_block(slots, need_slots, prefer_late=True))
 
 
 def _cheap_topup_now(inp: Inputs, dep: Departure | None, surplus: float) -> tuple[bool, float]:
@@ -493,29 +529,29 @@ def _cheap_topup_now(inp: Inputs, dep: Departure | None, surplus: float) -> tupl
 
 
 def _cheapest_free_slot_now(inp: Inputs, end: datetime, kwh: float, max_kw: float) -> bool:
-    """Is the current slot among the cheapest PUBLISHED slots until `end`
-    that are free for grid charging? Equal prices go to the earlier slot -
-    no point waiting for the same price. When the home battery feeds the
-    car, slots with PV above the base load don't count (now: measured,
+    """Is now inside the cheapest block of consecutive PUBLISHED slots until
+    `end` that are free for grid charging? Equal blocks go to the earlier
+    one - no point waiting for the same price. When the home battery feeds
+    the car, slots with PV above the base load don't count (now: measured,
     later: forecast): grid charging there would take the PV the battery
     needs, it only charges from export."""
     need_slots = max(1, math.ceil(kwh / max(max_kw, 0.1) / 0.25))
     now_slot = _floor_slot(inp.now)
     pv_limit = inp.base_kw + 0.3
     if inp.battery_feeds_car and inp.pv_kw > pv_limit:
         return False
-    free = []
-    for p in inp.prices:
-        if p.end <= now_slot or p.start >= end:
-            continue
-        if inp.battery_feeds_car and p.start > now_slot:
-            pv_kw = forecast_kwh(inp.forecast, p.start, p.end) / max(_h(p.start, p.end), 0.01)
-            if pv_kw * CHEAP_FORECAST_TRUST > pv_limit:
-                continue
-        free.append((p.price, p.start))
-    free.sort()
-    chosen = {t for _, t in free[:need_slots]}
-    return any(p.start <= inp.now < p.end and p.start in chosen for p in inp.prices)
+    slots: list[tuple[datetime, float | None]] = []
+    for p in sorted(inp.prices, key=lambda x: x.start):   # hourly prices -> 15-min slots
+        t = max(_floor_slot(p.start), now_slot)
+        while t < p.end and t < end:
+            price: float | None = p.price
+            if inp.battery_feeds_car and t > now_slot:
+                pv_kw = forecast_kwh(inp.forecast, t, t + SLOT) / 0.25
+                if pv_kw * CHEAP_FORECAST_TRUST > pv_limit:
+                    price = None
+            slots.append((t, price))
+            t += SLOT
+    return _in_block(inp, _best_block(slots, need_slots, prefer_late=False))
 
 
 # ---------------------------------------------------------------- the plan

tests/test_planner.py

@@ -365,3 +365,36 @@ def test_battery_feed_evidence():
     assert ev(3.0, 1.4, 3.8, -2.5, 18.0, 15.0) is None          # battery at its reserve: says nothing
     assert ev(0.0, 0.0, 0.8, -0.8, 40.0, 15.0) is None          # car not charging
     assert ev(3.0, 4.0, 3.8, -0.0, 40.0, 15.0) is None          # PV covers it all
+
+
+def test_grid_charging_is_one_block_not_scattered_quarter_hours():
+    """10.10. live: 11:45 17.16 ct, 12:00 17.40, 12:15 17.19, from 12:30
+    17.16 - the cheapest single quarter hours would stop the car at 12:00
+    and start it again at 12:30. One block instead; a running one goes on."""
+    now = datetime(2026, 10, 10, 11, 45, tzinfo=TZ)
+    day0 = now.replace(hour=0)
+
+    def tariff(t):
+        if (t.hour, t.minute) == (12, 0):
+            return 0.174
+        if (t.hour, t.minute) == (12, 15):
+            return 0.1719
+        return 0.1716 if day0.replace(hour=11, minute=45) <= t < day0.replace(hour=16, minute=30) else 0.20
+
+    prices = [P.PriceSlot(day0 + timedelta(minutes=15 * i), day0 + timedelta(minutes=15 * (i + 1)),
+                          tariff(day0 + timedelta(minutes=15 * i))) for i in range(96)]
+
+    def at(t, running):
+        inp = _oct10(t, pv_kw=6.8, battery_soc=25.0, car_soc=44.0, prices=prices,
+                     price_now=next(p.price for p in prices if p.start <= t < p.end), threshold=0.189,
+                     cheap_target=80.0)
+        inp.battery_feeds_car = False
+        inp.grid_running = running
+        return P.make_plan(inp)
+
+    assert not at(now, False).car_grid                    # best block starts 12:30
+    assert at(now.replace(hour=12, minute=30), False).car_grid
+    assert at(now.replace(hour=12, minute=0), True).car_grid   # already running: no stop for 0.2 ct
+    # the two cheapest single slots (0.1) are apart: the block 0.1+0.12+0.12 wins
+    blk = P._best_block([(now + i * P.SLOT, p) for i, p in enumerate([0.1, 0.4, 0.1, 0.12, 0.12, 0.12])], 3, False)
+    assert blk[0] == now + 2 * P.SLOT and blk[1] == 3