diff --git a/goodwe_controller/DECISIONS/EV-04-manual-mode.md b/goodwe_controller/DECISIONS/EV-04-manual-mode.md index 2c2b9e3..4fb034b 100644 --- a/goodwe_controller/DECISIONS/EV-04-manual-mode.md +++ b/goodwe_controller/DECISIONS/EV-04-manual-mode.md @@ -152,6 +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 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. 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 479f737..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: @@ -58,7 +61,8 @@ class CarMixin: self.car_over = False # ... held: the card and row say so self._car_over_since = None self._car_over_gone = None - self._car_batt_prev = None + self._car_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 @@ -414,6 +418,7 @@ 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 wants = bool(guard is not None and guard.engaged and guard.blind is None @@ -426,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, @@ -436,7 +458,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..5aaa015 --- /dev/null +++ b/goodwe_controller/test_ev19.py @@ -0,0 +1,654 @@ +"""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))) +# 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 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 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 +# 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)") +# =========================================================================== # +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], + "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], + "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, -1, 0, 2): + r = res(f"T10 {nm} restart R{k:+d}") + show(f"T10 {nm} restart R{k:+d}") + 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)) + 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())) + +# --- 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}") + 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"] + [ + 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())) +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..bce4918 --- /dev/null +++ b/goodwe_controller/tools/ev19_reserve.py @@ -0,0 +1,779 @@ +"""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, "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)}) + + 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 _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.""" + 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) + # 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) + 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)