From c25877fea4b7eb201130188b9bcc23c7db97bb54 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 22 Nov 2026 01:50:44 +0100 Subject: [PATCH 1/7] EV-13: a refused current write arms the stuck check only when the charger shows no life A refused write on a live charger no longer reads as a stuck reading 60 s later, so a refused write shows one amber row (charger_refused). A frozen charger still arms and is still caught. Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w --- goodwe_controller/app/carmode.py | 2 +- goodwe_controller/app/chargers.py | 112 +++- goodwe_controller/test_ev13.py | 972 ++++++++++++++++++++++++++++++ 3 files changed, 1078 insertions(+), 8 deletions(-) create mode 100644 goodwe_controller/test_ev13.py diff --git a/goodwe_controller/app/carmode.py b/goodwe_controller/app/carmode.py index af18a32..32a65a1 100644 --- a/goodwe_controller/app/carmode.py +++ b/goodwe_controller/app/carmode.py @@ -257,7 +257,7 @@ class ManualWriter: finally: self._stamp(now) tracker.end_write(self.last_done) - tracker.note_write(now, was, a) + tracker.note_write(now, was, a, ok, getattr(drv, "polls", ())) tracker.end_write(self.last_done) self.log.append(("current", a, now, ok)) if ok: diff --git a/goodwe_controller/app/chargers.py b/goodwe_controller/app/chargers.py index 7c96512..228b09f 100644 --- a/goodwe_controller/app/chargers.py +++ b/goodwe_controller/app/chargers.py @@ -70,6 +70,7 @@ TOOK_S = 10.0 # a write is "taken" when the read-back follows by t TOOK_TOL_A = 0.5 # ... to within this STUCK_S = 60.0 # EV-04: power and read-back unchanged after a write STUCK_MIN_A = 1.0 # ... that moved the setpoint by at least this +LIFE_KEEP_S = 40.0 # EV-13: samples kept to date a refused write's life OWN_WRITE_MUTE_S = 15.0 # the tracker's two-writer detector ignores our own # Volts used to bound a car figure by what the read-back allows (a physical # ceiling for the alarm path, never a setpoint). @@ -120,6 +121,7 @@ REQUIRED = ("current", "readback", "state", "power") _SETPOINT_RE = re.compile(r"^number\.(?P.+)_" + SETPOINT_SUFFIX + "$") _ROLE_ORDER = tuple(ROLES) +_LIFE_ROLES = ("power", "energy", "l1", "l2", "l3") # EV-13 #: power unit -> W. The probe and the reading both use this one table. _W_PER = {"mW": 0.001, "W": 1.0, "kW": 1000.0, "MW": 1000000.0} POWER_UNITS = tuple(_W_PER) @@ -161,6 +163,9 @@ class ChargerReading: error: str | None = None # None: no error (or not read) display: str | None = None why: str = "" # for the log only, "" when available + # EV-13: when the sample was TAKEN, on the tracker's clock. None: the + # caller's `now` (in the cycle that is the read's start, `now_mono`). + taken_at: float | None = None def _state_obj(obj): @@ -420,6 +425,9 @@ class AlfenHaDriver(ChargerDriver): self._clock = time.monotonic self.clamp_faults = [] # (asked, clamp), newest last, for the log self.sent = [] # every number value actually sent + # EV-13: what the latest write saw while it waited for the read-back, + # [(time, ChargerReading)]: the cycle's reads do not run inside it. + self.polls = [] @classmethod def from_options(cls, opts: dict) -> "AlfenHaDriver": @@ -498,6 +506,7 @@ class AlfenHaDriver(ChargerDriver): read-back followed within `TOOK_S`. A value above `clamp_a()` is a SOFTWARE FAULT: nothing is sent, it is logged (the clamp watchdog's shape) and the answer is False.""" + self.polls = [] try: a = float(a) except (TypeError, ValueError): @@ -522,7 +531,8 @@ class AlfenHaDriver(ChargerDriver): """Did the read-back follow the write, within `TOOK_S`?""" t0 = self._clock() while True: - st = await self._states(("readback", "current")) + st = await self._states(("readback", "current") + _LIFE_ROLES) + self._poll(st) seen = _first(_amps(st["readback"]), _amps(st["current"])) if seen is not None and abs(seen - a) <= TOOK_TOL_A: return True @@ -530,6 +540,18 @@ class AlfenHaDriver(ChargerDriver): return False await self._sleep(1.0) + def _poll(self, st: dict) -> None: + """EV-13: keep what this wait saw of energy, power and phase currents + (never raises: a write does not depend on it).""" + try: + cur = tuple(a for a in (_amps(st.get(k)) for k in ("l1", "l2", "l3")) + if a is not None) + self.polls.append((self._clock(), ChargerReading( + available=True, power_w=_watts(st.get("power")), + energy_kwh=_kwh(st.get("energy")), current_a=cur))) + except Exception: # noqa: BLE001 + pass + async def write_phases(self, n: int) -> bool: """Select 1 or 3 phases. ONLY THROUGH `carmode`'s safe sequence: the setting moves the contactors, so it is touched with the car paused.""" @@ -631,6 +653,26 @@ CHARGING, WAITING, NONE_, FULL, UNREACH, SETUP, FAULT = ( "charging", "waiting", "none", "full", "unreach", "setup", "fault") +def _life_vals(r) -> tuple: + """EV-13: what shows a charger is alive: energy, power, three phase + currents. None is "not read".""" + cur = tuple(r.current_a or ())[:3] + return (r.energy_kwh, r.power_w) + cur + (None,) * (3 - len(cur)) + + +def _alive(vals: tuple, pre: list) -> bool: + """A value that is present now, was present before the write, and differs + from every value before it. Present but unchanged, or not there before, is + no life.""" + for i, v in enumerate(vals): + if v is None: + continue + old = [p[i] for p in pre if p[i] is not None] + if old and all(v != o for o in old): + return True + return False + + @dataclass class CarTracker: """What the cycle learns about the car from the readings. Pure, clocked by @@ -663,6 +705,9 @@ class CarTracker: sig: tuple | None = None stuck_now: bool = False obs_at: float | None = None # monotonic second of the latest reading + # EV-13: a REFUSED write waits to see if the charger shows life (below) + _pend: dict | None = None + _ring: list = field(default_factory=list) # (taken-at, life values) _hist: list = field(default_factory=list) # (t, power W, energy Wh) # today's energy day: str | None = None @@ -684,6 +729,7 @@ class CarTracker: self.last_ok = now self.last_good, self.last_good_utc = r, now_utc if r.available: + self._life(r, now) self._sig(r, now) self._writer(r, now_utc, now) self._energy(r, day) @@ -727,19 +773,71 @@ class CarTracker: `OWN_WRITE_MUTE_S` from now, not from before the write.""" self.mute_until = now + OWN_WRITE_MUTE_S - def note_write(self, now: float, was_a, to_a) -> None: - """The add-on wrote the current. Its own change is not "another - writer" for `OWN_WRITE_MUTE_S`, and a write that moved the setpoint by - `STUCK_MIN_A` or more arms the stuck check: power and read-back that - have not changed `STUCK_S` later are a stuck reading, not a car.""" + def note_write(self, now: float, was_a, to_a, ok: bool = True, + polls=()) -> None: + """The add-on wrote the current at `now`. Its own change is not + "another writer" for `OWN_WRITE_MUTE_S`, and a write that moved the + setpoint by `STUCK_MIN_A` or more arms the stuck check: power and + read-back that have not changed `STUCK_S` later are a stuck reading, + not a car. + + EV-13: a write the charger REFUSED (`ok` False) arms it only when the + charger shows no life: the energy, a phase current or the power + changed in a sample taken after `now` and within `TOOK_S` of it, + against the last values before. A refused write on a charger that is + plainly alive is not a stuck reading. `polls` are the samples the + write itself saw while it waited, `[(time, ChargerReading)]`.""" self.mute_until = now + OWN_WRITE_MUTE_S try: moved = was_a is None or abs(float(to_a) - float(was_a)) \ >= STUCK_MIN_A except (TypeError, ValueError): moved = False - if moved and self.armed_at is None: + if self._pend is not None and now > self._pend["t"] + TOOK_S: + self._pend_arm() # the old window ran out + if not moved or self.armed_at is not None: + return + if ok: + self._pend = None self.armed_at, self.armed_sig = now, self.sig + return + if self._pend is not None: + return # an earlier refusal's window + before = [x for x in self._ring if x[0] <= now] + pre = [max(before, key=lambda x: x[0])[1]] if before else [] + self._pend = {"t": now, "pre": pre, "sig": self.sig} + later = [(t, _life_vals(r)) for t, r in polls] + later += [(t, v) for t, v in self._ring if t > now] + for t, v in sorted(later, key=lambda x: x[0]): + self._pend_feed(t, v, t) + + def _life(self, r, now: float) -> None: + """EV-13: file this sample (by when it was TAKEN) and let a refused + write's open window look at it.""" + t = now if r.taken_at is None else r.taken_at + v = _life_vals(r) + self._ring.append((t, v)) + top = max(x[0] for x in self._ring) + self._ring = [x for x in self._ring if top - x[0] <= LIFE_KEEP_S] + self._pend_feed(t, v, now) + + def _pend_feed(self, t: float, vals: tuple, arrival: float) -> None: + p = self._pend + if p is None: + return + if t <= p["t"]: + p["pre"] = (p["pre"] + [vals])[-8:] # taken before the send + elif t <= p["t"] + TOOK_S and _alive(vals, p["pre"]): + self._pend = None # life: nothing to arm + return + if max(t, arrival) > p["t"] + TOOK_S: + self._pend_arm() + + def _pend_arm(self) -> None: + """No life in the window: arm as the write would have, dated its send.""" + p, self._pend = self._pend, None + if p is not None and self.armed_at is None: + self.armed_at, self.armed_sig = p["t"], p["sig"] def _sig(self, r, now: float) -> None: sig = (r.power_w, r.allowed_a) diff --git a/goodwe_controller/test_ev13.py b/goodwe_controller/test_ev13.py new file mode 100644 index 0000000..ecab25b --- /dev/null +++ b/goodwe_controller/test_ev13.py @@ -0,0 +1,972 @@ +"""EV-13: a refused current write shows ONE amber row, not two. +`python3 -B test_ev13.py` + +The bug: `ManualWriter._write` armed the stuck-reading check on every write, +refused or not. A charger that ignores the write keeps its old setpoint, so the +read-back does not move, and 60 s later "Charger reading may be stuck" showed +beside "The charger did not take the setting", and the car figure was not +trusted (EV-15 rig: it latched the quarter). + +The rule (owner's delegate, decision (b)): a refused write skips the arm ONLY +when the charger shows life: a change in the energy counter, a phase current or +the power, in a sample taken after the write was sent and within `TOOK_S` of it, +against the last value before. Present but unchanged, absent before, a stale +sample (taken before the send): not life. No life: it arms as before, dated the +send. A frozen charger (every write looks refused) is still caught. + +Shapes: S = a tracker fed by a script (the test chooses each sample's values, +taken-at and arrival), W = the real Controller on `chargersim.SimCharger`, C = +`ev04_peak.drive` (the SAFETY-81 plant). Times are model seconds. +Mutating a module this file grades? Read MUTATION.md first (purge __pycache__). + + 1. S: what counts as life (T3-T10, T12, T15) + 2. W: live refusals, one amber row (T1, T2, T19) + 3. W: no life, accepted writes, transitions (T11, T14, T17, T18, T20, T21) + 4. W: errors, restart (T13, T25) + 5. C: the peak guard (T16, T22-T24) + 6. Writes, as on the base (T26) +""" + +import asyncio +import dataclasses +import hashlib +import logging +import os +import sys +from datetime import datetime, timezone + +HERE = os.path.dirname(os.path.abspath(__file__)) +sys.path.insert(0, os.path.join(HERE, "tools")) + +from app import carmode, chargers as CH, freshness # noqa: E402 +from app.main import Controller # noqa: E402 +from chargersim import FakeHa, SimCharger # noqa: E402 + +fails = [] + + +def check(name, cond): + print(f" {'ok ' if cond else 'FAIL'} {name}") + if not cond: + fails.append(name) + + +class _Log(logging.Handler): + def __init__(self): + super().__init__(logging.DEBUG) + self.rec = [] + + def emit(self, r): + self.rec.append((r.levelname, r.getMessage())) + + def text(self, level=None): + return "\n".join(m for lv, m in self.rec if level in (None, lv)) + + +LOG = _Log() +logging.getLogger("goodwe").addHandler(LOG) +logging.getLogger("goodwe").setLevel(logging.DEBUG) +logging.getLogger("goodwe").propagate = False + +UTC = datetime(2026, 11, 22, tzinfo=timezone.utc) +DAY = "2026-11-22" +TS = 1000.0 # t_s in the S shape +TOOK_S, STUCK_S = CH.TOOK_S, CH.STUCK_S + + +# =========================================================================== # +print("1. S: WHAT COUNTS AS LIFE") +# =========================================================================== # +def rd(e=1.000, p=11040.0, cur=(16.0, 15.9, 16.0), a=16.0, taken=None, + state="C"): + return CH.ChargerReading( + available=True, state=state, charging=state == "C", power_w=p, + energy_kwh=e, current_a=cur, allowed_a=a, setpoint_a=a, + phases_allowed=3, taken_at=taken) + + +def steady(changes=None, start=1, end=130, **base): + """One sample a second from TS+start to TS+end, taken on arrival. `changes` + is {second after TS: kwargs}; each change stays.""" + out, kw = [], dict(base) + for s in range(start, end + 1): + kw.update((changes or {}).get(s, {})) + out.append((TS + s, rd(**kw))) + return out + + +def play(timeline, mode="live", ok=False, was=16.0, to=10.0, pre_end=0, + pre=None, end=TS + 130): + """The tracker sees the pre-write samples, then the write (refused unless + `ok`), then `timeline` = [(arrival, ChargerReading)]. + live: the write returns at once (HA said no), samples come after it. + ring: the write waited TOOK_S; the cycle's samples came meanwhile. + polls: the write waited and saw the samples itself (nothing else did). + Returns (tracker, first second `stuck()` was True, armed_at ever set).""" + tr = CH.CarTracker() + seen = {"armed": False, "first": None} + + def obs(at, r): + tr.observe(r, at, UTC, DAY) + seen["armed"] |= tr.armed_at is not None + if seen["first"] is None and tr.stuck(at): + seen["first"] = at + + for i in range(-20, pre_end + 1): + obs(TS + i, rd(**(pre or {}))) + inside = [x for x in timeline if x[0] <= TS + TOOK_S] + outside = [x for x in timeline if x[0] > TS + TOOK_S] + if mode == "live": + tr.note_write(TS, was, to, ok) + rest = timeline + elif mode == "ring": + for at, r in inside: + obs(at, r) + tr.note_write(TS, was, to, ok) + rest = outside + else: + tr.note_write(TS, was, to, ok, [ + (r.taken_at if r.taken_at is not None else at, r) + for at, r in inside]) + rest = outside + seen["armed"] |= tr.armed_at is not None + for at, r in sorted(rest, key=lambda x: x[0]): + if at <= end: + obs(at, r) + return tr, seen["first"], seen["armed"] + + +MODES = ("live", "ring", "polls") + + +def pend(tr): + """The refusal window a tracker keeps open (None: none).""" + return getattr(tr, "_pend", None) + + +def life(name, changes, **kw): + for m in MODES: + tr, first, armed = play(steady(changes), m, **kw) + check(f"{name} [{m}]: not armed, never stuck to TS+130", + tr.armed_at is None and first is None and not armed + and not tr.stuck_now) + + +def armed(name, tl, at=TS, **kw): + for m in MODES: + tr, first, ever = play(tl, m, **kw) + check(f"{name} [{m}]: armed at the send, stuck at TS+60 (+-1), " + f"not before TS+59 (first {first})", + first is not None and TS + 59 <= first <= TS + 61 + and tr.armed_at == at and tr.stuck_now) + + +life("T3 energy alone steps 10 Wh at +4", {4: dict(e=1.010)}) +life("T4 one phase current alone (L2 15.9 -> 16.0) at +4", + {4: dict(cur=(16.0, 16.0, 16.0))}) +life("T5 power alone (11040 -> 11080 W) at +4", {4: dict(p=11080.0)}) +life("T9 the step at +9, inside the window", {9: dict(e=1.010)}) +life("T9 the step exactly at +10 (the edge counts)", {10: dict(e=1.010)}) +life("T12(a) power None, state C, energy rising", {4: dict(e=1.010)}, + pre=dict(p=None)) +armed("T6 present but unchanged: every sample repeats the pre-write values", + steady()) +armed("T9 the step at +11 is outside the window; armed_at is the send, not " + "+10 or +11", steady({11: dict(e=1.010)})) +armed("T10 energy absent before, present after: no change against a last " + "value", steady({4: dict(e=1.010)}), pre=dict(e=None)) +armed("T12(b) power None, nothing else changes", steady(p=None), + pre=dict(p=None)) + +# T7: a stale sample: the pre-write sample again, the same taken-at time +for what, e in (("the same values", 1.000), ("changed values", 1.010)): + tl = [(TS + s, rd(e=e, taken=TS - 1.0)) for s in range(1, 131)] + armed(f"T7 stale sample ({what}, taken-at TS-1 again and again)", tl) + +# T8: the late pre-write sample (EV-12 ordering): taken TS-1, arrives TS+2 +late = [(TS + s, rd(e=1.010, taken=TS - 1.0) if s == 2 else rd(e=1.010)) + for s in range(2, 131)] +armed("T8 a sample taken at TS-1 (+10 Wh) arrives at TS+2, nothing changes " + "after it", late, pre_end=-3) + +# T15: the STUCK_MIN_A edge is as before +t15 = CH.CarTracker() +t15.observe(rd(), TS, UTC, DAY) +t15.note_write(TS, 10, 10.9) +a09 = t15.armed_at +t15.note_write(TS, 10, 11) +a10 = t15.armed_at +t15b = CH.CarTracker() +t15b.observe(rd(), TS, UTC, DAY) +t15b.note_write(TS, None, 10) +check("T15 a 0.9 A move does not arm, 1.0 A does, an unknown `was` does", + a09 is None and a10 == TS and t15b.armed_at == TS) +t15c = CH.CarTracker() +t15c.observe(rd(), TS, UTC, DAY) +t15c.note_write(TS, 10, 10.9, False) +t15d = CH.CarTracker() +t15d.observe(rd(), TS, UTC, DAY) +t15d.note_write(TS, 10, 11, False) +for i in range(1, 80): + t15d.observe(rd(), TS + i, UTC, DAY) +check("T15 a refused 0.9 A move arms nothing and leaves nothing waiting; a " + "refused 1.0 A move with no life arms", + t15c.armed_at is None and pend(t15c) is None and t15d.armed_at == TS + and t15d.stuck_now) + +# the details the plan implies +tr = CH.CarTracker() +tr.observe(rd(), TS, UTC, DAY) +tr.note_write(TS, 16, 10, True) +check("E3: an accepted write arms at once, at the send", tr.armed_at == TS + and pend(tr) is None) +tr = CH.CarTracker() +for i in range(-5, 1): + tr.observe(rd(), TS + i, UTC, DAY) +tr.note_write(TS, 16, 10, False) +tr.observe(rd(), TS + 3, UTC, DAY) +tr.note_write(TS + 5, 10, 8, True) +check("an accepted write while a refusal's window is open arms at the " + "accepted write, and the window is dropped", + tr.armed_at == TS + 5 and pend(tr) is None) +tr = CH.CarTracker() +for i in range(-5, 1): + tr.observe(rd(), TS + i, UTC, DAY) +tr.note_write(TS, 16, 10, False) +tr.note_write(TS + 5, 10, 6, False) +tr.note_write(TS + 10, 6, 5, False) +for i in range(1, 70): + tr.observe(rd(), TS + i, UTC, DAY) +check("T20 shape: refusals 5 s apart with nothing changing arm once, dated " + "the FIRST", tr.armed_at == TS and tr.stuck_now) +tr = CH.CarTracker() +for i in range(-5, 1): + tr.observe(rd(), TS + i, UTC, DAY) +tr.note_write(TS, 16, 10, False) +for i in range(1, 5): + tr.observe(rd(e=1.010), TS + i, UTC, DAY) +tr.note_write(TS + 20, 10, 8, False) +check("a refusal that showed life leaves no window; a later refusal gets " + "its own", pend(tr) is not None and pend(tr)["t"] == TS + 20 + and tr.armed_at is None) + +# T18 (tracker): an armed check is neither cleared nor delayed by a refusal +tr = CH.CarTracker() +for i in range(-5, 1): + tr.observe(rd(), TS + i, UTC, DAY) +tr.note_write(TS, 16, 10, True) +for i in range(1, 20): + tr.observe(rd(), TS + i, UTC, DAY) +tr.note_write(TS + 20, 10, 8, False) +for i in range(20, 61): + tr.observe(rd(e=1.0 + i / 1000.0), TS + i, UTC, DAY) +check("T18 (tracker) an accepted write armed at TS; a live refusal at TS+20 " + "neither clears nor delays it: stuck at TS+60", + tr.armed_at == TS and tr.stuck_now and pend(tr) is None) + + +# =========================================================================== # +# W: the real Controller on the charger model +# =========================================================================== # +class _Store: + def __init__(self): + self.data = {} + + def set(self, k, v): + self.data[k] = v + + def get(self, k, d=None): + return self.data.get(k, d) + + def set_time(self, k, v): + self.data[k] = v.isoformat() + + def get_time(self, k): + v = self.data.get(k) + return None if v is None else datetime.fromisoformat(v) + + +class _Pub: + enabled = False + + def __init__(self): + self.values = [] + + def publish(self, v): + self.values.append(dict(v)) + + def close(self): + pass + + +class Site(FakeHa): + def __init__(self, charger, grid=500.0, batt=0.0, pv=2000.0): + super().__init__(charger, None) + self.grid, self.batt, self.pv = grid, batt, pv + + async def limits(self, _e): + return (-5000.0, 5000.0, 1.0) + + def _all(self): + out = super()._all() + for eid, val, unit in (("sensor.grid", self.grid, "W"), + ("sensor.soc", 50.0, "%"), + ("sensor.batt", self.batt, "W"), + ("sensor.pv", self.pv, "W")): + out[eid] = {"entity_id": eid, "state": str(val), + "attributes": {"unit_of_measurement": unit}} + return out + + async def number(self, entity_id, invert=False): + s = self._all().get(entity_id) + try: + v = float(s["state"]) + except (TypeError, ValueError, KeyError): + return None + return -v if invert else v + + async def set_number(self, entity_id, value): + if entity_id == "number.sp": + self.sets.append((entity_id, float(value))) + self.batt = float(value) + return True + return await super().set_number(entity_id, float(value)) + + +BASE = {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid", + "soc_entity": "sensor.soc", "batt_entity": "sensor.batt", + "meter_source": "off", "max_w": 5000, "gain": 0.6, "slew_w": 500, + "deadband_w": 15, "target_grid_w": 0, "step_w": 10, "heartbeat_s": 10, + "stale_input_s": 15, "shadow_mode": "off", "peak_cap_w": 3500, + "pv_entities": ["sensor.pv"]} +SET = "number.wallbox_power_connector_max_current_socket_1" +CAR = dict(BASE, ev_charger="alfen_ha", ev_max_a=16, ev_phases="auto", + ev_current_entity=SET) +CLOCK = [1000.0] +freshness.monotonic = lambda: CLOCK[0] + + +class World: + """A real Controller on the charger model, one clock for all of it.""" + + def __init__(self, opts=CAR, sim=None, store=None, setpoint=16, phases=3, + grid=800.0, beside=False): + self.sim = sim or SimCharger(setpoint_a=setpoint) + self.sim.plug_in() + self.sim.phases_allowed = phases + self.site = Site(self.sim, grid=grid) + self.store = store or _Store() + self.t = 1000.0 + CLOCK[0] = self.t + self.off = self.t - self.sim.t # sim time + off = this clock + self.make(opts) + if beside: + self.beside() + + def beside(self): + """The writer runs BESIDE the cycle, as in production: the cycle reads + (and the tracker sees) the charger while a write waits for its + read-back, one poll per cycle.""" + gate = asyncio.Event() + + async def sleep(_s): + gate.clear() + await gate.wait() + + async def settle(): + gate.set() + for _ in range(5): + await asyncio.sleep(0) + self.drv._sleep = sleep + self.c.car_settle = settle + + def make(self, opts): + self.c = Controller(dict(opts), self.site, self.store, _Pub(), + stop=asyncio.Event()) + self.c.auto = True + self.c.dev_min, self.c.dev_max = -5000.0, 5000.0 + self.drv = self.c.charger + self.drv._sleep = self.sleep + self.drv._clock = lambda: CLOCK[0] + + async def sleep(self, s): + self.sim.tick(s) + self.t += s + CLOCK[0] = self.t + + async def step(self, n=1, dt=1.0): + out = [] + for _ in range(n): + self.sim.tick(dt) + self.t += dt + CLOCK[0] = self.t + await self.c.read_inputs(now_mono=self.t) + await self.c.cycle() + await self.c.car_settle() + tk = self.c.car + out.append((tk.obs_at, tk.armed_at, tk.stuck(self.t))) + return out + + async def act(self, what, value): + return await self.c.handle_action(what, value=value) + + def rows(self): + return {r["id"]: r for r in self.c.checks()} + + def amber(self): + """The charger's amber rows: not ok, warn.""" + return sorted(i for i, r in self.rows().items() + if r["warn"] and not r["ok"] and i.startswith("charger")) + + def sends(self): + """The model seconds (this clock) of every current write received.""" + return [x[0] + self.off for x in self.sim.writes("current")] + + +def run(coro): + return asyncio.run(coro) + + +SEND = {} # T26: what the charger was sent, per shape + + +def keep(key, w, res): + """The writes of one run: the driver's calls (second, value, taken) and + what the model received (model second, kind, value).""" + SEND[key] = ([(round(t), a, r) for t, a, r in res], + [(round(x[0]), x[1], x[2]) for x in w.sim.writes()]) + + +async def live_car(setpoint=16, phases=3, **kw): + """Manual, the car charging `setpoint` A on `phases`, ramped up.""" + w = World(setpoint=setpoint, phases=phases, **kw) + await w.step(6) + await w.act("car_phases", phases) # the wish is what the car has + await w.act("car_mode", "manual") + await w.act("car_current", setpoint) + await w.step(4) + return w + + +def spy_on(w): + """[(send time, current, ok)] of every `write_current`.""" + res, real = [], w.drv.write_current + + async def spy(a): + t = w.t + r = await real(a) + res.append((t, a, r)) + return r + w.drv.write_current = spy + return res + + +def never_stuck(tr, lo=0): + return all(a is None and not s for _t, a, s in tr[lo:]) + + +def first_stuck(tr): + return next((t for t, _a, s in tr if s), None) + + + + +# =========================================================================== # +print("\n2. W: LIVE REFUSALS SHOW ONE AMBER ROW") +# =========================================================================== # +# Each W shape runs twice: the writer inside the cycle (the model's own +# waits), and BESIDE it as in production (the cycle reads while a write waits). +SIDES = ((False, "inside"), (True, "beside")) + + +async def t1(kind, beside): + w = await live_car(beside=beside) + w.sim.refuse = kind + res = spy_on(w) + await w.act("car_current", 10) + tr = await w.step(400) + return w, res, tr + + +for beside, side in SIDES: + for kind, nm in (("ignore", "T1 the charger ignores it (HA says yes)"), + ("error", "T2 HA refuses at once (False at +0)")): + LOG.rec.clear() + w, res, tr = run(t1(kind, beside)) + ts = [t for t, _a, _r in res] + keep(f"{nm[:2]}-{kind}-{side}", w, res) + nm = f"{nm} [{side}]" + check(f"{nm}: three tries about a minute apart, all refused, then " + f"it gives up ({[round(x - ts[0]) for x in ts]})", + len(res) == 3 and not any(r for _t, _a, r in res) + and all(55 <= b - a <= 75 for a, b in zip(ts, ts[1:])) + and w.c.car_writer.gave_up) + check(f"{nm}: the car shows life inside each window: never armed, " + "never stuck, to 400 s", never_stuck(tr)) + check(f"{nm}: after the 3rd try exactly ONE amber charger row, " + f"charger_refused ({w.amber()})", + w.amber() == ["charger_refused"]) + check(f"{nm}: the car figure is still used by the alarm path", + w.c.car_alarm_w() is not None) + check(f"{nm}: N8 one CHARGER_REFUSED warning, no Traceback; N7 no " + "'another writer' row", + LOG.text("WARNING").count("CHARGER_REFUSED") == 1 + and "Traceback" not in LOG.text() + and "charger_other" not in w.rows() + and "charger_writer" not in w.rows()) + + +async def t19(beside): + w = await live_car(16, 3, beside=beside) + w.sim.refuse = "ignore" + res = spy_on(w) + await w.act("car_phases", 1) + tr = await w.step(400) + return w, res, tr + + +for beside, side in SIDES: + LOG.rec.clear() + w, res, tr = run(t19(beside)) + keep(f"T19-{side}", w, res) + check(f"T19 [{side}] the 0 A of a phase change is ignored and the car " + "keeps drawing: tried MAX_TRIES times, no select, never armed or " + "stuck", len(res) == carmode.MAX_TRIES + and not any(r for _t, _a, r in res) + and all(a == 0.0 for _t, a, _r in res) + and not w.sim.writes("phases") and never_stuck(tr)) + check(f"T19 [{side}] ...and no charger_stuck row; charger_refused shows " + f"({w.amber()})", "charger_refused" in w.amber() + and "charger_stuck" not in w.amber()) + + +# =========================================================================== # +print("\n3. W: NO LIFE, ACCEPTED WRITES, TRANSITIONS") +# =========================================================================== # +async def t11(beside): + w = await live_car(beside=beside) + w.sim.set_current(5) # under 6 A: B, exactly 0 W, waiting + await w.step(8) + w.sim.refuse = "ignore" + res = spy_on(w) + await w.act("car_current", 10) + tr = await w.step(300) + return w, res, tr + + +for beside, side in SIDES: + LOG.rec.clear() + w, res, tr = run(t11(beside)) + keep(f"T11-{side}", w, res) + t_s = res[0][0] + fs = first_stuck(tr) + check(f"T11 [{side}] a paused car (B, 0 W) shows no life: it arms as " + f"today, stuck at t_s+60 ({fs - t_s if fs else None})", + w.sim.state == "B" and w.sim.power_w == 0.0 and fs is not None + and 59 <= fs - t_s <= 61) + check(f"T11 [{side}] ...and after the 3rd try both amber rows show: " + f"{w.amber()}", w.amber() == ["charger_refused", "charger_stuck"]) + + +async def t14(): + w = await live_car(beside=True) + w.sim.lag_s = 3.0 # the read-back is seen by the cycle + w.sim.freeze_power() # the power sticks, the rest is live + res = spy_on(w) + await w.act("car_current", 8) + tr = await w.step(100) + return w, res, tr + + +LOG.rec.clear() +w, res, tr = run(t14()) +t_s = res[0][0] +fs = first_stuck(tr) +check(f"T14 an ACCEPTED write (read-back 3 s late) under a frozen power: " + f"stuck at t_s+60 (+-1), as before ({fs - t_s if fs else None})", + res[0][2] is True and fs is not None and 59 <= fs - t_s <= 61 + and w.c.car.armed_at == t_s) +check("T14 ...the amber row 'charger_stuck' shows, and the car figure is not " + "trusted while stuck (N4)", "charger_stuck" in w.amber() + and w.c.car.car_w_trusted(w.t) is None and w.c.car_alarm_w() is None) + + +async def t17(): + w = await live_car(beside=True) + w.sim.refuse = "ignore" + res = spy_on(w) + await w.act("car_current", 10) + tr = await w.step(70) # tries at t_s and t_s+60: live + w.sim.refuse = None + w.sim.lag_s = 3.0 + w.sim.freeze_power() + await w.act("car_current", 12) + tr += await w.step(120) + return w, res, tr + + +LOG.rec.clear() +w, res, tr = run(t17()) +t_s, t_acc = res[0][0], res[-1][0] +fs = first_stuck(tr) +check(f"T17 live refusals (not armed), then an accepted write at t_s+" + f"{t_acc - t_s:.0f}: not armed before it, stuck at ITS +60 (+-1) " + f"({fs - t_acc if fs else None})", + res[-1][2] is True and t_acc - t_s > 61 and fs is not None + and 59 <= fs - t_acc <= 61 + and all(a is None for t, a, _s in tr if t < t_acc)) + + +async def t18(): + w = await live_car(beside=True) + w.sim.lag_s = 3.0 + w.sim.freeze_power() + res = spy_on(w) + await w.act("car_current", 12) # accepted: arms + tr = await w.step(19) + w.sim.lag_s = 0.0 + w.sim.refuse = "ignore" + await w.act("car_current", 10) # a live refusal 20 s later + tr += await w.step(100) + return w, res, tr + + +LOG.rec.clear() +w, res, tr = run(t18()) +t0 = res[0][0] +fs = first_stuck(tr) +check(f"T18 an accepted write armed at t0; a live refusal at t0+" + f"{res[1][0] - t0:.0f} neither clears nor delays it: stuck at t0+60 " + f"({fs - t0 if fs else None}), still dated t0", + len(res) >= 2 and res[1][2] is False and fs is not None + and 59 <= fs - t0 <= 61 and tr[-1][1] == t0 + and all(a == t0 for _t, a, _s in tr if a is not None)) + + +async def t21(beside): + w = await live_car(10, 3, beside=beside) + w.sim.lag_s = 14.0 + res = spy_on(w) + await w.act("car_current", 12) + tr = await w.step(120) + return w, res, tr + + +for beside, side in SIDES: + LOG.rec.clear() + w, res, tr = run(t21(beside)) + keep(f"T21-{side}", w, res) + check(f"T21 [{side}] HA took it, the read-back comes 14 s late (False at " + "+10): never stuck, no 'another writer' row, 12 A adopted, one " + "write", [(a, r) for _t, a, r in res] == [(12.0, False)] + and not any(st for _t, _a, st in tr) + and "charger_other" not in w.rows() + and "charger_writer" not in w.rows() + and w.c.car_writer.last_a == 12.0 and w.sim.readback_a == 12.0) + + +async def t20(beside): + """EV-28 T15 shape: the 0 A is taken and the car stops, the select is + taken, then the restore is refused MAX_TRIES times 5 s apart at 0 W.""" + w = await live_car(16, 3, beside=beside) + res = spy_on(w) + await w.act("car_phases", 1) + for _ in range(60): + await w.step(1) + if w.sim.phases_allowed == 1: + break + w.sim.refuse = "error" + tr = await w.step(150) + return w, res, tr + + +for beside, side in SIDES: + LOG.rec.clear() + w, res, tr = run(t20(beside)) + keep(f"T20-{side}", w, res) + rest = [x for x in res if x[1] == 16.0] + fs = first_stuck(tr) + t_r = rest[0][0] if rest else None + check(f"T20 [{side}] the 0 A is taken, the restore is refused " + f"{len(rest)} times at 0 W with nothing changing: it arms as on " + f"the base, dated the first refusal (stuck at +" + f"{fs - t_r if fs and t_r else None})", + len(rest) >= carmode.MAX_TRIES and not any(r for _t, _a, r in rest) + and w.sim.power_w == 0.0 and fs is not None and 59 <= fs - t_r <= 61) + check(f"T20 [{side}] ...no select besides the one made, and the rows " + f"are as on the base ({w.amber()})", + len(w.sim.writes("phases")) == 1 + and "charger_stuck" in w.amber()) + + +# =========================================================================== # +print("\n4. W: AN ERROR AND A RESTART") +# =========================================================================== # +async def t13(exc): + w = await live_car() + n0 = len(LOG.rec) + + async def boom(a): + await w.sleep(1.0) + raise exc + w.drv.write_current = boom + await w.act("car_current", 10) + tr = await w.step(30) + return w, tr, n0 + + +from app import hass # noqa: E402 +for exc in (RuntimeError("the link broke"), hass.ReadOnly("read only")): + LOG.rec.clear() + w, tr, n0 = run(t13(exc)) + errs = [m for lv, m in LOG.rec[n0:] + if lv == "ERROR" and "car charger step failed" in m] + check(f"T13 write_current raises {type(exc).__name__}: as on the base: " + "never armed, no window left, no refusal counted, the mute set, " + f"the step error logged once ({len(errs)})", + never_stuck(tr) and pend(w.c.car) is None + and w.c.car_writer.fails == 0 and w.c.car.mute_until > 0 + and len(errs) == 1) + + +async def t25(): + w = await live_car() + w.sim.refuse = "ignore" + await w.act("car_current", 10) + await w.step(75) # two tries + fails_before = w.c.car_writer.fails + w.make(CAR) # a restart: a new Controller + return w, fails_before + + +w, fb = run(t25()) +check("T25 a restart after 2 refusals: a fresh tracker and writer, nothing " + "armed, nothing waiting, no failures counted", + fb == 2 and w.c.car.armed_at is None and pend(w.c.car) is None + and not w.c.car.stuck(w.t) and w.c.car_writer.fails == 0) + +# =========================================================================== # +print("\n5. C: THE PEAK GUARD (the real Controller on the SAFETY-81 plant)") +# =========================================================================== # +import ev04_peak as P # noqa: E402 +import safety81_sim as s81 # noqa: E402 + +HOUSE = 3000.0 +AIM = 6050.0 + + +def drive(events, dur, house=HOUSE, aim=AIM, **kw): + """P.drive with a trace per second, taken before that second's cycle: + (second, armed_at, stuck, car_alarm_w, the alarms so far).""" + tr = [] + + def note(plant, c): + tr.append((plant.t, c.car.armed_at, c.car.stuck_now, c.car_alarm_w())) + ev = {t: note for t in range(0, dur)} + for t, fn in events.items(): + ev[t] = (lambda p, c, fn=fn: (fn(p, c), note(p, c))) + kw.setdefault("phases", 3) + kw.setdefault("setpoint", 16) + kw.setdefault("user_a", 16) + r = P.drive(s81.constant(house), dur=dur, rating=12000.0, soc=60.0, + cap=aim, events=ev, **kw) + return r, tr + + +def user_change(a): + def fn(plant, c): + asyncio.get_event_loop().create_task(c.handle_action( + "car_current", value=a)) + return fn + + +def reserve(plant, c): + """Both units at the peak reserve, the house on, the car 11 kW.""" + plant.soc = 19.0 + plant.load = lambda t: HOUSE + plant.ch.power_w + + +def sends(r): + return [(round(x[0]), x[1], x[2]) for x in r["sim"].writes()] + + +def amber_rows(r): + return sorted(x["id"] for x in r["c"].checks() + if x["warn"] and not x["ok"] and x["id"].startswith("charger")) + + +ALARMS = P.ALARMS + ("goodwe_peak_floor_limited",) + + +def alarm_list(r): + return P.ids(r, *P.ALARMS) + + +# T22: a live refusal under a car-caused overload raises nothing the twin +# does not +def t22_events(change): + ev = {300: lambda p, c: (reserve(p, c), setattr(p.ch, "refuse", "ignore") + if change else None)} + if change: + ev[301] = user_change(10) + return ev + + +r_ref, tr_ref = drive(t22_events(True), 700) +r_twin, tr_twin = drive(t22_events(False), 700) +w_ref = [x[3] for x in tr_ref if x[0] >= 300] +w_twin = [x[3] for x in tr_twin if x[0] >= 300] +check("T22 PRECONDITION: the refusals happened (3 tries) and the twin wrote " + "nothing", len(r_ref["sim"].writes("current")) == 3 + and r_twin["sim"].writes("current") == []) +check("T22 a live refusal under a car-caused overload: the car figure used by " + "the alarm path is the twin's every cycle from 300 to 700 (+-1 W)", + len(w_ref) == len(w_twin) and all( + (a is None and b is None) or (a is not None and b is not None + and abs(a - b) <= 1.0) + for a, b in zip(w_ref, w_twin))) +check(f"T22 ...and the alarms are the twin's ({alarm_list(r_ref)} vs " + f"{alarm_list(r_twin)})", alarm_list(r_ref) == alarm_list(r_twin) + and alarm_list(r_ref) == []) +check("T22 ...never armed, never stuck", all(a is None and not s + for _t, a, s, _w in tr_ref)) + +# T16: the test_ev04 section 9 shape: everything frozen, the car really goes, +# the user sets 10 A: the write is refused and nothing changes + + +def freeze_all(plant, c): + plant.ch.freeze() # every reading sticks, the + plant.ch.unplug() # read-back too; the car goes + plant.load = lambda at: 9000.0 + plant.ch.power_w + + +r16, tr16 = drive({60: lambda p, c: (freeze_all(p, c), + user_change(10)(p, c))}, 400, + house=1100.0, aim=3500.0) +SEND["T16"] = ([], sends(r16)) +log16 = [x for x in r16["c"].car_writer.log if x[0] == "current"] +t_s = log16[0][2] if log16 else None +fs = next((t for t, _a, s, _w in tr16 if s), None) +al16 = P.ids(r16, "goodwe_peak_saturated") +check(f"T16 everything frozen, the write is refused: it arms at t_s={t_s} " + f"and is stuck at t_s+60 +-2 (first {fs})", + t_s is not None and fs is not None and 58 <= fs - t_s <= 62 + and not any(x[3] for x in log16)) +check(f"T16 ...after MAX_TRIES both rows show: {amber_rows(r16)}", + amber_rows(r16) == ["charger_refused", "charger_stuck"]) +check("T16 ...the car figure is not used while stuck, and the normal alarm " + f"fires before freeze+60+60+25 ({al16})", + r16["c"].car_alarm_w() is None and len(al16) == 1 + and al16[0][0] < 60 + 60 + 25) + +# T23 (EV-10 trap): a 6 A, 1 phase car (1.38 kW) takes no energy step inside +# the window, so its refusal arms as today. The house then steps 1.7 kW over +# the aim: the car does not explain it, so the alarm comes at the twins' cycle. +def t23_events(change, t_s=570): + def house_drain(plant, c): # test_ev10's trap shape + plant.soc = 19.0 + plant.load = lambda at: 12000.0 + plant.ch.power_w + return {t_s - 1: lambda p, c: (setattr(p.ch, "refuse", "ignore") + if change else None), + t_s: user_change(8) if change else (lambda p, c: None), + t_s + 30: house_drain} + + +def t23(change, mode="manual"): + return drive(t23_events(change), 800, house=1100.0, aim=4500.0, + phases=1, setpoint=6, user_a=6, mode=mode) + + +r23, tr23 = t23(True) +r23a, tr23a = t23(False) +r23o, tr23o = t23(False, mode="off") +a23, a23a, a23o = (P.ids(x, *P.ALARMS) for x in (r23, r23a, r23o)) +check(f"T23 PRECONDITION: the refusal found no life (6 A, 1.38 kW): it armed " + f"as today, stuck at t_s+60", any(s for _t, _a, s, _w in tr23) + and len(r23["sim"].writes("current")) >= 1) +check(f"T23 the alarm fires at the same second as both twins (refusal " + f"{a23}, no write {a23a}, Off {a23o})", len(a23) == 1 + and [n for _t, n in a23] == [n for _t, n in a23a] + and abs(a23[0][0] - a23a[0][0]) <= 1 and a23o + and abs(a23[0][0] - a23o[0][0]) <= 1) + + +# T24 (EV-18): after a live refusal (not armed) the energy meter stops while +# the power says 11 kW: the figure is contradicted and the quarter latched. +# (The tries are at 300, 360 and 420, each live; the meter stops after them.) +def meter_stops(plant, c): + sim, tick = plant.ch, plant.ch.tick + + def stuck_meter(secs=1.0): + kwh = sim.kwh + tick(secs) + sim.kwh = kwh + sim.tick = stuck_meter + + +def t24(change): + ev = {299: lambda p, c: (reserve(p, c), setattr(p.ch, "refuse", "ignore") + if change else None), + 300: user_change(10) if change else (lambda p, c: None), + 432: meter_stops} # after the 3rd try's window + seen = [] + + def watch(plant, c): + seen.append((plant.t, c._car_contradicted(c.car_now()), + c._car_contra_block)) + for t in range(300, 700): + prev = ev.get(t) + ev[t] = (lambda p, c, prev=prev: (prev(p, c) if prev else None, + watch(p, c))) + r, tr = drive(ev, 700) + return r, tr, seen + + +r24, tr24, seen24 = t24(True) +check("T24 PRECONDITION: a live refusal at 300 (not armed)", + len(r24["sim"].writes("current")) >= 1 + and all(a is None and not st for t, a, st, _w in tr24)) +check("T24 after a live refusal the meter that falls short for a window " + "contradicts the figure and latches the quarter (a refusal hides no " + "contradiction)", any(x[1] for x in seen24) + and seen24[-1][2] is not None) + +# =========================================================================== # +print("\n6. WRITES: THE SAME AS ON THE BASE (T26, N3)") +# =========================================================================== # +if os.environ.get("EV13_DUMP"): + for k in sorted(SEND): + print("DUMP", repr(k), repr(SEND[k])) +BASE_SENDS = { # recorded on 76f4de2 (release/1.0 before EV-13) + 'T1-ignore-beside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], [(11, 'current', 10.0), (71, 'current', 10.0), (131, 'current', 10.0)]), + 'T1-ignore-inside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], [(11, 'current', 10.0), (71, 'current', 10.0), (131, 'current', 10.0)]), + 'T11-beside': ([(1019, 10.0, False), (1079, 10.0, False), (1139, 10.0, False)], [(19, 'current', 10.0), (79, 'current', 10.0), (139, 'current', 10.0)]), + 'T11-inside': ([(1019, 10.0, False), (1079, 10.0, False), (1139, 10.0, False)], [(19, 'current', 10.0), (79, 'current', 10.0), (139, 'current', 10.0)]), + 'T16': ([], [(61, 'current', 10.0), (131, 'current', 10.0), (201, 'current', 10.0)]), + 'T19-beside': ([(1011, 0.0, False), (1071, 0.0, False), (1131, 0.0, False)], [(11, 'current', 0.0), (71, 'current', 0.0), (131, 'current', 0.0)]), + 'T19-inside': ([(1011, 0.0, False), (1071, 0.0, False), (1131, 0.0, False)], [(11, 'current', 0.0), (71, 'current', 0.0), (131, 'current', 0.0)]), + 'T2-error-beside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], []), + 'T2-error-inside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], []), + 'T20-beside': ([(1011, 0.0, True), (1025, 16.0, False), (1030, 16.0, False), (1035, 16.0, False), (1095, 16.0, False), (1155, 16.0, False)], [(11, 'current', 0.0), (15, 'phases', 1)]), + 'T20-inside': ([(1011, 0.0, True), (1025, 16.0, False), (1030, 16.0, False), (1035, 16.0, False), (1095, 16.0, False), (1155, 16.0, False)], [(11, 'current', 0.0), (15, 'phases', 1)]), + 'T21-beside': ([(1011, 12.0, False)], [(11, 'current', 12.0)]), + 'T21-inside': ([(1011, 12.0, False)], [(11, 'current', 12.0)]), +} +for k in sorted(SEND): + check(f"T26 {k}: the writes (second, value, taken) and what the model " + "received are the base's", BASE_SENDS.get(k) == SEND[k]) +check("T26 no write above the clamp (16 A), and the one select (T20) came " + "with the car at 0 W", all(a <= 16.0 for v in SEND.values() + for _t, a, _r in v[0]) + and sorted(k for k, v in SEND.items() + if any(x[1] == "phases" for x in v[1])) == ["T20-beside", + "T20-inside"]) + +print() +if fails: + print(f"FAIL: {len(fails)} check(s)") + for f in fails: + print(" -", f) + sys.exit(1) +print("ok: EV-13") From c3903b796bb06195ad737d0f606cc1b3b0cf21c3 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 22 Nov 2026 02:23:56 +0100 Subject: [PATCH 2/7] EV-13: CHANGELOG line and DECISIONS note Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w --- goodwe_controller/CHANGELOG.md | 1 + goodwe_controller/DECISIONS/EV-04-manual-mode.md | 10 ++++++++++ 2 files changed, 11 insertions(+) diff --git a/goodwe_controller/CHANGELOG.md b/goodwe_controller/CHANGELOG.md index bf5a514..535e9fe 100644 --- a/goodwe_controller/CHANGELOG.md +++ b/goodwe_controller/CHANGELOG.md @@ -2,6 +2,7 @@ ### Not in a release yet +- When the car charger does not take a current setting but is plainly working, you now see one amber row ("did not take the setting"), not a second "reading may be stuck" ([[EV-13]]). - The add-on no longer changes the car's phases while the car still draws: it waits until the charger reads under 100 W, and if the car is still drawing after 20 s it gives the current back and tries again after 10 minutes ([[EV-28]]). - When the add-on changes the car's phases while the batteries are at the peak reserve, there is no longer a false "Battery stopped limiting the peak" for a moment ([[EV-15]]). diff --git a/goodwe_controller/DECISIONS/EV-04-manual-mode.md b/goodwe_controller/DECISIONS/EV-04-manual-mode.md index 39c2fa1..2237202 100644 --- a/goodwe_controller/DECISIONS/EV-04-manual-mode.md +++ b/goodwe_controller/DECISIONS/EV-04-manual-mode.md @@ -64,6 +64,16 @@ stops holding late in a period that the car already pushed over, because `excess_w` grows as the seconds run out; the average form does not, and it is the same test for a steady car. +**A refused write arms the stuck check only when the charger shows no life +(EV-13).** A charger that ignores a write keeps its old read-back, so the +check would read it as stuck 60 s later and show a second amber row beside +"did not take the setting". A refused write now arms only if, within `TOOK_S` +of the send, the energy, a phase current or the power changed in a sample taken +after the send, against the last value before (`CarTracker.note_write`, +`_alive`). Unchanged, absent before, or taken before the send is no life. No +life arms as before, dated the send. A write that raised, or was accepted, is +unchanged. A frozen charger (every write looks refused) still arms. + **A stale, stuck or frozen car figure must never hide a real overload.** Only `CarTracker.car_w_trusted` is used: fresh (the EV-03 rules, which also make an unavailable reading None at once), not stuck after a write (SAFETY-37's shape), From 1b39f1698a7f5e2d0ebe3774c4a81749b4203958 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 22 Nov 2026 03:56:53 +0100 Subject: [PATCH 3/7] EV-13 router round 1: lapse a refusal's window on unavailable readings; T27, T28 and the N-ids Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w --- goodwe_controller/app/chargers.py | 9 ++ goodwe_controller/test_ev13.py | 163 ++++++++++++++++++++++++++++++ 2 files changed, 172 insertions(+) diff --git a/goodwe_controller/app/chargers.py b/goodwe_controller/app/chargers.py index 228b09f..a6bd23e 100644 --- a/goodwe_controller/app/chargers.py +++ b/goodwe_controller/app/chargers.py @@ -728,6 +728,8 @@ class CarTracker: if usable: self.last_ok = now self.last_good, self.last_good_utc = r, now_utc + if not r.available: + self._pend_lapse(now) if r.available: self._life(r, now) self._sig(r, now) @@ -833,6 +835,13 @@ class CarTracker: if max(t, arrival) > p["t"] + TOOK_S: self._pend_arm() + def _pend_lapse(self, now: float) -> None: + """A reading that did not answer shows no life either: once the window + has run out the refusal arms, dated the send, as it did before.""" + p = self._pend + if p is not None and now > p["t"] + TOOK_S: + self._pend_arm() + def _pend_arm(self) -> None: """No life in the window: arm as the write would have, dated its send.""" p, self._pend = self._pend, None diff --git a/goodwe_controller/test_ev13.py b/goodwe_controller/test_ev13.py index ecab25b..fe22e79 100644 --- a/goodwe_controller/test_ev13.py +++ b/goodwe_controller/test_ev13.py @@ -139,6 +139,9 @@ def play(timeline, mode="live", ok=False, was=16.0, to=10.0, pre_end=0, MODES = ("live", "ring", "polls") +N1, N2 = [], [] # (name, never stuck) / (name, seconds from the send to stuck) + + def pend(tr): """The refusal window a tracker keeps open (None: none).""" return getattr(tr, "_pend", None) @@ -147,6 +150,7 @@ def pend(tr): def life(name, changes, **kw): for m in MODES: tr, first, armed = play(steady(changes), m, **kw) + N1.append((f"{name} [{m}]", first is None and not tr.stuck_now)) check(f"{name} [{m}]: not armed, never stuck to TS+130", tr.armed_at is None and first is None and not armed and not tr.stuck_now) @@ -155,6 +159,7 @@ def life(name, changes, **kw): def armed(name, tl, at=TS, **kw): for m in MODES: tr, first, ever = play(tl, m, **kw) + N2.append((f"{name} [{m}]", None if first is None else first - TS)) check(f"{name} [{m}]: armed at the send, stuck at TS+60 (+-1), " f"not before TS+59 (first {first})", first is not None and TS + 59 <= first <= TS + 61 @@ -501,6 +506,7 @@ for beside, side in SIDES: len(res) == 3 and not any(r for _t, _a, r in res) and all(55 <= b - a <= 75 for a, b in zip(ts, ts[1:])) and w.c.car_writer.gave_up) + N1.append((nm, never_stuck(tr))) check(f"{nm}: the car shows life inside each window: never armed, " "never stuck, to 400 s", never_stuck(tr)) check(f"{nm}: after the 3rd try exactly ONE amber charger row, " @@ -529,6 +535,7 @@ for beside, side in SIDES: LOG.rec.clear() w, res, tr = run(t19(beside)) keep(f"T19-{side}", w, res) + N1.append((f"T19 [{side}]", never_stuck(tr))) check(f"T19 [{side}] the 0 A of a phase change is ignored and the car " "keeps drawing: tried MAX_TRIES times, no select, never armed or " "stuck", len(res) == carmode.MAX_TRIES @@ -560,6 +567,7 @@ for beside, side in SIDES: keep(f"T11-{side}", w, res) t_s = res[0][0] fs = first_stuck(tr) + N2.append((f"T11 [{side}]", None if fs is None else fs - t_s)) check(f"T11 [{side}] a paused car (B, 0 W) shows no life: it arms as " f"today, stuck at t_s+60 ({fs - t_s if fs else None})", w.sim.state == "B" and w.sim.power_w == 0.0 and fs is not None @@ -687,6 +695,7 @@ for beside, side in SIDES: rest = [x for x in res if x[1] == 16.0] fs = first_stuck(tr) t_r = rest[0][0] if rest else None + N2.append((f"T20 [{side}]", None if not (fs and t_r) else fs - t_r)) check(f"T20 [{side}] the 0 A is taken, the restore is refused " f"{len(rest)} times at 0 W with nothing changing: it arms as on " f"the base, dated the first refusal (stuck at +" @@ -849,6 +858,8 @@ log16 = [x for x in r16["c"].car_writer.log if x[0] == "current"] t_s = log16[0][2] if log16 else None fs = next((t for t, _a, s, _w in tr16 if s), None) al16 = P.ids(r16, "goodwe_peak_saturated") +N2.append(("T16", None if fs is None else fs - t_s)) +N1.append(("T22", all(a is None and not st for _t, a, st, _w in tr_ref))) check(f"T16 everything frozen, the write is refused: it arms at t_s={t_s} " f"and is stuck at t_s+60 +-2 (first {fs})", t_s is not None and fs is not None and 58 <= fs - t_s <= 62 @@ -963,6 +974,158 @@ check("T26 no write above the clamp (16 A), and the one select (T20) came " if any(x[1] == "phases" for x in v[1])) == ["T20-beside", "T20-inside"]) +# =========================================================================== # +print("\n7. A REFUSAL, THEN THE CHARGER GOES UNAVAILABLE") +# =========================================================================== # +GONE = CH.ChargerReading(available=False, why="no answer") + + +def gone_then_back(back_at, mode): + """Refusal at TS; no answer until `back_at`; then the frozen reading.""" + tl = [(TS + s, GONE if s < back_at else rd()) for s in range(1, 131)] + return play(tl, mode) + + +for mode in ("live", "ring"): + tr, first, _ = gone_then_back(21, mode) + check(f"unavailable [{mode}]: a refusal, no answer from TS+1 to TS+20 " + f"(past TOOK_S), then the reading back and frozen: armed dated the " + f"send, stuck at TS+60 as on the base (first {first})", + tr.armed_at == TS and first is not None and TS + 59 <= first + <= TS + 61 and pend(tr) is None) + tl = [(TS + k, GONE) for k in range(1, 31)] + tr, first, _ = play(tl, mode) + check(f"unavailable [{mode}]: a refusal and no answer at all for 30 s: " + "armed dated the send while it is still unavailable, as on the " + "base", tr.armed_at == TS and pend(tr) is None) + tr, first, _ = gone_then_back(75, mode) + check(f"unavailable [{mode}]: no answer until TS+75: the window lapsed " + f"unseen, so the first reading back is stuck at once, as on the base " + f"(first {first})", tr.armed_at == TS and first == TS + 75) + tr, first, _ = gone_then_back(5, mode) + check(f"unavailable [{mode}]: back inside the window and frozen: the " + "window runs on and arms at the send", tr.armed_at == TS + and first is not None and TS + 59 <= first <= TS + 61) + +# =========================================================================== # +print("\n8. N-IDS") +# =========================================================================== # +check(f"N1: no stuck after refusals that all showed life (T1-T5, T9 edges, " + f"T12a, T19, T22: {len(N1)} runs)", len(N1) >= 20 + and all(ok for _n, ok in N1)) +check(f"N2: every refusal with no life is stuck within 61 s of its send " + f"(T6-T11, T12b, T16, T20: {len(N2)} runs)", len(N2) >= 20 + and all(d is not None and d <= 61 for _n, d in N2)) +check("N5: no house-caused alarm later than the no-write twin or Off (T22 " + "equals its twin; T23 within a second of both)", + alarm_list(r_ref) == alarm_list(r_twin) + and abs(a23[0][0] - a23a[0][0]) <= 1 and abs(a23[0][0] - a23o[0][0]) <= 1) +from app import messages # noqa: E402 +check("N6: the constants and the row texts (EN and NL) are the base's", + (CH.STUCK_S, CH.STUCK_MIN_A, CH.OWN_WRITE_MUTE_S, CH.TOOK_S) == + (60.0, 1.0, 15.0, 10.0) + and (carmode.MAX_TRIES, carmode.RETRY_S) == (3, 60.0) + and messages.row_charger_stuck() == + "The charger reading may be stuck, so check the charger." + and messages.row_charger_stuck().nl == + "De meting van de laadpaal staat mogelijk vast, dus controleer de " + "laadpaal." + and messages.row_charger_refused() == + "The charger did not take the setting, so check the charger." + and messages.row_charger_refused().nl == + "De laadpaal nam de instelling niet over, dus controleer de laadpaal.") + +# =========================================================================== # +print("\n9. T27: THE EV-04 SECTION 9 CHECKS ARE THE BASE'S; T28: THE MUTANTS") +# =========================================================================== # +S9_SHA = "2a40480c804574207b0c81096365363c8d608eeb32285a1c18700478fc37fc41" +src04 = open(os.path.join(HERE, "test_ev04.py")).read() +a9 = src04.index('9. THE PEAK GUARD') +b9 = src04.index("# a plausible figure is bounded by what the read-back allows") +sec9 = src04[a9:b9] +check("T27 test_ev04 section 9 is byte-identical to 76f4de2", + hashlib.sha256(sec9.encode()).hexdigest() == S9_SHA) +check("T27 ...its two stuck checks are there", + "the amber row 'Charger reading may be stuck' says so" in sec9 + and "...while stuck, the car figure is not used by the alarm path" in sec9) +# the other files T27 names (ev04, ev10, ev10b, ev15, ev18, ev19, ev28, +# named_absence, bytecode) are test files of their own: CI runs every +# test_*.py, so a red one fails this PR; not re-run from here. + +MUTANTS = { + "M1": (" before = [x for x in self._ring if x[0] <= now]\n", + " return\n before = [x for x in self._ring if x[0] " + "<= now]\n"), + "M2": (" if old and all(v != o for o in old):", " if old:"), + "M3": (" t = now if r.taken_at is None else r.taken_at\n", + " t = now\n"), + "M4": (" self._pend_feed(t, v, t)\n\n def _life", + " self._pend_feed(t, v, t)\n self._pend_arm()\n\n" + " def _life"), + "M5": (' if max(t, arrival) > p["t"] + TOOK_S:\n' + ' self._pend_arm()', + ' if max(t, arrival) > p["t"] + TOOK_S:\n' + ' self._pend_arm(max(t, arrival))'), +} +M5_SIG = (" def _pend_arm(self) -> None:", + " def _pend_arm(self, at=None) -> None:") +M5_SET = (' self.armed_at, self.armed_sig = p["t"], p["sig"]', + ' self.armed_at, self.armed_sig = (p["t"] if at is None ' + 'else at), p["sig"]') +# what each mutant must turn red (substrings of the failing check names) +RED = {"M1": ["T6 ", "T7 ", "T11 ", "T16 "], "M2": ["T6 "], + "M3": ["T7 ", "T8 "], "M4": ["T2 "], "M5": ["T9 ", "T16 "]} + + +def mutant_run(name): + """A copy of the tree with the bug put back; test_ev13 (and, for the + stuck rows, test_ev04) run in it. The children skip this section.""" + import shutil + import subprocess + import tempfile + d = tempfile.mkdtemp(prefix="ev13m-") + dst = os.path.join(d, "gc") + shutil.copytree(HERE, dst, ignore=shutil.ignore_patterns( + "__pycache__", "*.pyc")) + p = os.path.join(dst, "app", "chargers.py") + txt = open(p).read() + edits = [MUTANTS[name]] + ([M5_SIG, M5_SET] if name == "M5" else []) + for old, new in edits: + assert txt.count(old) == 1, (name, old) + txt = txt.replace(old, new) + open(p, "w").write(txt) + env = dict(os.environ, EV13_MUTANT="1", PYTHONDONTWRITEBYTECODE="1") + procs = {f: subprocess.Popen( + [sys.executable, "-B", f], cwd=dst, env=env, stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, text=True) + for f in ("test_ev13.py", "test_ev04.py")} + out = {f: pr.communicate()[0] for f, pr in procs.items()} + shutil.rmtree(d, ignore_errors=True) + return {f: [ln for ln in o.splitlines() if ln.strip().startswith("FAIL")] + for f, o in out.items()}, {f: procs[f].returncode for f in procs} + + +if not os.environ.get("EV13_MUTANT"): + import concurrent.futures + with concurrent.futures.ThreadPoolExecutor(5) as ex: + res = dict(zip(MUTANTS, ex.map(mutant_run, MUTANTS))) + for name in MUTANTS: + reds, rcs = res[name] + got = reds["test_ev13.py"] + check(f"T28 {name}: test_ev13 goes red ({len(got)} checks) in " + f"{RED[name]}", rcs["test_ev13.py"] != 0 + and all(any(k in ln for ln in got) for k in RED[name])) + check("T28 M1 also turns the two test_ev04 section 9 stuck checks red", + res["M1"][1]["test_ev04.py"] != 0 + and any("amber row 'Charger reading may be stuck'" in ln + for ln in res["M1"][0]["test_ev04.py"]) + and any("car figure is not used" in ln + for ln in res["M1"][0]["test_ev04.py"])) + check("T28 M2 turns test_ev04 section 9 red too; M3, M4 and M5 do not " + "(its 85 s bound is too loose to see M5's 10 s: see the report)", + res["M2"][1]["test_ev04.py"] != 0 + and all(res[m][1]["test_ev04.py"] == 0 for m in ("M3", "M4", "M5"))) + print() if fails: print(f"FAIL: {len(fails)} check(s)") From 5ebd830966afec5ab5ba9aa60beb4ba3133f9843 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 22 Nov 2026 05:44:31 +0100 Subject: [PATCH 4/7] EV-13 review: compare phase currents per phase; test a late read-back A phase that drops out or comes back shifted the compressed current_a tuple and read as life, so a frozen charger never armed. ChargerReading.phase_a keeps L1/L2/L3 with None for a missing phase and the life test uses it. Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w --- goodwe_controller/app/chargers.py | 16 +++++++---- goodwe_controller/test_ev13.py | 44 +++++++++++++++++++++++++++++-- 2 files changed, 53 insertions(+), 7 deletions(-) diff --git a/goodwe_controller/app/chargers.py b/goodwe_controller/app/chargers.py index a6bd23e..c6cb8ee 100644 --- a/goodwe_controller/app/chargers.py +++ b/goodwe_controller/app/chargers.py @@ -166,6 +166,7 @@ class ChargerReading: # EV-13: when the sample was TAKEN, on the tracker's clock. None: the # caller's `now` (in the cycle that is the read's start, `now_mono`). taken_at: float | None = None + phase_a: tuple = () # EV-13: L1, L2, L3 each, None if not read def _state_obj(obj): @@ -285,6 +286,7 @@ def reading_from_states(states: dict) -> ChargerReading: available=True, state=letter, connected=connected, charging=charging, power_w=power, energy_kwh=_kwh(states.get("energy")), current_a=currents, setpoint_a=_amps(states.get("current")), + phase_a=tuple(_amps(states.get(k)) for k in ("l1", "l2", "l3")), allowed_a=_amps(states.get("readback")), phases_allowed=_phases(states.get("phases_read")), station_a=_first(_amps(states.get("station_active")), @@ -544,11 +546,10 @@ class AlfenHaDriver(ChargerDriver): """EV-13: keep what this wait saw of energy, power and phase currents (never raises: a write does not depend on it).""" try: - cur = tuple(a for a in (_amps(st.get(k)) for k in ("l1", "l2", "l3")) - if a is not None) self.polls.append((self._clock(), ChargerReading( available=True, power_w=_watts(st.get("power")), - energy_kwh=_kwh(st.get("energy")), current_a=cur))) + energy_kwh=_kwh(st.get("energy")), + phase_a=tuple(_amps(st.get(k)) for k in ("l1", "l2", "l3"))))) except Exception: # noqa: BLE001 pass @@ -656,8 +657,13 @@ CHARGING, WAITING, NONE_, FULL, UNREACH, SETUP, FAULT = ( def _life_vals(r) -> tuple: """EV-13: what shows a charger is alive: energy, power, three phase currents. None is "not read".""" - cur = tuple(r.current_a or ())[:3] - return (r.energy_kwh, r.power_w) + cur + (None,) * (3 - len(cur)) + cur = tuple(r.phase_a or ()) + if len(cur) != 3: + # Only `current_a`, which leaves out a phase that is not read: which + # phase is which is then known only when all three are there. + cur = tuple(r.current_a or ()) + cur = cur if len(cur) == 3 else (None,) * 3 + return (r.energy_kwh, r.power_w) + cur def _alive(vals: tuple, pre: list) -> bool: diff --git a/goodwe_controller/test_ev13.py b/goodwe_controller/test_ev13.py index fe22e79..d89aa70 100644 --- a/goodwe_controller/test_ev13.py +++ b/goodwe_controller/test_ev13.py @@ -78,11 +78,13 @@ TOOK_S, STUCK_S = CH.TOOK_S, CH.STUCK_S print("1. S: WHAT COUNTS AS LIFE") # =========================================================================== # def rd(e=1.000, p=11040.0, cur=(16.0, 15.9, 16.0), a=16.0, taken=None, - state="C"): + state="C", ph=None): + """`cur` is `current_a` (a missing phase is left out of it); `ph` is the + per-phase `phase_a` (None for a missing phase) the driver also sets.""" return CH.ChargerReading( available=True, state=state, charging=state == "C", power_w=p, energy_kwh=e, current_a=cur, allowed_a=a, setpoint_a=a, - phases_allowed=3, taken_at=taken) + phases_allowed=3, taken_at=taken, phase_a=ph or ()) def steady(changes=None, start=1, end=130, **base): @@ -174,6 +176,21 @@ life("T9 the step at +9, inside the window", {9: dict(e=1.010)}) life("T9 the step exactly at +10 (the edge counts)", {10: dict(e=1.010)}) life("T12(a) power None, state C, energy rising", {4: dict(e=1.010)}, pre=dict(p=None)) +# P1/P2 (review): a phase that drops out or comes back is no change: the +# others must not shift against another phase's old value +armed("P1 L1 present before, absent after, all else frozen", + steady(cur=(16.0, 16.1))) +armed("P2 L1 absent before, present after (current_a only), all else frozen", + steady(), pre=dict(cur=(15.9, 16.0))) +armed("P1 per phase: L1 present before, absent after (phase_a)", + steady(cur=(16.0, 16.1), ph=(None, 16.0, 16.1)), + pre=dict(ph=(15.9, 16.0, 16.1))) +armed("P2 per phase: L1 absent before, present after (phase_a)", + steady(ph=(15.9, 16.0, 16.1)), pre=dict(cur=(16.0, 16.1), + ph=(None, 16.0, 16.1))) +life("P5 per phase: L1 absent, L2 really changes (phase_a)", + {4: dict(cur=(16.2, 16.1), ph=(None, 16.2, 16.1))}, + pre=dict(cur=(16.0, 16.1), ph=(None, 16.0, 16.1))) armed("T6 present but unchanged: every sample repeats the pre-write values", steady()) armed("T9 the step at +11 is outside the window; armed_at is the send, not " @@ -1007,6 +1024,29 @@ for mode in ("live", "ring"): "window runs on and arms at the send", tr.armed_at == TS and first is not None and TS + 59 <= first <= TS + 61) +# P4 (review): a refusal with no life, and a read-back that arrives late but +# inside TOOK_S. The base arms at the send and the moved read-back disarms it +# ("it moved: alive"); the window must do the same, not arm on the new value. +zero = dict(p=0.0, cur=(0.0, 0.0, 0.0)) +tr, first, ever = play(steady({5: dict(a=10.0)}, **zero), "live", pre=zero) +check(f"P4 [live]: no life, the read-back moves at +5, after the refusal was " + f"noted: armed dated the send and disarmed by the move, never stuck, " + f"as on the base ({tr.armed_at}, {first})", first is None + and tr.armed_at is None and not tr.stuck_now and pend(tr) is None) +tr, first, ever = play(steady({5: dict(a=10.0)}, **zero), "ring", pre=zero) +check(f"P4 [ring]: the read-back moved inside the window BEFORE the refusal " + f"was noted (the write waited): it still arms, dated the send, and is " + f"stuck at +60, as on the base (armed {tr.armed_at}, first {first})", + tr.armed_at == TS and first == TS + 60) +# ... and the same read-back arriving AFTER the window leaves it stuck until +# it moves: 12 s in, the base has been armed since the send, so it disarms then +tr, first, ever = play(steady({12: dict(a=10.0)}, **zero), "live", pre=zero) +check("P4 the read-back moves at +12 (after the window): disarmed then, " + "never stuck", first is None and tr.armed_at is None) +tr, first, ever = play(steady({70: dict(a=10.0)}, **zero), "live", pre=zero) +check(f"P4 the read-back moves at +70: stuck at +60 first, as on the base " + f"(first {first}-{TS})", first == TS + 60 and tr.armed_at is None) + # =========================================================================== # print("\n8. N-IDS") # =========================================================================== # From 0774d1efd5c800a27518edce9f4dcbb9e3132051 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 22 Nov 2026 06:54:30 +0100 Subject: [PATCH 5/7] EV-13 router round 3: N2 names P1/P2; P4 live window dated the send; kills R1 Co-Authored-By: Claude --- goodwe_controller/test_ev13.py | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/goodwe_controller/test_ev13.py b/goodwe_controller/test_ev13.py index d89aa70..b0c57d6 100644 --- a/goodwe_controller/test_ev13.py +++ b/goodwe_controller/test_ev13.py @@ -1033,6 +1033,28 @@ check(f"P4 [live]: no life, the read-back moves at +5, after the refusal was " f"noted: armed dated the send and disarmed by the move, never stuck, " f"as on the base ({tr.armed_at}, {first})", first is None and tr.armed_at is None and not tr.stuck_now and pend(tr) is None) +# The live case, looked at second by second: between the send and the move the +# refusal is a window dated the send (not yet armed, as nothing is decided); +# it arms dated TS when it runs out, with the sig AT THE SEND, so the moved +# read-back disarms it at once (kills the reviewer's R1: arm with the current sig). +_dates = [] +_tr = CH.CarTracker() +for _i in range(-20, 1): + _tr.observe(rd(**zero), TS + _i, UTC, DAY) +_orig = _tr._pend_arm +_tr._pend_arm = lambda: (_dates.append((_tr._pend or {}).get("t")), _orig()) +_tr.note_write(TS, 16.0, 10.0, False) +_mid = [] +for _s, _r in steady({5: dict(a=10.0)}, end=14, **zero): + _tr.observe(_r, _s, UTC, DAY) + _mid.append((_s - TS, (pend(_tr) or {}).get("t"), _tr.armed_at)) +check("P4 [live]: from the send to the move the refusal is an open window " + "dated TS (armed_at still None)", all(w == TS and a is None + for s, w, a in _mid if s < 11)) +check(f"P4 [live]: the window arms dated TS when it runs out, and the moved " + f"read-back disarms it in the same sample ({_dates}, {_mid[-1]})", + _dates == [TS] and _tr.armed_at is None and not _tr.stuck_now + and pend(_tr) is None) tr, first, ever = play(steady({5: dict(a=10.0)}, **zero), "ring", pre=zero) check(f"P4 [ring]: the read-back moved inside the window BEFORE the refusal " f"was noted (the write waited): it still arms, dated the send, and is " @@ -1056,6 +1078,12 @@ check(f"N1: no stuck after refusals that all showed life (T1-T5, T9 edges, " check(f"N2: every refusal with no life is stuck within 61 s of its send " f"(T6-T11, T12b, T16, T20: {len(N2)} runs)", len(N2) >= 20 and all(d is not None and d <= 61 for _n, d in N2)) +for _p in ("P1 L1 present before", "P2 L1 absent before", + "P1 per phase", "P2 per phase"): + _runs = [d for n, d in N2 if n.startswith(_p)] + check(f"N2 includes {_p!r} in all three modes: {len(_runs)} runs, each " + f"stuck within 61 s of its send", len(_runs) == 3 + and all(d is not None and d <= 61 for d in _runs)) check("N5: no house-caused alarm later than the no-write twin or Off (T22 " "equals its twin; T23 within a second of both)", alarm_list(r_ref) == alarm_list(r_twin) From 57a9f56a64006450a788755480f1eec87b8b21b4 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 22 Nov 2026 07:58:56 +0100 Subject: [PATCH 6/7] EV-13: guard the P4 live check's last sample (test_named_absence) Co-Authored-By: Claude --- goodwe_controller/test_ev13.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/goodwe_controller/test_ev13.py b/goodwe_controller/test_ev13.py index b0c57d6..98d2b29 100644 --- a/goodwe_controller/test_ev13.py +++ b/goodwe_controller/test_ev13.py @@ -1051,9 +1051,10 @@ for _s, _r in steady({5: dict(a=10.0)}, end=14, **zero): check("P4 [live]: from the send to the move the refusal is an open window " "dated TS (armed_at still None)", all(w == TS and a is None for s, w, a in _mid if s < 11)) +_last = _mid[-1] if _mid else None check(f"P4 [live]: the window arms dated TS when it runs out, and the moved " - f"read-back disarms it in the same sample ({_dates}, {_mid[-1]})", - _dates == [TS] and _tr.armed_at is None and not _tr.stuck_now + f"read-back disarms it in the same sample ({_dates}, {_last})", + _last is not None and _dates == [TS] and _tr.armed_at is None and not _tr.stuck_now and pend(_tr) is None) tr, first, ever = play(steady({5: dict(a=10.0)}, **zero), "ring", pre=zero) check(f"P4 [ring]: the read-back moved inside the window BEFORE the refusal " From 6cd775788d44a2c5dc42d06b7b6e3c3ea63d6658 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 22 Nov 2026 10:45:14 +0100 Subject: [PATCH 7/7] EV-13 review round 2: tie the driver's polls to the cycle reading per phase (D1, D2) Co-Authored-By: Claude --- goodwe_controller/test_ev13.py | 82 ++++++++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+) diff --git a/goodwe_controller/test_ev13.py b/goodwe_controller/test_ev13.py index 98d2b29..95b69c0 100644 --- a/goodwe_controller/test_ev13.py +++ b/goodwe_controller/test_ev13.py @@ -1070,6 +1070,88 @@ tr, first, ever = play(steady({70: dict(a=10.0)}, **zero), "live", pre=zero) check(f"P4 the read-back moves at +70: stuck at +60 first, as on the base " f"(first {first}-{TS})", first == TS + 60 and tr.armed_at is None) +# =========================================================================== # +print("\n7b. THE DRIVER'S POLLS ARE THE CYCLE'S READING, PER PHASE (review round 2)") +# =========================================================================== # +# On a frozen Alfen the polls `_took` keeps are all the tracker sees of the +# refusal's window. If `_poll` lists the phases in another order than +# `reading_from_states`, a frozen 1-phase car reads as a change and is never +# flagged. T11/T16/T20 run at 0 W (every phase 0 A) and the S shapes build +# their polls by hand, so these two checks tie the real driver to the cycle. +_clk = {"t": 0.0} + + +async def _frozen_1ph_3ph(phases): + """Real AlfenHaDriver on chargersim: a car on `phases` phases at 16 A, the + charger frozen (every state), the write ignored: `_took` times out and its + polls reach `note_write`.""" + sim = SimCharger(phases_allowed=phases, setpoint_a=16.0) + sim.car_phases = phases + sim.state, sim.power_w = "C", 16.0 * 230.0 * phases + sim.refuse = "ignore" + sim.freeze() + drv = CH.AlfenHaDriver("number.wallbox_" + CH.SETPOINT_SUFFIX, 16.0) + drv.bind(FakeHa(sim)) + drv._clock = lambda: _clk["t"] + + async def _sleep(sec): + _clk["t"] += sec + drv._sleep = _sleep + tr = CH.CarTracker() + _clk["t"] = TS - 10 + while _clk["t"] <= TS: + tr.observe(await drv.read(), _clk["t"], UTC, DAY) + _clk["t"] += 1.0 + _clk["t"] = TS + 0.3 + ok = await drv.write_current(10.0) + tr.note_write(TS, 16.0, 10.0, ok, drv.polls) + first = None + while _clk["t"] <= TS + 130: + _clk["t"] += 1.0 + tr.observe(await drv.read(), _clk["t"], UTC, DAY) + if first is None and tr.stuck(_clk["t"]): + first = _clk["t"] - TS + return ok, tr, first, len(drv.polls) + + +for _n in (1, 3): + _ok, _tr, _first, _np = asyncio.run(_frozen_1ph_3ph(_n)) + N2.append((f"D1 driver, frozen {_n}-phase car [driver]", + None if _first is None else _first)) + check(f"D1 driver on chargersim, frozen charger, {_n}-phase car at 16 A, " + f"write ignored (not ok, {_np} polls): armed at the send, stuck at " + f"+60 (+-1) (armed {_tr.armed_at}, first {_first})", + not _ok and _np >= 2 and _tr.armed_at == TS and _first is not None + and 59 <= _first <= 61.5) + + +async def _poll_vs_cycle(drop): + """`_life_vals` of `_poll`'s reading equals that of the cycle's reading, + on the same states, with distinct per-phase currents; `drop` removes a + phase (an entity that does not answer).""" + sim = SimCharger(phases_allowed=3, setpoint_a=16.0) + drv = CH.AlfenHaDriver("number.wallbox_" + CH.SETPOINT_SUFFIX, 16.0) + drv.bind(FakeHa(sim)) + st = await drv._states() + for k, v in (("l1", "15.5"), ("l2", "16.5"), ("l3", "17.5")): + st[k] = dict(st[k], state=v) if isinstance(st[k], dict) else st[k] + if drop: + st[drop] = None + cyc = CH.reading_from_states(st) + drv.polls = [] + drv._poll(st) + return cyc, drv.polls[0][1] + + +for _drop in (None, "l1", "l2", "l3"): + _cyc, _pl = asyncio.run(_poll_vs_cycle(_drop)) + check(f"D2 `_life_vals` of _poll's reading equals the cycle reading's, " + f"{'all three phases present' if _drop is None else _drop + ' missing'}" + f" ({CH._life_vals(_pl)[2:]} vs {CH._life_vals(_cyc)[2:]})", + CH._life_vals(_pl) == CH._life_vals(_cyc) and _cyc.available + and (_drop is not None or CH._life_vals(_cyc)[2:5] == + (15.5, 16.5, 17.5))) + # =========================================================================== # print("\n8. N-IDS") # =========================================================================== #