From 4950a2374f22828e11e36023dbb6385bb0060f5c Mon Sep 17 00:00:00 2001 From: ems-agent Date: Fri, 20 Nov 2026 20:16:25 +0100 Subject: [PATCH 1/3] EV-19: no floor alarm when the batteries first reach the reserve early in a Manual car session EV-15 rig F-B, reproduced on 43b0db7 (tools/ev19_reserve.py, T1 grid). At the reserve inverter-b goes on following the house, so its output rises in that cycle. The battery reading shows the rise one cycle before the P1 sample does, and EV-18's house figure (held - car + now - min(now, prev)) counted the new battery power as house load. `_car_need_house` latched: one PEAK_GUARD_FLOOR_LIMITED ERROR and goodwe_peak_soc_floor at R+1, red until the guard stopped wanting power. ctl_car._car_explains_alarm: for the house latch only, a reading above both earlier readings counts as house only up to the higher of them. The credit stays the lower of the last two readings. The claim, floor, setpoints and charger writes are unchanged (342 runs, same digests). test_ev19.py: T1-T17, T20, N1-N6 of reports/EV-19-test-plan.md; 49 checks red on 43b0db7, 124 of 124 green here. Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w --- .../DECISIONS/EV-04-manual-mode.md | 7 + goodwe_controller/app/ctl_car.py | 11 +- goodwe_controller/test_ev19.py | 564 +++++++++++++ goodwe_controller/tools/ev19_reserve.py | 752 ++++++++++++++++++ 4 files changed, 1332 insertions(+), 2 deletions(-) create mode 100644 goodwe_controller/test_ev19.py create mode 100644 goodwe_controller/tools/ev19_reserve.py diff --git a/goodwe_controller/DECISIONS/EV-04-manual-mode.md b/goodwe_controller/DECISIONS/EV-04-manual-mode.md index 2c2b9e3..6f0e852 100644 --- a/goodwe_controller/DECISIONS/EV-04-manual-mode.md +++ b/goodwe_controller/DECISIONS/EV-04-manual-mode.md @@ -152,6 +152,13 @@ up to 1.8 kW; the 40 Wh floor fixes that.) 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. +- **A battery rise is house only once a second reading shows it** (EV-19, EV-15 + rig F-B). At the reserve inverter-b goes on following the house, so its + output rises; the reading shows it one cycle before P1 does, and the house + figure (meter + battery) counted that power as house. `_car_need_house` + latched and the alarm stood. For the house figure, a reading above both + earlier ones counts only up to the higher of them; the credit stays the lower + of the last two readings. - **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 479f737..da37a70 100644 --- a/goodwe_controller/app/ctl_car.py +++ b/goodwe_controller/app/ctl_car.py @@ -58,7 +58,7 @@ 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_batt_prev = self._car_batt_prev2 = 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 @@ -414,7 +414,14 @@ class CarMixin: 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 + prev2, self._car_batt_prev2 = self._car_batt_prev2, prev self._car_batt_prev = now + # EV-19: the reading can show a rise one cycle before the meter does + # (the batteries pick up the house at the reserve), so a reading above + # both earlier ones is not yet counted as house. + seen = now + if now is not None and prev is not None and prev2 is not None: + seen = min(float(now), max(float(prev), float(prev2))) wants = bool(guard is not None and guard.engaged and guard.blind is None and (guard.wanted_w or 0.0) > 0.0) @@ -436,7 +443,7 @@ class CarMixin: 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) + self._car_lands_over(excl, seen, batt, target_w) if w is None or batt is None or not wants \ or not (guard.saturated or guard.floor_limited): return False diff --git a/goodwe_controller/test_ev19.py b/goodwe_controller/test_ev19.py new file mode 100644 index 0000000..bf4077c --- /dev/null +++ b/goodwe_controller/test_ev19.py @@ -0,0 +1,564 @@ +"""EV-19: no floor alarm when the batteries first reach the peak reserve early +in a Manual car session (EV-15 rig F-B). `python3 -B test_ev19.py` + +The rig: one PEAK_GUARD_FLOOR_LIMITED ERROR, one `goodwe_peak_soc_floor` and +one red sample the moment the batteries reached the reserve, while the excess +was smaller than the car. Reproduced (T1): at the reserve inverter-b goes on +following the house, so its output RISES in that cycle. The battery reading +shows the rise one cycle before the P1 sample does, and EV-18's "house" +(meter + what the batteries give now) counted the new battery power as house +load. That latched `_car_need_house` for the quarter: the alarm stood until +the guard stopped wanting power. Now a rise the reading shows above both +earlier readings is not counted as house until a second reading confirms it. +The credit stays the lower of the last two readings. + +T-ids are the test plan's (reports/EV-19-test-plan.md). "base" is 43b0db7. +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 ctl_car, tariff # noqa: E402 +from named_absence import first, nth, present # noqa: E402 +import ev19_reserve as V # noqa: E402 + +fails = [] + + +def check(name, cond): + print(f" {'ok ' if cond else 'FAIL'} {name}") + if not cond: + fails.append(name) + + +AIM = V.AIM +CAR = V.CAR + +# =========================================================================== # +print("1. UNIT: car_cycle in the reserve cycle (a real `_carq`)") +# =========================================================================== # +BS = datetime(2026, 11, 20, 20, 30, tzinfo=timezone.utc) # a quarter edge + + +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.""" + floor_limited, saturated = True, False + floor_w, able_w, ceiling_w = 0.0, None, AIM + 50.0 + engaged, blind, wanted_w, within_aim = True, None, 300.0, False + + +def urun(secs, grid, batt, w=lambda t: CAR): + """`car_cycle` once per second of `secs` (seconds from the edge). `grid(t)` + is the meter, `batt(t)` the site battery reading. {t: car_explains}.""" + c = _Car() + 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 + c._now = 10000.0 + t + c.w, c.site_batt_w = w(t), batt(t) + c.car_cycle(p, _G(), AIM, None) + out[t] = c.car_explains + return out + + +def run_of(d, t0, t1): + return [d[t] for t in sorted(d) if t0 <= t <= t1] + + +def rise(at, lo, hi): + """A battery reading that steps from `lo` to `hi` at `at`.""" + return lambda t: lo if t < at else hi + + +def meter(house, b, lag=1): + """The P1 figure: house + car - what the batteries gave `lag` cycles ago + (the reading leads the meter by that much).""" + return lambda t: house + CAR - b(t - lag) + + +HB = AIM + 520.0 - CAR # F-B: house + car at batteries 0 W = aim + 520 +b2 = rise(1, 0.0, 4600.0) +u2 = urun(range(-5, 61), meter(HB, b2), b2) +print(f" T2 unit E-1..E+3: {run_of(u2, -1, 3)}") +check("T2 unit: b starts following the house at the reserve (0 -> 4 600 W) " + "and the reading shows it one cycle before the meter: the car explains " + "every cycle, the rise cycle E+1 among them (base: not from E+1)", + all(run_of(u2, 0, 60)) and len(run_of(u2, 0, 60)) == 61) +u2s = urun(range(-5, 61), meter(HB, b2, lag=0), b2) +check("T2 unit: the same rise with the meter in step: explained every cycle", + all(run_of(u2s, 0, 60)) and len(run_of(u2s, 0, 60)) == 61) + +# T4: the landing without the car at aim + 9 / + 11 W in the rise cycle. The +# rise is at the edge, so with the lower reading credited (0 W) the house +# alone lands at exactly `house`. +b4 = rise(0, 0.0, 800.0) +u409 = urun(range(-3, 10), meter(AIM + 9.0, b4), b4) +u411 = urun(range(-3, 10), meter(AIM + 11.0, b4), b4) +print(f" T4 unit +9 {run_of(u409, 0, 3)} +11 {run_of(u411, 0, 3)}") +check("T4 unit: the house alone at aim + 9 W in the rise cycle: the car " + "explains from E+0 (base: no)", all(run_of(u409, 0, 9)) + and len(run_of(u409, 0, 9)) == 10) +check("T4 unit: at aim + 11 W it does not, from E+0 (as base)", + not any(run_of(u411, 0, 9)) and len(run_of(u411, 0, 9)) == 10) + +# N6 / T7(a): an unknown reading credits nothing; the lower reading is +# credited, not the higher or the last known one. +b7 = lambda t: None if t == 1 else b2(t) # noqa: E731 +u7 = urun(range(-5, 30), meter(HB, b2), b7) +check("T7(a) unit: the battery reading unknown in the rise cycle: nothing " + "explained in that cycle (no last-known W), explained from the next", + u7.get(1) is False and u7.get(0) is True and all(run_of(u7, 2, 29))) +u6 = urun(range(-5, 30), meter(AIM + 11.0 + 400.0, lambda t: 400.0, lag=0), + lambda t: 800.0 if t == 3 else 400.0) +check("N6 unit: b at 400 W, the house alone with it at aim + 11 W, one " + "reading of 800 W at E+3: not explained in any cycle", + not any(run_of(u6, 0, 29))) +# The rise counts as house once a second reading confirms it: b steps to +# 800 W and the meter, one cycle late, shows a house of aim + 811 W (the +# house steps with it), so with b's 800 W the house alone misses by 11 W. +b8 = rise(5, 0.0, 800.0) +u8 = urun(range(0, 30), lambda t: (AIM - 500.0 if t < 5 else AIM + 811.0) + + CAR - b8(t - 1), b8) +print(f" N6 unit house step with a rise E+4..E+8: {run_of(u8, 4, 8)}") +check("N6 unit: a house step that comes with a battery rise is latched at " + "most one cycle after the rise (E+6), and stays latched", + all(run_of(u8, 0, 4)) and not any(run_of(u8, 6, 29))) + +# =========================================================================== # +print("\n2. THE REAL CONTROLLER AT THE RESERVE (N=2, tools/ev19_reserve.py)") +# =========================================================================== # +JOBS = V.jobs() +RES = V.run_many(JOBS) + + +def res(name): + return RES[name] + + +def trusted(x): + return x["w"] is not None and x["w"] > 0.0 and not x["contra"] + + +def bad(x): + return bool(x["alarm"] or x["red"] or x["err"]) + + +def hits(r, t0=-10, t1=60): + """T1's reproduction: an alarm, red sample or ERROR in R-10..R+60 in a + cycle where the car figure is trusted (every T1 shape lands under the aim + without the car, so the car explains there).""" + return [int(x["t"] - r.R) for x in r.win(t0, t1) if bad(x) and trusted(x)] + + +def show(name): + r = res(name) + print(f" {name}: alarms {r.rel_alarms()} edges {r.edges()} errors " + f"{r.errors()} red {len(r.red())} s cmd {r.cmd}") + + +# Measured on base 43b0db7 with this file's own runs: the seconds from R of +# goodwe_peak_soc_floor in the honest shapes, which must not come later now. +BASE_ALARMS = { + "T4 +11 manual": [0, 857], "T5 t1 manual": [2], "T5 t4 manual": [11], + "T5 tau5 manual": [2], "T6 step R+0 manual": [2], + "T6 step R+1 manual": [2], "T6 step R+5 manual": [6], + "T7(a) T5": [2], "T7(b) T5": [2], "T8(c) frozen, the car stops": [2], + "T9(a) T5 b lost at R": [2], "T9(a) T5 b lost at R-1": [2], + "T9(b) T5 P1 5 s late at R": [5], "T10 T5 twin": [2], + "T10 T5 restart R-2": [2], "T10 T5 restart R+2": [2], + "T11 T5 R=E-1": [2], "T11 T5 R=E+0": [0, 2], "T11 T5 R=E+1": [0, 2], + "T11 T5 R=E+43": [2], "T12 T5 1->3 at R-15": [2], + "T12 T5 1->3 at R+5": [2], "T13(a) draws 100 W manual": [0, 857], + "T14(c) N=1 T5": [2], "T15 honest manual": [13], + "T16 x10 T5 manual": [20], "T16 x10 T6 manual": [20], + "T16 mono1 T5 manual": [20], "T16 mono1 T6 manual": [20], + "T16 x10 T11 T5 R=E-10": [20], "T16 x10 T11 T5 R=E+0": [0, 20], + "T16 x10 T11 T5 R=E+10": [0, 20], "T16 x10 T11 T5 R=E+40": [20], + "T16 mono1 T11 T5 R=E-10": [20], "T16 mono1 T11 T5 R=E+0": [0, 20], + "T16 mono1 T11 T5 R=E+10": [0, 20], "T16 mono1 T11 T5 R=E+40": [20], + "T16 mono1 T3 t1 bw=0": [600], "T16 mono1 T3 t1 bw=2000": [700], + "T16 mono1 T3 t1 bw=4250": [800], "T16 mono1 T3 t4 bw=0": [600], + "T16 mono1 T3 t4 bw=2000": [700], "T16 mono1 T3 t4 bw=4250": [800], +} +# The T1 cells that reproduce F-B on base (G0): b following the house from R. +BASE_REPRO = [f"T1 core bw={bw} t2 rp={rp}" for bw in (0, 400, 800) + for rp in (30, 100, 110, 180, 600)] + [ + "T1 d: x10 wall+mono t2 bw=1200", "T1 d: x10 wall, mono x1 t2 bw=1200"] + + +def as_base(k): + """The same alarm seconds as base.""" + return res(k).rel_alarms() == BASE_ALARMS[k] + +# --- T1: the reproduction grid ------------------------------------------------ # +T1 = sorted(k for k in JOBS if k.startswith("T1 ")) +C5 = [k for k in T1 if k.startswith("T1 b: energy")] +rep = {k: hits(res(k)) for k in T1} +print(f" T1 cells {len(T1)}; reproducing on this tree: " + f"{sorted(k for k in T1 if rep[k])}") +check("T1: no grid cell reproduces F-B: no notice, ERROR or red sample in " + "R-10..R+60 while the car figure is trusted (base: the " + f"{len(BASE_REPRO)} tau2 cells with b at 0-800 W at R)", + not [k for k in T1 if rep[k]]) +for k in C5: + show(k) +check("T1 C5 cells (the energy meter late or never stepping): the figure is " + "untrusted (contradicted or unknown) wherever the alarm stands, as EV-18 " + "Expected 5 wants", all(not trusted(x) for k in C5 + for x in res(k).win(-10, 60) if bad(x))) + +# --- T2: THE red-before test -------------------------------------------------- # +T2 = BASE_REPRO +for k in T2: + r = res(k) + lim = [x for x in r.win(0, 60) if x["floor_lim"]] + check(f"T2 {k[3:]}: no notice, no ERROR, no red sample R-60..R+900; the " + f"car explains every floor-limited cycle of R..R+60", + r.quiet(-60, 900) and bool(lim) and all(x["explains"] for x in lim)) +check("T2 PRECONDITION: every reproducing cell is in the grid (b at 0, 400, " + "800 W x 5 plug-in times; x10 and mono x1 with b at 1 200 W)", + len(T2) == 17 and all(k in RES for k in T2)) +r2 = res("T1 core bw=0 t2 rp=180") +x1 = r2.at(1) +check("T2 PRECONDITION: in the rise cycle the reading shows b's 4 600 W, the " + "guard is floor-limited and wants power", + present(x1) and x1["batt"] == 4600.0 and x1["floor_lim"] + and x1["wants"]) + +# --- T3: the battery W sweep --------------------------------------------------- # +T3 = sorted(k for k in JOBS if k.startswith("T3 ")) +loud = [k for k in T3 if not res(k).quiet(-60, 900)] +print(f" T3 cells {len(T3)}, with an alarm or red sample: {loud}") +check("T3: tau1 and tau2, b at R 0..4 600 W in 200 W steps and 9 600 W " + "(tau5): no alarm and no red sample in any cell", loud == []) + +# --- T4 controller ------------------------------------------------------------- # +for k in ("T4 +9 manual", "T4 +11 manual", "T4 +11 off"): + show(k) +check("T4: the house alone at aim + 9 W, b following the house from R: no " + "alarm (base: R+1)", res("T4 +9 manual").quiet(-60, 900)) +check("T4: at aim + 11 W the alarm in the same cycle as base and as Off " + "(R+0)", as_base("T4 +11 manual") + and res("T4 +11 manual").rel_alarms()[:1] + == res("T4 +11 off").rel_alarms()[:1] == [0]) + + +# --- T5 / T6: honest alarms ---------------------------------------------------- # +def same_as_off(k): + on, off = res(f"{k} manual"), res(f"{k} off") + show(f"{k} manual") + show(f"{k} off") + a = on.rel_alarms() + return (bool(a) and a == off.rel_alarms() + and on.errors() == off.errors()) + + +for k in ("T5 t1", "T5 t4", "T5 tau5"): + check(f"{k}: the excess is more than the car: PEAK_GUARD_FLOOR_LIMITED, " + f"the ERROR and the notice at the same second as Off and as base", + same_as_off(k) and as_base(f"{k} manual")) + check(f"{k}: the car explains no cycle", + not any(x["explains"] for x in res(f"{k} manual").tr)) +for n in (0, 1, 5): + k = f"T6 step R+{n}" + show(f"{k} manual") + check(f"{k}: the house steps to aim + 1 900 W at R+{n}: the alarm and " + f"the ERROR at the same second as base, R+{BASE_ALARMS[k + ' manual'][0]}" + f" (no grace, no hold; Off alarms from R+0, where the car explains)", + as_base(f"{k} manual") and res(f"{k} manual").errors() + == BASE_ALARMS[f"{k} manual"]) + + +# --- T7: unknown values -------------------------------------------------------- # +def only_while_unknown(r, t0=-60, t1=900): + """Every alarm / red cycle has an untrusted car figure in it or in the + cycle before (the alarm clears within 1 cycle of the first trusted one).""" + prev = None + for x in r.win(t0, t1): + if bad(x) and trusted(x) and (prev is None or trusted(prev)): + return False + prev = x + return True + + +show("T7(a) T2") +check("T7(a) T2: inverter-a's reading unknown at R and R+1: no alarm", + res("T7(a) T2").quiet(-60, 900)) +check("T7(a) T5: the alarm at the same second as base and as Off (the " + "guard grades nothing without the reading)", as_base("T7(a) T5") + and res("T7(a) T5").rel_alarms() == res("T7(a) T5 off").rel_alarms()) +show("T7(b) T2") +check("T7(b) T2: the charger unavailable at R: an alarm only while the " + "figure is unknown, cleared within 1 cycle of the first trusted one", + only_while_unknown(res("T7(b) T2"))) +check("T7(b) T5: the alarm at the same second as base and as Off", + as_base("T7(b) T5") + and res("T7(b) T5").rel_alarms() == res("T7(b) T5 off").rel_alarms()) + +# --- T8: a stale car figure ---------------------------------------------------- # +r8a = res("T8(a) Off 120 s, Manual R-5") +show("T8(a) Off 120 s, Manual R-5") +check("T8(a): nothing before Manual is trusted (car_alarm_w None)", + all(x["w"] is None for x in r8a.tr if x["t"] < r8a.R - 5)) +check("T8(a): after Manual, as T2: no alarm R-60..R+900", + r8a.quiet(-60, 900)) +r8b = res("T8(b) stale R-5..R+20") +show("T8(b) stale R-5..R+20") +check("T8(b) PRECONDITION: the figure goes untrusted (older than 15 s)", + any(x["w"] is None for x in r8b.win(0, 25))) +check("T8(b): the alarm only while the figure is stale, cleared within 1 " + "cycle of the first fresh one", only_while_unknown(r8b)) +r8c, r8co = res("T8(c) frozen, the car stops"), res("T8(c) off") +show("T8(c) frozen, the car stops") +a8 = nth(r8c.rel_alarms(), 0) +untr = first(int(x["t"] - r8c.R) for x in r8c.tr + if x["t"] >= r8c.R - 30 and not trusted(x)) +check("T8(c): the alarm at base's second, as Off, within 114 s of the stop", + present(a8) and a8 <= -30 + 114 + and as_base("T8(c) frozen, the car stops") + and r8c.rel_alarms() == r8co.rel_alarms()) +check("T8(c): never explained after the figure goes untrusted", + present(untr) and not any(x["explains"] for x in r8c.tr + if x["t"] >= r8c.R + untr)) + +# --- T9: comms ------------------------------------------------------------------ # +for nm in ("T2", "T5"): + for k in (f"T9(a) {nm} b lost at R", f"T9(a) {nm} b lost at R-1", + f"T9(b) {nm} P1 5 s late at R"): + show(k) + r = res(k) + if nm == "T2": + check(f"{k}: no alarm edge", r.edges() == []) + else: + check(f"{k}: the alarm at the base second " + f"(R+{BASE_ALARMS[k][0]})", as_base(k)) + +# --- T10: a restart ------------------------------------------------------------ # +for nm in ("T2", "T5"): + tw = res(f"T10 {nm} twin") + for k in (-2, 2): + r = res(f"T10 {nm} restart R{k:+d}") + show(f"T10 {nm} restart R{k:+d}") + if nm == "T2": + check(f"T10 T2 restart at R{k:+d}: no notice, no red sample, as " + f"the unrestarted twin", r.quiet(-60, 900) + and tw.quiet(-60, 900)) + else: + check(f"T10 T5 restart at R{k:+d}: the alarm at the base second " + f"and the twin's, red as the twin", + as_base(f"T10 T5 restart R{k:+d}") and as_base("T10 T5 twin") + and len(r.red()) == len(tw.red())) + +# --- T11: the quarter edge ------------------------------------------------------ # +for rr in (-1, 0, 1, 43): + r = res(f"T11 T2 R=E{rr:+d}") + show(f"T11 T2 R=E{rr:+d}") + wa = [(int(x["t"] - r.E), x["within_aim"]) for x in r.tr + if r.E - 1 <= x["t"] <= r.E] + print(f" T11 T2 R=E{rr:+d}: within_aim at E-1/E+0 {wa} (F1, not " + f"asserted)") + check(f"T11 T2 R=E{rr:+d}: no alarm across the edge", r.quiet(-60, 900)) + check(f"T11 T5 R=E{rr:+d}: the alarm at the same seconds as base and " + f"as Off", as_base(f"T11 T5 R=E{rr:+d}") + and res(f"T11 T5 R=E{rr:+d}").rel_alarms() + == res(f"T11 T5 R=E{rr:+d} off").rel_alarms()) +pre = res("T11 C4 T2 R=E+1") +show("T11 C4 T2 R=E+1") +wa = [(int(x["t"] - pre.E), x["within_aim"]) for x in pre.tr + if pre.E - 1 <= x["t"] <= pre.E] +print(f" T11 C4: within_aim at E-1/E+0 {wa} (F1, not asserted)") +check("T11 C4 PRECONDITION: the guard wants power in the last 60 s of the " + "old quarter (house 13 350 W all along, car 1 380 W)", + all(x["wants"] for x in pre.tr if pre.E - 60 <= x["t"] < pre.E)) +sat = [x for x in pre.win(-60, -1) if x["red"]] +print(f" T11 C4: red before R {[int(x['t'] - pre.R) for x in sat]} (near " + f"the old quarter's end, the guard saturated: SAFETY-81's row)") +check("T11 C4: SAFETY-126's latch carried over the edge, the reserve at " + "E+1: no floor notice or ERROR R-60..R+900, no red sample from R; " + "before R red only where the guard is saturated (not the floor alarm)", + pre.quiet(0, 900) and not [t for t in pre.rel_alarms() if t >= -60] + and all(x["lim"] and not x["floor_lim"] and not x["alarm"] + for x in sat)) + +# --- T12: our own phase change -------------------------------------------------- # +for k in (-15, 5): + r = res(f"T12 T2 1->3 at R{k:+d}") + show(f"T12 T2 1->3 at R{k:+d}") + check(f"T12 T2, 1->3 at R{k:+d}: no alarm during our own pause or after", + r.quiet(-60, 900)) + on, off = res(f"T12 T5 1->3 at R{k:+d}"), res(f"T12 T5 1->3 at R{k:+d} off") + show(f"T12 T5 1->3 at R{k:+d}") + a, ao = nth(on.rel_alarms(), 0), nth(off.rel_alarms(), 0) + check(f"T12 T5, 1->3 at R{k:+d}: the alarm at base's second, no later " + f"than Off's and within OWN_PAUSE_MAX_S " + f"({ctl_car.OWN_PAUSE_MAX_S:.0f} s) of the request", + present(a, ao) and a <= ao and as_base(f"T12 T5 1->3 at R{k:+d}") + and a <= max(k, 0) + ctl_car.OWN_PAUSE_MAX_S) + +# --- T13: a wrong charger reply ------------------------------------------------- # +r13 = res("T13(a) draws 400 W manual") +show("T13(a) draws 400 W manual") +check("T13(a) 400 W: the energy meter never contradicts a 1 380 W figure " + "when 400 W is drawn (CORR_RATIO 0.5 and its slack; EV-18 T9(b)), so " + "nothing is uncorroborated and the figure explains; base's R+1 alarm " + "was F-B", not any(x["contra"] for x in r13.tr) + and all(x["w"] == CAR for x in r13.win(-60, 60))) +r13c = res("T13(a) draws 100 W manual") +show("T13(a) draws 100 W manual") +show("T13(a) draws 100 W off") +c0 = first(x["t"] for x in r13c.tr if x["contra"]) +a13 = nth(r13c.rel_alarms(), 0) +check("T13(a) 100 W PRECONDITION: the energy meter contradicts the figure " + "within 104 + 10 s of the plug-in (R-180)", + present(c0) and c0 <= r13c.R - 180 + 114) +check("T13(a) 100 W: the alarm at base's second and Off's, and never " + "explained after the contradiction in that quarter", + present(a13) and as_base("T13(a) draws 100 W manual") + and r13c.rel_alarms() == res("T13(a) draws 100 W off").rel_alarms() + and not any(x["explains"] for x in r13c.tr + if present(c0) and x["t"] >= c0 + and x["block"] == r13c.at(0)["block"])) +for k in ("T13(b) the write ignored, 0 A", "T14(a) 0 W in C", + "T14(a) idle B"): + show(f"{k} manual") + check(f"{k}: the car at 0 W explains nothing: the alarm as Off", + same_as_off(k) and not any( + x["explains"] for x in res(f"{k} manual").tr)) + +# --- T14: configuration -------------------------------------------------------- # +show("T14(b) ev_charger off") +check("T14(b) ev_charger off: no explanation, the alarm as Off", + res("T14(b) ev_charger off").rel_alarms() + == res("T14(b) off").rel_alarms() != [] + and not any(x["explains"] for x in res("T14(b) ev_charger off").tr)) +for tj in ("t1", "t4"): + show(f"T14(c) N=1 anchor {tj}") + check(f"T14(c) N=1 anchor {tj}: no alarm", + res(f"T14(c) N=1 anchor {tj}").quiet(-60, 900)) +check("T14(c) N=1 T5: the alarm at the same second as base and as Off", + as_base("T14(c) N=1 T5") and res("T14(c) N=1 T5").rel_alarms() + == res("T14(c) N=1 T5 off").rel_alarms()) + +# --- T15: one battery first ----------------------------------------------------- # +for k in ("T15 anchor manual", "T15 honest manual", "T15 honest off"): + show(k) +check("T15 anchor: a at the reserve at R, b at R+360: no alarm", + res("T15 anchor manual").quiet(-60, 900)) +check("T15 honest (house 19 000 W): the alarm after ALARM_HOLD_S at the " + "base second (R+13; Off R+11, as base)", as_base("T15 honest manual")) + +# --- T16: x10 -------------------------------------------------------------------- # +for xn in ("x10", "mono1"): + r = res(f"T16 {xn} T2") + show(f"T16 {xn} T2") + check(f"T16 {xn} T2 PRECONDITION: the rise cycle reads b's 4 600 W", + present(r.at(10)) and r.at(10)["batt"] == 4600.0) + check(f"T16 {xn} T2: no alarm (base: R+10, 10 red cycles)", + r.quiet(-60, 900)) + t3 = sorted(k for k in JOBS if k.startswith(f"T16 {xn} T3 ")) + print(f" T16 {xn} T3 alarms " + f"{[(k[10:], res(k).rel_alarms()) for k in t3]}") + check(f"T16 {xn} T3 ({len(t3)} cells): no alarm R-60..R+300", + all(res(k).quiet(-60, 300) for k in t3)) + # mono x1 / wall x10: the car's energy is counted on the monotonic clock, + # a tenth of the wall's, so its share of the quarter is short and the + # house latch sets late in the quarter (EV-18 F2, out of scope), as base. + check(f"T16 {xn} T3: any later alarm at base's second (EV-18 F2)", + all(as_base(k) if k in BASE_ALARMS else res(k).quiet(-60, 900) + for k in t3)) + for k in ("T5", "T6"): + show(f"T16 {xn} {k} manual") + check(f"T16 {xn} {k}: the alarm at the base second", + as_base(f"T16 {xn} {k} manual")) + check(f"T16 {xn} T7(b) T2: an alarm only while the figure is unknown", + only_while_unknown(res(f"T16 {xn} T7(b) T2"))) + for rr in (-10, 0, 10, 40): + check(f"T16 {xn} T11 T2 R=E{rr:+d}: no alarm", + res(f"T16 {xn} T11 T2 R=E{rr:+d}").quiet(-60, 900)) + check(f"T16 {xn} T11 T5 R=E{rr:+d}: the alarm at the base seconds", + as_base(f"T16 {xn} T11 T5 R=E{rr:+d}")) + +# --- T17: no flicker -------------------------------------------------------------- # +r17 = res("T17 flicker") +print(f" T17 alarm edges per quarter {r17.edges_per_quarter()}") +check("T17: the house alone straddles aim + 10 W, the batteries cross the " + "reserve 3 times: at most one alarm edge per quarter", + all(v <= 1 for v in r17.edges_per_quarter().values())) + +# --- N2: the car explains only with a trusted, non-zero figure ----------------- # +bad2 = sorted(k for k, r in RES.items() + if any(x["explains"] and not trusted(x) for x in r.tr)) +check(f"N2: car_explains never True with car_alarm_w None, 0 W or " + f"contradicted, in any of the {len(RES)} runs: {bad2}", bad2 == []) + +for k in ("N2 no energy entity", "N2 reports 11 kW at 6 A"): + show(f"{k} manual") + check(f"{k}: the figure is not trusted for the alarm (no corroboration, " + f"or capped by the read-back): nothing explained, the alarm as Off", + same_as_off(k) and not any( + x["explains"] for x in res(f"{k} manual").tr)) +check("N2 PRECONDITION: the charger without an energy entity reports a " + "fresh 1 380 W", all(x["car_raw"] == CAR for x in + res("N2 no energy entity manual").win(-60, 60))) + +# --- N4 / T20: no control change --------------------------------------------- # +for nm in ("T2", "T5"): + a = res("T1 core bw=0 t2 rp=180") if nm == "T2" else res("T10 T5 twin") + check(f"N4 {nm}: the claim, the floor, the setpoints and the charger " + f"writes are those of the same run with the car never explaining", + a.cmd == res(f"N4 {nm} explain off").cmd) + +# --- N5: at most one floor-alarm edge per quarter ------------------------------ # +# Base 43b0db7 has 2 edges in the first quarter of these runs: the guard lets +# go for one cycle at R+1 (the battery reads 0 W, the meter does not show it +# yet), in Off and in the C5 cells too. Not EV-19's; head must not add one. +BASE_TWO = ["T1 b: energy first step late", "T1 b: energy never steps", + "T11 T5 R=E+0", "T11 T5 R=E+0 off", "T11 T5 R=E+1", + "T11 T5 R=E+1 off", "T16 mono1 T11 T5 R=E+0", + "T16 mono1 T11 T5 R=E+10", "T16 mono1 T6 off", + "T16 x10 T11 T5 R=E+0", "T16 x10 T11 T5 R=E+10", "T16 x10 T6 off", + "T6 step R+0 off", "T6 step R+1 off", "T6 step R+5 off"] +many = sorted(k for k, r in RES.items() + if any(v > (2 if k in BASE_TWO and q == 0 else 1) + for q, v in r.edges_per_quarter().items())) +check(f"N5: at most one floor-alarm edge per quarter in every run, and no " + f"more than base where base has two ({len(RES)} runs): {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/ev19_reserve.py b/goodwe_controller/tools/ev19_reserve.py new file mode 100644 index 0000000..319c5b4 --- /dev/null +++ b/goodwe_controller/tools/ev19_reserve.py @@ -0,0 +1,752 @@ +"""EV-19: the real Controller, N=2, when the batteries first reach the peak +reserve `R` early in a Manual car session (EV-15 F-B). Used by test_ev19.py. + + python3 tools/ev19_reserve.py # the T1 grid, one row per cell + +The units stand at 21 % and give `bw` W (`force`) until `R`, where both read +19 %; after `R` they follow the trajectory `traj`. The house is set so that +house + car with the batteries at 0 W lands at aim + `over` W (F-B: +520 W, +less than the 1 380 W car). Manual is set, then the car plugs in, `rp` s +before `R`. The run starts `E` s before a quarter edge (rig.BASE moved back), +so `R = E + r_rel`. One dict per cycle, taken after it. + +Trajectories after R: t1 both 0 W; t2 a 0 W, b follows the house (the loop +below the reserve covers house + car, up to b's rating); t3 both ramp to 0 W +over 3 cycles; t4 as t1, but every battery reading is 10 s old (the rig reads +battery W every 10 fake s, P1 every 5) while P1 is fresh; t4r as t1, but P1 +is 5 s late while the battery reading is fresh. +""" + +import hashlib +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 ev18_peak as H # noqa: E402 +import opt11_identity as rig # noqa: E402 +import safety81_sim as s81 # noqa: E402 +from app import peakguard # noqa: E402 +from chargersim import SimCharger # noqa: E402 + +AIM = H.AIM +CAR = 1380.0 +FLOOR = H.FLOOR +RATE = {"a": 5000.0, "b": 4600.0} +OPTS = H.OPTS +OPTS1 = {"peak_soc_floor": 20, "inverters": [OPTS["inverters"][0]]} + + +class Meter(SimCharger): + """A charger whose energy meter shows no 10 Wh step until `hold_until` + (sim seconds; None: always live, float('inf'): never).""" + + hold_until = None + _held = None + + def _build(self): + if self.hold_until is None or self.t >= self.hold_until: + self._held = None + return super()._build() + if self._held is None: + self._held = self.kwh + keep, self.kwh = self.kwh, self._held + try: + return super()._build() + finally: + self.kwh = keep + + +class Draw(Meter): + """A charger that draws `real_w` while charging and reports `say_w` + (as test_ev18's). `c_at_0`: it stays in mode3 C while drawing 0 W.""" + + def __init__(self, real_w, say_w, c_at_0=False, **kw): + super().__init__(**kw) + self.real_w, self.say_w, self.c_at_0 = real_w, say_w, c_at_0 + + def target_w(self): + if super().target_w() <= 0.0: + return 0.0 + return self.real_w + + def tick(self, seconds=1.0): + super().tick(seconds) + if self.c_at_0 and self.state == "B" and not self.full: + self.state = "C" + + def _build(self): + keep, self._frozen_w = self._frozen_w, self.say_w + try: + return super()._build() + finally: + self._frozen_w = keep + + +class Plant(H.Plant): + """`batt_lag`: every battery reading is that many s old. `p1_lag` with + `p1_from`: P1 that many s late from that second on.""" + + batt_lag = 0.0 + p1_lag = 0.0 + p1_from = 0.0 + house = None + + def batt_of(self, u, at): + f = self.force.get(u) + if f is not None: + return float(f(at, self)) + return P.CarPlantN.batt_of(self, u, at) + + def grid(self, at): + if self.p1_lag and at >= self.p1_from: + at = at - self.p1_lag + return super().grid(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 + if self.batt_lag and e.startswith("sensor.batt_") \ + and e[-1] in self.socs: + return self.batt_of(e[-1], self.t - self.batt_lag) + return await P.CarPlantN.number(self, e, invert) + + +def split(bw, units="ab"): + """`bw` over the units, each capped at its rating.""" + if len(units) == 1: + return {units: min(bw, RATE[units])} + a = min(RATE["a"], bw / 2.0) + b = min(RATE["b"], bw - a) + a = min(RATE["a"], bw - b) + return {"a": a, "b": b} + + +def traj_fn(u, traj, before, R, house, step=1): + """Unit `u`'s W at time `at`: `before` until the first cycle after R + (R + `step`), then the trajectory. P1 is sampled 0.3 s before each cycle, + so the battery reading shows a change one cycle before the meter does.""" + def f(at, plant): + if at < R + step: + return before + if traj in ("t1", "t4", "t4r"): + return 0.0 + if traj == "t2": + if u == "a": + return 0.0 + return min(RATE["b"], house(at) + plant.ch.power_w) + if traj == "t3": + k = int((at - R) // step) + return before * max(0.0, (3 - k) / 3.0) + if traj == "keep": + return before + raise ValueError(traj) + return f + + +def run(*, bw=4250.0, traj="t1", rp=180, r_rel=43, order="manual", + energy="ok", x=1, mono_x=None, aim=AIM, over=520.0, house_w=None, + house_fn=None, car_a=6, n=2, extra=None, rel=None, lost=None, + after=900, + soc_after=None, soc0=21.0, mode="manual", sim=None, + explain_off=False, latch_off=False, force=None, plug_at=None, + man_at=None, opts=None, pre_w=H.PRE_W): + """One run; returns (run, trace, meta). `over`: house + car at batteries + 0 W lands at aim + `over` W (ignored with `house_w`). `order`: 'manual' + (Manual at plug-in - 3 s), 'plug' (plug-in at R-185, Manual at R-180), + 'off120' (plug-in and charging in Off from R-180, Manual at R-60). + `energy`: 'ok', 'late' (first 10 Wh step at plug-in + 150 s), 'never'. + `mode`: 'manual' or 'off' (Off throughout: the base for honest alarms). + `house_fn`: fn(t, R) for the house after the step. `extra`: events at + run seconds, `rel`: at seconds from R. `lost`: {unit: seconds from R}. + `plug_at` / `man_at`: plug-in / Manual at these seconds from R (override + `order`). `force`: {unit: fn(at, plant) or None (the unit obeys)}. + `opts`: added to the options. `pre_w`: the house before its step.""" + units = "ab" if n == 2 else "a" + step = int(x) + if order == "plug": + lead = 185 + elif order == "off120": + lead = 180 + else: + lead = rp + 3 + if plug_at is not None or man_at is not None: + lead = -min(v for v in (plug_at, man_at) if v is not None) + E = 150 + while E + r_rel - lead - 2 * step < 10: + E += 150 + E = int(-(-E // step) * step) + R = E + r_rel + if x != 1: + R = int(-(-R // step) * step) + hw = (aim + over - CAR) if house_w is None else house_w + t_house = min(E - 120, R - lead - step) + if x != 1: + t_house = int(t_house // step * step) + + def house(t): + if t < t_house: + return pre_w + if house_fn is not None: + return house_fn(t, R) + return hw + + sp = split(bw, units) + frc = {u: traj_fn(u, traj, sp[u], R, house, step) for u in units} + frc.update(force or {}) + soc_after = soc_after or {u: 19.0 for u in units} + lagb = 10.0 if traj == "t4" else 0.0 + cls = type("Plant", (Plant,), { + "force": frc, "batt_lag": lagb, + "lost": {u: {R + k for k in v} for u, v in (lost or {}).items()}, + "p1_lag": 5.0 if traj == "t4r" else 0.0, "p1_from": float(R)}) + + s = sim or Meter(setpoint_a=car_a) + if energy == "never": + s.hold_until = float("inf") + if x != 1: + tick = s.tick + s.tick = lambda secs=1.0: tick(secs * x) + + if order == "plug": + t_plug, t_man = R - 185, R - 180 + elif order == "off120": + t_plug, t_man = R - 180, R - 60 + else: + t_plug, t_man = R - rp, R - rp - 3 + if plug_at is not None: + t_plug = R + plug_at + if man_at is not None: + t_man = R + man_at + if x != 1: + t_plug = int(t_plug // step * step) + t_man = int(t_man // step * step) + if t_man == t_plug and order != "plug": + t_man -= step + + tr = [] + n_err = [len(H.ERR.rec)] + + def hook(plant, c): + 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 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 = [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 H.ERR.rec[n_err[0]:] + if "may not draw the battery lower" in m] + n_err[0] = len(H.ERR.rec) + cl = peakguard.claim(g) if g is not None else None + mono = c.car_now() + tr.append({ + "t": plant.t, "explains": c.car_explains, + "lim": bool(g is not None and (g.floor_limited + or g.saturated)), + "floor_lim": bool(g is not None and g.floor_limited), + "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), + "wanted": None if g is None else g.wanted_w, + "target": None if g is None else g.target_w, + "alarm": c._peak_floor_limited, "red": red, "err": errs, + "w": c.car_alarm_w(), "car_raw": c.car.car_w(mono), + "batt": c.site_batt_w, + "true_batt": plant.batt(plant.t), + "need_real": c._car_need_real, "need_excl": c._car_need_excl, + "need_house": c._car_need_house, "over_now": c._car_over_now, + "contra": c._car_contra_block is not None and ( + c._peak_proj_real is not None + and c._car_contra_block + == c._peak_proj_real.block_start), + "idle": c._car_idle(mono), "peak_needed": c._peak_needed, + "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 + + def set_manual(p, c): + c._car_action("car_mode", "manual", c.car_now()) + + def plug(p, c): + p.ch.plug_in() + if energy == "late": + p.ch.hold_until = p.ch.t + 150.0 + + def reserve(p, c): + p.socs.update(soc_after) + + ev = {} + + def add(t, fn): + t = int(t) + old = ev.get(t) + ev[t] = fn if old is None else ( + lambda p, c, a_=old, b_=fn: (a_(p, c), b_(p, c))) + + add(0, hook) + add(t_plug, plug) + if mode == "manual": + add(t_man, set_manual) + add(R, reserve) + for t, fn in (extra or {}).items(): + add(t, fn) + for t, fn in (rel or {}).items(): + add(R + t, fn) + base, tick0 = rig.BASE, s81.TICK + rig.BASE, s81.TICK = base - timedelta(seconds=E), float(x) + o = dict(OPTS if n == 2 else OPTS1, **(opts or {})) + try: + r = P.drive(house, dur=R + after + step, rating=5000.0, + soc={u: soc0 for u in units}, cap=aim + H.MARGIN, + phases=1, n=n, plant_cls=cls, opts=o, dev_w=5000.0, + setpoint=car_a, user_a=car_a, mode="off", events=ev, + sim=s, plug=False) + finally: + rig.BASE, s81.TICK = base, tick0 + meta = {"E": E, "R": R, "t_plug": t_plug, "t_man": t_man, + "t_house": t_house, "house_w": hw, "step": step} + return r, tr, meta + + +# ---------------------------------------------------------- event helpers +# For `rel` (seconds from R) or `extra` (run seconds). +def p1_gap(t0, secs): + """No P1 sample reaches the add-on for `secs` from `t0` (it is late).""" + def off(p, c): + c.p1._ev19_submit = c.p1.submit + c.p1.submit = lambda *a, **k: None + + def on(p, c): + c.p1.submit = c.p1._ev19_submit + return {t0: off, t0 + secs: on} + + +def stale(t0, t1): + """The charger's readings stop reaching the car tracker from t0 to t1: + its figure ages past `stale_s`.""" + def off(p, c): + c.car._ev19_observe = c.car.observe + c.car.observe = lambda *a, **k: None + + def on(p, c): + c.car.observe = c.car._ev19_observe + return {t0: off, t1: on} + + +def unavailable(t0, t1): + return {t0: lambda p, c: p.ch.go_unavailable(True), + t1: lambda p, c: p.ch.go_unavailable(False)} + + +def restart(t0): + return {t0: lambda p, c: H.restart(c)} + + +def phases(t0, n=3): + """The user asks for `n` phases (the add-on's own 0 A pause follows).""" + return {t0: lambda p, c: c._car_action("car_phases", n, c.car_now())} + + +def socs(t0, **s): + return {t0: lambda p, c: p.socs.update(s)} + + +def merge(*evs): + out = {} + for e in evs: + for t, fn in e.items(): + old = out.get(t) + out[t] = fn if old is None else ( + lambda p, c, a_=old, b_=fn: (a_(p, c), b_(p, c))) + return out + + +# --------------------------------------------------------------- grading +def window(tr, t0, t1): + return [x for x in tr if t0 <= x["t"] <= t1] + + +def alarms(r): + return H.alarms(r) + + +def edges(tr): + return H.edges(tr) + + +def bad(x): + """An alarm, red sample or ERROR in this cycle.""" + return bool(x["alarm"] or x["red"] or x["err"]) + + +def repro(r, tr, meta, t0=-10, t1=60): + """T1's definition: a floor notice, ERROR or red sample in R-10..R+60 in + a cycle where the car figure is trusted (the shape lands under the aim + without the car, so the car explains). Returns (cycles, C5-only cycles).""" + R = meta["R"] + w = window(tr, R + t0, R + t1) + notes = [t for t in alarms(r) if R + t0 <= t <= R + t1] + hit = [x["t"] for x in w if bad(x) and x["w"] is not None + and x["w"] > 0.0] + c5 = [x["t"] for x in w if bad(x) and not (x["w"] is not None + and x["w"] > 0.0)] + return hit, c5, notes + + +def quiet(r, tr, t0, t1): + return (not [t for t in alarms(r) if t0 <= t <= t1] + and not any(bad(x) for x in window(tr, t0, t1))) + + +def commands(r, tr): + 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 row(name, r, tr, meta): + hit, c5, notes = repro(r, tr, meta) + R = meta["R"] + first = hit[:1] + cause = "" + if first: + x = next(y for y in tr if y["t"] == first[0]) + cause = (f"w={x['w']:.0f} batt={x['batt']} true={x['true_batt']:.0f}" + f" real={x['need_real']:d} excl={x['need_excl']:d} " + f"house={x['need_house']:d} over={x['over_now']:d} " + f"contra={x['contra']:d} pn={x['peak_needed']:d} " + f"wa={x['within_aim']:d} wanted={x['wanted']:.0f}") + return (f"{name:42s} R={R:5d} notes {[t - R for t in notes]} " + f"hit {[t - R for t in hit][:6]}{'...' if len(hit) > 6 else ''}" + f" n={len(hit)} c5 {len(c5)} err " + f"{len([x for x in window(tr, R - 10, R + 60) if x['err']])} " + f"red900 {len([x for x in window(tr, R - 60, R + 900) if x['red']])}" + f" {cause}") + + +def t2_shape(**kw): + """The reproducing shape (T2): b follows the house from R, 0 W before.""" + return dict(dict(bw=0.0, traj="t2"), **kw) + + +def t5_shape(**kw): + """The honest shape (T5): the house alone misses the aim by 1 680 W, more + than the 1 380 W car; the batteries give 4 250 W until R.""" + return dict(dict(bw=4250.0, traj="t1", house_w=AIM + 1680.0), **kw) + + +def flicker_force(bw=2000.0): + """T17: each unit gives bw/2 above its reserve and ramps to 0 W over 3 + cycles once at it (tau3); back above it, it gives bw/2 again at once.""" + def mk(u): + st = {"since": None} + + def f(at, plant): + if plant.socs[u] >= 20.0: + st["since"] = None + return bw / 2.0 + if st["since"] is None: + st["since"] = at + k = int(at - st["since"]) + return bw / 2.0 * max(0.0, (3 - k) / 3.0) + return f + return {"a": mk("a"), "b": mk("b")} + + +def _step_house(k, lo=AIM + 520.0 - CAR, hi=AIM + 1900.0): + return lambda t, R: lo if t < R + k else hi + + +def _ignoring(): + """The charger accepts the 6 A write and ignores it: the car stays at + 0 A.""" + s = Meter(setpoint_a=0) + s.refuse = "ignore" + return s + + +def _full_at_plug(p, c): + """The car is full (after the plug-in at R-180): mode3 B, 0 W.""" + p.ch.car_full() + + +def _no_energy(p, c): + """The charger has no energy entity.""" + p.ch.no_energy = True + + +def _freeze_stop(p, c): + p.ch.freeze() + p.ch.car_full() + + +def jobs(): + """Every controller run test_ev19.py grades: {name: kwargs}.""" + j = {} + for name, kw in grid(): + j["T1 " + name] = kw + # T3: the battery W sweep + for tj in ("t1", "t2"): + for bw in range(0, 4601, 200): + j[f"T3 {tj} bw={bw}"] = dict(bw=float(bw), traj=tj) + j[f"T3 {tj} tau5"] = dict(bw=9600.0, traj=tj, aim=6000.0, + house_w=5200.0) + # T4: the landing without the car at aim + 9 / + 11 W + for d in (9, 11): + for md in ("manual", "off"): + j[f"T4 +{d} {md}"] = t2_shape(house_w=AIM + d, mode=md) + # T5: honest at the reserve + for tj in ("t1", "t4"): + for md in ("manual", "off"): + j[f"T5 {tj} {md}"] = t5_shape(traj=tj, mode=md) + for md in ("manual", "off"): + j[f"T5 tau5 {md}"] = dict(bw=9600.0, traj="t1", aim=6000.0, + house_w=7700.0, mode=md) + # T6: the honest step in the reserve cycle + for k in (0, 1, 5): + for md in ("manual", "off"): + j[f"T6 step R+{k} {md}"] = dict(bw=4250.0, traj="t1", mode=md, + house_fn=_step_house(k)) + # T7: unknown values + for nm, sh in (("T2", t2_shape), ("T5", t5_shape)): + j[f"T7(a) {nm}"] = sh(lost={"a": {0, 1}}) + j[f"T7(b) {nm}"] = sh(rel=unavailable(0, 1)) + j["T7(a) T5 off"] = t5_shape(lost={"a": {0, 1}}, mode="off") + j["T7(b) T5 off"] = t5_shape(rel=unavailable(0, 1), mode="off") + # T8: a stale car figure + j["T8(a) Off 120 s, Manual R-5"] = t2_shape(plug_at=-125, man_at=-5) + j["T8(b) stale R-5..R+20"] = t2_shape(rel=stale(-5, 20)) + j["T8(c) frozen, the car stops"] = t5_shape(rel={-30: _freeze_stop}) + j["T8(c) off"] = t5_shape(rel={-30: _freeze_stop}, mode="off") + # T9: comms + for nm, sh in (("T2", t2_shape), ("T5", t5_shape)): + j[f"T9(a) {nm} b lost at R"] = sh(lost={"b": {0}}) + j[f"T9(a) {nm} b lost at R-1"] = sh(lost={"b": {-1}}) + j[f"T9(b) {nm} P1 5 s late at R"] = sh(rel=p1_gap(0, 5)) + # T10: a restart + for nm, sh in (("T2", t2_shape), ("T5", t5_shape)): + j[f"T10 {nm} twin"] = sh() + for k in (-2, 2): + j[f"T10 {nm} restart R{k:+d}"] = sh(rel=restart(k)) + # T11: the quarter edge + for rr in (-1, 0, 1, 43): + j[f"T11 T2 R=E{rr:+d}"] = t2_shape(r_rel=rr) + j[f"T11 T5 R=E{rr:+d}"] = t5_shape(r_rel=rr) + j[f"T11 T5 R=E{rr:+d} off"] = t5_shape(r_rel=rr, mode="off") + # C4: the old quarter heads over the aim (the house high all along), so the + # guard wants power in its last 60 s and SAFETY-126's latch is carried + j["T11 C4 T2 R=E+1"] = t2_shape(r_rel=1, house_w=13350.0, pre_w=13350.0) + # T12: our own phase change + for k in (-15, 5): + j[f"T12 T2 1->3 at R{k:+d}"] = t2_shape(rel=phases(k)) + j[f"T12 T5 1->3 at R{k:+d}"] = t5_shape(rel=phases(k)) + j[f"T12 T5 1->3 at R{k:+d} off"] = t5_shape(rel=phases(k), + mode="off") + # T13: a wrong charger reply + # (a): the house + the 400 W it really draws lands at aim + 520 W, so the + # house alone misses by 120 W; (b) and T14(a): the car draws 0 W and the + # house alone lands at aim + 520 W. An alarm is due in each. + for md in ("manual", "off"): + j[f"T13(a) draws 400 W {md}"] = t2_shape( + sim=Draw(400.0, CAR, setpoint_a=6), house_w=AIM + 120.0, mode=md) + j[f"T13(a) draws 100 W {md}"] = t2_shape( + sim=Draw(100.0, CAR, setpoint_a=6), house_w=AIM + 420.0, mode=md) + j[f"T13(b) the write ignored, 0 A {md}"] = t2_shape( + sim=_ignoring(), house_w=AIM + 520.0, mode=md) + # T14: configuration + j[f"T14(a) 0 W in C {md}"] = t2_shape( + sim=Draw(0.0, 0.0, c_at_0=True, setpoint_a=6), + house_w=AIM + 520.0, mode=md) + j[f"T14(a) idle B {md}"] = t2_shape( + house_w=AIM + 520.0, mode=md, rel={-179: _full_at_plug}) + j["T14(b) ev_charger off"] = t2_shape(opts={"ev_charger": "off"}) + j["T14(b) off"] = t2_shape(mode="off") + for tj in ("t1", "t4"): + j[f"T14(c) N=1 anchor {tj}"] = dict(n=1, bw=4250.0, traj=tj) + j["T14(c) N=1 T5"] = t5_shape(n=1) + j["T14(c) N=1 T5 off"] = t5_shape(n=1, mode="off") + # T15: one battery first (SAFETY-87) + for nm, hw in (("anchor", AIM + 520.0 - CAR), ("honest", 19000.0)): + for md in ("manual", "off"): + j[f"T15 {nm} {md}"] = dict( + bw=4250.0, traj="t1", house_w=hw, mode=md, + force={"b": None}, soc_after={"a": 19.0, "b": 35.0}, + rel=socs(360, b=19.0)) + # T16: x10 (wall and mono), and mono x1 / wall x10 + for xn, xk in (("x10", dict(x=10)), ("mono1", dict(x=10, mono_x=1))): + xk = dict(xk, r_rel=40) + # x10: b at 1 200 W before R (at 0 W, which the forced unit holds + # against the guard's floor, SAFETY-37's gate reads it as frozen) + xk2 = dict(xk, bw=1200.0) + j[f"T16 {xn} T2"] = t2_shape(**xk2) + for tj in ("t1", "t4"): + for bw in (0.0, 2000.0, 4250.0): + j[f"T16 {xn} T3 {tj} bw={bw:.0f}"] = dict(bw=bw, traj=tj, + **xk) + for md in ("manual", "off"): + j[f"T16 {xn} T5 {md}"] = t5_shape(mode=md, **xk) + j[f"T16 {xn} T6 {md}"] = dict(bw=4250.0, traj="t1", mode=md, + house_fn=_step_house(0), **xk) + j[f"T16 {xn} T7(b) T2"] = t2_shape(rel=unavailable(0, 10), **xk2) + for rr in (-10, 0, 10, 40): + j[f"T16 {xn} T11 T2 R=E{rr:+d}"] = t2_shape( + **dict(xk2, r_rel=rr)) + j[f"T16 {xn} T11 T5 R=E{rr:+d}"] = t5_shape(**dict(xk, r_rel=rr)) + # T17: no flicker + j["T17 flicker"] = dict( + force=flicker_force(), after=1200, + rel=merge(socs(300, a=21.0, b=21.0), socs(600, a=19.0, b=19.0)), + house_fn=lambda t, R: AIM + 10.0 + (40.0 if int(t // 7) % 2 + else -40.0)) + # N2: figures only `car_w_trusted` keeps out of the alarm path: no energy + # entity (never corroborated, never contradicted) and 11 kW reported at + # a 6 A read-back (capped at 1 518 W; the house alone misses by 1 680 W) + for md in ("manual", "off"): + j[f"N2 no energy entity {md}"] = t2_shape(extra={0: _no_energy}, + mode=md) + j[f"N2 reports 11 kW at 6 A {md}"] = t5_shape( + sim=Draw(CAR, 11000.0, setpoint_a=6), mode=md) + # T20 / N4: the same runs with the car never explaining + j["N4 T2 explain off"] = t2_shape(explain_off=True) + j["N4 T5 explain off"] = t5_shape(explain_off=True) + return j + + +def grid(): + """The T1 cells: (name, kwargs).""" + cells = [] + for bw in (0.0, 400.0, 800.0, 2000.0, 4250.0, 9600.0): + for tj in ("t1", "t2", "t3", "t4", "t4r"): + for rp in (30, 100, 110, 180, 600): + kw = dict(bw=bw, traj=tj, rp=rp) + if bw == 9600.0: + kw.update(aim=6000.0, house_w=5200.0) + cells.append((f"core bw={bw:.0f} {tj} rp={rp}", kw)) + cells.append(("a: plug R-185, Manual R-180", dict(order="plug"))) + cells.append(("a: Off 120 s, Manual R-60", dict(order="off120"))) + cells.append(("b: energy first step late", dict(energy="late"))) + cells.append(("b: energy never steps", dict(energy="never"))) + for rr in (-60, 0, 1, 43, 450, 890): + cells.append((f"c: R=E{rr:+d}", dict(r_rel=rr))) + cells.append(("d: x10 wall+mono", dict(x=10, r_rel=40))) + cells.append(("d: x10 wall, mono x1", dict(x=10, mono_x=1, r_rel=40))) + for tj, bw in (("t4", 4250.0), ("t2", 4250.0), ("t2", 1200.0)): + cells.append((f"d: x10 wall+mono {tj} bw={bw:.0f}", + dict(x=10, r_rel=40, traj=tj, bw=bw))) + cells.append((f"d: x10 wall, mono x1 {tj} bw={bw:.0f}", + dict(x=10, mono_x=1, r_rel=40, traj=tj, bw=bw))) + return cells + + +class Res: + """What a check needs from one run, picklable: the notices (`raised`, + seconds and ids), the trace, the command digest and the run's times.""" + + def __init__(self, r, tr, meta): + self.raised = list(r["raised"]) + self.tr, self.meta = tr, meta + self.cmd = commands(r, tr) + self.R, self.E = meta["R"], meta["E"] + + def alarms(self): + return [t for t, n in self.raised if n == FLOOR] + + def rel_alarms(self): + return [int(t - self.R) for t in self.alarms()] + + def edges(self): + return [int(t - self.R) for t in edges(self.tr)] + + def errors(self): + return [int(x["t"] - self.R) for x in self.tr if x["err"]] + + def red(self, t0=-60, t1=900): + return [int(x["t"] - self.R) for x in + window(self.tr, self.R + t0, self.R + t1) if x["red"]] + + def at(self, k): + return next((x for x in self.tr if x["t"] == self.R + k), None) + + def win(self, t0, t1): + return window(self.tr, self.R + t0, self.R + t1) + + def quiet(self, t0=-60, t1=900): + return quiet({"raised": self.raised}, self.tr, + self.R + t0, self.R + t1) + + def edges_per_quarter(self): + """False -> True edges of the floor alarm per quarter (N5).""" + out = {} + for t in edges(self.tr): + q = int((t - self.E) // 900) + out[q] = out.get(q, 0) + 1 + return out + + def summary(self): + return {"alarms": self.rel_alarms(), "edges": self.edges(), + "errors": self.errors(), "red": len(self.red()), + "cmd": self.cmd} + + +_JOBS = {} + + +def _job(name): + import logging + logging.disable(logging.WARNING) + return name, Res(*run(**_JOBS[name])) + + +def run_many(jobs, procs=None): + """{name: kwargs} -> {name: Res}, `procs` runs at a time (fork: the + kwargs may hold functions).""" + import multiprocessing + _JOBS.clear() + _JOBS.update(jobs) + procs = procs or int(os.environ.get("EV19_JOBS", "0")) \ + or min(8, os.cpu_count() or 1) + ctx = multiprocessing.get_context("fork") + with ctx.Pool(procs) as pool: + return dict(pool.imap_unordered(_job, list(jobs), chunksize=1)) + + +def _one(cell): + import logging + logging.disable(logging.WARNING) + name, kw = cell + try: + r, tr, meta = run(**kw) + except Exception as e: # noqa: BLE001 + import traceback + return name, f"{name:42s} Traceback {e!r}\n{traceback.format_exc()}" + return name, row(name, r, tr, meta) + + +if __name__ == "__main__": + import multiprocessing + cells = grid() + if len(sys.argv) > 1: + cells = [c for c in cells if any(a in c[0] for a in sys.argv[1:])] + with multiprocessing.Pool(int(os.environ.get("EV19_JOBS", "8"))) as pool: + for _name, line in pool.imap(_one, cells): + print(line, flush=True) -- 2.54.0 From c2bb32ec932db9e428b33efb505d6752d20c4912 Mon Sep 17 00:00:00 2001 From: ems-agent Date: Fri, 20 Nov 2026 22:13:19 +0100 Subject: [PATCH 2/3] EV-19 review round 1: discount a battery rise only while the meter has not moved [Major] The rise discount applied to any rise, also one the meter already shows, so an honest house step answered by one cycle of battery power alarmed one cycle after base (review repro: T6 step + burst, R+6 instead of R+5). Now a reading above both earlier ones is discounted only while the meter's house side (held - car; held alone when a car figure is unknown) moved no more than RISE_STILL_W (50 W) since the last cycle. Tests: the burst shapes (unit, meter in step and one cycle late; controller, step at R+5 and R+30, 3 000 / 4 600 W) at base's second; the "N6 unit" check tightened to the rise cycle; the RISE_STILL_W boundary; a pin on EV-18's `_car_over_now` (mC); T10 restarts at R-1 and R (mE). test_ev19: 144 of 144 here, 52 red on 43b0db7. Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w --- .../DECISIONS/EV-04-manual-mode.md | 12 ++- goodwe_controller/app/ctl_car.py | 27 +++++-- goodwe_controller/test_ev19.py | 79 ++++++++++++++++--- goodwe_controller/tools/ev19_reserve.py | 29 ++++++- 4 files changed, 127 insertions(+), 20 deletions(-) diff --git a/goodwe_controller/DECISIONS/EV-04-manual-mode.md b/goodwe_controller/DECISIONS/EV-04-manual-mode.md index 6f0e852..4fb034b 100644 --- a/goodwe_controller/DECISIONS/EV-04-manual-mode.md +++ b/goodwe_controller/DECISIONS/EV-04-manual-mode.md @@ -152,13 +152,17 @@ up to 1.8 kW; the 40 Wh floor fixes that.) 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. -- **A battery rise is house only once a second reading shows it** (EV-19, EV-15 +- **A battery rise the meter has not shown is not house yet** (EV-19, EV-15 rig F-B). At the reserve inverter-b goes on following the house, so its output rises; the reading shows it one cycle before P1 does, and the house figure (meter + battery) counted that power as house. `_car_need_house` - latched and the alarm stood. For the house figure, a reading above both - earlier ones counts only up to the higher of them; the credit stays the lower - of the last two readings. + latched and the alarm stood. Now, while the meter's house side (held - car) + moved no more than `RISE_STILL_W` since the last cycle, a reading above both + earlier ones counts only up to the higher of them. A meter that moved shows + the rise (an honest step with a battery burst alarms at once, as before). A + rise the meter does not move with at all is graded as F-B: the one case the + readings cannot tell apart. The credit stays the lower of the last two + readings; `_car_over_now` is unchanged. - **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 da37a70..d87d1bc 100644 --- a/goodwe_controller/app/ctl_car.py +++ b/goodwe_controller/app/ctl_car.py @@ -31,6 +31,9 @@ OVER_OFF_HOLD_S = 180.0 OWN_PAUSE_MAX_S = (carmode.ZERO_WAIT_S + carmode.SETTLE_S + carmode.MAX_TRIES * 15.0 + 10.0) OWN_PAUSE_TAIL_S = chargers.CORR_WINDOW_S +# EV-19: the meter's house side (held - car) moved no more than this since the +# last cycle: it has not shown a battery rise the reading already shows. +RISE_STILL_W = 50.0 class CarMixin: @@ -59,6 +62,7 @@ class CarMixin: self._car_over_since = None self._car_over_gone = None self._car_batt_prev = self._car_batt_prev2 = None + self._car_hx_prev = None # EV-19: last cycle's (held, car W) 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 @@ -416,12 +420,6 @@ class CarMixin: now, prev = self.site_batt_w, self._car_batt_prev prev2, self._car_batt_prev2 = self._car_batt_prev2, prev self._car_batt_prev = now - # EV-19: the reading can show a rise one cycle before the meter does - # (the batteries pick up the house at the reserve), so a reading above - # both earlier ones is not yet counted as house. - seen = now - if now is not None and prev is not None and prev2 is not None: - seen = min(float(now), max(float(prev), float(prev2))) wants = bool(guard is not None and guard.engaged and guard.blind is None and (guard.wanted_w or 0.0) > 0.0) @@ -433,6 +431,23 @@ class CarMixin: if batt is not None and prev is not None: batt = min(float(batt), float(prev)) excl = self.car_exclude_alarm(real_proj, w) + # EV-19: the reading can show a rise one cycle before the meter does + # (the batteries pick up the house at the reserve). While the meter's + # house side (held - car; held alone when a car figure is unknown) has + # not moved, a reading above both earlier ones is not yet counted as + # house; a meter that moved shows it (no discount). + held = float(real_proj.held_w) + hp, self._car_hx_prev = self._car_hx_prev, (held, w) + still = False + if hp is not None: + moved = held - hp[0] + if w is not None and hp[1] is not None: + moved -= float(w) - float(hp[1]) + still = abs(moved) <= RISE_STILL_W + seen = now + if still and now is not None and prev is not None \ + and prev2 is not None: + seen = min(float(now), max(float(prev), float(prev2))) if wants and batt is not None: self._car_need_real = self._car_need_real or \ peakguard.misses_aim(real_proj, batt_w=batt, diff --git a/goodwe_controller/test_ev19.py b/goodwe_controller/test_ev19.py index bf4077c..57ca96e 100644 --- a/goodwe_controller/test_ev19.py +++ b/goodwe_controller/test_ev19.py @@ -147,16 +147,55 @@ u6 = urun(range(-5, 30), meter(AIM + 11.0 + 400.0, lambda t: 400.0, lag=0), check("N6 unit: b at 400 W, the house alone with it at aim + 11 W, one " "reading of 800 W at E+3: not explained in any cycle", not any(run_of(u6, 0, 29))) -# The rise counts as house once a second reading confirms it: b steps to -# 800 W and the meter, one cycle late, shows a house of aim + 811 W (the -# house steps with it), so with b's 800 W the house alone misses by 11 W. +# A house step that comes with a battery rise: b steps to 800 W and the +# meter, one cycle late, shows a house of aim + 811 W, so with b's 800 W the +# house alone misses by 11 W. The meter moved, so nothing is discounted. b8 = rise(5, 0.0, 800.0) u8 = urun(range(0, 30), lambda t: (AIM - 500.0 if t < 5 else AIM + 811.0) + CAR - b8(t - 1), b8) print(f" N6 unit house step with a rise E+4..E+8: {run_of(u8, 4, 8)}") -check("N6 unit: a house step that comes with a battery rise is latched at " - "most one cycle after the rise (E+6), and stays latched", - all(run_of(u8, 0, 4)) and not any(run_of(u8, 6, 29))) +check("N6 unit: a house step that comes with a battery rise is latched in " + "the rise cycle (E+5, as base), and stays latched", + all(run_of(u8, 0, 4)) and not any(run_of(u8, 5, 29))) + +# Review round 1 (Major): an honest house step at E+5 answered by ONE reading +# of battery power, the meter in step (it shows the burst too) or one cycle +# late. Not explained from E+5, the step's own cycle, as base. +for H, burst, lag in ((2000.0, 4600.0, 0), (1900.0, 3000.0, 0), + (5000.0, 4600.0, 0), (2000.0, 4600.0, 1), + (1900.0, 3000.0, 1)): + hs = (lambda t, H=H: AIM - 500.0 if t < 5 else AIM + H) + bb = (lambda t, burst=burst: burst if t == 5 else 0.0) + ub = urun(range(0, 15), lambda t, hs=hs, bb=bb, lag=lag: + hs(t) + CAR - bb(t - lag), bb) + check(f"RB unit: house -> aim + {H:.0f} W at E+5 with one {burst:.0f} W " + f"reading, meter {'in step' if lag == 0 else 'one cycle late'}: " + f"explained to E+4, not from E+5 (base: the same)", + ub.get(4) is True and not any(run_of(ub, 5, 14)) + and len(run_of(ub, 5, 14)) == 10) + +# The discount needs a still meter: the F-B rise (T2 unit) with the house +# side of the meter moving by RISE_STILL_W -/+ 10 W in the rise cycle. +STILL = getattr(ctl_car, "RISE_STILL_W", 50.0) # 43b0db7 has none +for d, want in ((STILL - 10.0, True), (STILL + 10.0, False)): + ud = urun(range(-5, 10), lambda t, d=d: HB + (d if t >= 1 else 0.0) + + CAR - b2(t - 1), b2) + check(f"RISE_STILL_W: the meter's house side moves {d:.0f} W in the rise " + f"cycle: {'still, the rise is not yet house (explained)' if want else 'moved, the rise counts as house (not explained, as base)'}", + ud.get(1) is want and ud.get(0) is True) + +# Review round 1 (mC): EV-18's `_car_over_now` keeps the reading as it is. b +# gives 2 000 W, the house alone with it lands under the aim and the period +# with the car too, so nothing explains; b rises to 4 000 W at E+5 one cycle +# before the meter: the period with the car on the reading as it is lands +# over, so the car explains from E+5. +bc = rise(5, 2000.0, 4000.0) +uc = urun(range(0, 15), lambda t: AIM + 500.0 + CAR - bc(t - 1), bc) +print(f" over_now unit E+3..E+7: {run_of(uc, 3, 7)}") +check("over_now unit: `_car_over_now` grades the undiscounted reading: not " + "explained E+0..E+4, explained from the rise cycle E+5", + not any(run_of(uc, 0, 4)) and all(run_of(uc, 5, 14)) + and len(run_of(uc, 5, 14)) == 10) # =========================================================================== # print("\n2. THE REAL CONTROLLER AT THE RESERVE (N=2, tools/ev19_reserve.py)") @@ -200,6 +239,8 @@ BASE_ALARMS = { "T9(a) T5 b lost at R": [2], "T9(a) T5 b lost at R-1": [2], "T9(b) T5 P1 5 s late at R": [5], "T10 T5 twin": [2], "T10 T5 restart R-2": [2], "T10 T5 restart R+2": [2], + "T10 T5 restart R-1": [2], "T10 T5 restart R+0": [2], + "T10 T2 restart R+0": [1], "T11 T5 R=E-1": [2], "T11 T5 R=E+0": [0, 2], "T11 T5 R=E+1": [0, 2], "T11 T5 R=E+43": [2], "T12 T5 1->3 at R-15": [2], "T12 T5 1->3 at R+5": [2], "T13(a) draws 100 W manual": [0, 857], @@ -370,10 +411,16 @@ for nm in ("T2", "T5"): # --- T10: a restart ------------------------------------------------------------ # for nm in ("T2", "T5"): tw = res(f"T10 {nm} twin") - for k in (-2, 2): + for k in (-2, -1, 0, 2): r = res(f"T10 {nm} restart R{k:+d}") show(f"T10 {nm} restart R{k:+d}") - if nm == "T2": + if nm == "T2" and k == 0: + # the rise cycle R+1 has no reading from two cycles back: nothing + # is discounted (the old behaviour), so the alarm is base's + check("T10 T2 restart at R+0: no reading two cycles back in the " + "rise cycle, so no discount: the alarm as base (R+1)", + as_base("T10 T2 restart R+0")) + elif nm == "T2": check(f"T10 T2 restart at R{k:+d}: no notice, no red sample, as " f"the unrestarted twin", r.quiet(-60, 900) and tw.quiet(-60, 900)) @@ -383,6 +430,18 @@ for nm in ("T2", "T5"): as_base(f"T10 T5 restart R{k:+d}") and as_base("T10 T5 twin") and len(r.red()) == len(tw.red())) +# --- Review round 1 (Major), controller: the T6 step with a one-cycle burst ---- # +for k in (5, 30): + for hi in (1900, 2500): + for burst in ("3000", "4600"): + nm = f"RB step R+{k} aim+{hi} burst {burst} manual" + r = res(nm) + show(nm) + check(f"{nm[:-7]}: P1 and the reading both show the burst: the " + f"notice, the ERROR and the first red sample at the step, " + f"R+{k}, as base", r.rel_alarms() == [k] + and r.errors() == [k] and r.red()[:1] == [k]) + # --- T11: the quarter edge ------------------------------------------------------ # for rr in (-1, 0, 1, 43): r = res(f"T11 T2 R=E{rr:+d}") @@ -551,7 +610,9 @@ BASE_TWO = ["T1 b: energy first step late", "T1 b: energy never steps", "T11 T5 R=E+1 off", "T16 mono1 T11 T5 R=E+0", "T16 mono1 T11 T5 R=E+10", "T16 mono1 T6 off", "T16 x10 T11 T5 R=E+0", "T16 x10 T11 T5 R=E+10", "T16 x10 T6 off", - "T6 step R+0 off", "T6 step R+1 off", "T6 step R+5 off"] + "T6 step R+0 off", "T6 step R+1 off", "T6 step R+5 off"] + [ + f"RB step R+{k} aim+{hi} burst {b} off" for k in (5, 30) + for hi in (1900, 2500) for b in (3000, 4600)] many = sorted(k for k, r in RES.items() if any(v > (2 if k in BASE_TWO and q == 0 else 1) for q, v in r.edges_per_quarter().items())) diff --git a/goodwe_controller/tools/ev19_reserve.py b/goodwe_controller/tools/ev19_reserve.py index 319c5b4..bce4918 100644 --- a/goodwe_controller/tools/ev19_reserve.py +++ b/goodwe_controller/tools/ev19_reserve.py @@ -201,7 +201,7 @@ def run(*, bw=4250.0, traj="t1", rp=180, r_rel=43, order="manual", soc_after = soc_after or {u: 19.0 for u in units} lagb = 10.0 if traj == "t4" else 0.0 cls = type("Plant", (Plant,), { - "force": frc, "batt_lag": lagb, + "force": frc, "batt_lag": lagb, "R": R, "lost": {u: {R + k for k in v} for u, v in (lost or {}).items()}, "p1_lag": 5.0 if traj == "t4r" else 0.0, "p1_from": float(R)}) @@ -477,6 +477,17 @@ def _step_house(k, lo=AIM + 520.0 - CAR, hi=AIM + 1900.0): return lambda t, R: lo if t < R + k else hi +def _burst(k, w): + """Inverter-b: 2 125 W until R+1, then `w` for 0.5 s before the cycle at + R+k (P1, sampled 0.3 s before it, and the reading both show it), else + 0 W.""" + def f(at, plant): + if at < plant.R + 1: + return 4250.0 / 2.0 + return w if plant.R + k - 0.5 <= at <= plant.R + k else 0.0 + return f + + def _ignoring(): """The charger accepts the 6 A write and ignores it: the car stays at 0 A.""" @@ -626,6 +637,22 @@ def jobs(): mode=md) j[f"N2 reports 11 kW at 6 A {md}"] = t5_shape( sim=Draw(CAR, 11000.0, setpoint_a=6), mode=md) + # Review round 1: an honest house step answered by ONE cycle of inverter-b + # power that P1 and the reading both show (the meter in step), after the + # T6 shape (4 250 W until R, then 0 W). + for k in (5, 30): + for hi in (1900, 2500): + for burst in (3000.0, 4600.0): + for md in ("manual", "off"): + j[f"RB step R+{k} aim+{hi} burst {burst:.0f} {md}"] = dict( + bw=4250.0, traj="t1", mode=md, + house_fn=_step_house(k - 0.5, hi=AIM + hi), + force={"b": _burst(k, burst)}) + # T10 (mE): restarts at R-1 and R, so the rise cycle has no reading from + # two cycles back + for nm, sh in (("T2", t2_shape), ("T5", t5_shape)): + for k in (-1, 0): + j[f"T10 {nm} restart R{k:+d}"] = sh(rel=restart(k)) # T20 / N4: the same runs with the car never explaining j["N4 T2 explain off"] = t2_shape(explain_off=True) j["N4 T5 explain off"] = t5_shape(explain_off=True) -- 2.54.0 From 77684ecfadc0feccf83b6c5db17a2562e500b885 Mon Sep 17 00:00:00 2001 From: ems-agent Date: Fri, 20 Nov 2026 23:14:09 +0100 Subject: [PATCH 3/3] EV-19 review round 2: pin the 50 W blind band and the car term of the stillness test Test-only. Two unit checks in test_ev19.py: an honest step with a burst that moves the meter's house side +/-60 W alarms in base's cycle, and inside the band (0 W) the car explains at most the step's own cycle; a car step offset by a burst at the meter is not discounted. They kill RISE_STILL_W = 500 W and a stillness test without the car term. Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w --- goodwe_controller/test_ev19.py | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/goodwe_controller/test_ev19.py b/goodwe_controller/test_ev19.py index 57ca96e..5aaa015 100644 --- a/goodwe_controller/test_ev19.py +++ b/goodwe_controller/test_ev19.py @@ -184,6 +184,35 @@ for d, want in ((STILL - 10.0, True), (STILL + 10.0, False)): f"cycle: {'still, the rise is not yet house (explained)' if want else 'moved, the rise counts as house (not explained, as base)'}", ud.get(1) is want and ud.get(0) is True) +# Review round 2: the blind band in absolute W (the owner's 50 W; change this +# check with the owner). An honest step at E+5 (house aim - 500 -> aim + 1 900 +# W, more than the car) with one burst that leaves the meter's house side +# moving d W: at |d| = 60 the alarm cycle is base's (E+5); inside the band +# (d = 0) the car explains at most the step's own cycle, never from E+6. +for dd in (60.0, -60.0, 0.0): + hb = (lambda t: AIM - 500.0 if t < 5 else AIM + 1900.0) + bd = (lambda t, B=2400.0 - dd: B if t == 5 else 0.0) + ubd = urun(range(0, 15), lambda t, hb=hb, bd=bd: hb(t) + CAR - bd(t), bd) + print(f" band d={dd:+.0f} W E+4..E+8: {run_of(ubd, 4, 8)}") + t0 = 5 if dd else 6 + check(f"band: an honest step whose burst moves the meter's house side " + f"{dd:+.0f} W: not explained from E+{t0}", + ubd.get(4) is True and not any(run_of(ubd, t0, 14)) + and len(run_of(ubd, t0, 14)) == 15 - t0) + +# Review round 2: the stillness test uses the house side (held - car). The car +# steps 1 380 -> 2 760 W, the house aim - 500 -> aim + 3 000 W (more than the +# car) and b gives one reading of 4 880 W, all at E+5, meter in step: the +# meter's total stays, its house side drops 1 380 W, so nothing is discounted. +hc = (lambda t: AIM - 500.0 if t < 5 else AIM + 3000.0) +wc = (lambda t: CAR if t < 5 else 2 * CAR) +bc5 = (lambda t: 4880.0 if t == 5 else 0.0) +ucw = urun(range(0, 15), lambda t: hc(t) + wc(t) - bc5(t), bc5, w=wc) +check("car term: the car steps up with the house and a burst, the meter's " + "total still: not explained from E+5 (as base)", + ucw.get(4) is True and not any(run_of(ucw, 5, 14)) + and len(run_of(ucw, 5, 14)) == 10) + # Review round 1 (mC): EV-18's `_car_over_now` keeps the reading as it is. b # gives 2 000 W, the house alone with it lands under the aim and the period # with the car too, so nothing explains; b rises to 4 000 W at E+5 one cycle -- 2.54.0