From 12c97b56f44553ee69ef5c4ab3bd221bc96d4dcc Mon Sep 17 00:00:00 2001 From: ems-agent Date: Thu, 19 Nov 2026 02:59:50 +0100 Subject: [PATCH 1/4] EV-18: no floor alarm at a quarter's start while the car explains the excess EV-15 rig F-A: with both batteries at the peak reserve and the car charging, PEAK_GUARD_FLOOR_LIMITED and goodwe_peak_soc_floor fired at a quarter's start and stayed red for the quarter, the excess smaller than the car. Two causes, both held by the per-quarter latch `_car_need_excl`: - C2: "without the car" assumed the batteries give 0 W from now on, so what the loop still gives below the reserve counted as house (T2 red on base); - C1: one cycle with no trusted car figure latched it for the quarter (T1). Owner 2026-11-19 (Q1-Q3): without the car the batteries keep giving what they give now (lower of two readings, every cycle); a house need seen with a trusted car figure stays latched to the quarter's end (`_car_need_house`); an unknown car figure keeps the alarm only while it is unknown. A car known to draw nothing (fresh reading, not charging) still grades the house's own need. After a restart or a gap only the rest of the quarter is graded without the car. A 0 W figure explains nothing outside our own pause (EV-15). The guard's claim, floor, setpoints and charger writes are unchanged (N4: 41 runs, same command digests as base). test_ev18.py: the test plan's T1-T18, T2b, T2c, N2-N5 (tools/ev18_peak.py: the real Controller across one quarter edge, N=2 at the reserve). Co-Authored-By: Claude --- .../DECISIONS/EV-04-manual-mode.md | 20 +- goodwe_controller/app/ctl_car.py | 94 ++- goodwe_controller/test_ev18.py | 681 ++++++++++++++++++ goodwe_controller/tools/ev18_peak.py | 207 ++++++ 4 files changed, 975 insertions(+), 27 deletions(-) create mode 100644 goodwe_controller/test_ev18.py create mode 100644 goodwe_controller/tools/ev18_peak.py diff --git a/goodwe_controller/DECISIONS/EV-04-manual-mode.md b/goodwe_controller/DECISIONS/EV-04-manual-mode.md index bfa3e39..e49e675 100644 --- a/goodwe_controller/DECISIONS/EV-04-manual-mode.md +++ b/goodwe_controller/DECISIONS/EV-04-manual-mode.md @@ -97,10 +97,10 @@ up to 1.8 kW; the 40 Wh floor fixes that.) 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. + still under the aim (rig: 5888 W against 6000 W). A car of 0 W explains + nothing; a stale, stuck or uncorroborated figure is `None` and the normal + alarms stand while it is (EV-18 below). There is no minimum car power: the + comparison itself is what separates car from house. - **The period without the car is not clipped at 0 W** (EV-10b). The rig showed EV-10 failing: house 3 kW, car 11 kW, batteries 8.1 kW, aim 6 kW. The batteries give more than the house uses, so the house alone is an export; `car_exclude` @@ -137,6 +137,18 @@ up to 1.8 kW; the 40 Wh floor fixes that.) drew in the pause is kept apart (`ws_p`), so `car_exclude`, the guard's input, the claim, floor and writes are unchanged. A house overload still fails the test without the car, so it alarms as on Off. +- **The batteries as they give now, and no latch from an unknown** (EV-18, EV-15 + rig F-A). At the reserve the loop still gives some battery power; "without the + car, batteries at 0 W" counted it as house, `_car_need_excl` latched at the + quarter's start and the floor alarm stood for the quarter with the excess + smaller than the car. Owner 2026-11-19: without the car the batteries keep + giving what they give now (the lower of two readings, every cycle); a miss so + (`_car_need_house`) seen with a trusted car figure stays latched to the + quarter's end. The car explains where the period with it misses on the same + batteries (`_car_over_now`), or by the EV-10 test above. A `None` car figure + or battery reading explains nothing in that cycle and latches nothing. After + a restart or a gap the car's share of what is done is unknown (`_carq` + `whole`), so only the rest of the period is graded without the car. - **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. diff --git a/goodwe_controller/app/ctl_car.py b/goodwe_controller/app/ctl_car.py index 41615da..726173a 100644 --- a/goodwe_controller/app/ctl_car.py +++ b/goodwe_controller/app/ctl_car.py @@ -60,6 +60,7 @@ class CarMixin: self._car_over_gone = None self._car_batt_prev = None self._car_need_real = self._car_need_excl = False # EV-10 latches + self._car_need_house = self._car_over_now = False # EV-18 latches self._car_latch_block = None self._car_over_notified = None # the session a notice was raised for self._car_session = 0 @@ -235,6 +236,16 @@ class CarMixin: <= OWN_PAUSE_MAX_S return 0.0 <= mono - wr.phase_done_at <= OWN_PAUSE_TAIL_S + def _car_idle(self, mono) -> bool: + """EV-18: is the car known to draw nothing? A fresh reading that says + it is not charging (mode3 A or B) at under `CAR_PEAK_MIN_W`. Not an + unknown figure: the house's own need is graded in such a cycle.""" + r = getattr(self.car, "reading", None) + if r is None or not r.available or r.charging is not False: + return False + p = self.car.car_w(mono) + return p is not None and p < CAR_PEAK_MIN_W + def _car_quarter(self, proj, w, mono, wg=None) -> None: """The car's energy in the open quarter, for the average the guard's house leaves out and for the peak line. `wg` (EV-15) is the figure for @@ -244,8 +255,16 @@ class CarMixin: key = None if proj is None else proj.block_start last = q["mono"] if key != q["key"]: + # EV-18: `whole` when the count covers the block: it follows on + # from the block before, or starts in its first seconds (not + # after a restart or a gap). + whole = key is not None and ( + float(proj.elapsed_s) <= 5.0 or ( + last is not None and q["key"] is not None + and (key - q["key"]).total_seconds() == QUARTER_S)) self._car_bank(q) q["key"], q["ws"], q["ws_p"] = key, 0.0, 0.0 + q["whole"] = whole if key is not None and last is not None: dt = min(max(mono - last, 0.0), 5.0) if w is not None: @@ -322,7 +341,8 @@ 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. wg = w - if w is None and self._car_own_pause(mono): + own = (w is None or float(w) <= 0.0) and self._car_own_pause(mono) + 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) @@ -330,7 +350,14 @@ class CarMixin: 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, wg) + # EV-18: a car known to draw nothing counts as 0 W for the latches + # (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 = False if self.car_cover: explains = over = graded elif w is not None: @@ -360,35 +387,41 @@ class CarMixin: 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 + quarter (`_car_need_real`, and `_car_need_excl` without the car). + EV-18 (owner 2026-11-19): without the car, the batteries keep giving + what they give now (the lower of two readings), re-checked every cycle; + a miss seen so (`_car_need_house`) never lets the car explain for the + rest of the quarter. The car also explains where the period with it, + on the same batteries, misses (`_car_over_now`). Only a trusted figure + latches: an untrusted car (`w` None) or an unknown battery reading + explains nothing in that cycle only. All reset at a new quarter and + when the guard no longer wants power, whatever the cover option says + (this runs every cycle). DECISIONS/EV-04-manual-mode.md (EV-18).""" + now, prev = self.site_batt_w, self._car_batt_prev + self._car_batt_prev = now 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: + if real_proj.block_start != self._car_latch_block or not wants: self._car_latch_block = real_proj.block_start self._car_need_real = self._car_need_excl = False - if not wants: - self._car_need_real = self._car_need_excl = False + self._car_need_house = self._car_over_now = False + batt = now if batt is not None and prev is not None: batt = min(float(batt), float(prev)) excl = self.car_exclude_alarm(real_proj, w) - if wants: - 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 \ + if wants and batt is not None: + self._car_need_real = self._car_need_real or \ + peakguard.misses_aim(real_proj, batt_w=batt, + target_w=target_w) + self._car_over_now = self._car_over_now or \ + self._car_lands_over(real_proj, now, batt, target_w) + if w is not None: + whole = self._carq.get("whole", True) + self._car_need_excl = self._car_need_excl or \ peakguard.misses_aim(excl, batt_w=batt, target_w=target_w) + self._car_need_house = self._car_need_house or \ + self._car_lands_over(excl, now, batt, target_w, whole) if w is None or batt is None or not wants \ or not (guard.saturated or guard.floor_limited): return False @@ -398,7 +431,8 @@ class CarMixin: rating = guard.able_w else: return bool(not guard.within_aim and self._car_need_real - and not self._car_need_excl) + and not self._car_need_house + and (self._car_over_now or not self._car_need_excl)) def high(p): return peakguard.load_too_high( @@ -406,6 +440,20 @@ class CarMixin: achievable_w=rating) return bool(high(real_proj) and not high(excl)) + @staticmethod + def _car_lands_over(p, now, gives, target_w, whole=True) -> bool: + """EV-18: does the period end more than `ALARM_MISS_W` over the aim + with the batteries giving `gives` W from now on (`now`: what they gave + in the meter's figure)? Not `whole`: the car's share of what is done + is not known (a restart, a gap), so only the rest is graded.""" + if whole: + return peakguard.load_too_high(p, batt_w=now, ceiling_w=target_w, + achievable_w=gives) + if QUARTER_S - float(p.elapsed_s) <= 0.0: + return False + rest = float(p.held_w) + float(now) - float(gives) + return rest - float(target_w) > peakguard.ALARM_MISS_W + 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_ev18.py b/goodwe_controller/test_ev18.py new file mode 100644 index 0000000..01c3853 --- /dev/null +++ b/goodwe_controller/test_ev18.py @@ -0,0 +1,681 @@ +"""EV-18: no floor alarm at a quarter's start while the car explains the excess +(EV-15 rig F-A). `python3 -B test_ev18.py` + +The rig: both batteries at the peak reserve, the car charging, and +PEAK_GUARD_FLOOR_LIMITED + `goodwe_peak_soc_floor` at a quarter's start, red +for most of the quarter, while the grid excess was smaller than the car. Two +causes, both latched for the quarter by `_car_need_excl`: + C1 one cycle with no trusted car figure set the latch (T1); + C2 "without the car" assumed the batteries give 0 W from now on, so what + the loop still gives below the reserve counted as house (T2). +The rule now (owner 2026-11-19, Q1-Q3): without the car the batteries keep +giving what they give now (the lower of the last two readings, re-checked +every cycle); a house need seen with a trusted car figure stays latched to the +quarter's end; an unknown car figure keeps the alarm only while it is unknown. + +T-ids are the test plan's (reports/EV-18-test-plan.md). "base" is 9fdce02. +Mutating a module this file grades? Read MUTATION.md first (purge __pycache__). +""" + +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 chargers as CH, ctl_car, tariff # noqa: E402 +from chargersim import SimCharger # noqa: E402 +from named_absence import first, nth, present # noqa: E402 +import ev04_peak as P # noqa: E402 +import ev18_peak as H # noqa: E402 + +fails = [] + + +def check(name, cond): + print(f" {'ok ' if cond else 'FAIL'} {name}") + if not cond: + fails.append(name) + + +AIM = H.AIM +CAR = 1380.0 +E = H.E +# Measured on base 9fdce02 with this file's own runs: the seconds of +# goodwe_peak_soc_floor in the honest shapes, which must not come later now. An +# honest shape steps the house at E, and the meter shows it at E+1. +T5_BASE = [E + 1] # also T6 (T5 shape), T8, T9(a), T10(b) T5 +T7_BASE = E + 72 +T9B_BASE = [] # 400 W real: never uncorroborated (Findings) +T9C_BASE = E + 1 # 100 W real: never trusted at the edge +T10A_T5_BASE = [E + 2] # the guard disengages at E+1 (no battery reading) +T11_BASE = [E + 13] # SAFETY-87: ALARM_HOLD_S after the step +T13_BASE = [E + 301] +T15_T5_BASE = [E + 10] # x10: one cycle + +# =========================================================================== # +print("1. UNIT: car_cycle ACROSS A QUARTER EDGE (a real `_carq`, not preset)") +# =========================================================================== # +BS = datetime(2026, 11, 17, 21, 15, tzinfo=timezone.utc) # the edge E + + +class _Car(ctl_car.CarMixin): + def __init__(self): + self.o = {"ev_batt_cover": True} + self.w = CAR + self._now = 0.0 + self.site_batt_w, self.site_rating_w = 0.0, 9600.0 + self.store = type("S", (), {"data": {}, "set": lambda s, k, v: 0})() + self.car_init({}, self.store) + + 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 _G: + """Floor-limited, the floor leaves nothing (floor_w 0), wants power.""" + def __init__(self, wants=True, within_aim=False): + self.floor_limited, self.saturated = True, False + self.floor_w, self.able_w, self.ceiling_w = 0.0, None, AIM + 50.0 + self.engaged, self.blind = True, None + self.wanted_w = 300.0 if wants else 0.0 + self.within_aim = within_aim + + +def urun(secs, grid, batt, w, *, x=1, mono_x=None, c=None, guard=None): + """`car_cycle` once per entry of `secs` (seconds from the edge E, `x` fake + seconds apart). `grid(t)` is the meter (house + car - batteries), + `batt(t)` the site battery reading, `w(t)` the trusted car figure. Returns + (car, {t: car_explains}).""" + c = c or _Car() + mono_x = x if mono_x is None else mono_x + done, out = {}, {} + for t in secs: + q = t // 900 + bs, el = BS + timedelta(seconds=900 * q), t - 900 * q + g = float(grid(t)) + d = done.get(bs, g * el) + p = tariff.Projection( + projected_w=(d + g * (900 - el)) / 900.0, + elapsed_w=(d / el if el else g), elapsed_s=float(el), + covered_frac=1.0, complete=False, block_start=bs, held_w=g) + done[bs] = d + g * x + c._now = 10000.0 + t * mono_x / x + c.w, c.site_batt_w = w(t), batt(t) + c.car_cycle(p, guard(t) if guard else _G(), AIM, None) + out[t] = c.car_explains + return c, out + + +def const(v): + return lambda t: v + + +def run_of(d, t0, t1): + return [d[t] for t in sorted(d) if t0 <= t <= t1] + + +# --- T1: the car figure untrusted for the edge's first cycles --------------- # +def t1(x=1, mono_x=None): + _c, ex = urun(range(-30, 121, x), const(13000.0 + CAR), const(0.0), + lambda t: None if 0 <= t <= 2 * x else CAR, x=x, + mono_x=mono_x) + return ex + + +ex = t1() +print(f" T1 explains E-1..E+5: {run_of(ex, -1, 5)}") +check("T1 PRECONDITION: before the edge the car (trusted) explains the " + "excess (house 13 000 W, car 1 380 W, grid 14 380 W)", + all(run_of(ex, -30, -1)) and len(run_of(ex, -30, -1)) == 30) +check("T1 (Expected 5): while the car figure is unknown (E+0..E+2) it " + "explains nothing, so the alarm stands", not any(run_of(ex, 0, 2))) +_c1b, ex1b = urun(range(-30, 121), const(12500.0 + CAR - 800.0), const(800.0), + lambda t: None if 0 <= t <= 2 else CAR) +check("T1b (the EV-10 path: the grid lands under the aim, the batteries at " + "0 W would miss; house 12 500 W, b 800 W): unknown E+0..E+2, released " + "at E+3 and explained to E+120", + not any(run_of(ex1b, 0, 2)) and all(run_of(ex1b, 3, 120)) + and len(run_of(ex1b, 3, 120)) == 118) +check("T1 (Expected 3): released at the first trusted cycle (E+3) and " + "explained to E+120 (base: latched False to E+120)", + all(run_of(ex, 3, 120)) and len(run_of(ex, 3, 120)) == 118) + +# --- T2c: the battery W boundary, graded on the lower of two readings ------- # +def t2c(b_of): + _c, ex = urun(range(0, 6), lambda t: 14000.0 + CAR - b_of(t), b_of, + const(CAR)) + return run_of(ex, 0, 5) + + +e391, e389 = t2c(const(391.0)), t2c(const(389.0)) +e395 = t2c(lambda t: 395.0 if t == 0 else 385.0) +print(f" T2c 391 W {e391}, 389 W {e389}, 395 then 385 W {e395}") +check("T2c: b steady at 391 W (house alone with the real batteries lands " + "13 609 W, aim + 9 W): the car explains from E+0", all(e391) + and len(e391) == 6) +check("T2c: b at 389 W (13 611 W, aim + 11 W): it does not, from E+0", + not any(e389) and len(e389) == 6) +check("T2c: readings 395 then 385 W: graded on 385 W, no explanation from " + "the second cycle on", not any(e395[1:]) and len(e395) == 6) + +# --- T4: ALARM_MISS_W, batteries at 0 W -------------------------------------- # +e09 = run_of(urun(range(0, 6), const(13609.0 + CAR), const(0.0), + const(CAR))[1], 0, 5) +e11 = run_of(urun(range(0, 6), const(13611.0 + CAR), const(0.0), + const(CAR))[1], 0, 5) +check("T4 unit: the house alone at aim + 9 W: the car explains from E+0; at " + "aim + 11 W it does not", all(e09) and len(e09) == 6 and not any(e11)) + +# --- T8 / N2: 0 W and tiny cars ---------------------------------------------- # +e0 = run_of(urun(range(-5, 30), const(14000.0 - 800.0), const(800.0), + const(0.0))[1], -5, 29) +e50 = run_of(urun(range(-5, 30), const(14090.0 + 50.0), const(0.0), + const(50.0))[1], -5, 29) +check("T8 unit: a 0 W car never explains, whatever the batteries give (T2 " + "shape, b 800 W)", not any(e0) and len(e0) == 35) +check("T8 unit: a 50 W car with the house at 14 090 W never explains", + not any(e50) and len(e50) == 35) +# N2: a car that drew 11 kW earlier in the quarter and now reports 0 W +c0, ex0 = urun(range(0, 400), lambda t: 2600.0 + (11040.0 if t < 300 else 0.0), + const(0.0), lambda t: 11040.0 if t < 300 else 0.0) +check("N2: a trusted 0 W figure explains nothing, also after the car drew " + "earlier in the quarter", not any(run_of(ex0, 300, 399))) + +# --- T8 unit: a car known to draw nothing is not an unknown car ------------- # +class _Tracker: + """The two things `_car_idle` reads: the reading, and its fresh power.""" + def __init__(self, available): + self.reading = CH.ChargerReading(available=available, state="B", + charging=False, power_w=0.0) + + def car_w(self, _now): + return 0.0 if self.reading.available else None + + @staticmethod + def status(*_a): + return "charging" + + +def idle_then_charging(available): + c = _Car() + c.car = _Tracker(available) + _c, ex = urun(range(0, 900), + lambda t: 14090.0 if t < 60 else 13000.0 + CAR, const(0.0), + lambda t: None if t < 60 else CAR, c=c) + return ex + + +exi, exu = idle_then_charging(True), idle_then_charging(False) +check("T8 unit: a car known idle (mode3 B, 0 W, fresh) while the house alone " + "misses (14 090 W): that house need is latched, so the car charging " + "from E+60 does not explain the quarter (test_ev10's `swapped` case)", + not any(run_of(exi, 0, 899))) +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))) + +# --- 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)) +check("T10(a) unit, T2 shape: the cycle with no battery reading explains " + "nothing (no last-known W credited); the next ones do", + eA.get(1) is False and eA.get(0) is True and all(run_of(eA, 2, 9)) + and len(run_of(eA, 2, 9)) == 8) + +# --- T13 unit: a house need seen with a trusted car stays latched ----------- # +c13, e13 = urun(range(-5, 1000), + lambda t: (15500.0 if 300 <= t < 360 else 13000.0) + CAR, + const(0.0), const(CAR)) +check("T13 unit: the house steps to 15 500 W at E+300 for 60 s (landing " + "without the car 14 667 W): not explained from E+300 to the quarter's " + "end, though the house is back at 13 000 W from E+360", + all(run_of(e13, 0, 299)) and not any(run_of(e13, 300, 899)) + and len(run_of(e13, 300, 899)) == 600) +check("T13 unit: ...and released by the new quarter", all(run_of(e13, 900, 999))) +c13g, e13g = urun(range(0, 400), + lambda t: (15500.0 if 100 <= t < 160 else 13000.0) + CAR, + const(0.0), const(CAR), + guard=lambda t: _G(wants=not (t == 250))) +check("T13 unit: ...or by the guard no longer wanting power (EV-10)", + not any(run_of(e13g, 100, 249)) and all(run_of(e13g, 251, 399))) + +# --- T14: no flicker --------------------------------------------------------- # +def floor_edges(ex): + """Per quarter, False -> True edges of the floor alarm the stub implies + (floor-limited, within_aim False, not explained).""" + out, was = {}, False + for t in sorted(ex): + al = not ex[t] + if al and not was: + out[t // 900] = out.get(t // 900, 0) + 1 + was = al + return out + + +_ca, eta = urun(range(0, 1200), + lambda t: 13610.0 + (40.0 if int(t // 7) % 2 else -40.0) + CAR, + const(0.0), const(CAR)) +_cb, etb = urun(range(0, 1200), + lambda t: 14000.0 + CAR - (400.0 if int(t // 7) % 2 else 800.0), + lambda t: 400.0 if int(t // 7) % 2 else 800.0, const(CAR)) +fa, fb = floor_edges(eta), floor_edges(etb) +print(f" T14 alarm edges per quarter: (a) {fa} (b) {fb}") +check("T14(a): the house alone straddles aim + 10 W by 40 W every 7 s: at " + "most one alarm edge per quarter", all(v <= 1 for v in fa.values())) +check("T14(b): T2 shape with b alternating 400 / 800 W every 7 s: no alarm " + "edge at all (base: one per quarter)", fb == {}) + +# --- T15 unit: x10 ------------------------------------------------------------ # +ex10 = t1(x=10) +check("T15 unit x10 (wall and mono 10 s a cycle): T1 the same; released " + "within 1 cycle (E+30, the first trusted cycle)", + not any(run_of(ex10, 0, 20)) and all(run_of(ex10, 30, 120)) + and all(run_of(ex10, -30, -10))) +ex10m = t1(x=10, mono_x=1) +check("T15 unit, mono x1 and wall x10: the same verdicts (the edge comes from " + "the projection's block_start, not from mono)", + not any(run_of(ex10m, 0, 20)) and all(run_of(ex10m, 30, 120))) + +# =========================================================================== # +print("\n2. THE REAL CONTROLLER ACROSS THE EDGE (N=2, both at the reserve)") +# =========================================================================== # + + +RUNS = [] # (name, alarm edges) of every run, for N5 + + +def summary(name, r, tr): + RUNS.append((name, H.edges(tr))) + w = H.window(tr, E - 120, E + 900) + lim = [x for x in w if x["lim"]] + print(f" {name}: alarms {[t - E for t in H.alarms(r)]} edges " + f"{[t - E for t in H.edges(tr)]} red {len(H.red_secs(tr))} s " + f"(first {[t - E for t in H.red_secs(tr)[:1]]}) errors " + f"{len(H.errors(tr))} limited {len(lim)} explained " + f"{sum(1 for x in lim if x['explains'])} cmd {H.commands(r, tr)}") + return w, lim + + +def quiet(r, tr): + """No floor notification, no ERROR, no red peak_guard row, E-120..E+900.""" + return H.alarms(r) == [] and H.red_secs(tr) == [] and H.errors(tr) == [] + + +def all_explained(lim, t0=E - 120): + return bool(lim) and all(x["explains"] for x in lim if x["t"] >= t0) + + +ZERO = const(0.0) + + +def honest(w): + """An honest shape steps at the edge, so Off has no alarm before it.""" + return H.shape(w, at=E) + +# --- T2: the rig F-A shape ---------------------------------------------------- # +r2, tr2 = H.run(H.shape(14000.0), a=ZERO, b=const(800.0)) +w2, lim2 = summary("T2", r2, tr2) +check("T2 PRECONDITION: limited at the reserve from the edge, the car trusted, " + "b 800 W, grid excess 980 W < car", + present(first(x for x in w2 if x["t"] == E and x["lim"])) + and all(x["w"] == CAR and x["batt"] == 800.0 for x in lim2)) +check("T2: no goodwe_peak_soc_floor, no PEAK_GUARD_FLOOR_LIMITED ERROR, no " + "red peak_guard row in E-120..E+900 (base: alarm at E+0, red to E+900)", + quiet(r2, tr2)) +check("T2: the car explains every floor-limited cycle, E+0..E+10 among them", + all_explained(lim2) and len([x for x in lim2 if x["t"] <= E + 10]) == 11) + +# --- T2b: the batteries give less later --------------------------------------- # +r2i, tr2i = H.run(H.shape(14000.0), a=ZERO, + b=lambda t: 800.0 if t < E + 300 else 0.0) +summary("T2b(i)", r2i, tr2i) +a2i = H.alarms(r2i) +check("T2b(i): b drops to 0 W at E+300 (landing without the car 13 733 W): " + "the alarm fires within 1 cycle of E+300", + len(a2i) == 1 and E + 300 <= nth(a2i, 0) <= E + 301) +check("T2b(i): ...and stays to the quarter's end (a house need with a " + "trusted car is latched)", all(x["alarm"] and x["red"] for x in + H.window(tr2i, E + 302, E + 899))) +r2ii, tr2ii = H.run(H.shape(14000.0), a=ZERO, + b=lambda t: 800.0 if t < E + 300 else 400.0) +summary("T2b(ii)", r2ii, tr2ii) +check("T2b(ii): b drops to 400 W (landing 13 467 W): no alarm to E+900", + quiet(r2ii, tr2ii)) + +# --- T3: batteries at 0 W, and the 11 kW car ---------------------------------- # +r3, tr3 = H.run(H.shape(13000.0), a=ZERO, b=ZERO) +w3, lim3 = summary("T3", r3, tr3) +check("T3: batteries 0 W, house 13 000 W, car 1 380 W: no alarm, no red row, " + "the car explains every limited cycle incl. E+0..E+10, one car notice", + quiet(r3, tr3) and all_explained(lim3) + and len(P.ids(r3, P.OVER)) == 1 + and all(x["explains"] for x in lim3 if x["t"] <= E + 10)) + + +def plug_at(t0): + return {t0: lambda p, c: p.ch.plug_in()} + + +r3k, tr3k = H.run(H.shape(2600.0, before=2600.0), a=ZERO, b=ZERO, car_a=16, + phases=3, aim=6344.0, plug=False, extra=plug_at(E - 120)) +w3k, lim3k = summary("T3 11 kW", r3k, tr3k) +check("T3 11 kW: house 2 600 W, car 11 kW, aim 6 344 W (base P 21:30): no " + "alarm, the car explains every limited cycle", + quiet(r3k, tr3k) and all_explained(lim3k) + and len(P.ids(r3k, P.OVER)) == 1) + +# --- T4 controller ------------------------------------------------------------ # +r409, tr409 = H.run(H.shape(13609.0), a=ZERO, b=ZERO) +summary("T4 13 609", r409, tr409) +check("T4: the house alone at aim + 9 W: no alarm", quiet(r409, tr409)) +r411, tr411 = H.run(H.shape(13611.0), a=ZERO, b=ZERO) +r411o, tr411o = H.run(H.shape(13611.0), a=ZERO, b=ZERO, mode="off") +summary("T4 13 611", r411, tr411) +summary("T4 13 611 Off", r411o, tr411o) +check("T4: at aim + 11 W the alarm at the same cycle as Off (and as base, " + "E+0)", H.alarms(r411) == H.alarms(r411o) == [E]) + +# --- T5: an honest alarm ------------------------------------------------------ # +r5, tr5 = H.run(honest(14090.0), a=ZERO, b=ZERO) +r5o, tr5o = H.run(honest(14090.0), a=ZERO, b=ZERO, mode="off") +summary("T5", r5, tr5) +summary("T5 Off", r5o, tr5o) +check("T5: grid excess 1 870 W > car 1 380 W: the alarm and the ERROR at the " + "same second as Off and as base (E+1, the step's first sample)", + H.alarms(r5) == H.alarms(r5o) == T5_BASE + and nth(H.errors(tr5), 0) == nth(H.errors(tr5o), 0) == E + 1) +check("T5: the car explains no cycle", not any(x["explains"] for x in tr5)) + + +# --- T6: the car figure unknown across the edge ------------------------------- # +def unavailable(t0, t1): + return {t0: lambda p, c: p.ch.go_unavailable(True), + t1: lambda p, c: p.ch.go_unavailable(False)} + + +r6, tr6 = H.run(H.shape(13000.0), a=ZERO, b=ZERO, + extra=unavailable(E - 20, E + 60)) +summary("T6 T3 shape", r6, tr6) +back = first(x["t"] for x in tr6 if x["t"] >= E + 60 and x["w"] is not None) +check("T6 T3 shape: while unknown the car explains nothing and the alarm " + "stands from E+0, as base", + H.alarms(r6) == [E] and not any( + x["explains"] for x in H.window(tr6, E - 5, E + 59)) + and all(x["alarm"] for x in H.window(tr6, E, E + 59))) +check("T6 T3 shape: released within 1 cycle of the first trusted cycle after " + "E+60, no new alarm edge to E+900 (base: red to E+900)", + present(back) and all(not x["alarm"] and x["explains"] for x in + H.window(tr6, back + 1, E + 899)) + and H.edges(tr6) == [E]) +r6h, tr6h = H.run(honest(14090.0), a=ZERO, b=ZERO, + extra=unavailable(E - 20, E + 60)) +summary("T6 T5 shape", r6h, tr6h) +check("T6 T5 shape: the alarm at the base second and it stands throughout", + H.alarms(r6h) == T5_BASE and all(x["alarm"] for x in + H.window(tr6h, E + 1, E + 899))) + + +# --- T7: a frozen car figure, the car really stops ---------------------------- # +def frozen_stop(p, c): + p.ch.freeze() + p.ch.car_full() + + +r7, tr7 = H.run(honest(14090.0), a=ZERO, b=ZERO, extra={E - 30: frozen_stop}) +summary("T7", r7, tr7) +first7 = nth(H.alarms(r7), 0) +untr = first(x["t"] for x in tr7 if x["t"] >= E - 30 and x["w"] is None) +check("T7: the alarm within 114 s of the stop (max(60, 40 Wh / 1.38 kW) " + "+ 10), no later than base", + present(first7) and first7 <= E - 30 + 114 and first7 <= T7_BASE) +check("T7: never explained after the figure goes untrusted", + present(untr) and not any(x["explains"] for x in tr7 if x["t"] >= untr)) + + +# --- T8: a car at 0 W, and a 50 W car ----------------------------------------- # +class Draw(SimCharger): + """A charger that draws `real_w` while charging and reports `say_w`.""" + def __init__(self, real_w, say_w, **kw): + super().__init__(**kw) + self.real_w, self.say_w = real_w, say_w + + def target_w(self): + return 0.0 if super().target_w() <= 0.0 else self.real_w + + def _build(self): + keep, self._frozen_w = self._frozen_w, self.say_w + try: + return super()._build() + finally: + self._frozen_w = keep + + +def full(p, c): + p.ch.car_full() + + +for nm, kw in (("house 14 090 W", dict(house=honest(14090.0), b=ZERO)), + ("T2 shape", dict(house=honest(14000.0), b=const(800.0)))): + r8, tr8 = H.run(a=ZERO, extra={1: full}, **kw) + r8o, tr8o = H.run(a=ZERO, extra={1: full}, mode="off", **kw) + summary(f"T8 0 W, {nm}", r8, tr8) + summary(f"T8 0 W, {nm}, Off", r8o, tr8o) + check(f"T8: a car plugged at 0 W, {nm}: the alarm at the same second as " + f"Off, nothing explained", H.alarms(r8) == H.alarms(r8o) + and H.alarms(r8) != [] and not any(x["explains"] for x in tr8)) +r8s, tr8s = H.run(honest(14090.0), a=ZERO, b=ZERO, + sim=Draw(50.0, 50.0, setpoint_a=6)) +r8so, tr8so = H.run(honest(14090.0), a=ZERO, b=ZERO, mode="off", + sim=Draw(50.0, 50.0, setpoint_a=6)) +summary("T8 50 W", r8s, tr8s) +check("T8: a 50 W car, house 14 090 W: the alarm at the same second as Off, " + "nothing explained", H.alarms(r8s) == H.alarms(r8so) == T5_BASE + and not any(x["explains"] for x in tr8s)) + +# --- T9: a wrong charger reply ------------------------------------------------ # +r9a, tr9a = H.run(honest(13900.0), a=ZERO, b=ZERO, + sim=Draw(1380.0, 11000.0, setpoint_a=6)) +summary("T9(a)", r9a, tr9a) +check("T9(a): reports 11 kW, read-back 6 A 1-ph (cap 1 518 W): the house " + "alone misses, the alarm at the base second", + H.alarms(r9a) == T5_BASE and all(x["w"] is None or x["w"] <= 1518.0 + for x in tr9a)) +r9b, tr9b = H.run(honest(13900.0), a=ZERO, b=ZERO, + sim=Draw(400.0, 1380.0, setpoint_a=6)) +summary("T9(b)", r9b, tr9b) +check("T9(b): reports 1 380 W, draws 400 W: the same alarms as base (none: " + "400 W corroborates a 1 380 W figure, CORR_RATIO 0.5; see the dev " + "report's Findings)", H.alarms(r9b) == T9B_BASE) +r9c, tr9c = H.run(honest(13900.0), a=ZERO, b=ZERO, + sim=Draw(100.0, 1380.0, setpoint_a=6)) +summary("T9(c)", r9c, tr9c) +a9c = nth(H.alarms(r9c), 0) +check("T9(c): reports 1 380 W, draws 100 W: the first alarm once the figure " + "is uncorroborated, at most 104 s + 10 s after the edge, no later than " + "base", present(a9c) and a9c <= E + 114 and a9c <= T9C_BASE) +print(f" T9(c) alarm edges {[t - E for t in H.edges(tr9c)]} (base: one; " + f"the meter's 10 Wh step re-corroborates the figure every 360 s and " + f"Expected 3/5 release the alarm then: see the dev report)") + +# --- T10: a lost battery reading, an unavailable charger ---------------------- # +for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))), + ("T5", dict(house=honest(14090.0), b=ZERO))): + r10, tr10 = H.run(a=ZERO, lost={"b": {E + 1}}, **kw) + summary(f"T10(a) {nm}", r10, tr10) + gap = first(x for x in tr10 if x["t"] == E + 1) + nxt = first(x for x in tr10 if x["t"] == E + 2) + check(f"T10(a) {nm}: inverter-b's reading lost at E+1: that cycle grades " + f"nothing (P_SAFETY owns a missing input), the next one grades on " + f"what is measured", present(gap, nxt) and gap["batt"] is None + and nxt["batt"] == (800.0 if nm == "T2" else 0.0)) + if nm == "T2": + check("T10(a) T2: no alarm edge (base: E+0)", quiet(r10, tr10)) + else: + check("T10(a) T5: the same alarm seconds as base", + H.alarms(r10) == T10A_T5_BASE) + r10b, tr10b = H.run(a=ZERO, extra=unavailable(E + 1, E + 2), **kw) + summary(f"T10(b) {nm}", r10b, tr10b) + if nm == "T2": + check("T10(b) T2: the charger unavailable for one cycle (E+1): the " + "alarm stands for that cycle only (Expected 5)", + H.edges(tr10b) == [E + 1] + and all(not x["alarm"] for x in H.window(tr10b, E + 2, E + 899)) + and all(x["explains"] for x in H.window(tr10b, E + 2, E + 899) + if x["lim"])) + else: + check("T10(b) T5: the alarm at the base second and it stands", + H.alarms(r10b) == T5_BASE and all( + x["alarm"] for x in H.window(tr10b, E + 1, E + 899))) + +# --- 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}) + summary(f"T11{nm}", r11, tr11) + if house < 18000.0: + check("T11(i): b able, house 17 500 W, car 1 380 W: no alarm across E", + H.alarms(r11) == [] and P.ids(r11, *P.ALARMS) == []) + else: + check("T11(ii): house 19 000 W: the alarm at the base second", + [t for t, _n in P.ids(r11, *P.ALARMS)] == T11_BASE) + +# --- T12 (record only): plug-in at E+0, the reserve at E+180 ------------------ # +def reserve_at(p, c): + p.socs.update({"a": 19.0, "b": 19.0}) + + +r12, tr12 = H.run(H.shape(13000.0), soc={"a": 40.0, "b": 40.0}, plug=False, + extra={E: lambda p, c: p.ch.plug_in(), E + 180: reserve_at}) +summary("T12 (record, F-B)", r12, tr12) + +# --- T13 controller: the latch is kept ---------------------------------------- # +r13, tr13 = H.run(H.shape(lambda t: 15500.0 if E + 300 <= t < E + 360 + else 13000.0), a=ZERO, b=ZERO) +summary("T13", r13, tr13) +check("T13: the house steps to 15 500 W at E+300 for 60 s: the alarm at " + "the base second (E+301, the step's first sample), and red to the " + "quarter's end", H.alarms(r13) == T13_BASE and all( + x["alarm"] and x["red"] for x in H.window(tr13, E + 301, E + 899))) + +# --- T16: the edge paths ------------------------------------------------------ # +for nm, kw in (("(a)(b)(c) SAFETY-91 roll, modes on", {}), + ("(d) the guard not wanting at the edge", + dict(lost={"b": {E}}))): + r16, tr16 = H.run(H.shape(13000.0), a=ZERO, b=ZERO, **kw) + w16, lim16 = summary(f"T16{nm}", r16, tr16) + f16 = first(x for x in tr16 if x["t"] >= E and x["lim"]) + pre = first(x for x in tr16 if x["t"] == E - 1) + check(f"T16{nm}: the car explains from the first limited cycle of the " + f"new block, no alarm, no red row, `_carq` key = block_start", + present(f16) and quiet(r16, tr16) and all( + x["explains"] and x["key"] == x["block"] + for x in tr16 if x["t"] >= f16["t"] and x["lim"])) + if not kw: + print(f" T16(c): within_aim at E-1 {pre['within_aim'] if present(pre) else pre}" + " (SAFETY-126's latch carried; not asserted)") + else: + g0 = first(x for x in tr16 if x["t"] == E) + check("T16(d) PRECONDITION: the guard did not want power at E+0", + present(g0) and not g0["wants"]) + + +# --- T17: a restart ----------------------------------------------------------- # +def restart_at(t0): + return {t0: lambda p, c: H.restart(c)} + + +for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))), + ("T3", dict(house=H.shape(13000.0), b=ZERO)), + ("T5", dict(house=honest(14090.0), b=ZERO))): + rr0, tr0 = H.run(a=ZERO, **kw) + for at in (E + 2, E + 300): + rr, trr = H.run(a=ZERO, extra=restart_at(at), **kw) + summary(f"T17 {nm} restart at E+{at - E}", rr, trr) + if nm == "T5": + check(f"T17 T5, restart at E+{at - E}: the alarm at the base " + f"second and again on the first cycle after the restart, " + f"as base; red throughout", + H.alarms(rr) == T5_BASE + [at] and len(H.red_secs(trr)) + == len(H.red_secs(tr0))) + else: + check(f"T17 {nm}, restart at E+{at - E}: the same as without " + f"(no floor notice, no ERROR, no red row)", + quiet(rr, trr) and quiet(rr0, tr0)) + print(f" T17 {nm} car-over notices: twin " + f"{[t - E for t, _n in P.ids(rr0, P.OVER)]}, restarted " + f"{[t - E for t, _n in P.ids(rr, P.OVER)]} (EV-11's " + f"once-per-session state does not survive a restart, as on " + f"base)") + +# --- T15 controller: x10 ------------------------------------------------------ # +# F2 (out of scope, filed apart): `_car_quarter` caps a cycle's dt at 5 s, so at +# 10 s a cycle half the car's energy is counted, and late in the quarter the +# house alone seems to miss the aim (T2 from about E+540, T3 E+820, as on base +# for T3). The x10 verdicts are graded to E+500; what comes after is printed. +F2_FROM = E + 500 +for nm, kw, want in ( + ("T2", dict(house=H.shape(14000.0), b=const(800.0)), "quiet"), + ("T3", dict(house=H.shape(13000.0), b=ZERO), "quiet"), + ("T5", dict(house=honest(14090.0), b=ZERO), "alarm"), + ("T6", dict(house=H.shape(13000.0), b=ZERO, + extra=unavailable(E - 20, E + 60)), "release")): + rx, trx = H.run(a=ZERO, x=10, **kw) + summary(f"T15 x10 {nm}", rx, trx) + early = [x for x in trx if x["t"] < F2_FROM] + print(f" T15 x10 {nm}: alarms after E+500 (F2) " + f"{[t - E for t in H.alarms(rx) if t >= F2_FROM]}") + if want == "quiet": + check(f"T15 x10 {nm}: no alarm, no red row, every limited cycle " + f"explained, E-120..E+500", + not [t for t in H.alarms(rx) if t < F2_FROM] + and H.red_secs(trx, t1=F2_FROM - 1) == [] + and all_explained([x for x in early if x["lim"]])) + elif want == "alarm": + check("T15 x10 T5: the alarm at the base second (E+10, one cycle)", + H.alarms(rx) == T15_T5_BASE) + else: + bk = first(x["t"] for x in trx if x["t"] >= E + 60 + and x["w"] is not None) + check("T15 x10 T6: the alarm while unknown, released within 1 cycle " + "(10 fake s) of the first trusted one, no new edge to E+500", + present(bk) and bk <= E + 70 + and all(not x["alarm"] for x in H.window(trx, bk, F2_FROM - 1)) + and [t for t in H.edges(trx) if t < F2_FROM] == [E]) + +# --- N4: the alarm decision changes no command -------------------------------- # +for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))), + ("T5", dict(house=honest(14090.0), b=ZERO))): + ra, tra = H.run(a=ZERO, **kw) + rb, trb = H.run(a=ZERO, explain_off=True, **kw) + check(f"N4 {nm}: the claim, the floor, the battery setpoints and the " + f"charger writes are identical whether the car explains or not", + H.commands(ra, tra) == H.commands(rb, trb)) + +# --- N5: at most one floor-alarm edge per quarter ---------------------------- # +def per_quarter(ts): + out = {} + for t in ts: + out[(t - E) // 900] = out.get((t - E) // 900, 0) + 1 + return out + + +many = [(nm, ts) for nm, ts in RUNS + if not nm.startswith("T9(c)") + 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; T9(c) apart, x10 to E+500): {many}", many == []) + +print() +print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed") +sys.exit(1 if fails else 0) diff --git a/goodwe_controller/tools/ev18_peak.py b/goodwe_controller/tools/ev18_peak.py new file mode 100644 index 0000000..b104d66 --- /dev/null +++ b/goodwe_controller/tools/ev18_peak.py @@ -0,0 +1,207 @@ +"""EV-18: the real Controller across one quarter edge `E`, N=2, both units at +the peak reserve and the car charging (`ev04_peak.drive`). Used by test_ev18.py. + +The run starts `E` s before an edge (rig.BASE is moved back for the run), with +a light house so the first quarter does not raise the month's peak (the aim +stays `AIM`). At `E - 120` the house steps to the shape, so the guard first +wants power at the edge, as on the rig (EV-15 F-A). `force` makes a unit give +what the loop gives below the reserve whatever it is told; `lost` drops its +reading for some seconds (the grid still sees it). The trace is one dict per +cycle, taken after it. +""" + +import hashlib +import logging +import os +import sys +from datetime import timedelta + +HERE = os.path.dirname(os.path.abspath(__file__)) +sys.path.insert(0, HERE) + +import ev04_peak as P # noqa: E402 +import opt11_identity as rig # noqa: E402 +import safety81_sim as s81 # noqa: E402 +from app import peakguard # noqa: E402 + +E = 150 # the edge, in run seconds +AIM = 13600.0 +MARGIN = 50.0 +PRE_W = 5000.0 # the first quarter's house: under the cap +FLOOR = "goodwe_peak_soc_floor" +OPTS = {"peak_soc_floor": 20, "inverters": [ + {"name": "inverter-a", "setpoint_entity": "number.sp_a", + "soc_entity": "sensor.soc_a", "batt_entity": "sensor.batt_a", + "max_w": 5000, "bms_soc_floor": 10}, + {"name": "inverter-b", "setpoint_entity": "number.sp_b", + "soc_entity": "sensor.soc_b", "batt_entity": "sensor.batt_b", + "max_w": 4600, "bms_soc_floor": 10}]} + + +class _Errors(logging.Handler): + def __init__(self): + super().__init__(logging.ERROR) + self.rec = [] + + def emit(self, r): + self.rec.append(r.getMessage()) + + +ERR = _Errors() +_lg = logging.getLogger("goodwe") +_lg.addHandler(ERR) +_lg.setLevel(logging.ERROR) +_lg.propagate = False + + +class Plant(P.CarPlantN): + force = {} + lost = {} + + def batt_of(self, u, at): + f = self.force.get(u) + if f is not None: + return float(f(at)) + return super().batt_of(u, at) + + async def number(self, e, invert=False): + for u, secs in self.lost.items(): + if e == "sensor.batt_" + u and int(self.t) in secs: + return None + return await super().number(e, invert) + + +def shape(after, before=PRE_W, at=None): + """The house: `before` until `at` (E - 120), then `after` (W or fn(t)).""" + at = E - 120 if at is None else at + return lambda t: before if t < at else (after(t) if callable(after) + else after) + + +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): + """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).""" + force = {} + if a is not None: + force["a"] = a + if b is not None: + force["b"] = b + cls = type("Plant", (Plant,), {"force": force, "lost": lost or {}}) + tr = [] + n_err = [len(ERR.rec)] + dur = E + 900 if dur is None else dur + + def hook(plant, c): + orig = c.car_settle + if explain_off: + c._car_explains_alarm = lambda *a_, **k_: False + if mono_x is not None and mono_x != x: + c.car_now = (lambda f=c.car_now: f() * mono_x / x) + + async def settle(): + await orig() + g = c.peak_guard + red = [] + if plant.t >= E - 130: + red = [r_["id"] for r_ in c.checks() + if r_["ok"] is False and not r_["warn"] + and r_["id"] == "peak_guard"] + errs = [m for m in ERR.rec[n_err[0]:] + if "may not draw the battery lower" in m] + n_err[0] = len(ERR.rec) + cl = peakguard.claim(g) if g is not None else None + tr.append({ + "t": plant.t, "explains": c.car_explains, + "lim": bool(g is not None and (g.floor_limited + or g.saturated)), + "within_aim": bool(g is not None and g.within_aim), + "wants": bool(g is not None and g.engaged + and (g.wanted_w or 0.0) > 0.0), + "alarm": c._peak_floor_limited, "red": red, "err": errs, + "w": c.car_alarm_w(), "batt": c.site_batt_w, + "key": c._carq["key"], + "block": (c._peak_proj_real.block_start + if c._peak_proj_real is not None else None), + "floor_w": g.floor_w if g is not None else None, + "lo": getattr(cl, "lo", None), + "sp": tuple(i.last_write for i in c.inverters)}) + c.car_settle = settle + + ev = {0: hook} + for t, fn in (extra or {}).items(): + if t == 0: + ev[0] = (lambda p, c, fn=fn: (hook(p, c), fn(p, c))) + else: + ev[t] = fn + socs = soc or {"a": 19.0, "b": 19.0} + s = sim + if s is None: + from chargersim import SimCharger + s = SimCharger(setpoint_a=car_a) + if x != 1: + tick = s.tick + s.tick = lambda secs=1.0: tick(secs * x) + base, step = rig.BASE, s81.TICK + rig.BASE, s81.TICK = base - timedelta(seconds=E), float(x) + try: + r = P.drive(house, dur=dur, rating=5000.0, soc=socs, + cap=aim + MARGIN, phases=phases, n=2, plant_cls=cls, + opts=OPTS, dev_w=5000.0, setpoint=car_a, user_a=car_a, + mode=mode, events=ev, sim=s, plug=plug) + finally: + rig.BASE, s81.TICK = base, step + return r, tr + + +def alarms(r): + """Seconds of each goodwe_peak_soc_floor notification.""" + return [t for t, n in r["raised"] if n == FLOOR] + + +def window(tr, t0, t1): + return [x for x in tr if t0 <= x["t"] <= t1] + + +def edges(tr): + """Seconds at which the floor alarm goes False -> True.""" + out, was = [], False + for x in tr: + if x["alarm"] and not was: + out.append(x["t"]) + was = x["alarm"] + return out + + +def red_secs(tr, t0=None, t1=None): + t0 = E - 120 if t0 is None else t0 + t1 = E + 900 if t1 is None else t1 + return [x["t"] for x in window(tr, t0, t1) if x["red"]] + + +def errors(tr): + return [x["t"] for x in tr if x["err"]] + + +def commands(r, tr): + """A digest of every command: the units' setpoints, the charger's writes, + and the guard's floor and claim per cycle (N4).""" + h = hashlib.sha256() + for u in sorted(r["plant"].hists): + h.update(repr((u, r["plant"].hists[u])).encode()) + h.update(repr(r["sim"].writes()).encode()) + h.update(repr([(x["t"], x["floor_w"], x["lo"], x["sp"]) + for x in tr]).encode()) + return h.hexdigest()[:16] + + +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.""" + mode, n, a = c.car_mode, c.car_n, c.car_a + c.car_init(c.o, c.store) + c.car_mode, c.car_n, c.car_a = mode, n, a + c.car._hist.clear() + c._peak_floor_limited = False -- 2.54.0 From 5db56b5f28ab544ac973308870ae15a217026be8 Mon Sep 17 00:00:00 2001 From: ems-agent Date: Thu, 19 Nov 2026 11:28:04 +0100 Subject: [PATCH 2/4] EV-18 review round 1: restart keeps the house's done part; contradicted figure untrusted to the quarter's end - [Critical] After a restart or a gap only the rest of the quarter was graded without the car (`_carq["whole"]`), which dropped the house's own energy from before it and hid an honest alarm (review repro: house 18 kW then 12 kW, restart at E+310). The rest-only grading is gone: the car is credited only with energy counted since the start, the rest of what is done counts as house (base's side). T17b covers it; T17 T2 at E+300 now alarms from the restart (the conservative side). - [Major] Owner 2026-11-19: a figure the energy meter contradicted (fresh, charging, not corroborated) stays untrusted to the quarter's end, also as the EV-15 stand-in. T9(c): one alarm edge, red to the end; T9(c) is back in the N5 check. - [Major] T2c lagging-meter variant (readings 389 W then 800 W, the meter at 800 W): the house latch grades on the lower reading. - Unit stub: a run that starts mid-quarter has the car counted since the quarter's start (no restart). Co-Authored-By: Claude --- .../DECISIONS/EV-04-manual-mode.md | 8 ++- goodwe_controller/app/ctl_car.py | 48 ++++++++------- goodwe_controller/test_ev18.py | 60 +++++++++++++++++-- 3 files changed, 86 insertions(+), 30 deletions(-) diff --git a/goodwe_controller/DECISIONS/EV-04-manual-mode.md b/goodwe_controller/DECISIONS/EV-04-manual-mode.md index e49e675..3a45fb7 100644 --- a/goodwe_controller/DECISIONS/EV-04-manual-mode.md +++ b/goodwe_controller/DECISIONS/EV-04-manual-mode.md @@ -146,9 +146,11 @@ up to 1.8 kW; the 40 Wh floor fixes that.) (`_car_need_house`) seen with a trusted car figure stays latched to the quarter's end. The car explains where the period with it misses on the same batteries (`_car_over_now`), or by the EV-10 test above. A `None` car figure - or battery reading explains nothing in that cycle and latches nothing. After - a restart or a gap the car's share of what is done is unknown (`_carq` - `whole`), so only the rest of the period is graded without the car. + or battery reading explains nothing in that cycle and latches nothing; a car + known to draw nothing (fresh, not charging) still grades the house's need. + Owner 2026-11-19: a figure the energy meter contradicted (fresh, charging, + not corroborated) stays untrusted to the quarter's end. After a restart or a + gap the car's earlier energy is not known, so it counts as house. - **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. diff --git a/goodwe_controller/app/ctl_car.py b/goodwe_controller/app/ctl_car.py index 726173a..53bfa88 100644 --- a/goodwe_controller/app/ctl_car.py +++ b/goodwe_controller/app/ctl_car.py @@ -62,6 +62,7 @@ class CarMixin: self._car_need_real = self._car_need_excl = False # EV-10 latches self._car_need_house = self._car_over_now = False # EV-18 latches self._car_latch_block = None + self._car_contra_block = None # EV-18: the quarter it was contradicted self._car_over_notified = None # the session a notice was raised for self._car_session = 0 self._car_prev_state = None @@ -236,6 +237,17 @@ class CarMixin: <= OWN_PAUSE_MAX_S 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`).""" + 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)) + def _car_idle(self, mono) -> bool: """EV-18: is the car known to draw nothing? A fresh reading that says it is not charging (mode3 A or B) at under `CAR_PEAK_MIN_W`. Not an @@ -255,16 +267,8 @@ class CarMixin: key = None if proj is None else proj.block_start last = q["mono"] if key != q["key"]: - # EV-18: `whole` when the count covers the block: it follows on - # from the block before, or starts in its first seconds (not - # after a restart or a gap). - whole = key is not None and ( - float(proj.elapsed_s) <= 5.0 or ( - last is not None and q["key"] is not None - and (key - q["key"]).total_seconds() == QUARTER_S)) self._car_bank(q) q["key"], q["ws"], q["ws_p"] = key, 0.0, 0.0 - q["whole"] = whole if key is not None and last is not None: dt = min(max(mono - last, 0.0), 5.0) if w is not None: @@ -340,8 +344,15 @@ class CarMixin: # EV-15: the figure for grading only. Our own phase change holds the # car at 0 A and the energy meter cannot corroborate it then, so for # that bounded time its fresh, not stuck figure stands in. - wg = w 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) @@ -417,11 +428,10 @@ class CarMixin: self._car_over_now = self._car_over_now or \ self._car_lands_over(real_proj, now, batt, target_w) if w is not None: - whole = self._carq.get("whole", True) self._car_need_excl = self._car_need_excl or \ peakguard.misses_aim(excl, batt_w=batt, target_w=target_w) self._car_need_house = self._car_need_house or \ - self._car_lands_over(excl, now, batt, target_w, whole) + self._car_lands_over(excl, now, batt, target_w) if w is None or batt is None or not wants \ or not (guard.saturated or guard.floor_limited): return False @@ -441,18 +451,14 @@ class CarMixin: return bool(high(real_proj) and not high(excl)) @staticmethod - def _car_lands_over(p, now, gives, target_w, whole=True) -> bool: + def _car_lands_over(p, now, gives, target_w) -> bool: """EV-18: does the period end more than `ALARM_MISS_W` over the aim with the batteries giving `gives` W from now on (`now`: what they gave - in the meter's figure)? Not `whole`: the car's share of what is done - is not known (a restart, a gap), so only the rest is graded.""" - if whole: - return peakguard.load_too_high(p, batt_w=now, ceiling_w=target_w, - achievable_w=gives) - if QUARTER_S - float(p.elapsed_s) <= 0.0: - return False - rest = float(p.held_w) + float(now) - float(gives) - return rest - float(target_w) > peakguard.ALARM_MISS_W + in the meter's figure)? Of what is done, only the car's energy counted + since the add-on started is the car's (a restart or a gap leaves the + rest with the house).""" + return peakguard.load_too_high(p, batt_w=now, ceiling_w=target_w, + achievable_w=gives) 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_ev18.py b/goodwe_controller/test_ev18.py index 01c3853..a18ffd9 100644 --- a/goodwe_controller/test_ev18.py +++ b/goodwe_controller/test_ev18.py @@ -99,6 +99,11 @@ def urun(secs, grid, batt, w, *, x=1, mono_x=None, c=None, guard=None): c = c or _Car() mono_x = x if mono_x is None else mono_x done, out = {}, {} + t0 = nth(list(secs), 0) + if c._carq["key"] is None and present(t0) and t0 % 900: + # started mid-quarter: the car was counted since its start (no restart) + c._carq.update(key=BS + timedelta(seconds=900 * (t0 // 900)), + ws=float(w(t0) or 0.0) * (t0 % 900), ws_p=0.0) for t in secs: q = t // 900 bs, el = BS + timedelta(seconds=900 * q), t - 900 * q @@ -167,6 +172,18 @@ check("T2c: b at 389 W (13 611 W, aim + 11 W): it does not, from E+0", not any(e389) and len(e389) == 6) check("T2c: readings 395 then 385 W: graded on 385 W, no explanation from " "the second cycle on", not any(e395[1:]) and len(e395) == 6) +# review round 1 (MD): the meter shows the higher output while the readings +# are 389 W then 800 W. b gives 800 W; one reading of 389 W at E+3, the meter +# still at 800 W. House 14 005 W: at E+4 the house latch grades on the lower +# reading (389 W), rest 13 616 W, landing 13 614 W > aim + 10 W; on the +# current one (800 W) it would be 13 205 W. +_cl, elag = urun(range(0, 12), const(14005.0 + CAR - 800.0), + lambda t: 389.0 if t == 3 else 800.0, const(CAR)) +print(f" T2c lagging meter E+0..E+11: {run_of(elag, 0, 11)}") +check("T2c (meter lags, readings 389 then 800 W): explained before, the " + "house latch sets on the lower reading at E+4 and holds to E+11", + all(run_of(elag, 0, 3)) and not any(run_of(elag, 4, 11)) + and len(run_of(elag, 4, 11)) == 8) # --- T4: ALARM_MISS_W, batteries at 0 W -------------------------------------- # e09 = run_of(urun(range(0, 6), const(13609.0 + CAR), const(0.0), @@ -503,9 +520,12 @@ a9c = nth(H.alarms(r9c), 0) check("T9(c): reports 1 380 W, draws 100 W: the first alarm once the figure " "is uncorroborated, at most 104 s + 10 s after the edge, no later than " "base", present(a9c) and a9c <= E + 114 and a9c <= T9C_BASE) -print(f" T9(c) alarm edges {[t - E for t in H.edges(tr9c)]} (base: one; " - f"the meter's 10 Wh step re-corroborates the figure every 360 s and " - f"Expected 3/5 release the alarm then: see the dev report)") +check("T9(c) (owner 2026-11-19): the meter contradicted the figure, so it " + "stays untrusted to the quarter's end: one alarm edge, red and never " + "explained to E+899 (the meter's 10 Wh step re-corroborates it every " + "360 s)", H.edges(tr9c) == [a9c] and all( + x["alarm"] and x["red"] and not x["explains"] + for x in H.window(tr9c, a9c, E + 899))) # --- T10: a lost battery reading, an unavailable charger ---------------------- # for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))), @@ -606,6 +626,16 @@ for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))), f"as base; red throughout", H.alarms(rr) == T5_BASE + [at] and len(H.red_secs(trr)) == len(H.red_secs(tr0))) + elif nm == "T2" and at == E + 300: + # review round 1: the car's energy before a restart is not known, + # so it counts as house (never credited to the car). Here that + # tips the house alone over the aim: the alarm stands from the + # restart, the conservative side (base: red from E+0). + check("T17 T2, restart at E+300: quiet before the restart; after " + "it the car's unknown earlier share counts as house, so at " + "most one alarm edge, at the restart", + quiet(rr0, tr0) and H.red_secs(trr, t1=at - 1) == [] + and H.edges(trr) in ([], [at])) else: check(f"T17 {nm}, restart at E+{at - E}: the same as without " f"(no floor notice, no ERROR, no red row)", @@ -616,6 +646,25 @@ for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))), f"once-per-session state does not survive a restart, as on " f"base)") +# --- T17b (review round 1): a house need only the done part shows ----------- # +def heavy_then_light(t): + """House 18 000 W for E..E+300, then 12 000 W: alone it lands 14 000 W.""" + if t < E: + return H.PRE_W if t < E - 120 else 12000.0 + return 18000.0 if t < E + 300 else 12000.0 + + +r17b0, tr17b0 = H.run(heavy_then_light, a=ZERO, b=ZERO) +r17b, tr17b = H.run(heavy_then_light, a=ZERO, b=ZERO, + extra=restart_at(E + 310)) +summary("T17b no restart", r17b0, tr17b0) +summary("T17b restart at E+310", r17b, tr17b) +check("T17b: the house heavy before a restart at E+310 (alone it lands " + "14 000 W, excess 1 780 W > car): red to the quarter's end and never " + "explained, as without the restart (and as base and Off)", + len(H.red_secs(tr17b, E, E + 899)) == len(H.red_secs(tr17b0, E, E + 899)) + == 899 and not any(x["explains"] for x in H.window(tr17b, E, E + 899))) + # --- T15 controller: x10 ------------------------------------------------------ # # F2 (out of scope, filed apart): `_car_quarter` caps a cycle's dt at 5 s, so at # 10 s a cycle half the car's energy is counted, and late in the quarter the @@ -669,12 +718,11 @@ def per_quarter(ts): many = [(nm, ts) for nm, ts in RUNS - if not nm.startswith("T9(c)") - and any(v > 1 for v in per_quarter( + if 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; T9(c) apart, x10 to E+500): {many}", many == []) + f"({len(RUNS)} runs; x10 to E+500): {many}", many == []) print() print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed") -- 2.54.0 From 93c6628eca94a77656cebb5125b57a8038d45329 Mon Sep 17 00:00:00 2001 From: ems-agent Date: Thu, 19 Nov 2026 12:18:06 +0100 Subject: [PATCH 3/4] EV-18 review round 2: the contradiction latch touches only the alarm; an unknown energy reading is not a contradiction - [Critical] The latch set `w = None` before `_car_quarter`, so with cover off the guard's input (`car_exclude`) counted the car as house and the batteries discharged. The latch now changes only the figure graded for the alarm; the car's energy count, the guard's input and the car-over row keep the unlatched `car_alarm_w()`. Cover-off N4 twins (energy gap, T9(c) liar, SoC 60 % and at the reserve) give the same commands as without the latch. - [Major] `corroborated()` is False for an unknown energy reading, so one missing reading latched a correct figure for the quarter. New `CarTracker.contradicted()`: only a meter that answered over a whole window and fell short. R1 (energy entity unknown 1 s at E+200, T2 and T3 shapes): red for that cycle only, explained from the next. - Minors: unit checks that a contradiction in our own pause latches nothing (MF) and that the latch ends with the quarter (MG). Co-Authored-By: Claude --- goodwe_controller/app/chargers.py | 11 +++ goodwe_controller/app/ctl_car.py | 33 +++++---- goodwe_controller/test_ev18.py | 107 ++++++++++++++++++++++++++- goodwe_controller/tools/ev18_peak.py | 20 ++++- 4 files changed, 153 insertions(+), 18 deletions(-) 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.""" -- 2.54.0 From ef8c5dcf627ba7ad18bfac14ee2e982dec6e63ae Mon Sep 17 00:00:00 2001 From: ems-agent Date: Thu, 19 Nov 2026 13:02:02 +0100 Subject: [PATCH 4/4] EV-18 review round 3: the DECISIONS line and a comment say what the contradiction latch does Wording only. DECISIONS/EV-04: a contradiction is a meter that answered and fell short (an unknown reading is none), and it grades no alarm while the guard's input keeps the figure. ctl_car.car_cycle: the car-over row keeps the figure only with the cover off. Co-Authored-By: Claude --- goodwe_controller/DECISIONS/EV-04-manual-mode.md | 7 ++++--- goodwe_controller/app/ctl_car.py | 2 +- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/goodwe_controller/DECISIONS/EV-04-manual-mode.md b/goodwe_controller/DECISIONS/EV-04-manual-mode.md index 3a45fb7..2c2b9e3 100644 --- a/goodwe_controller/DECISIONS/EV-04-manual-mode.md +++ b/goodwe_controller/DECISIONS/EV-04-manual-mode.md @@ -148,9 +148,10 @@ up to 1.8 kW; the 40 Wh floor fixes that.) batteries (`_car_over_now`), or by the EV-10 test above. A `None` car figure or battery reading explains nothing in that cycle and latches nothing; a car known to draw nothing (fresh, not charging) still grades the house's need. - Owner 2026-11-19: a figure the energy meter contradicted (fresh, charging, - not corroborated) stays untrusted to the quarter's end. After a restart or a - gap the car's earlier energy is not known, so it counts as house. + Owner 2026-11-19: a figure the energy meter contradicted (it answered over a + whole window and fell short; an unknown reading is no contradiction) grades + no alarm to the quarter's end; the guard's input keeps it. After a restart + or a gap the car's earlier energy is not known, so it counts as house. - **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. diff --git a/goodwe_controller/app/ctl_car.py b/goodwe_controller/app/ctl_car.py index d3f86a2..479f737 100644 --- a/goodwe_controller/app/ctl_car.py +++ b/goodwe_controller/app/ctl_car.py @@ -355,7 +355,7 @@ class CarMixin: # 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. + # (`car_exclude`) and, with the cover off, the car-over row keep it. 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 -- 2.54.0