diff --git a/goodwe_controller/app/chargers.py b/goodwe_controller/app/chargers.py index caa6618..7c96512 100644 --- a/goodwe_controller/app/chargers.py +++ b/goodwe_controller/app/chargers.py @@ -790,6 +790,17 @@ class CarTracker: return got_wh >= CORR_RATIO * exp_wh - CORR_SLACK_WH return True + def contradicted(self, now: float) -> bool: + """EV-18: did the energy meter answer over a whole window and fall + short (`corroborated` compared and failed)? Not when the energy + reading is unknown, the window is empty or still short, or the car is + not charging: those are unknown, not contradicted.""" + r = self.reading + if r is None or not r.available or r.charging is not True \ + or r.energy_kwh is None or not self._hist: + return False + return not self.corroborated(now) + def stuck(self, now: float) -> bool: """Power and read-back unchanged `STUCK_S` after a write that moved the setpoint. Cleared the moment either moves.""" diff --git a/goodwe_controller/app/ctl_car.py b/goodwe_controller/app/ctl_car.py index 53bfa88..d3f86a2 100644 --- a/goodwe_controller/app/ctl_car.py +++ b/goodwe_controller/app/ctl_car.py @@ -238,15 +238,17 @@ class CarMixin: return 0.0 <= mono - wr.phase_done_at <= OWN_PAUSE_TAIL_S def _car_contradicted(self, mono) -> bool: - """EV-18 (owner 2026-11-19): does the charger's energy meter - contradict a fresh, not stuck figure of a charging car? Then that - figure stays untrusted to the quarter's end (`car_cycle`).""" + """EV-18 (owner 2026-11-19): did the charger's energy meter answer + and fall short of a fresh, not stuck figure of a charging car + (`CarTracker.contradicted`)? Then that figure stays untrusted for the + alarm to the quarter's end (`car_cycle`). An unknown energy reading + contradicts nothing.""" r = getattr(self.car, "reading", None) if r is None or not r.available or r.charging is not True \ or not self.car_manual(): return False return (self.car.car_w(mono) is not None and not self.car.stuck(mono) - and not self.car.corroborated(mono)) + and self.car.contradicted(mono)) def _car_idle(self, mono) -> bool: """EV-18: is the car known to draw nothing? A fresh reading that says @@ -345,18 +347,19 @@ class CarMixin: # car at 0 A and the energy meter cannot corroborate it then, so for # that bounded time its fresh, not stuck figure stands in. own = (w is None or float(w) <= 0.0) and self._car_own_pause(mono) - # EV-18: a figure the meter contradicted is not trusted again in - # that quarter, not even as the stand-in for our own pause. - key = None if real_proj is None else real_proj.block_start - if key is not None and not own and self._car_contradicted(mono): - self._car_contra_block = key - if key is not None and key == self._car_contra_block: - w, own = None, False wg = w if w is None and own: wg = self.car.car_w_paused(mono) self._car_quarter(real_proj, w, mono, wg) self._car_session_tick(mono) + # EV-18 (owner 2026-11-19): a figure the meter contradicted grades no + # alarm again in that quarter, not even as our own pause's stand-in. + # The alarm decision only: the car's energy count, the guard's input + # (`car_exclude`) and the car-over row keep the figure. + key = None if real_proj is None else real_proj.block_start + if key is not None and not own and self._car_contradicted(mono): + self._car_contra_block = key + contra = key is not None and key == self._car_contra_block explains = over = False if real_proj is not None and target_w is not None \ and real_proj.block_start is not None: @@ -365,9 +368,11 @@ class CarMixin: # (the house's own need); it and a 0 W figure explain nothing, # but in our own pause (EV-15). idle = wg is None and self._car_idle(mono) - graded = self._car_explains_alarm(real_proj, guard, target_w, - 0.0 if idle else wg) - if idle or (w is not None and float(w) <= 0.0 and not own): + graded = self._car_explains_alarm( + real_proj, guard, target_w, + None if contra else 0.0 if idle else wg) + if contra or idle or (w is not None and float(w) <= 0.0 + and not own): graded = False if self.car_cover: explains = over = graded diff --git a/goodwe_controller/test_ev18.py b/goodwe_controller/test_ev18.py index a18ffd9..9737c5c 100644 --- a/goodwe_controller/test_ev18.py +++ b/goodwe_controller/test_ev18.py @@ -241,6 +241,65 @@ check("T8 unit: the same with the charger unavailable (unknown car): the " "alarm stands while unknown and is released at E+60 (Expected 5)", not any(run_of(exu, 0, 59)) and all(run_of(exu, 60, 899))) +# --- the contradiction latch (owner 2026-11-19), unit ----------------------- # +class _TrackerC: + """A charging car whose energy meter contradicts it when `contra(t)`.""" + def __init__(self, contra): + self.contra = contra + self.reading = CH.ChargerReading(available=True, state="C", + charging=True, power_w=CAR) + + def car_w(self, _now): + return CAR + + def stuck(self, _now): + return False + + def contradicted(self, now): + return self.contra(now - 10000.0) + + def car_w_paused(self, _now): + return CAR + + @staticmethod + def status(*_a): + return "charging" + + +class _CarC(_Car): + def __init__(self, contra, own): + super().__init__() + self.car, self.own = _TrackerC(contra), own + + def car_manual(self): + return True + + def _car_own_pause(self, mono): + return self.own(mono - 10000.0) + + +def contra_run(contra, own, secs): + c = _CarC(contra, own) + _c, ex = urun(secs, const(13000.0 + CAR), const(0.0), + lambda t: None if contra(t) or own(t) else CAR, c=c) + return ex + + +never = lambda t: False # noqa: E731 +exg = contra_run(lambda t: 300 <= t < 306, never, range(0, 1100)) +check("contradiction (T3 shape): the meter contradicts the figure at E+300: " + "not explained from E+300 to the quarter's end, though trusted again " + "from E+306", all(run_of(exg, 0, 299)) and not any(run_of(exg, 300, 899)) + and len(run_of(exg, 300, 899)) == 600) +check("contradiction: released by the next quarter (review MG): explained " + "again from E+900", all(run_of(exg, 900, 1099)) + and len(run_of(exg, 900, 1099)) == 200) +exf = contra_run(lambda t: 100 <= t < 130, lambda t: 100 <= t < 130, + range(0, 400)) +check("contradiction during our own pause (EV-15) latches nothing (review " + "MF): the stand-in explains in it, the trusted figure after it", + all(run_of(exf, 0, 399)) and len(run_of(exf, 0, 399)) == 400) + # --- T10(a) unit: the battery reading lost for one cycle --------------------- # cA, eA = urun(range(-3, 10), const(14000.0 + CAR - 800.0), lambda t: None if t == 1 else 800.0, const(CAR)) @@ -557,6 +616,18 @@ for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))), H.alarms(r10b) == T5_BASE and all( x["alarm"] for x in H.window(tr10b, E + 1, E + 899))) +# --- R1 (review round 2): the energy reading unknown for one cycle ----------- # +for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))), + ("T3", dict(house=H.shape(13000.0), b=ZERO))): + rg, trg = H.run(a=ZERO, extra=H.energy_gap(E + 200), **kw) + summary(f"R1 {nm} energy gap at E+200", rg, trg) + check(f"R1 {nm}: the charger's energy entity unknown for one cycle " + f"(E+200) on a correct car: unknown, not contradicted, so red for " + f"that cycle only and explained from the next (Expected 5)", + H.red_secs(trg) == [E + 200] and H.edges(trg) == [E + 200] + and all(x["explains"] for x in H.window(trg, E + 201, E + 899) + if x["lim"])) + # --- T11: one battery first (SAFETY-87) --------------------------------------- # for nm, house in (("(i) 17 500 W", 17500.0), ("(ii) 19 000 W", 19000.0)): r11, tr11 = H.run(honest(house), soc={"a": 19.0, "b": 35.0}) @@ -709,6 +780,31 @@ for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))), f"charger writes are identical whether the car explains or not", H.commands(ra, tra) == H.commands(rb, trb)) +# N4 with "Batteries help with the peak" off (review round 2): the guard's +# input is `car_exclude`, which reads the car's energy count. The +# contradiction latch must not touch it: the same commands with the latch off. +for nm, kw in ( + ("SoC 60 %, energy gap at E+200", + dict(house=H.shape(13000.0), soc={"a": 60.0, "b": 60.0}, + extra=H.energy_gap(E + 200))), + ("at the reserve, energy gap at E+200", + dict(house=H.shape(13000.0), a=ZERO, b=ZERO, + extra=H.energy_gap(E + 200))), + ("SoC 60 %, the T9(c) liar", + dict(house=honest(13900.0), soc={"a": 60.0, "b": 60.0}, + sim=Draw(100.0, 1380.0, setpoint_a=6))), + ("at the reserve, the T9(c) liar", + dict(house=honest(13900.0), a=ZERO, b=ZERO, + sim=Draw(100.0, 1380.0, setpoint_a=6)))): + ra, tra = H.run(cover=False, **kw) + if "sim" in kw: + kw = dict(kw, sim=Draw(100.0, 1380.0, setpoint_a=6)) + rb, trb = H.run(cover=False, latch_off=True, **kw) + summary(f"N4 cover off, {nm}", ra, tra) + check(f"N4 cover off, {nm}: the claim, the floor, the setpoints and the " + f"charger writes are those of the same run without the " + f"contradiction latch", H.commands(ra, tra) == H.commands(rb, trb)) + # --- N5: at most one floor-alarm edge per quarter ---------------------------- # def per_quarter(ts): out = {} @@ -717,12 +813,19 @@ def per_quarter(ts): return out +# Cover off, the T9(c) liar at the reserve: the guard's own engagement flips +# as the liar's figure is corroborated now and then (its input is +# `car_exclude`), pre-existing (base: 4 edges). Printed, not graded here. +LIAR_OFF = "N4 cover off, at the reserve, the T9(c) liar" +print(f" {LIAR_OFF}: alarm edges " + f"{[[t - E for t in ts] for nm, ts in RUNS if nm == LIAR_OFF]}") many = [(nm, ts) for nm, ts in RUNS - if any(v > 1 for v in per_quarter( + if nm != LIAR_OFF and any(v > 1 for v in per_quarter( [t for t in ts if not nm.startswith("T15 x10") or t < F2_FROM]) .values())] check(f"N5: at most one floor-alarm edge per quarter in every run " - f"({len(RUNS)} runs; x10 to E+500): {many}", many == []) + f"({len(RUNS)} runs; x10 to E+500; the cover-off liar apart): " + f"{many}", many == []) print() print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed") diff --git a/goodwe_controller/tools/ev18_peak.py b/goodwe_controller/tools/ev18_peak.py index b104d66..9d3f38c 100644 --- a/goodwe_controller/tools/ev18_peak.py +++ b/goodwe_controller/tools/ev18_peak.py @@ -80,10 +80,12 @@ def shape(after, before=PRE_W, at=None): def run(house, *, a=None, b=None, lost=None, car_a=6, phases=1, aim=AIM, mode="manual", dur=None, extra=None, sim=None, soc=None, plug=True, - x=1, mono_x=None, explain_off=False): + x=1, mono_x=None, explain_off=False, latch_off=False, + cover=True): """One run; returns (run, trace). `x`: fake seconds per cycle (wall and monotonic both; `mono_x` sets the monotonic rate apart). `explain_off`: - the car never explains (for the control-identity check).""" + the car never explains, `latch_off`: no contradiction latch (both for the + control-identity check). `cover`: the option `ev_batt_cover`.""" force = {} if a is not None: force["a"] = a @@ -98,6 +100,10 @@ def run(house, *, a=None, b=None, lost=None, car_a=6, phases=1, aim=AIM, orig = c.car_settle if explain_off: c._car_explains_alarm = lambda *a_, **k_: False + if latch_off: + c._car_contradicted = lambda *a_, **k_: False + if not cover: + c.o["ev_batt_cover"] = False if mono_x is not None and mono_x != x: c.car_now = (lambda f=c.car_now: f() * mono_x / x) @@ -197,6 +203,16 @@ def commands(r, tr): return h.hexdigest()[:16] +def energy_gap(at, secs=1): + """The charger's energy entity is missing (unknown) for `secs` from `at`.""" + def on(p, c): + p.ch.no_energy = True + + def off(p, c): + p.ch.no_energy = False + return {at: on, at + secs: off} + + def restart(c): """A restart as the car side sees it: a fresh `car_init` and an empty corroboration history, and no floor alarm standing."""