Files
goodwe-addon/goodwe_controller/test_ev15.py
T
glenn schrooyenandClaude 07f703d1bc
checks / unit (pull_request) Successful in 21m47s
infra-pin / fresh (pull_request) Successful in 1s
EV-15: test_ev15 guards its own indexing (named absence)
Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-17 13:39:11 +01:00

266 lines
11 KiB
Python

"""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 run(house, cap, t_res, t_sw, new, *, extra=None, mode="manual",
sim_fn=None, dur=895, plug=True):
"""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))
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:
from chargersim import SimCharger
sim = SimCharger(setpoint_a=16)
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.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()
if fails:
print(f"FAIL: {len(fails)} check(s)")
for f in fails:
print(" -", f)
sys.exit(1)
print("ok: EV-15")