"""EV-15: the add-on's own phase change at the peak reserve raises no alarm. `python3 -B test_ev15.py` The rig (EV-10 and EV-10b, F-2): cover on, the batteries at the reserve, the car charging and explaining the excess. The add-on's own 3 -> 1 phase switch sets the car to 0 A; with the car not charging its figure is no longer corroborated (`CarTracker.corroborated`), so `car_alarm_w()` is None, nothing is explained, and PEAK_GUARD_FLOOR_LIMITED plus `goodwe_peak_soc_floor` fire. The rule: for the add-on's own sequence only (`ctl_car._car_own_pause`, bounded) the car's fresh, not stuck figure stands in for grading. 1. The rig shapes end to end through the car cycle: 3 -> 1 and 1 -> 3. 2. A house overload that starts during the sequence still alarms, as on Off. 3. Aborted (Off, Stop, unplug), refused, an outside writer: no grace. 4. The bounds, and the figure that stands in (stale, stuck: nothing). Mutating a module this file grades? Read MUTATION.md first (purge __pycache__). """ import asyncio import logging import os import sys HERE = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, os.path.join(HERE, "tools")) from app import ctl_car, carmode, chargers as CH # noqa: E402 import ev04_peak as P # noqa: E402 import safety81_sim as s81 # noqa: E402 logging.disable(logging.CRITICAL) fails = [] def check(name, cond): print(f" {'ok ' if cond else 'FAIL'} {name}") if not cond: fails.append(name) def at(t, fn): return {"t": t, "fn": fn} def beside(plant, c): """The writer runs BESIDE the cycle, as in production (`car_kick`): its 1 s poll for the read-back lands after the cycle's own read, and the cycle does not wait for the writer (`ev04_peak.drive` does).""" gate = asyncio.Event() async def sleep(_s): gate.clear() await gate.wait() async def settle(): gate.set() for _ in range(5): await asyncio.sleep(0) c.charger._sleep = sleep c.car_settle = settle def run(house, cap, t_res, t_sw, new, *, extra=None, mode="manual", sim_fn=None, dur=895, plug=True, side=False): """Reserve at `t_res`, our phase change to `new` at `t_sw`. Returns the run, a per-second trace (second, own-pause, explains, red rows) and the alarms.""" tr = [] def note(plant, c): red = [x["id"] for x in c.checks() if x["ok"] is False and not x["warn"]] \ if t_sw - 5 <= plant.t <= t_sw + 90 else [] g = c.peak_guard lim = bool(g is not None and (g.floor_limited or g.saturated)) tr.append((plant.t, getattr(c, "_car_own_pause", lambda _t: False)(c.car_now()), c.car_explains, red, plant.ch.power_w, plant.ch.state, lim)) def reserve(plant, c): plant.soc = 19.0 plant.load = lambda t: house + plant.ch.power_w def switch(plant, c): asyncio.get_event_loop().create_task( c.handle_action("car_phases", value=new)) ev = {t: note for t in range(0, dur)} ev[t_res] = lambda p, c: (reserve(p, c), note(p, c)) ev[t_sw] = lambda p, c: (switch(p, c), note(p, c)) if side: ev[t_sw - 2] = lambda p, c: (beside(p, c), note(p, c)) for t, fn in (extra or {}).items(): prev = ev.get(t, note) ev[t] = (lambda p, c, prev=prev, fn=fn: (fn(p, c), prev(p, c))) sim = None if sim_fn is not None or side: from chargersim import SimCharger sim = SimCharger(setpoint_a=16) sim_fn = sim_fn or (lambda s: None) sim_fn(sim) r = P.drive(s81.constant(house), dur=dur, rating=12000.0, soc=60.0, cap=cap, phases=(3 if new == 1 else 1), user_a=16, setpoint=16, mode=mode, events=ev, sim=sim, plug=plug) return r, tr, P.ids(r, *P.ALARMS) def reds(tr): return [x for x in tr if x[3]] # =========================================================================== # print("1. THE RIG SHAPES THROUGH THE CAR CYCLE") # =========================================================================== # SHAPES = ( ("EV-10 shape: house 3 kW, car 11 kW, aim 6 kW, 3 -> 1", 3000.0, 6050.0, 300, 600, 1), ("EV-10b shape: a 9411 W limit, 3 -> 1", 2000.0, 9461.0, 300, 600, 1), ("1 -> 3 (the car 3.7 kW, then 11 kW), aim 5 kW", 2500.0, 5050.0, 100, 600, 3), ) for name, house, cap, t_res, t_sw, new in SHAPES: r, tr, al = run(house, cap, t_res, t_sw, new) c, sim = r["c"], r["sim"] sw = [x for x in sim.writes() if x[1] == "phases"] check(f"{name}: the car at the reserve covers, and the add-on's own " f"sequence ran (0 A, select, the current back)", len(sw) == 1 and [x[2] for x in sim.writes("current")][-2:] == [0.0, 16.0] and sim.phases_allowed == new) pause = [x for x in tr if x[1]] check(f"{name}: the own-pause grace was on during it, and ended", len(pause) >= 10 and not any(x[1] for x in tr[-1:]) and (pause[-1][0] - pause[0][0]) <= getattr(ctl_car, "OWN_PAUSE_MAX_S", 0) + getattr(ctl_car, "OWN_PAUSE_TAIL_S", 0)) check(f"{name}: no PEAK_GUARD_FLOOR_LIMITED / saturated, no " f"goodwe_peak_soc_floor notification", al == []) check(f"{name}: no red row in any sample around the switch", reds(tr) == []) limited = [x for x in tr if x[1] and x[6]] check(f"{name}: in every cycle of the sequence in which the guard is " f"limited (the cycle of the rig's alarm among them) the car " f"explains it", len(limited) >= 1 and all(x[2] for x in limited) and any(x[2] for x in tr if x[0] == t_sw + 1)) check(f"{name}: and in every limited cycle after it, to the quarter's end", all(x[2] for x in tr if x[0] >= t_sw and x[6])) # =========================================================================== # print("\n2. A HOUSE OVERLOAD DURING THE SEQUENCE STILL ALARMS") # =========================================================================== # def overload(plant, c): plant.load = lambda t: 25000.0 + plant.ch.power_w r, tr, al = run(3000.0, 6050.0, 300, 600, 1, extra={606: overload}) ro, tro, alo = run(3000.0, 6050.0, 300, 600, 1, extra={606: overload}, mode="off", plug=False) rn, trn, aln = run(3000.0, 6050.0, 300, 900, 1, extra={606: overload}) check("PRECONDITION: on Off (no car) the same load alarms, and in Manual " "with no phase change", alo != [] and aln != []) check("a 25 kW house overload that starts 6 s into the sequence (the car " "paused): the alarm fires", al != []) print(f" alarm seconds: in the sequence {[t for t, _ in al]}, Off without " f"the car {[t for t, _ in alo]}, Manual with no phase change " f"{[t for t, _ in aln]}") check("...at the same second as on Off and as in Manual with no phase change", bool(al) and bool(alo) and bool(aln) and al[0][0] == alo[0][0] == aln[0][0]) check("...and the car does not explain it (during the sequence too)", not any(x[2] for x in tr if 640 <= x[0] <= 660)) # =========================================================================== # print("\n3. ABORTED, REFUSED, OUTSIDE: NO GRACE AFTER IT") # =========================================================================== # def hit(res, t0, secs): return [x for x in res if t0 <= x[0] <= t0 + secs and x[1]] def off_now(plant, c): asyncio.get_event_loop().create_task(c.handle_action("car_mode", value="off")) def stop_now(plant, c): c.auto = False def unplug(plant, c): plant.ch.unplug() slow = lambda s: setattr(s, "stop_delay_s", 8.0) # noqa: E731 for what, fn in (("Off", off_now), ("Stop", stop_now), ("unplug", unplug)): r, tr, al = run(3000.0, 6050.0, 300, 600, 1, extra={602: fn}, sim_fn=slow) check(f"{what} 2 s into the sequence: the grace is off from the next " f"cycle on", not hit(tr, 604, 200) and any(x[1] for x in tr if 600 <= x[0] <= 602)) def refuse_phases(sim): sim.request_phases = lambda n: False r, tr, al = run(3000.0, 6050.0, 300, 600, 1, sim_fn=refuse_phases) check("the select is refused: the grace ends at once (no cycle of it after " "the refusal), the current comes back", len([x for x in r["sim"].writes("current")]) >= 2 and not hit(tr, 606, 200)) def outside_zero(plant, c): plant.ch.set_current(0.0) r2, tr2, al2 = run(3000.0, 6050.0, 300, 900, 1, extra={602: outside_zero}) check("an outside writer's 0 A: no grace, and the normal grading (no car " "power: nothing explained) raises the alarm as before", not any(x[1] for x in tr2) and not any(x[2] for x in tr2 if 610 <= x[0] <= 700) and al2 != []) # =========================================================================== # print("\n4. THE BOUNDS AND THE FIGURE THAT STANDS IN") # =========================================================================== # class _C(ctl_car.CarMixin): """The mixin with just what `_car_own_pause` reads.""" def __init__(self): self.o = {} self.car_init({}, type("S", (), {"data": {}, "set": lambda s, k, v: 0})()) self.car_mode = carmode.MANUAL self.auto, self.shadow = True, False self.inverters, self.site_sign_wd = [], type("W", (), {"tripped": False})() self.circ_wd = type("W", (), {"tripped": False})() self.charger = type("H", (), {"configured": lambda s: True})() self.car = CH.CarTracker() self.car.reading = CH.ChargerReading(available=True, state="B") c = _C() c.car_writer.seq = {"stage": "settle", "t0": 100.0, "n": 1, "tries": 0, "prev": 16.0} M = ctl_car.OWN_PAUSE_MAX_S check("bound: the sequence's own maximum is its waits (0 A wait, settle, " "three tries at 15 s, the select) and no more", M == carmode.ZERO_WAIT_S + carmode.SETTLE_S + carmode.MAX_TRIES * 15.0 + 10.0 and ctl_car.OWN_PAUSE_TAIL_S == CH.CORR_WINDOW_S) check("bound: on at the 0 A write and up to the maximum", c._car_own_pause(100.0) and c._car_own_pause(100.0 + M)) check("bound: off one second past it", not c._car_own_pause(101.0 + M)) c.car_writer.seq = None c.car_writer.phase_done_at = 200.0 T = ctl_car.OWN_PAUSE_TAIL_S check("bound: after the current is set again it lasts one corroboration " "window", c._car_own_pause(200.0 + T) and not c._car_own_pause(201.0 + T)) c.car_writer.phase_done_at = None check("no sequence and none just done: no grace", not c._car_own_pause(100.0)) c.car_writer.seq = {"stage": "settle", "t0": 100.0, "failed": True} check("a refused write marks the sequence: no grace", not c._car_own_pause(110.0)) c.car_writer.seq = {"stage": "settle", "t0": 100.0} c.car_mode = carmode.OFF check("Off: no grace", not c._car_own_pause(110.0)) c.car_mode, c.shadow = carmode.MANUAL, True check("shadow mode: no grace", not c._car_own_pause(110.0)) c.shadow, c.auto = False, False check("control stopped: no grace", not c._car_own_pause(110.0)) c.auto = True c.car_writer.hold = True check("another writer (hold): no grace", not c._car_own_pause(110.0)) c.car_writer.hold = False c.car_writer.seq, c.car_writer.zero_sent_at = None, 100.0 check("0 A sent, not yet back: grace from the send, to the maximum, no more", c._car_own_pause(100.0) and c._car_own_pause(100.0 + M) and not c._car_own_pause(101.0 + M)) c.car_writer.zero_sent_at = None c.car_writer.phase_done_at = 200.0 c.car_writer.hold = True check("another writer in the 60 s after the current is set: no grace", not c._car_own_pause(210.0)) c.car_writer.hold, c.car_writer.phase_done_at = False, None c.car_writer.seq = {"stage": "settle", "t0": 100.0} c.car.reading = CH.ChargerReading(available=True, state="A") check("unplugged: no grace", not c._car_own_pause(110.0)) c.car.reading = CH.ChargerReading(available=True, state="B") check("PRECONDITION: the same state is on", c._car_own_pause(110.0)) tk = CH.CarTracker() tk.reading = CH.ChargerReading(available=True, state="B", power_w=500.0, allowed_a=16.0, phases_allowed=1) tk.last_ok = 0.0 check("the stand-in figure is the fresh reading, capped by the read-back", tk.car_w_paused(5.0) == 500.0 and tk.car_w_trusted(5.0) is None) check("a stale reading stands in for nothing", tk.car_w_paused(100.0) is None) tk.stuck_now = True check("a stuck reading stands in for nothing", tk.car_w_paused(5.0) is None) # =========================================================================== # print("\n5. THE WRITER RUNS BESIDE THE CYCLE (review F-1)") # =========================================================================== # # The car stops (state B) in the same Home Assistant update as the 0 A # read-back; the write has not returned yet, so no sequence exists. The window # opens when the write is SENT (`ManualWriter.zero_sent_at`). def lagged(lag, delay): def f(s): s.lag_s, s.stop_delay_s = lag, delay return f for lag, delay in ((2, 0), (0, 0), (2, 3), (5, 2)): r, tr, al = run(3000.0, 6050.0, 300, 600, 1, side=True, sim_fn=lagged(lag, delay)) nm = f"beside the cycle, lag {lag} s, stop delay {delay} s" limited = [x for x in tr if x[0] >= 600 and x[6]] check(f"{nm}: our sequence ran (select once, then 16 A again)", len([x for x in r["sim"].writes("phases")]) == 1 and r["sim"].phases_allowed == 1 and [x[2] for x in r["sim"].writes("current")][-2:] == [0.0, 16.0]) check(f"{nm}: no PEAK_GUARD_FLOOR_LIMITED, no goodwe_peak_soc_floor", al == []) check(f"{nm}: no red row, and the car explains every limited cycle", reds(tr) == [] and all(x[2] for x in limited)) def not_taken(plant, c): plant.ch.refuse = "ignore" # HA accepts, the charger does nothing r, tr, al = run(3000.0, 6050.0, 300, 600, 1, side=True, sim_fn=lagged(0, 0), extra={600: not_taken}) check("the 0 A write is not taken (read-back never follows): the window was " "open while it waited", any(x[1] for x in tr if 600 <= x[0] <= 606)) own = [x[0] for x in tr if x[1]] runs = 1 + len([1 for a, b in zip(own, own[1:]) if b - a > 1]) check("...and no grace after the refusal (the retry, RETRY_S later, opens it " "again only while that write waits: at most 3 runs of 11 s), no " "sequence made", not hit(tr, 613, 40) and r["c"].car_writer.seq is None and 1 <= runs <= 3 and len(own) <= 3 * 11) check("...the car went on charging and nothing was written but the 0 A", r["sim"].power_w > 5000.0 and not r["sim"].writes("phases")) print() if fails: print(f"FAIL: {len(fails)} check(s)") for f in fails: print(" -", f) sys.exit(1) print("ok: EV-15")