From 8efc385956c460337c84e9549f4b878bc5f2345e Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 16 Nov 2026 15:27:46 +0100 Subject: [PATCH 1/5] EV-10, EV-11, EV-12: car-alone peak alarm, steady car-over row, own write not another writer EV-10: the car is the cause when the period without it (projected minus the car's fresh, corroborated average) is at or under the aim, also with the projection still under it. EV-11: car_over stays on until the test has been false for 180 s. EV-12: the tracker's own-write mute opens before the write and runs 15 s from its return. Co-Authored-By: Claude --- goodwe_controller/CHANGELOG.md | 1 + .../DECISIONS/EV-04-manual-mode.md | 19 + goodwe_controller/app/carmode.py | 9 +- goodwe_controller/app/chargers.py | 11 + goodwe_controller/app/ctl_car.py | 34 +- goodwe_controller/test_ev10.py | 446 ++++++++++++++++++ 6 files changed, 509 insertions(+), 11 deletions(-) create mode 100644 goodwe_controller/test_ev10.py diff --git a/goodwe_controller/CHANGELOG.md b/goodwe_controller/CHANGELOG.md index 45fac1e..93c0a05 100644 --- a/goodwe_controller/CHANGELOG.md +++ b/goodwe_controller/CHANGELOG.md @@ -3,6 +3,7 @@ ### Not in a release yet - The *Car* card can now charge: choose **Manual** and set the current (6 A up to the charger limit) and 1 or 3 phases, on Home or from Home Assistant. The car is never slowed for the peak limit, the add-on says so instead of raising false peak alarms, and the batteries help cover it unless you switch that off. Off still writes nothing ([[EV-04]]). +- Car charger fixes: when the car alone takes the batteries to the peak reserve, the add-on no longer raises "Battery stopped limiting the peak" (the grey "Car over the peak limit" note says it instead); that note and the Car card's reason stay steady instead of flickering; and switching to Off right after the add-on's own change no longer shows "Something else changes the charger". ## 0.23.0 diff --git a/goodwe_controller/DECISIONS/EV-04-manual-mode.md b/goodwe_controller/DECISIONS/EV-04-manual-mode.md index c9585bc..bc27ac7 100644 --- a/goodwe_controller/DECISIONS/EV-04-manual-mode.md +++ b/goodwe_controller/DECISIONS/EV-04-manual-mode.md @@ -84,6 +84,25 @@ about 0.8 kW (40 Wh over the 180 s kept) the figure is believed; it cannot hide an overload that matters. (Round 2 had a 15 Wh slack that cancelled the 50 % rule up to 1.8 kW; the 40 Wh floor fixes that.) +## EV-10, EV-11, EV-12: the rig's three findings (EV-04 test F-1 to F-3) + +- **The car is the cause when the period without it would not need the + batteries** (EV-10). `car_cycle` tests `projected - car_avg_w <= aim` (the car's + average over the same window, fresh and corroborated only) instead of + `projected > aim`, so it also holds when the car alone has taken the batteries + to the reserve and the projection is still under the aim (rig: 5888 W against + 6000 W). The car must draw at least `CAR_PEAK_MIN_W`. A stale, stuck or + uncorroborated figure is `None` and the normal alarms stand. +- **Steady row, no hold on the alarm** (EV-11). Cause: after the car's own quarter + became the month peak, the aim sat on the grid it made (14.04 kW +-40 W), so + the test crossed the aim every few seconds. `car_over` (row, card, notice) now + stays on until the test has been false for `OVER_OFF_HOLD_S` = 180 s (the rig's + longest gap; shorter than a quarter) and a gap does not restart the 10 s + on-count. `car_explains`, which the alarms read, has no hold. +- **Our own write is ours until its mute ends** (EV-12). The mute of the tracker's + own detector opens before the write and runs 15 s from when it returns, because + the read-back reaches the cycle while the write still waits for it. + ## The one write shadow mode allows When the add-on has paused the car (0 A) for a phase change and has not yet diff --git a/goodwe_controller/app/carmode.py b/goodwe_controller/app/carmode.py index 347988f..0284b15 100644 --- a/goodwe_controller/app/carmode.py +++ b/goodwe_controller/app/carmode.py @@ -248,9 +248,14 @@ class ManualWriter: "to it until you change it.", cur, known[0]) async def _write(self, drv, a, was, now, tracker) -> bool: - ok = await drv.write_current(a) - self._stamp(now) + tracker.begin_write() # EV-12: the read-back is ours + try: + ok = await drv.write_current(a) + finally: + self._stamp(now) + tracker.end_write(self.last_done) tracker.note_write(now, was, a) + tracker.end_write(self.last_done) self.log.append(("current", a, now, ok)) if ok: self.last_a = a diff --git a/goodwe_controller/app/chargers.py b/goodwe_controller/app/chargers.py index f02a573..ed62829 100644 --- a/goodwe_controller/app/chargers.py +++ b/goodwe_controller/app/chargers.py @@ -716,6 +716,17 @@ class CarTracker: return None # -- EV-04: the stuck-reading rule ------------------------------------------- + def begin_write(self) -> None: + """EV-12: a write of ours is in flight. Its read-back can reach the + tracker before `note_write` runs (the write waits for it), so the mute + is open until `end_write`.""" + self.mute_until = float("inf") + + def end_write(self, now: float) -> None: + """EV-12: the write returned (or failed). The mute runs + `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 diff --git a/goodwe_controller/app/ctl_car.py b/goodwe_controller/app/ctl_car.py index 52587a6..edd9106 100644 --- a/goodwe_controller/app/ctl_car.py +++ b/goodwe_controller/app/ctl_car.py @@ -20,6 +20,9 @@ CAR_PEAK_KEY = "car_peak_q" # {quarter start iso: the car's average W} CAR_PEAK_MIN_W = 50.0 # a quarter the car hardly touched is not kept CAR_PEAK_KEEP = 3200 # about a month of quarters OVER_HOLD_S = peakguard.ALARM_HOLD_S +# EV-11: the card, the row and Why stay on this long after the car stops being +# the cause (the rig's off gaps were 20 s to 3 min), or until it really ends. +OVER_OFF_HOLD_S = 180.0 class CarMixin: @@ -46,6 +49,7 @@ class CarMixin: self.car_explains = False # the car alone explains the excess self.car_over = False # ... held: the card and row say so self._car_over_since = None + self._car_over_gone = None self._car_over_notified = None # the session a notice was raised for self._car_session = 0 self._car_prev_state = None @@ -255,26 +259,38 @@ class CarMixin: explains = over = False if w is not None and real_proj is not None and target_w is not None \ and real_proj.block_start is not None: - # The car explains the excess when the house alone would land the - # period under the aim: what the car takes over the whole period - # (`car_avg_w`) is at least how far the projection is over it. + # The car explains the excess when the period WITHOUT the car + # (`projected - car_avg_w`, over the same window) would be at or + # under the aim: the car, not the house, needs the batteries. EV-10: + # this holds with the projection still under the aim, when the + # car alone took the batteries to the reserve. + car_avg = self.car_avg_w(real_proj, w) + without = float(real_proj.projected_w) - car_avg ex = float(real_proj.projected_w) - float(target_w) - beyond = ex > 0.0 and self.car_avg_w(real_proj, w) >= ex if self.car_cover: explains = bool( - beyond and guard is not None + car_avg >= CAR_PEAK_MIN_W and without <= float(target_w) + and guard is not None and (guard.saturated or guard.floor_limited)) over = explains else: - over = beyond + over = ex > 0.0 and car_avg >= ex self.car_explains = explains + # EV-11: on once the condition has stood for OVER_HOLD_S, a short gap + # in it not starting that count again; off only after it has been gone + # for OVER_OFF_HOLD_S. `car_explains` (the alarm decision) has no hold. if over: + self._car_over_gone = None if self._car_over_since is None: self._car_over_since = mono - held = mono - self._car_over_since >= OVER_HOLD_S + if mono - self._car_over_since >= OVER_HOLD_S: + self.car_over = True else: - self._car_over_since, held = None, False - self.car_over = held + if self._car_over_gone is None: + self._car_over_gone = mono + if mono - self._car_over_gone >= OVER_OFF_HOLD_S: + self.car_over, self._car_over_since = False, None + self._car_over_gone = None def _car_session_tick(self, mono) -> None: """A charging session is a plug-in: the state goes from no car to a diff --git a/goodwe_controller/test_ev10.py b/goodwe_controller/test_ev10.py new file mode 100644 index 0000000..bf79461 --- /dev/null +++ b/goodwe_controller/test_ev10.py @@ -0,0 +1,446 @@ +"""EV-10, EV-11, EV-12: three rig findings of EV-04's test (F-1, F-2, F-3). +`python3 -B test_ev10.py` + +1. EV-10: the car alone takes the batteries to the peak reserve while the period + is still projected UNDER the aim: no alarm, one grey notice. A stuck car + figure with a house overload, and a house-only drain, still alarm. Mutant: + an uncorroborated car figure in the "period without the car" test. +2. EV-11: the grey row and the Car Why do not flicker while the car keeps the + period over the limit; a real end clears them after OVER_OFF_HOLD_S. The + alarm decision (`car_explains`) has no hold. +3. EV-12: the add-on's own write, and Off within 15 s of it, is never "another + writer"; a real outside change afterwards still shows the row. +""" + +import asyncio +import logging +import os +import sys +from datetime import datetime, timedelta, timezone + +HERE = os.path.dirname(os.path.abspath(__file__)) +sys.path.insert(0, os.path.join(HERE, "tools")) + +from app import ctl_car, homeview, chargers as CH # noqa: E402 +from app.main import Controller # noqa: E402 +from app import freshness # noqa: E402 +from chargersim import FakeHa, SimCharger # noqa: E402 +import ev04_peak as P # noqa: E402 +import safety81_sim as s81 # noqa: E402 +import opt11_identity as rig # 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())) + + +LOG = _Log() +_lg = logging.getLogger("goodwe") +_lg.addHandler(LOG) +_lg.setLevel(logging.DEBUG) +_lg.propagate = False + +# =========================================================================== # +print("1. EV-10: THE CAR ALONE TAKES THE BATTERIES TO THE RESERVE (F-1)") +# =========================================================================== # +CAP = 4500.0 # the aim is 4450 W (50 W margin) +HOUSE = 1100.0 + + +def at_reserve(plant, c): + """The batteries reach the peak reserve late in the period, and the house + eases a little: the period is still projected UNDER the aim.""" + plant.soc = 19.0 + plant.load = lambda at: 780.0 + plant.ch.power_w + + +def alarms(r): + return P.ids(r, *P.ALARMS) + + +UNDER = [] # (second, projected W, aim W) while floor-limited + + +def watch(first, fn): + """Events for seconds 840 to 894: `fn` at `first`, and a note of every + cycle in which the guard is floor-limited.""" + def note(plant, c): + g = c.peak_guard + if g is not None and g.floor_limited: + UNDER.append((plant.t, g.projected_w, g.target_w)) + ev = {t: note for t in range(first - 10, 895)} + ev[first] = lambda plant, c: (fn(plant, c), note(plant, c)) + return ev + + +LOG.rec.clear() +r10 = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0, + cap=CAP, phases=1, events=watch(850, at_reserve)) +ERR10 = [m for lv, m in LOG.rec if lv in ("ERROR", "WARNING")] +check("PRECONDITION: the guard was floor-limited with the projection UNDER " + "the aim (the rig's 5888 W against 6000 W)", + any(p < a for _t, p, a in UNDER)) +check("the car alone: no 'Load too high', no 'Battery stopped limiting the " + "peak'", alarms(r10) == []) +rows10 = {x["id"]: x for x in r10["c"].checks()} +check("...no red row; the grey 'Car over the peak limit' row says it", + rows10["peak_guard"]["ok"] is True + and not [x for x in r10["c"].checks() + if x["ok"] is False and not x["warn"]] + and rows10.get("car_over", {}).get("ok") is True) +check("...one grey notice for the session", len(P.ids(r10, P.OVER)) == 1) +check("...no ERROR (or WARNING) line was logged for it", ERR10 == []) + + +def house_stuck(plant, c): + at_reserve(plant, c) + plant.ch.freeze() # the reading stops moving + plant.ch.unplug() # the car really goes + plant.load = lambda at: 9000.0 + plant.ch.power_w + asyncio.get_event_loop().create_task(c.handle_action("car_current", + value=10)) + + +r10s = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0, + cap=CAP, phases=1, events=watch(850, house_stuck)) +check("a stuck car figure and a house overload at the reserve: the normal " + "alarm still fires", + [n for _t, n in alarms(r10s)] + and all(n in P.ALARMS for _t, n in alarms(r10s))) + + +def house_drain(plant, c): + plant.soc = 19.0 + plant.load = lambda at: 12000.0 + plant.ch.power_w + + +r10h = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0, + cap=CAP, phases=1, user_a=6, setpoint=6, + events=watch(600, house_drain)) +check("a house-only drain to the reserve with the car charging little: the " + "normal alarm still fires", + alarms(r10h) != [] and not r10h["c"].car_explains) + +r10off = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0, + cap=CAP, phases=1, mode="off", events=watch(850, at_reserve)) +check("PRECONDITION: Off, the same case raises the normal alarm (the false " + "alarm Manual must not make)", alarms(r10off) != []) + + +# a direct unit of the rule: the car's average, the period without it +class _Car(ctl_car.CarMixin): + def __init__(self, cover=True, w=3700.0): + self.o = {"ev_batt_cover": cover} + self.w = w + self._now = 0.0 + self.car_init({}, type("S", (), {"data": {}, "set": lambda s, k, v: 0})()) + + def car_now(self): + return self._now + + def car_alarm_w(self): + return self.w + + class car: # noqa: N801 + @staticmethod + def status(*_a): + return "charging" + + +class _Proj: + def __init__(self, proj_w, elapsed=850.0): + self.projected_w, self.elapsed_s, self.held_w = proj_w, elapsed, proj_w + self.block_start = datetime(2026, 11, 16, 20, 0, tzinfo=timezone.utc) + + +class _G: + def __init__(self, floor=True, sat=False): + self.floor_limited, self.saturated = floor, sat + + +def explains(proj_w, car_w, *, floor=True, cover=True, car_so_far_w=None): + c = _Car(cover, car_w) + p = _Proj(proj_w) + c._carq = {"key": p.block_start, + "ws": (car_w if car_so_far_w is None else car_so_far_w) + * p.elapsed_s, "mono": 0.0} + c.car_cycle(p, _G(floor), 4450.0, None) + return c.car_explains + + +check("rule: the period without the car (4468 - 3700 = 768 W) is under the " + "aim: the car explains it, even with the projection under the aim", + explains(4300.0, 3700.0) and explains(4468.0, 3700.0)) +check("rule: without the car it is still over the aim: the car does not " + "explain it", not explains(9000.0, 3700.0)) +check("rule: no car power, no explanation", not explains(4300.0, 0.0)) +check("rule: the guard is not floor-limited or saturated: nothing to explain", + not explains(4300.0, 3700.0, floor=False)) + +# =========================================================================== # +print("\n2. EV-11: THE 'CAR OVER THE PEAK LIMIT' ROW DOES NOT FLICKER (F-2)") +# =========================================================================== # +# The cause (rig p7off 21:18 to 21:45, plant.csv): after 21:15 the car's own +# quarter (14.0 kW) was the month peak, so the aim was that quarter's average +# and the grid of the next ones (14.04 kW, +-40 W of noise) sat ON it. The +# projection crossed the aim every few seconds, `ex > 0` came and went, and +# `car_over` followed it with no hold on the way off. + + +def over_run(c, secs, proj_of, w_of=lambda t: 11000.0, t0=0.0, target=14000.0, + cover=False): + """Run `car_cycle` once a second; returns (car_over, car_explains) per second.""" + out = [] + for k in range(secs): + t = t0 + k + c._now = t + c.w = w_of(t) + p = _Proj(proj_of(t), elapsed=300.0 + (t % 400)) + c._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s, + "mono": t} + c.car_cycle(p, _G(True), target, None) + out.append((c.car_over, c.car_explains)) + return out + + +def noisy(t): + """The projection straddles the aim: +-40 W, a new value every 7 s.""" + return 14000.0 + (40.0 if int(t // 7) % 2 else -40.0) * (1 + (int(t) % 3)) + + +c11 = _Car(cover=False) +o11 = over_run(c11, 1200, noisy) +flips = sum(1 for a, b in zip(o11, o11[1:]) if a[0] != b[0]) +check("while the car keeps the period at the limit the row stays on: one " + "switch on in 20 minutes, none off", flips == 1 and o11[-1][0] is True) +check("it turns on after the existing 10 s hold, not later than the first " + "10 s the condition has stood (a gap does not restart the count)", + next((i for i, x in enumerate(o11) if x[0]), 10**6) <= 25) + +# the condition on its own, for the PRECONDITION: the same input flips +c11o = _Car(cover=False) +raw = [] +for k in range(1200): + c11o._now = float(k) + p = _Proj(noisy(k), elapsed=300.0 + (k % 400)) + c11o._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s, "mono": k} + ex = p.projected_w - 14000.0 + raw.append(ex > 0.0 and c11o.car_avg_w(p, 11000.0) >= ex) +raw_flips = sum(1 for a, b in zip(raw, raw[1:]) if a != b) +check("PRECONDITION: the condition itself flips many times in those 20 " + "minutes", raw_flips > 20) + +# a real end: the car stops (no trusted power) after 600 s +c11e = _Car(cover=False) +o11e = over_run(c11e, 1000, lambda t: 14500.0, + w_of=lambda t: 11000.0 if t < 600 else None) +off_at = next((i for i, x in enumerate(o11e) if i > 600 and not x[0]), -1) +check("a real end: the row stays for OVER_OFF_HOLD_S (180 s) and then goes", + off_at == 600 + int(ctl_car.OVER_OFF_HOLD_S) + and not any(x[0] for x in o11e[off_at:])) +o11r = over_run(c11e, 100, lambda t: 14500.0, t0=1000.0) +check("it comes back after the usual 10 s if the condition returns after " + "it went", o11r[9][0] is False and o11r[10][0] is True) + +# the alarm decision has no hold: a real house overload is never delayed +c11a = _Car(cover=True) +o11a = over_run(c11a, 60, lambda t: 4300.0, target=4450.0) +check("decision 1 on: the car explains it at once (no hold)", + o11a[0][1] is True) +c11a.w = None # the figure is not trusted +c11a._now = 61.0 +c11a.car_cycle(_Proj(4300.0), _G(True), 4450.0, None) +check("...and the moment the car figure is not trusted it explains nothing, " + "so the normal alarms stand at once (the grey row may stay)", + c11a.car_explains is False) + +# the whole thing on the real controller: the Why does not flicker either +def p7_like(plant, c): + plant.load = lambda at: 3000.0 + plant.ch.power_w + + +r11 = P.drive(s81.constant(HOUSE), dur=700, rating=2000.0, soc=60.0, cap=CAP, + phases=3, opts={"ev_batt_cover": False}) +ov = [s[2] for s in r11["snaps"]] +check("real controller, cover off, an 11 kW car: the flag is steady once on", + sum(1 for a, b in zip(ov, ov[1:]) if a != b) <= 1 and ov[-1] is True) + +# =========================================================================== # +print("\n3. EV-12: OUR OWN WRITE IS NOT ANOTHER WRITER (F-3)") +# =========================================================================== # +CLOCK = [1000.0] +freshness.monotonic = lambda: CLOCK[0] +SET = "number.wallbox_power_connector_max_current_socket_1" +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"], "ev_charger": "alfen_ha", "ev_max_a": 16, + "ev_phases": "auto", "ev_current_entity": SET} + + +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 publish(self, v): + pass + + def close(self): + pass + + +class Site(FakeHa): + def __init__(self, charger): + super().__init__(charger, None) + + 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", 800.0, "W"), + ("sensor.soc", 50.0, "%"), + ("sensor.batt", 0.0, "W"), + ("sensor.pv", 2000.0, "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): + return await super().set_number(entity_id, float(value)) + + +class World: + """A real Controller on the charger model. While a write waits for its + read-back, the controller's own reading goes on (as in production, where + the cycle runs while the writer task waits): that is how the read-back of + our own write reaches the tracker BEFORE the write returns.""" + + def __init__(self, setpoint=10): + self.sim = SimCharger(setpoint_a=setpoint) + self.sim.plug_in() + self.sim.lag_s = 2.0 # the rig's read-back lag + self.sim.phases_allowed = 1 + self.t = 1000.0 + CLOCK[0] = self.t + self.c = Controller(dict(BASE), Site(self.sim), _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 + await self.c.read_inputs(now_mono=self.t) # the cycle reads on + + async def step(self, n=1): + for _ in range(n): + self.sim.tick(1.0) + self.t += 1.0 + CLOCK[0] = self.t + await self.c.read_inputs(now_mono=self.t) + await self.c.cycle() + await self.c.car_settle() + + def rows(self): + return {r["id"]: r for r in self.c.checks()} + + +async def own_then_off(wait): + w = World() + await w.step(3) + await w.c.handle_action("car_mode", value="manual") + await w.c.handle_action("car_current", value=12) + await w.step(wait) + await w.c.handle_action("car_mode", value="off") + await w.step(40) + return w + + +w12 = asyncio.run(own_then_off(2)) +check("PRECONDITION: the add-on wrote 12 A and the charger took it", + w12.sim.readback_a == 12 and len(w12.sim.writes("current")) == 1) +check("our own write, then Off 2 s later: no 'Something else changes the " + "charger'", "charger_writer" not in w12.rows() + and w12.c.car.writer_at_utc is None) +w12b = asyncio.run(own_then_off(14)) +check("...and 14 s later (inside the 15 s)", "charger_writer" not in + w12b.rows() and w12b.c.car.writer_at_utc is None) + + +async def own_then_outside(): + w = await own_then_off(2) + w.sim.set_current(7) # somebody else, afterwards + await w.step(3) + early = "charger_writer" in w.rows() + await w.step(30) + return early, "charger_writer" in w.rows() + + +early12, late12 = asyncio.run(own_then_outside()) +check("an outside change after that still shows the row (within 30 s)", + late12 is True) + + +async def manual_own(): + w = World() + await w.step(3) + await w.c.handle_action("car_mode", value="manual") + await w.c.handle_action("car_current", value=12) + await w.step(60) + await w.c.handle_action("car_current", value=8) + await w.step(20) + return w + + +wm = asyncio.run(manual_own()) +check("Manual: two writes of ours, never 'another writer' in the tracker", + wm.c.car.writer_at_utc is None and "charger_other" not in wm.rows()) + +print() +print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed") +sys.exit(1 if fails else 0) -- 2.54.0 From 50d5ae90d2ebdab4373eaec9349c6f9fe63cafc9 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 16 Nov 2026 15:41:57 +0100 Subject: [PATCH 2/5] EV-11: the end of a charging session clears the car-over state at once Co-Authored-By: Claude --- goodwe_controller/app/ctl_car.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/goodwe_controller/app/ctl_car.py b/goodwe_controller/app/ctl_car.py index edd9106..72504b5 100644 --- a/goodwe_controller/app/ctl_car.py +++ b/goodwe_controller/app/ctl_car.py @@ -299,6 +299,9 @@ class CarMixin: if s in (chargers.NONE_,) and self._car_prev_state not in ( None, chargers.NONE_): self._car_over_notified = None + # The session is over: that is a real end, with no hold. + self.car_over = False + self._car_over_since = self._car_over_gone = None if s not in (chargers.NONE_, None) and self._car_prev_state in ( chargers.NONE_, None): self._car_session += 1 -- 2.54.0 From a60342e4e84a67fa83dd570767c45c4690e0644a Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 16 Nov 2026 16:12:42 +0100 Subject: [PATCH 3/5] EV-10: test_ev10 points at MUTATION.md and guards its indexed reads Co-Authored-By: Claude --- goodwe_controller/test_ev10.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/goodwe_controller/test_ev10.py b/goodwe_controller/test_ev10.py index bf79461..55af1cb 100644 --- a/goodwe_controller/test_ev10.py +++ b/goodwe_controller/test_ev10.py @@ -10,6 +10,7 @@ alarm decision (`car_explains`) has no hold. 3. EV-12: the add-on's own write, and Off within 15 s of it, is never "another writer"; a real outside change afterwards still shows the row. +Mutating a module this file grades? Read MUTATION.md first (purge __pycache__). """ import asyncio @@ -225,7 +226,7 @@ c11 = _Car(cover=False) o11 = over_run(c11, 1200, noisy) flips = sum(1 for a, b in zip(o11, o11[1:]) if a[0] != b[0]) check("while the car keeps the period at the limit the row stays on: one " - "switch on in 20 minutes, none off", flips == 1 and o11[-1][0] is True) + "switch on in 20 minutes, none off", flips == 1 and len(o11) == 1200 and o11[-1][0] is True) check("it turns on after the existing 10 s hold, not later than the first " "10 s the condition has stood (a gap does not restart the count)", next((i for i, x in enumerate(o11) if x[0]), 10**6) <= 25) @@ -253,13 +254,13 @@ check("a real end: the row stays for OVER_OFF_HOLD_S (180 s) and then goes", and not any(x[0] for x in o11e[off_at:])) o11r = over_run(c11e, 100, lambda t: 14500.0, t0=1000.0) check("it comes back after the usual 10 s if the condition returns after " - "it went", o11r[9][0] is False and o11r[10][0] is True) + "it went", len(o11r) == 100 and o11r[9][0] is False and o11r[10][0] is True) # the alarm decision has no hold: a real house overload is never delayed c11a = _Car(cover=True) o11a = over_run(c11a, 60, lambda t: 4300.0, target=4450.0) check("decision 1 on: the car explains it at once (no hold)", - o11a[0][1] is True) + len(o11a) == 60 and o11a[0][1] is True) c11a.w = None # the figure is not trusted c11a._now = 61.0 c11a.car_cycle(_Proj(4300.0), _G(True), 4450.0, None) -- 2.54.0 From 646f61e730c27907a9d434fa11de460bb0a0b664 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 16 Nov 2026 18:07:25 +0100 Subject: [PATCH 4/5] EV-10 round 2: judge the car against the alarm's own landing; test failed writes; honest hold wording Co-Authored-By: Claude --- .../DECISIONS/EV-04-manual-mode.md | 22 +++-- goodwe_controller/app/ctl_car.py | 65 +++++++++--- goodwe_controller/test_ev10.py | 99 ++++++++++++++++--- 3 files changed, 150 insertions(+), 36 deletions(-) diff --git a/goodwe_controller/DECISIONS/EV-04-manual-mode.md b/goodwe_controller/DECISIONS/EV-04-manual-mode.md index bc27ac7..f6183ca 100644 --- a/goodwe_controller/DECISIONS/EV-04-manual-mode.md +++ b/goodwe_controller/DECISIONS/EV-04-manual-mode.md @@ -86,18 +86,24 @@ up to 1.8 kW; the 40 Wh floor fixes that.) ## EV-10, EV-11, EV-12: the rig's three findings (EV-04 test F-1 to F-3) -- **The car is the cause when the period without it would not need the - batteries** (EV-10). `car_cycle` tests `projected - car_avg_w <= aim` (the car's - average over the same window, fresh and corroborated only) instead of - `projected > aim`, so it also holds when the car alone has taken the batteries - to the reserve and the projection is still under the aim (rig: 5888 W against - 6000 W). The car must draw at least `CAR_PEAK_MIN_W`. A stale, stuck or +- **The car is the cause when the alarm's own test says so** (EV-10). + `car_cycle` (`_car_explains_alarm`) grades the alarm's test on the period as it + is and on the period without the car's fresh, corroborated average + (`car_exclude`): the car explains the alarm only if the test is true with it + and false without it. The test is the alarm's own landing (`_car_grade`: the + batteries give only what they still can, `load_too_high` for a saturated guard + and for a floor with other batteries, `misses_aim` for a floor with none), not + the plain projection, which still counts the batteries' help. So the car alone + taking the batteries to the reserve is silent (rig: 5888 W against 6000 W), + while a house-caused drain with a small car still alarms. No minimum car power + is needed: a car that changes nothing cannot flip the test. A stale, stuck or uncorroborated figure is `None` and the normal alarms stand. - **Steady row, no hold on the alarm** (EV-11). Cause: after the car's own quarter became the month peak, the aim sat on the grid it made (14.04 kW +-40 W), so the test crossed the aim every few seconds. `car_over` (row, card, notice) now - stays on until the test has been false for `OVER_OFF_HOLD_S` = 180 s (the rig's - longest gap; shorter than a quarter) and a gap does not restart the 10 s + stays on until the test has been false for `OVER_OFF_HOLD_S` = 180 s (longer than + the gaps seen on the rig, 150 to 250 s at 50 s sampling, and shorter than a + quarter) and a gap does not restart the 10 s on-count. `car_explains`, which the alarms read, has no hold. - **Our own write is ours until its mute ends** (EV-12). The mute of the tracker's own detector opens before the write and runs 15 s from when it returns, because diff --git a/goodwe_controller/app/ctl_car.py b/goodwe_controller/app/ctl_car.py index 72504b5..e269068 100644 --- a/goodwe_controller/app/ctl_car.py +++ b/goodwe_controller/app/ctl_car.py @@ -21,7 +21,8 @@ CAR_PEAK_MIN_W = 50.0 # a quarter the car hardly touched is not kept CAR_PEAK_KEEP = 3200 # about a month of quarters OVER_HOLD_S = peakguard.ALARM_HOLD_S # EV-11: the card, the row and Why stay on this long after the car stops being -# the cause (the rig's off gaps were 20 s to 3 min), or until it really ends. +# the cause: longer than the gaps seen on the rig (150 to 250 s at 50 s +# sampling) and shorter than a quarter, or until the session really ends. OVER_OFF_HOLD_S = 180.0 @@ -50,6 +51,8 @@ class CarMixin: self.car_over = False # ... held: the card and row say so self._car_over_since = None self._car_over_gone = None + self._car_batt_prev = None + self._car_needed = False # EV-10: SAFETY-126's latch without the car self._car_over_notified = None # the session a notice was raised for self._car_session = 0 self._car_prev_state = None @@ -257,24 +260,16 @@ class CarMixin: self._car_quarter(real_proj, w, mono) self._car_session_tick(mono) explains = over = False - if w is not None and real_proj is not None and target_w is not None \ + if real_proj is not None and target_w is not None \ and real_proj.block_start is not None: - # The car explains the excess when the period WITHOUT the car - # (`projected - car_avg_w`, over the same window) would be at or - # under the aim: the car, not the house, needs the batteries. EV-10: - # this holds with the projection still under the aim, when the - # car alone took the batteries to the reserve. - car_avg = self.car_avg_w(real_proj, w) - without = float(real_proj.projected_w) - car_avg - ex = float(real_proj.projected_w) - float(target_w) if self.car_cover: - explains = bool( - car_avg >= CAR_PEAK_MIN_W and without <= float(target_w) - and guard is not None - and (guard.saturated or guard.floor_limited)) + # EV-10: the car explains the ALARM (`_car_explains_alarm`). + explains = self._car_explains_alarm(real_proj, guard, + target_w, w) over = explains - else: - over = ex > 0.0 and car_avg >= ex + elif w is not None: + ex = float(real_proj.projected_w) - float(target_w) + over = ex > 0.0 and self.car_avg_w(real_proj, w) >= ex self.car_explains = explains # EV-11: on once the condition has stood for OVER_HOLD_S, a short gap # in it not starting that count again; off only after it has been gone @@ -292,6 +287,44 @@ class CarMixin: self.car_over, self._car_over_since = False, None self._car_over_gone = None + def _car_explains_alarm(self, real_proj, guard, target_w, w) -> bool: + """EV-10: is the alarm's own test true with the car and false without + its fresh, corroborated share (`car_exclude`)? The tests are the + alarms': a saturated guard and a floor with other batteries left are + graded by `load_too_high` on where the period lands (SAFETY-81 / 87); a + floor that leaves nothing is graded by `within_aim`, which SAFETY-126 + latches for the quarter once the batteries at 0 W would miss the aim. + `_car_needed` is that latch on the period without the car; an + untrusted car figure (`w` None) sets it, so nothing is explained.""" + batt, prev = self.site_batt_w, self._car_batt_prev + self._car_batt_prev = batt + wants = bool(guard is not None and guard.engaged + and guard.blind is None + and (guard.wanted_w or 0.0) > 0.0) + if not wants: + self._car_needed = False + if batt is not None and prev is not None: + batt = min(float(batt), float(prev)) + excl = self.car_exclude(real_proj, w) + if wants: + self._car_needed = self._car_needed or w is None or batt is None \ + or peakguard.misses_aim(excl, batt_w=batt, target_w=target_w) + if w is None or batt is None or not wants \ + or not (guard.saturated or guard.floor_limited): + return False + if guard.saturated: + rating = self.site_rating_w + elif (guard.floor_w or 0.0) > 0.0 and guard.able_w is not None: + rating = guard.able_w + else: + return bool(not guard.within_aim and not self._car_needed) + + def high(p): + return peakguard.load_too_high( + p, batt_w=batt, ceiling_w=guard.ceiling_w, + achievable_w=rating) + return bool(high(real_proj) and not high(excl)) + def _car_session_tick(self, mono) -> None: """A charging session is a plug-in: the state goes from no car to a car. The notice is raised once per session.""" diff --git a/goodwe_controller/test_ev10.py b/goodwe_controller/test_ev10.py index 55af1cb..fbb0288 100644 --- a/goodwe_controller/test_ev10.py +++ b/goodwe_controller/test_ev10.py @@ -14,6 +14,7 @@ Mutating a module this file grades? Read MUTATION.md first (purge __pycache__). """ import asyncio +import dataclasses import logging import os import sys @@ -135,6 +136,38 @@ check("a house-only drain to the reserve with the car charging little: the " "normal alarm still fires", alarms(r10h) != [] and not r10h["c"].car_explains) + + +def plug_late(plant, c): + plant.ch.plug_in() + + +def house_reserve(plant, c): + plant.soc = 19.0 + plant.load = lambda at: 3075.0 + plant.ch.power_w + + +def swapped_events(): + ev = watch(850, house_reserve) + ev[800] = plug_late + return ev + + +def swapped(mode): + return P.drive(s81.constant(6000.0), dur=895, rating=12000.0, soc=60.0, + cap=CAP, phases=1, user_a=6, setpoint=6, mode=mode, + plug=False, events=swapped_events()) + + +r10x = swapped("manual") +r10xo = swapped("off") +check("PRECONDITION (review): a 6 kW HOUSE drains the batteries, the car " + "plugs in late (a small share); the projection is under the aim at the " + "reserve, and Off raises the alarm", alarms(r10xo) != [] + and any(p < a for _t, p, a in UNDER)) +check("the house drains the batteries and a small car is plugged in: the " + "normal alarm still fires in Manual", alarms(r10x) != []) + r10off = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0, cap=CAP, phases=1, mode="off", events=watch(850, at_reserve)) check("PRECONDITION: Off, the same case raises the normal alarm (the false " @@ -147,6 +180,7 @@ class _Car(ctl_car.CarMixin): self.o = {"ev_batt_cover": cover} self.w = w self._now = 0.0 + self.site_batt_w, self.site_rating_w = 300.0, 5000.0 self.car_init({}, type("S", (), {"data": {}, "set": lambda s, k, v: 0})()) def car_now(self): @@ -161,33 +195,44 @@ class _Car(ctl_car.CarMixin): return "charging" +@dataclasses.dataclass class _Proj: - def __init__(self, proj_w, elapsed=850.0): - self.projected_w, self.elapsed_s, self.held_w = proj_w, elapsed, proj_w - self.block_start = datetime(2026, 11, 16, 20, 0, tzinfo=timezone.utc) + projected_w: float + elapsed_s: float = 850.0 + held_w: float = 0.0 + block_start: object = datetime(2026, 11, 16, 20, 0, tzinfo=timezone.utc) + + def __post_init__(self): + self.held_w = self.projected_w class _G: - def __init__(self, floor=True, sat=False): + def __init__(self, floor=True, sat=False, within_aim=False): self.floor_limited, self.saturated = floor, sat + self.floor_w, self.able_w, self.ceiling_w = 0.0, None, 4500.0 + self.engaged, self.blind, self.wanted_w = True, None, 300.0 + self.within_aim = within_aim -def explains(proj_w, car_w, *, floor=True, cover=True, car_so_far_w=None): +def explains(proj_w, car_w, *, floor=True, cover=True, car_so_far_w=None, + within_aim=False): c = _Car(cover, car_w) p = _Proj(proj_w) c._carq = {"key": p.block_start, "ws": (car_w if car_so_far_w is None else car_so_far_w) * p.elapsed_s, "mono": 0.0} - c.car_cycle(p, _G(floor), 4450.0, None) + c.car_cycle(p, _G(floor, within_aim=within_aim), 4450.0, None) return c.car_explains -check("rule: the period without the car (4468 - 3700 = 768 W) is under the " - "aim: the car explains it, even with the projection under the aim", - explains(4300.0, 3700.0) and explains(4468.0, 3700.0)) +check("rule: the alarm's test is true with the car (4468 W, the batteries " + "at 0 W land 4485 W) and false without it (768 W): the car explains it, " + "with the projection under the aim", explains(4468.0, 3700.0)) +check("rule: where the alarm would not fire anyway nothing is explained", + not explains(4300.0, 3700.0, within_aim=True)) check("rule: without the car it is still over the aim: the car does not " "explain it", not explains(9000.0, 3700.0)) -check("rule: no car power, no explanation", not explains(4300.0, 0.0)) +check("rule: no car power, no explanation", not explains(9000.0, 0.0)) check("rule: the guard is not floor-limited or saturated: nothing to explain", not explains(4300.0, 3700.0, floor=False)) @@ -209,7 +254,7 @@ def over_run(c, secs, proj_of, w_of=lambda t: 11000.0, t0=0.0, target=14000.0, t = t0 + k c._now = t c.w = w_of(t) - p = _Proj(proj_of(t), elapsed=300.0 + (t % 400)) + p = _Proj(proj_of(t), elapsed_s=300.0 + (t % 400)) c._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s, "mono": t} c.car_cycle(p, _G(True), target, None) @@ -236,7 +281,7 @@ c11o = _Car(cover=False) raw = [] for k in range(1200): c11o._now = float(k) - p = _Proj(noisy(k), elapsed=300.0 + (k % 400)) + p = _Proj(noisy(k), elapsed_s=300.0 + (k % 400)) c11o._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s, "mono": k} ex = p.projected_w - 14000.0 raw.append(ex > 0.0 and c11o.car_avg_w(p, 11000.0) >= ex) @@ -442,6 +487,36 @@ wm = asyncio.run(manual_own()) check("Manual: two writes of ours, never 'another writer' in the tracker", wm.c.car.writer_at_utc is None and "charger_other" not in wm.rows()) + +async def failed_write_then_outside(how): + """A write that RAISES or returns FAILURE must still close the self-mute: + a later outside change shows the row.""" + w = World() + await w.step(3) + await w.c.handle_action("car_mode", value="manual") + + async def bad(a): + await w.sleep(1.0) + if how == "raise": + raise RuntimeError("the charger link broke") + return False + w.drv.write_current = bad + await w.c.handle_action("car_current", value=12) + await w.step(3) # the write is tried + await w.c.handle_action("car_mode", value="off") + await w.step(20) # past the 15 s mute + w.sim.set_current(7) # somebody else + await w.step(3) + return w + + +for how in ("raise", "fail"): + wf = asyncio.run(failed_write_then_outside(how)) + check(f"a write that {'raises' if how == 'raise' else 'returns failure'}" + ": the mute closes within 15 s, and a later outside change shows " + "the row", wf.c.car.mute_until < wf.t + and "charger_writer" in wf.rows()) + print() print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed") sys.exit(1 if fails else 0) -- 2.54.0 From 269b89d6b0dddc9be232ee4342afb795c7b6fa49 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 16 Nov 2026 19:28:02 +0100 Subject: [PATCH 5/5] EV-10 round 3: grade the floor case on the same landing with and without the car; per-quarter latches independent of the cover option; stricter write-mute test Co-Authored-By: Claude --- .../DECISIONS/EV-04-manual-mode.md | 27 ++++---- goodwe_controller/app/ctl_car.py | 47 ++++++++----- goodwe_controller/test_ev10.py | 68 +++++++++++++++---- 3 files changed, 100 insertions(+), 42 deletions(-) diff --git a/goodwe_controller/DECISIONS/EV-04-manual-mode.md b/goodwe_controller/DECISIONS/EV-04-manual-mode.md index f6183ca..9b099a2 100644 --- a/goodwe_controller/DECISIONS/EV-04-manual-mode.md +++ b/goodwe_controller/DECISIONS/EV-04-manual-mode.md @@ -86,18 +86,21 @@ up to 1.8 kW; the 40 Wh floor fixes that.) ## EV-10, EV-11, EV-12: the rig's three findings (EV-04 test F-1 to F-3) -- **The car is the cause when the alarm's own test says so** (EV-10). - `car_cycle` (`_car_explains_alarm`) grades the alarm's test on the period as it - is and on the period without the car's fresh, corroborated average - (`car_exclude`): the car explains the alarm only if the test is true with it - and false without it. The test is the alarm's own landing (`_car_grade`: the - batteries give only what they still can, `load_too_high` for a saturated guard - and for a floor with other batteries, `misses_aim` for a floor with none), not - the plain projection, which still counts the batteries' help. So the car alone - taking the batteries to the reserve is silent (rig: 5888 W against 6000 W), - while a house-caused drain with a small car still alarms. No minimum car power - is needed: a car that changes nothing cannot flip the test. A stale, stuck or - uncorroborated figure is `None` and the normal alarms stand. +- **The car is the cause when the alarm's own test says so, on the same + landing** (EV-10). `car_cycle` (`_car_explains_alarm`) runs the alarm's test on + the period as it is and on the period without the car's fresh, corroborated + average (`car_exclude`): the car explains the alarm only if it is true with the + car and false without it. A saturated guard, and a floor with other batteries + left, use `load_too_high` on the landing (the batteries give only what they + still can). A floor that leaves nothing uses SAFETY-126's `misses_aim` (the + batteries at 0 W from now on), which is latched for the quarter; the add-on keeps + that latch twice, with and without the car, from the same readings. Both reset + at a new quarter and when the guard stops wanting power, and they run every + cycle, so the cover option does not touch them. This holds with the projection + still under the aim (rig: 5888 W against 6000 W). A car of 0 W makes the two the + same, so it explains nothing; a stale, stuck or uncorroborated figure is `None`, + sets the latch without the car, and the normal alarms stand. There is no minimum + car power: the comparison itself is what separates car from house. - **Steady row, no hold on the alarm** (EV-11). Cause: after the car's own quarter became the month peak, the aim sat on the grid it made (14.04 kW +-40 W), so the test crossed the aim every few seconds. `car_over` (row, card, notice) now diff --git a/goodwe_controller/app/ctl_car.py b/goodwe_controller/app/ctl_car.py index e269068..b9c0cab 100644 --- a/goodwe_controller/app/ctl_car.py +++ b/goodwe_controller/app/ctl_car.py @@ -52,7 +52,8 @@ class CarMixin: self._car_over_since = None self._car_over_gone = None self._car_batt_prev = None - self._car_needed = False # EV-10: SAFETY-126's latch without the car + self._car_need_real = self._car_need_excl = False # EV-10 latches + self._car_latch_block = None self._car_over_notified = None # the session a notice was raised for self._car_session = 0 self._car_prev_state = None @@ -262,11 +263,10 @@ class CarMixin: explains = over = False if real_proj is not None and target_w is not None \ and real_proj.block_start is not None: + # EV-10: every cycle, so the latches do not depend on the option. + graded = self._car_explains_alarm(real_proj, guard, target_w, w) if self.car_cover: - # EV-10: the car explains the ALARM (`_car_explains_alarm`). - explains = self._car_explains_alarm(real_proj, guard, - target_w, w) - over = explains + explains = over = graded elif w is not None: ex = float(real_proj.projected_w) - float(target_w) over = ex > 0.0 and self.car_avg_w(real_proj, w) >= ex @@ -289,26 +289,40 @@ class CarMixin: def _car_explains_alarm(self, real_proj, guard, target_w, w) -> bool: """EV-10: is the alarm's own test true with the car and false without - its fresh, corroborated share (`car_exclude`)? The tests are the - alarms': a saturated guard and a floor with other batteries left are - graded by `load_too_high` on where the period lands (SAFETY-81 / 87); a - floor that leaves nothing is graded by `within_aim`, which SAFETY-126 - latches for the quarter once the batteries at 0 W would miss the aim. - `_car_needed` is that latch on the period without the car; an - untrusted car figure (`w` None) sets it, so nothing is explained.""" + its fresh, corroborated share (`car_exclude`), on the same landing? The + tests are the alarms': a saturated guard and a floor with other + batteries left are graded by `load_too_high` on where the period lands + (SAFETY-81 / 87); a floor that leaves nothing is graded by SAFETY-126's + `misses_aim` (the batteries at 0 W from now on), latched for the + quarter. That latch is kept here twice, on the period as it is + (`_car_need_real`) and without the car (`_car_need_excl`), from the + same `misses_aim` and the same batteries reading. Both reset at a new + quarter and when the guard no longer wants power, whatever the cover + option says (this runs every cycle). A car that is 0 W, or untrusted + (`w` None sets the second latch), makes the two equal and explains + nothing.""" batt, prev = self.site_batt_w, self._car_batt_prev self._car_batt_prev = batt wants = bool(guard is not None and guard.engaged and guard.blind is None and (guard.wanted_w or 0.0) > 0.0) + if real_proj.block_start != self._car_latch_block: + self._car_latch_block = real_proj.block_start + self._car_need_real = self._car_need_excl = False if not wants: - self._car_needed = False + self._car_need_real = self._car_need_excl = False if batt is not None and prev is not None: batt = min(float(batt), float(prev)) excl = self.car_exclude(real_proj, w) if wants: - self._car_needed = self._car_needed or w is None or batt is None \ - or peakguard.misses_aim(excl, batt_w=batt, target_w=target_w) + if batt is None: + self._car_need_real = self._car_need_excl = True + else: + self._car_need_real = self._car_need_real or \ + peakguard.misses_aim(real_proj, batt_w=batt, + target_w=target_w) + self._car_need_excl = self._car_need_excl or w is None or \ + peakguard.misses_aim(excl, batt_w=batt, target_w=target_w) if w is None or batt is None or not wants \ or not (guard.saturated or guard.floor_limited): return False @@ -317,7 +331,8 @@ class CarMixin: elif (guard.floor_w or 0.0) > 0.0 and guard.able_w is not None: rating = guard.able_w else: - return bool(not guard.within_aim and not self._car_needed) + return bool(not guard.within_aim and self._car_need_real + and not self._car_need_excl) def high(p): return peakguard.load_too_high( diff --git a/goodwe_controller/test_ev10.py b/goodwe_controller/test_ev10.py index fbb0288..eaea080 100644 --- a/goodwe_controller/test_ev10.py +++ b/goodwe_controller/test_ev10.py @@ -215,24 +215,60 @@ class _G: def explains(proj_w, car_w, *, floor=True, cover=True, car_so_far_w=None, - within_aim=False): - c = _Car(cover, car_w) - p = _Proj(proj_w) - c._carq = {"key": p.block_start, - "ws": (car_w if car_so_far_w is None else car_so_far_w) - * p.elapsed_s, "mono": 0.0} - c.car_cycle(p, _G(floor, within_aim=within_aim), 4450.0, None) + within_aim=False, earlier=(), block=0, c=None, at=0.0): + """One cycle of `car_cycle` on a stub; `earlier` are projections of + cycles before it in the same quarter (they latch SAFETY-126's test).""" + c = c or _Car(cover, car_w) + c.w = car_w + for k, e in enumerate(tuple(earlier) + (proj_w,)): + p = _Proj(e) + p.block_start = p.block_start + timedelta(minutes=15 * block) + c._now = at - len(earlier) + k + c._carq = {"key": p.block_start, + "ws": ((car_w or 0.0) if car_so_far_w is None else car_so_far_w) + * p.elapsed_s, "mono": c._now} + c.car_cycle(p, _G(floor, within_aim=within_aim), 4450.0, None) return c.car_explains check("rule: the alarm's test is true with the car (4468 W, the batteries " "at 0 W land 4485 W) and false without it (768 W): the car explains it, " "with the projection under the aim", explains(4468.0, 3700.0)) +check("rule: under the aim, the quarter's test latched by the car's share " + "(4600 W earlier), the car explains the alarm (the positive under-aim " + "case; a single 4300 W cycle has no landing miss to explain, so it " + "needs the earlier cycle)", explains(4300.0, 3700.0, earlier=(4600.0,))) check("rule: where the alarm would not fire anyway nothing is explained", not explains(4300.0, 3700.0, within_aim=True)) check("rule: without the car it is still over the aim: the car does not " "explain it", not explains(9000.0, 3700.0)) -check("rule: no car power, no explanation", not explains(9000.0, 0.0)) +check("rule: no car power, no explanation", not explains(4300.0, 0.0)) +check("rule: ...also when the test was latched earlier in the quarter", + not explains(4300.0, 0.0, earlier=(4600.0,)) + and not explains(9000.0, 0.0)) +check("rule: an untrusted car figure (None) explains nothing", + not explains(4300.0, None, earlier=(4600.0,))) +# the latches: per quarter, and independent of the cover option +c4 = _Car(True, 3700.0) +explains(9000.0, 3700.0, c=c4, block=0) # the house needs it: latched +check("latch: in the same quarter the house need stays latched, so the car " + "does not explain", not explains(4300.0, 3700.0, c=c4, block=0, at=10.0)) +check("latch: a new quarter starts clean: the car alone explains it again", + explains(4300.0, 3700.0, c=c4, block=1, at=1000.0, + earlier=(4600.0,))) +c5 = _Car(False, 3700.0) # cover OFF +explains(9000.0, 3700.0, c=c5, block=0) # the house needs it +c5.o["ev_batt_cover"] = True # ... and the option flips +check("latch: the option flipping to ON does not lose a house need seen " + "while it was off", not explains(4300.0, 3700.0, c=c5, block=0, at=10.0)) +c6 = _Car(True, 3700.0) +explains(9000.0, 3700.0, c=c6, block=0) +c6.o["ev_batt_cover"] = False +explains(4300.0, 3700.0, c=c6, block=0, at=10.0) +c6.o["ev_batt_cover"] = True +check("latch: ... nor does flipping it off and on again", + not explains(4300.0, 3700.0, c=c6, block=0, at=20.0)) + check("rule: the guard is not floor-limited or saturated: nothing to explain", not explains(4300.0, 3700.0, floor=False)) @@ -490,32 +526,36 @@ check("Manual: two writes of ours, never 'another writer' in the tracker", async def failed_write_then_outside(how): """A write that RAISES or returns FAILURE must still close the self-mute: - a later outside change shows the row.""" + it ends 15 s after the write returned, and a later outside change shows + the row.""" w = World() await w.step(3) await w.c.handle_action("car_mode", value="manual") + ret = [] async def bad(a): await w.sleep(1.0) + ret.append(w.t) # when the write came back if how == "raise": raise RuntimeError("the charger link broke") return False w.drv.write_current = bad await w.c.handle_action("car_current", value=12) await w.step(3) # the write is tried + closed = (bool(ret) and w.c.car.mute_until <= ret[-1] + 15.0 + 1e-6) await w.c.handle_action("car_mode", value="off") await w.step(20) # past the 15 s mute w.sim.set_current(7) # somebody else await w.step(3) - return w + return w, closed for how in ("raise", "fail"): - wf = asyncio.run(failed_write_then_outside(how)) + wf, closed = asyncio.run(failed_write_then_outside(how)) check(f"a write that {'raises' if how == 'raise' else 'returns failure'}" - ": the mute closes within 15 s, and a later outside change shows " - "the row", wf.c.car.mute_until < wf.t - and "charger_writer" in wf.rows()) + ": the mute ends within 15 s of the write's return, and a later " + "outside change shows the row", + closed and "charger_writer" in wf.rows()) print() print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed") -- 2.54.0