A refused write on a live charger no longer reads as a stuck reading 60 s later, so a refused write shows one amber row (charger_refused). A frozen charger still arms and is still caught. Co-Authored-By: Claude <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w
973 lines
36 KiB
Python
973 lines
36 KiB
Python
"""EV-13: a refused current write shows ONE amber row, not two.
|
|
`python3 -B test_ev13.py`
|
|
|
|
The bug: `ManualWriter._write` armed the stuck-reading check on every write,
|
|
refused or not. A charger that ignores the write keeps its old setpoint, so the
|
|
read-back does not move, and 60 s later "Charger reading may be stuck" showed
|
|
beside "The charger did not take the setting", and the car figure was not
|
|
trusted (EV-15 rig: it latched the quarter).
|
|
|
|
The rule (owner's delegate, decision (b)): a refused write skips the arm ONLY
|
|
when the charger shows life: a change in the energy counter, a phase current or
|
|
the power, in a sample taken after the write was sent and within `TOOK_S` of it,
|
|
against the last value before. Present but unchanged, absent before, a stale
|
|
sample (taken before the send): not life. No life: it arms as before, dated the
|
|
send. A frozen charger (every write looks refused) is still caught.
|
|
|
|
Shapes: S = a tracker fed by a script (the test chooses each sample's values,
|
|
taken-at and arrival), W = the real Controller on `chargersim.SimCharger`, C =
|
|
`ev04_peak.drive` (the SAFETY-81 plant). Times are model seconds.
|
|
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
|
|
|
1. S: what counts as life (T3-T10, T12, T15)
|
|
2. W: live refusals, one amber row (T1, T2, T19)
|
|
3. W: no life, accepted writes, transitions (T11, T14, T17, T18, T20, T21)
|
|
4. W: errors, restart (T13, T25)
|
|
5. C: the peak guard (T16, T22-T24)
|
|
6. Writes, as on the base (T26)
|
|
"""
|
|
|
|
import asyncio
|
|
import dataclasses
|
|
import hashlib
|
|
import logging
|
|
import os
|
|
import sys
|
|
from datetime import datetime, timezone
|
|
|
|
HERE = os.path.dirname(os.path.abspath(__file__))
|
|
sys.path.insert(0, os.path.join(HERE, "tools"))
|
|
|
|
from app import carmode, chargers as CH, freshness # noqa: E402
|
|
from app.main import Controller # noqa: E402
|
|
from chargersim import FakeHa, SimCharger # noqa: E402
|
|
|
|
fails = []
|
|
|
|
|
|
def check(name, cond):
|
|
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
|
if not cond:
|
|
fails.append(name)
|
|
|
|
|
|
class _Log(logging.Handler):
|
|
def __init__(self):
|
|
super().__init__(logging.DEBUG)
|
|
self.rec = []
|
|
|
|
def emit(self, r):
|
|
self.rec.append((r.levelname, r.getMessage()))
|
|
|
|
def text(self, level=None):
|
|
return "\n".join(m for lv, m in self.rec if level in (None, lv))
|
|
|
|
|
|
LOG = _Log()
|
|
logging.getLogger("goodwe").addHandler(LOG)
|
|
logging.getLogger("goodwe").setLevel(logging.DEBUG)
|
|
logging.getLogger("goodwe").propagate = False
|
|
|
|
UTC = datetime(2026, 11, 22, tzinfo=timezone.utc)
|
|
DAY = "2026-11-22"
|
|
TS = 1000.0 # t_s in the S shape
|
|
TOOK_S, STUCK_S = CH.TOOK_S, CH.STUCK_S
|
|
|
|
|
|
# =========================================================================== #
|
|
print("1. S: WHAT COUNTS AS LIFE")
|
|
# =========================================================================== #
|
|
def rd(e=1.000, p=11040.0, cur=(16.0, 15.9, 16.0), a=16.0, taken=None,
|
|
state="C"):
|
|
return CH.ChargerReading(
|
|
available=True, state=state, charging=state == "C", power_w=p,
|
|
energy_kwh=e, current_a=cur, allowed_a=a, setpoint_a=a,
|
|
phases_allowed=3, taken_at=taken)
|
|
|
|
|
|
def steady(changes=None, start=1, end=130, **base):
|
|
"""One sample a second from TS+start to TS+end, taken on arrival. `changes`
|
|
is {second after TS: kwargs}; each change stays."""
|
|
out, kw = [], dict(base)
|
|
for s in range(start, end + 1):
|
|
kw.update((changes or {}).get(s, {}))
|
|
out.append((TS + s, rd(**kw)))
|
|
return out
|
|
|
|
|
|
def play(timeline, mode="live", ok=False, was=16.0, to=10.0, pre_end=0,
|
|
pre=None, end=TS + 130):
|
|
"""The tracker sees the pre-write samples, then the write (refused unless
|
|
`ok`), then `timeline` = [(arrival, ChargerReading)].
|
|
live: the write returns at once (HA said no), samples come after it.
|
|
ring: the write waited TOOK_S; the cycle's samples came meanwhile.
|
|
polls: the write waited and saw the samples itself (nothing else did).
|
|
Returns (tracker, first second `stuck()` was True, armed_at ever set)."""
|
|
tr = CH.CarTracker()
|
|
seen = {"armed": False, "first": None}
|
|
|
|
def obs(at, r):
|
|
tr.observe(r, at, UTC, DAY)
|
|
seen["armed"] |= tr.armed_at is not None
|
|
if seen["first"] is None and tr.stuck(at):
|
|
seen["first"] = at
|
|
|
|
for i in range(-20, pre_end + 1):
|
|
obs(TS + i, rd(**(pre or {})))
|
|
inside = [x for x in timeline if x[0] <= TS + TOOK_S]
|
|
outside = [x for x in timeline if x[0] > TS + TOOK_S]
|
|
if mode == "live":
|
|
tr.note_write(TS, was, to, ok)
|
|
rest = timeline
|
|
elif mode == "ring":
|
|
for at, r in inside:
|
|
obs(at, r)
|
|
tr.note_write(TS, was, to, ok)
|
|
rest = outside
|
|
else:
|
|
tr.note_write(TS, was, to, ok, [
|
|
(r.taken_at if r.taken_at is not None else at, r)
|
|
for at, r in inside])
|
|
rest = outside
|
|
seen["armed"] |= tr.armed_at is not None
|
|
for at, r in sorted(rest, key=lambda x: x[0]):
|
|
if at <= end:
|
|
obs(at, r)
|
|
return tr, seen["first"], seen["armed"]
|
|
|
|
|
|
MODES = ("live", "ring", "polls")
|
|
|
|
|
|
def pend(tr):
|
|
"""The refusal window a tracker keeps open (None: none)."""
|
|
return getattr(tr, "_pend", None)
|
|
|
|
|
|
def life(name, changes, **kw):
|
|
for m in MODES:
|
|
tr, first, armed = play(steady(changes), m, **kw)
|
|
check(f"{name} [{m}]: not armed, never stuck to TS+130",
|
|
tr.armed_at is None and first is None and not armed
|
|
and not tr.stuck_now)
|
|
|
|
|
|
def armed(name, tl, at=TS, **kw):
|
|
for m in MODES:
|
|
tr, first, ever = play(tl, m, **kw)
|
|
check(f"{name} [{m}]: armed at the send, stuck at TS+60 (+-1), "
|
|
f"not before TS+59 (first {first})",
|
|
first is not None and TS + 59 <= first <= TS + 61
|
|
and tr.armed_at == at and tr.stuck_now)
|
|
|
|
|
|
life("T3 energy alone steps 10 Wh at +4", {4: dict(e=1.010)})
|
|
life("T4 one phase current alone (L2 15.9 -> 16.0) at +4",
|
|
{4: dict(cur=(16.0, 16.0, 16.0))})
|
|
life("T5 power alone (11040 -> 11080 W) at +4", {4: dict(p=11080.0)})
|
|
life("T9 the step at +9, inside the window", {9: dict(e=1.010)})
|
|
life("T9 the step exactly at +10 (the edge counts)", {10: dict(e=1.010)})
|
|
life("T12(a) power None, state C, energy rising", {4: dict(e=1.010)},
|
|
pre=dict(p=None))
|
|
armed("T6 present but unchanged: every sample repeats the pre-write values",
|
|
steady())
|
|
armed("T9 the step at +11 is outside the window; armed_at is the send, not "
|
|
"+10 or +11", steady({11: dict(e=1.010)}))
|
|
armed("T10 energy absent before, present after: no change against a last "
|
|
"value", steady({4: dict(e=1.010)}), pre=dict(e=None))
|
|
armed("T12(b) power None, nothing else changes", steady(p=None),
|
|
pre=dict(p=None))
|
|
|
|
# T7: a stale sample: the pre-write sample again, the same taken-at time
|
|
for what, e in (("the same values", 1.000), ("changed values", 1.010)):
|
|
tl = [(TS + s, rd(e=e, taken=TS - 1.0)) for s in range(1, 131)]
|
|
armed(f"T7 stale sample ({what}, taken-at TS-1 again and again)", tl)
|
|
|
|
# T8: the late pre-write sample (EV-12 ordering): taken TS-1, arrives TS+2
|
|
late = [(TS + s, rd(e=1.010, taken=TS - 1.0) if s == 2 else rd(e=1.010))
|
|
for s in range(2, 131)]
|
|
armed("T8 a sample taken at TS-1 (+10 Wh) arrives at TS+2, nothing changes "
|
|
"after it", late, pre_end=-3)
|
|
|
|
# T15: the STUCK_MIN_A edge is as before
|
|
t15 = CH.CarTracker()
|
|
t15.observe(rd(), TS, UTC, DAY)
|
|
t15.note_write(TS, 10, 10.9)
|
|
a09 = t15.armed_at
|
|
t15.note_write(TS, 10, 11)
|
|
a10 = t15.armed_at
|
|
t15b = CH.CarTracker()
|
|
t15b.observe(rd(), TS, UTC, DAY)
|
|
t15b.note_write(TS, None, 10)
|
|
check("T15 a 0.9 A move does not arm, 1.0 A does, an unknown `was` does",
|
|
a09 is None and a10 == TS and t15b.armed_at == TS)
|
|
t15c = CH.CarTracker()
|
|
t15c.observe(rd(), TS, UTC, DAY)
|
|
t15c.note_write(TS, 10, 10.9, False)
|
|
t15d = CH.CarTracker()
|
|
t15d.observe(rd(), TS, UTC, DAY)
|
|
t15d.note_write(TS, 10, 11, False)
|
|
for i in range(1, 80):
|
|
t15d.observe(rd(), TS + i, UTC, DAY)
|
|
check("T15 a refused 0.9 A move arms nothing and leaves nothing waiting; a "
|
|
"refused 1.0 A move with no life arms",
|
|
t15c.armed_at is None and pend(t15c) is None and t15d.armed_at == TS
|
|
and t15d.stuck_now)
|
|
|
|
# the details the plan implies
|
|
tr = CH.CarTracker()
|
|
tr.observe(rd(), TS, UTC, DAY)
|
|
tr.note_write(TS, 16, 10, True)
|
|
check("E3: an accepted write arms at once, at the send", tr.armed_at == TS
|
|
and pend(tr) is None)
|
|
tr = CH.CarTracker()
|
|
for i in range(-5, 1):
|
|
tr.observe(rd(), TS + i, UTC, DAY)
|
|
tr.note_write(TS, 16, 10, False)
|
|
tr.observe(rd(), TS + 3, UTC, DAY)
|
|
tr.note_write(TS + 5, 10, 8, True)
|
|
check("an accepted write while a refusal's window is open arms at the "
|
|
"accepted write, and the window is dropped",
|
|
tr.armed_at == TS + 5 and pend(tr) is None)
|
|
tr = CH.CarTracker()
|
|
for i in range(-5, 1):
|
|
tr.observe(rd(), TS + i, UTC, DAY)
|
|
tr.note_write(TS, 16, 10, False)
|
|
tr.note_write(TS + 5, 10, 6, False)
|
|
tr.note_write(TS + 10, 6, 5, False)
|
|
for i in range(1, 70):
|
|
tr.observe(rd(), TS + i, UTC, DAY)
|
|
check("T20 shape: refusals 5 s apart with nothing changing arm once, dated "
|
|
"the FIRST", tr.armed_at == TS and tr.stuck_now)
|
|
tr = CH.CarTracker()
|
|
for i in range(-5, 1):
|
|
tr.observe(rd(), TS + i, UTC, DAY)
|
|
tr.note_write(TS, 16, 10, False)
|
|
for i in range(1, 5):
|
|
tr.observe(rd(e=1.010), TS + i, UTC, DAY)
|
|
tr.note_write(TS + 20, 10, 8, False)
|
|
check("a refusal that showed life leaves no window; a later refusal gets "
|
|
"its own", pend(tr) is not None and pend(tr)["t"] == TS + 20
|
|
and tr.armed_at is None)
|
|
|
|
# T18 (tracker): an armed check is neither cleared nor delayed by a refusal
|
|
tr = CH.CarTracker()
|
|
for i in range(-5, 1):
|
|
tr.observe(rd(), TS + i, UTC, DAY)
|
|
tr.note_write(TS, 16, 10, True)
|
|
for i in range(1, 20):
|
|
tr.observe(rd(), TS + i, UTC, DAY)
|
|
tr.note_write(TS + 20, 10, 8, False)
|
|
for i in range(20, 61):
|
|
tr.observe(rd(e=1.0 + i / 1000.0), TS + i, UTC, DAY)
|
|
check("T18 (tracker) an accepted write armed at TS; a live refusal at TS+20 "
|
|
"neither clears nor delays it: stuck at TS+60",
|
|
tr.armed_at == TS and tr.stuck_now and pend(tr) is None)
|
|
|
|
|
|
# =========================================================================== #
|
|
# W: the real Controller on the charger model
|
|
# =========================================================================== #
|
|
class _Store:
|
|
def __init__(self):
|
|
self.data = {}
|
|
|
|
def set(self, k, v):
|
|
self.data[k] = v
|
|
|
|
def get(self, k, d=None):
|
|
return self.data.get(k, d)
|
|
|
|
def set_time(self, k, v):
|
|
self.data[k] = v.isoformat()
|
|
|
|
def get_time(self, k):
|
|
v = self.data.get(k)
|
|
return None if v is None else datetime.fromisoformat(v)
|
|
|
|
|
|
class _Pub:
|
|
enabled = False
|
|
|
|
def __init__(self):
|
|
self.values = []
|
|
|
|
def publish(self, v):
|
|
self.values.append(dict(v))
|
|
|
|
def close(self):
|
|
pass
|
|
|
|
|
|
class Site(FakeHa):
|
|
def __init__(self, charger, grid=500.0, batt=0.0, pv=2000.0):
|
|
super().__init__(charger, None)
|
|
self.grid, self.batt, self.pv = grid, batt, pv
|
|
|
|
async def limits(self, _e):
|
|
return (-5000.0, 5000.0, 1.0)
|
|
|
|
def _all(self):
|
|
out = super()._all()
|
|
for eid, val, unit in (("sensor.grid", self.grid, "W"),
|
|
("sensor.soc", 50.0, "%"),
|
|
("sensor.batt", self.batt, "W"),
|
|
("sensor.pv", self.pv, "W")):
|
|
out[eid] = {"entity_id": eid, "state": str(val),
|
|
"attributes": {"unit_of_measurement": unit}}
|
|
return out
|
|
|
|
async def number(self, entity_id, invert=False):
|
|
s = self._all().get(entity_id)
|
|
try:
|
|
v = float(s["state"])
|
|
except (TypeError, ValueError, KeyError):
|
|
return None
|
|
return -v if invert else v
|
|
|
|
async def set_number(self, entity_id, value):
|
|
if entity_id == "number.sp":
|
|
self.sets.append((entity_id, float(value)))
|
|
self.batt = float(value)
|
|
return True
|
|
return await super().set_number(entity_id, float(value))
|
|
|
|
|
|
BASE = {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
|
|
"soc_entity": "sensor.soc", "batt_entity": "sensor.batt",
|
|
"meter_source": "off", "max_w": 5000, "gain": 0.6, "slew_w": 500,
|
|
"deadband_w": 15, "target_grid_w": 0, "step_w": 10, "heartbeat_s": 10,
|
|
"stale_input_s": 15, "shadow_mode": "off", "peak_cap_w": 3500,
|
|
"pv_entities": ["sensor.pv"]}
|
|
SET = "number.wallbox_power_connector_max_current_socket_1"
|
|
CAR = dict(BASE, ev_charger="alfen_ha", ev_max_a=16, ev_phases="auto",
|
|
ev_current_entity=SET)
|
|
CLOCK = [1000.0]
|
|
freshness.monotonic = lambda: CLOCK[0]
|
|
|
|
|
|
class World:
|
|
"""A real Controller on the charger model, one clock for all of it."""
|
|
|
|
def __init__(self, opts=CAR, sim=None, store=None, setpoint=16, phases=3,
|
|
grid=800.0, beside=False):
|
|
self.sim = sim or SimCharger(setpoint_a=setpoint)
|
|
self.sim.plug_in()
|
|
self.sim.phases_allowed = phases
|
|
self.site = Site(self.sim, grid=grid)
|
|
self.store = store or _Store()
|
|
self.t = 1000.0
|
|
CLOCK[0] = self.t
|
|
self.off = self.t - self.sim.t # sim time + off = this clock
|
|
self.make(opts)
|
|
if beside:
|
|
self.beside()
|
|
|
|
def beside(self):
|
|
"""The writer runs BESIDE the cycle, as in production: the cycle reads
|
|
(and the tracker sees) the charger while a write waits for its
|
|
read-back, one poll per cycle."""
|
|
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)
|
|
self.drv._sleep = sleep
|
|
self.c.car_settle = settle
|
|
|
|
def make(self, opts):
|
|
self.c = Controller(dict(opts), self.site, self.store, _Pub(),
|
|
stop=asyncio.Event())
|
|
self.c.auto = True
|
|
self.c.dev_min, self.c.dev_max = -5000.0, 5000.0
|
|
self.drv = self.c.charger
|
|
self.drv._sleep = self.sleep
|
|
self.drv._clock = lambda: CLOCK[0]
|
|
|
|
async def sleep(self, s):
|
|
self.sim.tick(s)
|
|
self.t += s
|
|
CLOCK[0] = self.t
|
|
|
|
async def step(self, n=1, dt=1.0):
|
|
out = []
|
|
for _ in range(n):
|
|
self.sim.tick(dt)
|
|
self.t += dt
|
|
CLOCK[0] = self.t
|
|
await self.c.read_inputs(now_mono=self.t)
|
|
await self.c.cycle()
|
|
await self.c.car_settle()
|
|
tk = self.c.car
|
|
out.append((tk.obs_at, tk.armed_at, tk.stuck(self.t)))
|
|
return out
|
|
|
|
async def act(self, what, value):
|
|
return await self.c.handle_action(what, value=value)
|
|
|
|
def rows(self):
|
|
return {r["id"]: r for r in self.c.checks()}
|
|
|
|
def amber(self):
|
|
"""The charger's amber rows: not ok, warn."""
|
|
return sorted(i for i, r in self.rows().items()
|
|
if r["warn"] and not r["ok"] and i.startswith("charger"))
|
|
|
|
def sends(self):
|
|
"""The model seconds (this clock) of every current write received."""
|
|
return [x[0] + self.off for x in self.sim.writes("current")]
|
|
|
|
|
|
def run(coro):
|
|
return asyncio.run(coro)
|
|
|
|
|
|
SEND = {} # T26: what the charger was sent, per shape
|
|
|
|
|
|
def keep(key, w, res):
|
|
"""The writes of one run: the driver's calls (second, value, taken) and
|
|
what the model received (model second, kind, value)."""
|
|
SEND[key] = ([(round(t), a, r) for t, a, r in res],
|
|
[(round(x[0]), x[1], x[2]) for x in w.sim.writes()])
|
|
|
|
|
|
async def live_car(setpoint=16, phases=3, **kw):
|
|
"""Manual, the car charging `setpoint` A on `phases`, ramped up."""
|
|
w = World(setpoint=setpoint, phases=phases, **kw)
|
|
await w.step(6)
|
|
await w.act("car_phases", phases) # the wish is what the car has
|
|
await w.act("car_mode", "manual")
|
|
await w.act("car_current", setpoint)
|
|
await w.step(4)
|
|
return w
|
|
|
|
|
|
def spy_on(w):
|
|
"""[(send time, current, ok)] of every `write_current`."""
|
|
res, real = [], w.drv.write_current
|
|
|
|
async def spy(a):
|
|
t = w.t
|
|
r = await real(a)
|
|
res.append((t, a, r))
|
|
return r
|
|
w.drv.write_current = spy
|
|
return res
|
|
|
|
|
|
def never_stuck(tr, lo=0):
|
|
return all(a is None and not s for _t, a, s in tr[lo:])
|
|
|
|
|
|
def first_stuck(tr):
|
|
return next((t for t, _a, s in tr if s), None)
|
|
|
|
|
|
|
|
|
|
# =========================================================================== #
|
|
print("\n2. W: LIVE REFUSALS SHOW ONE AMBER ROW")
|
|
# =========================================================================== #
|
|
# Each W shape runs twice: the writer inside the cycle (the model's own
|
|
# waits), and BESIDE it as in production (the cycle reads while a write waits).
|
|
SIDES = ((False, "inside"), (True, "beside"))
|
|
|
|
|
|
async def t1(kind, beside):
|
|
w = await live_car(beside=beside)
|
|
w.sim.refuse = kind
|
|
res = spy_on(w)
|
|
await w.act("car_current", 10)
|
|
tr = await w.step(400)
|
|
return w, res, tr
|
|
|
|
|
|
for beside, side in SIDES:
|
|
for kind, nm in (("ignore", "T1 the charger ignores it (HA says yes)"),
|
|
("error", "T2 HA refuses at once (False at +0)")):
|
|
LOG.rec.clear()
|
|
w, res, tr = run(t1(kind, beside))
|
|
ts = [t for t, _a, _r in res]
|
|
keep(f"{nm[:2]}-{kind}-{side}", w, res)
|
|
nm = f"{nm} [{side}]"
|
|
check(f"{nm}: three tries about a minute apart, all refused, then "
|
|
f"it gives up ({[round(x - ts[0]) for x in ts]})",
|
|
len(res) == 3 and not any(r for _t, _a, r in res)
|
|
and all(55 <= b - a <= 75 for a, b in zip(ts, ts[1:]))
|
|
and w.c.car_writer.gave_up)
|
|
check(f"{nm}: the car shows life inside each window: never armed, "
|
|
"never stuck, to 400 s", never_stuck(tr))
|
|
check(f"{nm}: after the 3rd try exactly ONE amber charger row, "
|
|
f"charger_refused ({w.amber()})",
|
|
w.amber() == ["charger_refused"])
|
|
check(f"{nm}: the car figure is still used by the alarm path",
|
|
w.c.car_alarm_w() is not None)
|
|
check(f"{nm}: N8 one CHARGER_REFUSED warning, no Traceback; N7 no "
|
|
"'another writer' row",
|
|
LOG.text("WARNING").count("CHARGER_REFUSED") == 1
|
|
and "Traceback" not in LOG.text()
|
|
and "charger_other" not in w.rows()
|
|
and "charger_writer" not in w.rows())
|
|
|
|
|
|
async def t19(beside):
|
|
w = await live_car(16, 3, beside=beside)
|
|
w.sim.refuse = "ignore"
|
|
res = spy_on(w)
|
|
await w.act("car_phases", 1)
|
|
tr = await w.step(400)
|
|
return w, res, tr
|
|
|
|
|
|
for beside, side in SIDES:
|
|
LOG.rec.clear()
|
|
w, res, tr = run(t19(beside))
|
|
keep(f"T19-{side}", w, res)
|
|
check(f"T19 [{side}] the 0 A of a phase change is ignored and the car "
|
|
"keeps drawing: tried MAX_TRIES times, no select, never armed or "
|
|
"stuck", len(res) == carmode.MAX_TRIES
|
|
and not any(r for _t, _a, r in res)
|
|
and all(a == 0.0 for _t, a, _r in res)
|
|
and not w.sim.writes("phases") and never_stuck(tr))
|
|
check(f"T19 [{side}] ...and no charger_stuck row; charger_refused shows "
|
|
f"({w.amber()})", "charger_refused" in w.amber()
|
|
and "charger_stuck" not in w.amber())
|
|
|
|
|
|
# =========================================================================== #
|
|
print("\n3. W: NO LIFE, ACCEPTED WRITES, TRANSITIONS")
|
|
# =========================================================================== #
|
|
async def t11(beside):
|
|
w = await live_car(beside=beside)
|
|
w.sim.set_current(5) # under 6 A: B, exactly 0 W, waiting
|
|
await w.step(8)
|
|
w.sim.refuse = "ignore"
|
|
res = spy_on(w)
|
|
await w.act("car_current", 10)
|
|
tr = await w.step(300)
|
|
return w, res, tr
|
|
|
|
|
|
for beside, side in SIDES:
|
|
LOG.rec.clear()
|
|
w, res, tr = run(t11(beside))
|
|
keep(f"T11-{side}", w, res)
|
|
t_s = res[0][0]
|
|
fs = first_stuck(tr)
|
|
check(f"T11 [{side}] a paused car (B, 0 W) shows no life: it arms as "
|
|
f"today, stuck at t_s+60 ({fs - t_s if fs else None})",
|
|
w.sim.state == "B" and w.sim.power_w == 0.0 and fs is not None
|
|
and 59 <= fs - t_s <= 61)
|
|
check(f"T11 [{side}] ...and after the 3rd try both amber rows show: "
|
|
f"{w.amber()}", w.amber() == ["charger_refused", "charger_stuck"])
|
|
|
|
|
|
async def t14():
|
|
w = await live_car(beside=True)
|
|
w.sim.lag_s = 3.0 # the read-back is seen by the cycle
|
|
w.sim.freeze_power() # the power sticks, the rest is live
|
|
res = spy_on(w)
|
|
await w.act("car_current", 8)
|
|
tr = await w.step(100)
|
|
return w, res, tr
|
|
|
|
|
|
LOG.rec.clear()
|
|
w, res, tr = run(t14())
|
|
t_s = res[0][0]
|
|
fs = first_stuck(tr)
|
|
check(f"T14 an ACCEPTED write (read-back 3 s late) under a frozen power: "
|
|
f"stuck at t_s+60 (+-1), as before ({fs - t_s if fs else None})",
|
|
res[0][2] is True and fs is not None and 59 <= fs - t_s <= 61
|
|
and w.c.car.armed_at == t_s)
|
|
check("T14 ...the amber row 'charger_stuck' shows, and the car figure is not "
|
|
"trusted while stuck (N4)", "charger_stuck" in w.amber()
|
|
and w.c.car.car_w_trusted(w.t) is None and w.c.car_alarm_w() is None)
|
|
|
|
|
|
async def t17():
|
|
w = await live_car(beside=True)
|
|
w.sim.refuse = "ignore"
|
|
res = spy_on(w)
|
|
await w.act("car_current", 10)
|
|
tr = await w.step(70) # tries at t_s and t_s+60: live
|
|
w.sim.refuse = None
|
|
w.sim.lag_s = 3.0
|
|
w.sim.freeze_power()
|
|
await w.act("car_current", 12)
|
|
tr += await w.step(120)
|
|
return w, res, tr
|
|
|
|
|
|
LOG.rec.clear()
|
|
w, res, tr = run(t17())
|
|
t_s, t_acc = res[0][0], res[-1][0]
|
|
fs = first_stuck(tr)
|
|
check(f"T17 live refusals (not armed), then an accepted write at t_s+"
|
|
f"{t_acc - t_s:.0f}: not armed before it, stuck at ITS +60 (+-1) "
|
|
f"({fs - t_acc if fs else None})",
|
|
res[-1][2] is True and t_acc - t_s > 61 and fs is not None
|
|
and 59 <= fs - t_acc <= 61
|
|
and all(a is None for t, a, _s in tr if t < t_acc))
|
|
|
|
|
|
async def t18():
|
|
w = await live_car(beside=True)
|
|
w.sim.lag_s = 3.0
|
|
w.sim.freeze_power()
|
|
res = spy_on(w)
|
|
await w.act("car_current", 12) # accepted: arms
|
|
tr = await w.step(19)
|
|
w.sim.lag_s = 0.0
|
|
w.sim.refuse = "ignore"
|
|
await w.act("car_current", 10) # a live refusal 20 s later
|
|
tr += await w.step(100)
|
|
return w, res, tr
|
|
|
|
|
|
LOG.rec.clear()
|
|
w, res, tr = run(t18())
|
|
t0 = res[0][0]
|
|
fs = first_stuck(tr)
|
|
check(f"T18 an accepted write armed at t0; a live refusal at t0+"
|
|
f"{res[1][0] - t0:.0f} neither clears nor delays it: stuck at t0+60 "
|
|
f"({fs - t0 if fs else None}), still dated t0",
|
|
len(res) >= 2 and res[1][2] is False and fs is not None
|
|
and 59 <= fs - t0 <= 61 and tr[-1][1] == t0
|
|
and all(a == t0 for _t, a, _s in tr if a is not None))
|
|
|
|
|
|
async def t21(beside):
|
|
w = await live_car(10, 3, beside=beside)
|
|
w.sim.lag_s = 14.0
|
|
res = spy_on(w)
|
|
await w.act("car_current", 12)
|
|
tr = await w.step(120)
|
|
return w, res, tr
|
|
|
|
|
|
for beside, side in SIDES:
|
|
LOG.rec.clear()
|
|
w, res, tr = run(t21(beside))
|
|
keep(f"T21-{side}", w, res)
|
|
check(f"T21 [{side}] HA took it, the read-back comes 14 s late (False at "
|
|
"+10): never stuck, no 'another writer' row, 12 A adopted, one "
|
|
"write", [(a, r) for _t, a, r in res] == [(12.0, False)]
|
|
and not any(st for _t, _a, st in tr)
|
|
and "charger_other" not in w.rows()
|
|
and "charger_writer" not in w.rows()
|
|
and w.c.car_writer.last_a == 12.0 and w.sim.readback_a == 12.0)
|
|
|
|
|
|
async def t20(beside):
|
|
"""EV-28 T15 shape: the 0 A is taken and the car stops, the select is
|
|
taken, then the restore is refused MAX_TRIES times 5 s apart at 0 W."""
|
|
w = await live_car(16, 3, beside=beside)
|
|
res = spy_on(w)
|
|
await w.act("car_phases", 1)
|
|
for _ in range(60):
|
|
await w.step(1)
|
|
if w.sim.phases_allowed == 1:
|
|
break
|
|
w.sim.refuse = "error"
|
|
tr = await w.step(150)
|
|
return w, res, tr
|
|
|
|
|
|
for beside, side in SIDES:
|
|
LOG.rec.clear()
|
|
w, res, tr = run(t20(beside))
|
|
keep(f"T20-{side}", w, res)
|
|
rest = [x for x in res if x[1] == 16.0]
|
|
fs = first_stuck(tr)
|
|
t_r = rest[0][0] if rest else None
|
|
check(f"T20 [{side}] the 0 A is taken, the restore is refused "
|
|
f"{len(rest)} times at 0 W with nothing changing: it arms as on "
|
|
f"the base, dated the first refusal (stuck at +"
|
|
f"{fs - t_r if fs and t_r else None})",
|
|
len(rest) >= carmode.MAX_TRIES and not any(r for _t, _a, r in rest)
|
|
and w.sim.power_w == 0.0 and fs is not None and 59 <= fs - t_r <= 61)
|
|
check(f"T20 [{side}] ...no select besides the one made, and the rows "
|
|
f"are as on the base ({w.amber()})",
|
|
len(w.sim.writes("phases")) == 1
|
|
and "charger_stuck" in w.amber())
|
|
|
|
|
|
# =========================================================================== #
|
|
print("\n4. W: AN ERROR AND A RESTART")
|
|
# =========================================================================== #
|
|
async def t13(exc):
|
|
w = await live_car()
|
|
n0 = len(LOG.rec)
|
|
|
|
async def boom(a):
|
|
await w.sleep(1.0)
|
|
raise exc
|
|
w.drv.write_current = boom
|
|
await w.act("car_current", 10)
|
|
tr = await w.step(30)
|
|
return w, tr, n0
|
|
|
|
|
|
from app import hass # noqa: E402
|
|
for exc in (RuntimeError("the link broke"), hass.ReadOnly("read only")):
|
|
LOG.rec.clear()
|
|
w, tr, n0 = run(t13(exc))
|
|
errs = [m for lv, m in LOG.rec[n0:]
|
|
if lv == "ERROR" and "car charger step failed" in m]
|
|
check(f"T13 write_current raises {type(exc).__name__}: as on the base: "
|
|
"never armed, no window left, no refusal counted, the mute set, "
|
|
f"the step error logged once ({len(errs)})",
|
|
never_stuck(tr) and pend(w.c.car) is None
|
|
and w.c.car_writer.fails == 0 and w.c.car.mute_until > 0
|
|
and len(errs) == 1)
|
|
|
|
|
|
async def t25():
|
|
w = await live_car()
|
|
w.sim.refuse = "ignore"
|
|
await w.act("car_current", 10)
|
|
await w.step(75) # two tries
|
|
fails_before = w.c.car_writer.fails
|
|
w.make(CAR) # a restart: a new Controller
|
|
return w, fails_before
|
|
|
|
|
|
w, fb = run(t25())
|
|
check("T25 a restart after 2 refusals: a fresh tracker and writer, nothing "
|
|
"armed, nothing waiting, no failures counted",
|
|
fb == 2 and w.c.car.armed_at is None and pend(w.c.car) is None
|
|
and not w.c.car.stuck(w.t) and w.c.car_writer.fails == 0)
|
|
|
|
# =========================================================================== #
|
|
print("\n5. C: THE PEAK GUARD (the real Controller on the SAFETY-81 plant)")
|
|
# =========================================================================== #
|
|
import ev04_peak as P # noqa: E402
|
|
import safety81_sim as s81 # noqa: E402
|
|
|
|
HOUSE = 3000.0
|
|
AIM = 6050.0
|
|
|
|
|
|
def drive(events, dur, house=HOUSE, aim=AIM, **kw):
|
|
"""P.drive with a trace per second, taken before that second's cycle:
|
|
(second, armed_at, stuck, car_alarm_w, the alarms so far)."""
|
|
tr = []
|
|
|
|
def note(plant, c):
|
|
tr.append((plant.t, c.car.armed_at, c.car.stuck_now, c.car_alarm_w()))
|
|
ev = {t: note for t in range(0, dur)}
|
|
for t, fn in events.items():
|
|
ev[t] = (lambda p, c, fn=fn: (fn(p, c), note(p, c)))
|
|
kw.setdefault("phases", 3)
|
|
kw.setdefault("setpoint", 16)
|
|
kw.setdefault("user_a", 16)
|
|
r = P.drive(s81.constant(house), dur=dur, rating=12000.0, soc=60.0,
|
|
cap=aim, events=ev, **kw)
|
|
return r, tr
|
|
|
|
|
|
def user_change(a):
|
|
def fn(plant, c):
|
|
asyncio.get_event_loop().create_task(c.handle_action(
|
|
"car_current", value=a))
|
|
return fn
|
|
|
|
|
|
def reserve(plant, c):
|
|
"""Both units at the peak reserve, the house on, the car 11 kW."""
|
|
plant.soc = 19.0
|
|
plant.load = lambda t: HOUSE + plant.ch.power_w
|
|
|
|
|
|
def sends(r):
|
|
return [(round(x[0]), x[1], x[2]) for x in r["sim"].writes()]
|
|
|
|
|
|
def amber_rows(r):
|
|
return sorted(x["id"] for x in r["c"].checks()
|
|
if x["warn"] and not x["ok"] and x["id"].startswith("charger"))
|
|
|
|
|
|
ALARMS = P.ALARMS + ("goodwe_peak_floor_limited",)
|
|
|
|
|
|
def alarm_list(r):
|
|
return P.ids(r, *P.ALARMS)
|
|
|
|
|
|
# T22: a live refusal under a car-caused overload raises nothing the twin
|
|
# does not
|
|
def t22_events(change):
|
|
ev = {300: lambda p, c: (reserve(p, c), setattr(p.ch, "refuse", "ignore")
|
|
if change else None)}
|
|
if change:
|
|
ev[301] = user_change(10)
|
|
return ev
|
|
|
|
|
|
r_ref, tr_ref = drive(t22_events(True), 700)
|
|
r_twin, tr_twin = drive(t22_events(False), 700)
|
|
w_ref = [x[3] for x in tr_ref if x[0] >= 300]
|
|
w_twin = [x[3] for x in tr_twin if x[0] >= 300]
|
|
check("T22 PRECONDITION: the refusals happened (3 tries) and the twin wrote "
|
|
"nothing", len(r_ref["sim"].writes("current")) == 3
|
|
and r_twin["sim"].writes("current") == [])
|
|
check("T22 a live refusal under a car-caused overload: the car figure used by "
|
|
"the alarm path is the twin's every cycle from 300 to 700 (+-1 W)",
|
|
len(w_ref) == len(w_twin) and all(
|
|
(a is None and b is None) or (a is not None and b is not None
|
|
and abs(a - b) <= 1.0)
|
|
for a, b in zip(w_ref, w_twin)))
|
|
check(f"T22 ...and the alarms are the twin's ({alarm_list(r_ref)} vs "
|
|
f"{alarm_list(r_twin)})", alarm_list(r_ref) == alarm_list(r_twin)
|
|
and alarm_list(r_ref) == [])
|
|
check("T22 ...never armed, never stuck", all(a is None and not s
|
|
for _t, a, s, _w in tr_ref))
|
|
|
|
# T16: the test_ev04 section 9 shape: everything frozen, the car really goes,
|
|
# the user sets 10 A: the write is refused and nothing changes
|
|
|
|
|
|
def freeze_all(plant, c):
|
|
plant.ch.freeze() # every reading sticks, the
|
|
plant.ch.unplug() # read-back too; the car goes
|
|
plant.load = lambda at: 9000.0 + plant.ch.power_w
|
|
|
|
|
|
r16, tr16 = drive({60: lambda p, c: (freeze_all(p, c),
|
|
user_change(10)(p, c))}, 400,
|
|
house=1100.0, aim=3500.0)
|
|
SEND["T16"] = ([], sends(r16))
|
|
log16 = [x for x in r16["c"].car_writer.log if x[0] == "current"]
|
|
t_s = log16[0][2] if log16 else None
|
|
fs = next((t for t, _a, s, _w in tr16 if s), None)
|
|
al16 = P.ids(r16, "goodwe_peak_saturated")
|
|
check(f"T16 everything frozen, the write is refused: it arms at t_s={t_s} "
|
|
f"and is stuck at t_s+60 +-2 (first {fs})",
|
|
t_s is not None and fs is not None and 58 <= fs - t_s <= 62
|
|
and not any(x[3] for x in log16))
|
|
check(f"T16 ...after MAX_TRIES both rows show: {amber_rows(r16)}",
|
|
amber_rows(r16) == ["charger_refused", "charger_stuck"])
|
|
check("T16 ...the car figure is not used while stuck, and the normal alarm "
|
|
f"fires before freeze+60+60+25 ({al16})",
|
|
r16["c"].car_alarm_w() is None and len(al16) == 1
|
|
and al16[0][0] < 60 + 60 + 25)
|
|
|
|
# T23 (EV-10 trap): a 6 A, 1 phase car (1.38 kW) takes no energy step inside
|
|
# the window, so its refusal arms as today. The house then steps 1.7 kW over
|
|
# the aim: the car does not explain it, so the alarm comes at the twins' cycle.
|
|
def t23_events(change, t_s=570):
|
|
def house_drain(plant, c): # test_ev10's trap shape
|
|
plant.soc = 19.0
|
|
plant.load = lambda at: 12000.0 + plant.ch.power_w
|
|
return {t_s - 1: lambda p, c: (setattr(p.ch, "refuse", "ignore")
|
|
if change else None),
|
|
t_s: user_change(8) if change else (lambda p, c: None),
|
|
t_s + 30: house_drain}
|
|
|
|
|
|
def t23(change, mode="manual"):
|
|
return drive(t23_events(change), 800, house=1100.0, aim=4500.0,
|
|
phases=1, setpoint=6, user_a=6, mode=mode)
|
|
|
|
|
|
r23, tr23 = t23(True)
|
|
r23a, tr23a = t23(False)
|
|
r23o, tr23o = t23(False, mode="off")
|
|
a23, a23a, a23o = (P.ids(x, *P.ALARMS) for x in (r23, r23a, r23o))
|
|
check(f"T23 PRECONDITION: the refusal found no life (6 A, 1.38 kW): it armed "
|
|
f"as today, stuck at t_s+60", any(s for _t, _a, s, _w in tr23)
|
|
and len(r23["sim"].writes("current")) >= 1)
|
|
check(f"T23 the alarm fires at the same second as both twins (refusal "
|
|
f"{a23}, no write {a23a}, Off {a23o})", len(a23) == 1
|
|
and [n for _t, n in a23] == [n for _t, n in a23a]
|
|
and abs(a23[0][0] - a23a[0][0]) <= 1 and a23o
|
|
and abs(a23[0][0] - a23o[0][0]) <= 1)
|
|
|
|
|
|
# T24 (EV-18): after a live refusal (not armed) the energy meter stops while
|
|
# the power says 11 kW: the figure is contradicted and the quarter latched.
|
|
# (The tries are at 300, 360 and 420, each live; the meter stops after them.)
|
|
def meter_stops(plant, c):
|
|
sim, tick = plant.ch, plant.ch.tick
|
|
|
|
def stuck_meter(secs=1.0):
|
|
kwh = sim.kwh
|
|
tick(secs)
|
|
sim.kwh = kwh
|
|
sim.tick = stuck_meter
|
|
|
|
|
|
def t24(change):
|
|
ev = {299: lambda p, c: (reserve(p, c), setattr(p.ch, "refuse", "ignore")
|
|
if change else None),
|
|
300: user_change(10) if change else (lambda p, c: None),
|
|
432: meter_stops} # after the 3rd try's window
|
|
seen = []
|
|
|
|
def watch(plant, c):
|
|
seen.append((plant.t, c._car_contradicted(c.car_now()),
|
|
c._car_contra_block))
|
|
for t in range(300, 700):
|
|
prev = ev.get(t)
|
|
ev[t] = (lambda p, c, prev=prev: (prev(p, c) if prev else None,
|
|
watch(p, c)))
|
|
r, tr = drive(ev, 700)
|
|
return r, tr, seen
|
|
|
|
|
|
r24, tr24, seen24 = t24(True)
|
|
check("T24 PRECONDITION: a live refusal at 300 (not armed)",
|
|
len(r24["sim"].writes("current")) >= 1
|
|
and all(a is None and not st for t, a, st, _w in tr24))
|
|
check("T24 after a live refusal the meter that falls short for a window "
|
|
"contradicts the figure and latches the quarter (a refusal hides no "
|
|
"contradiction)", any(x[1] for x in seen24)
|
|
and seen24[-1][2] is not None)
|
|
|
|
# =========================================================================== #
|
|
print("\n6. WRITES: THE SAME AS ON THE BASE (T26, N3)")
|
|
# =========================================================================== #
|
|
if os.environ.get("EV13_DUMP"):
|
|
for k in sorted(SEND):
|
|
print("DUMP", repr(k), repr(SEND[k]))
|
|
BASE_SENDS = { # recorded on 76f4de2 (release/1.0 before EV-13)
|
|
'T1-ignore-beside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], [(11, 'current', 10.0), (71, 'current', 10.0), (131, 'current', 10.0)]),
|
|
'T1-ignore-inside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], [(11, 'current', 10.0), (71, 'current', 10.0), (131, 'current', 10.0)]),
|
|
'T11-beside': ([(1019, 10.0, False), (1079, 10.0, False), (1139, 10.0, False)], [(19, 'current', 10.0), (79, 'current', 10.0), (139, 'current', 10.0)]),
|
|
'T11-inside': ([(1019, 10.0, False), (1079, 10.0, False), (1139, 10.0, False)], [(19, 'current', 10.0), (79, 'current', 10.0), (139, 'current', 10.0)]),
|
|
'T16': ([], [(61, 'current', 10.0), (131, 'current', 10.0), (201, 'current', 10.0)]),
|
|
'T19-beside': ([(1011, 0.0, False), (1071, 0.0, False), (1131, 0.0, False)], [(11, 'current', 0.0), (71, 'current', 0.0), (131, 'current', 0.0)]),
|
|
'T19-inside': ([(1011, 0.0, False), (1071, 0.0, False), (1131, 0.0, False)], [(11, 'current', 0.0), (71, 'current', 0.0), (131, 'current', 0.0)]),
|
|
'T2-error-beside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], []),
|
|
'T2-error-inside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], []),
|
|
'T20-beside': ([(1011, 0.0, True), (1025, 16.0, False), (1030, 16.0, False), (1035, 16.0, False), (1095, 16.0, False), (1155, 16.0, False)], [(11, 'current', 0.0), (15, 'phases', 1)]),
|
|
'T20-inside': ([(1011, 0.0, True), (1025, 16.0, False), (1030, 16.0, False), (1035, 16.0, False), (1095, 16.0, False), (1155, 16.0, False)], [(11, 'current', 0.0), (15, 'phases', 1)]),
|
|
'T21-beside': ([(1011, 12.0, False)], [(11, 'current', 12.0)]),
|
|
'T21-inside': ([(1011, 12.0, False)], [(11, 'current', 12.0)]),
|
|
}
|
|
for k in sorted(SEND):
|
|
check(f"T26 {k}: the writes (second, value, taken) and what the model "
|
|
"received are the base's", BASE_SENDS.get(k) == SEND[k])
|
|
check("T26 no write above the clamp (16 A), and the one select (T20) came "
|
|
"with the car at 0 W", all(a <= 16.0 for v in SEND.values()
|
|
for _t, a, _r in v[0])
|
|
and sorted(k for k, v in SEND.items()
|
|
if any(x[1] == "phases" for x in v[1])) == ["T20-beside",
|
|
"T20-inside"])
|
|
|
|
print()
|
|
if fails:
|
|
print(f"FAIL: {len(fails)} check(s)")
|
|
for f in fails:
|
|
print(" -", f)
|
|
sys.exit(1)
|
|
print("ok: EV-13")
|