The writer runs beside the cycle and the car can stop before the write returns, so no sequence existed yet and the latch set. Window now opens at send (zero_sent_at), cleared on return; ends on another writer in the tail too. Co-Authored-By: Claude <noreply@anthropic.com>
345 lines
15 KiB
Python
345 lines
15 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 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")
|