Files
goodwe-addon/goodwe_controller/test_ev04.py
T
glenn schrooyenandClaude 6e6344eb02
checks / unit (pull_request) Successful in 21m33s
infra-pin / fresh (pull_request) Successful in 2s
EV-04 round 3: guard the L4 test's reads for test_named_absence
Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-16 08:22:16 +01:00

1867 lines
74 KiB
Python

"""EV-04: the car charger's Manual mode, the first card that WRITES to a charger.
`python3 -B test_ev04.py`
1. Off writes nothing (EV-03's no-write test keeps passing for Off), whatever
the user sets while Off.
2. Mode, current and phases are runtime state: actions, refusals, the store, the
mode after a restart.
3. Manual writes the current once per user change, read back within 10 s.
4. The clamp: nothing above min(ev_max_a, station limit, entity range) is ever
sent (property-style), and a value above it is a software fault.
5. Phase changes: the safe sequence in order, one switch per 10 minutes.
6. Shadow mode and a stopped control write nothing; the card says what it would.
7. Fail states, the Manual column.
8. Another writer.
9. The peak guard's alarm path: the car you set is not a false alarm, and a
stale or stuck reading never hides a real overload (real Controller, 1 s
cycle, the SAFETY-81 plant plus a charger).
10. Decision 1: batteries help on and off.
11. The peak line: set by the car, and the Peak card's car line.
12. Home Assistant entities, strings, the page's /action route.
13. The simulator.
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
"""
import asyncio
import io
import json
import logging
import os
import random
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 carmode, chargers as CH, homeview, messages, mqtt # noqa: E402
from app.main import Controller # noqa: E402
from app import freshness # 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 _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 _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)
class Site(FakeHa):
"""The charger model plus a grid, a battery and a solar entity."""
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] # one clock for the whole file
class World:
"""A real Controller on the charger model, one clock for all of it."""
def __init__(self, opts=CAR, sim=None, store=None, plug=True, setpoint=10,
grid=800.0, phases=1, **simkw):
self.sim = sim or SimCharger(setpoint_a=setpoint, **simkw)
if plug:
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.make(opts)
def make(self, opts):
self.opts = dict(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
if hasattr(self.drv, "_sleep"):
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):
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()
async def step_race(self, n=1, dt=1.0):
"""The production order: the writer task can finish AFTER the cycle's
read and BEFORE that cycle's kick (read -> task settles -> cycle), so
the step that follows sees a reading older than the write."""
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.car_settle()
await self.c.cycle()
async def act(self, what, value):
return await self.c.handle_action(what, value=value)
def writes(self, what=None):
return self.sim.writes(what)
def rows(self):
return {r["id"]: r for r in self.c.checks()}
def run(coro):
return asyncio.run(coro)
# =========================================================================== #
print("1. OFF WRITES NOTHING")
# =========================================================================== #
async def part1():
w = World()
await w.step(5)
await w.act("car_current", 14) # the user sets values while Off
await w.act("car_phases", 3)
await w.step(60)
return w
w1 = run(part1())
check("PRECONDITION: the charger was read and the car is charging",
w1.c.car.status(CLOCK[0]) == "charging" and w1.c.car.reading.power_w > 1000)
check("PRECONDITION: the mode is Off (the default)", w1.c.car_mode == "off")
check("Off: no number write and no service call names a charger entity, "
"although the user set 14 A and 3 phases while Off",
w1.site.charger_writes() == [] and w1.sim.log == [])
check("Off: the driver was never asked to send anything", w1.drv.sent == [])
check("Off: the model's own setpoint is where it was (10 A, 1 phase)",
w1.sim.setpoint_a == 10 and w1.sim.phases_allowed == 1)
check("the user's values were kept for when Manual is chosen",
w1.c.car_a == 14 and w1.c.car_n == 3)
# =========================================================================== #
print("\n2. MODE, CURRENT, PHASES: RUNTIME STATE")
# =========================================================================== #
async def part2():
w = World()
out = {}
out["manual"] = await w.act("car_mode", "manual")
out["bad_mode"] = await w.act("car_mode", "solar") # not in this card
out["night"] = await w.act("car_mode", "night")
out["a12"] = await w.act("car_current", 12)
out["a5"] = await w.act("car_current", 5)
out["a17"] = await w.act("car_current", 17) # above ev_max_a
out["a_text"] = await w.act("car_current", "x")
out["a_bool"] = await w.act("car_current", True)
out["a_nan"] = await w.act("car_current", float("nan"))
out["a_half"] = await w.act("car_current", 12.5)
out["n2"] = await w.act("car_phases", 2)
out["n3"] = await w.act("car_phases", 3)
return w, out
w2, o2 = run(part2())
check("Manual is chosen at once, no restart", o2["manual"] == {
"mode": "manual", "current": 6.0, "phases": 1} and w2.c.car_mode == "manual"
or w2.c.car_mode == "manual")
check("Solar and Night are not accepted (EV-05, EV-02)",
"error" in o2["bad_mode"] and "error" in o2["night"]
and w2.c.car_mode == "manual")
check("a current between 6 A and the clamp is accepted and stored",
"error" not in o2["a12"] and w2.store.data.get("car_current") == 12.0)
check("5 A, 17 A (above ev_max_a 16), text, a bool, NaN and 12.5 are refused",
all("error" in o2[k] for k in ("a5", "a17", "a_text", "a_bool",
"a_nan", "a_half")))
check("the refused values did not change the stored current",
w2.c.car_a == 12.0 and w2.store.data["car_current"] == 12.0)
check("phases: 2 refused, 3 accepted and stored",
"error" in o2["n2"] and w2.store.data.get("car_phases") == 3)
check("the three live in the store (like OPT-11's modes)",
w2.store.data.get("car_mode") == "manual")
check("every refusal is a plain sentence",
all(isinstance(o2[k].get("error"), str) for k in ("bad_mode", "a5")))
async def part2b():
out = {}
# no charger at all: refused, nothing stored
w = World(BASE)
out["nocharger"] = await w.act("car_mode", "manual")
out["stored"] = dict(w.store.data)
# one-phase-only installation
w = World(dict(CAR, ev_phases="1"))
out["n3"] = await w.act("car_phases", 3)
out["n1"] = await w.act("car_phases", 1)
return out
o2b = run(part2b())
check("with no charger the actions are refused and nothing is stored",
"error" in o2b["nocharger"] and "car_mode" not in o2b["stored"])
check("ev_phases 1: 3 phases cannot be chosen, 1 can",
"error" in o2b["n3"] and "error" not in o2b["n1"])
async def part2c():
out = {}
for start, stored in (("keep", "manual"), ("off", "manual"),
("keep", None), ("keep", "solar")):
st = _Store()
if stored:
st.data["car_mode"] = stored
w = World(dict(CAR, ev_mode_start=start), store=st)
out[(start, stored)] = (w.c.car_mode, st.data.get("car_mode"))
return out
o2c = run(part2c())
check("ev_mode_start keep: a restart keeps Manual",
o2c[("keep", "manual")][0] == "manual")
check("ev_mode_start off: a restart starts in Off and the store says so",
o2c[("off", "manual")] == ("off", "off"))
check("no stored mode, or one this build does not know, is Off",
o2c[("keep", None)][0] == "off" and o2c[("keep", "solar")][0] == "off")
# =========================================================================== #
print("\n3. MANUAL WRITES THE CURRENT ONCE PER USER CHANGE")
# =========================================================================== #
async def part3():
w = World(setpoint=10)
await w.step(3)
await w.act("car_mode", "manual")
await w.act("car_current", 12)
await w.step(30)
n1 = len(w.writes("current"))
sent1 = list(w.drv.sent)
await w.step(60) # nothing asked: nothing written
n2 = len(w.writes("current"))
await w.act("car_current", 8)
await w.step(10)
n3 = len(w.writes("current"))
await w.act("car_current", 8) # the same value again
await w.step(10)
n4 = len(w.writes("current"))
return w, n1, sent1, n2, n3, n4
w3, n1, sent1, n2, n3, n4 = run(part3())
check("choosing Manual at 12 A writes 12 A once", n1 == 1 and sent1 == [12.0])
check("the charger took it: setpoint and read-back are 12 A (then 8 A)",
w3.sim.setpoint_a == 8 and w3.sim.readback_a == 8)
check("60 s with nothing asked: no further write", n2 == 1)
check("a new value (8 A) is one more write", n3 == 2)
check("the same value again is not written (the charger already has it)",
n4 == 2)
check("the add-on's own write is not 'another writer' in the page",
"charger_writer" not in w3.rows() and "charger_other" not in w3.rows())
def spy_on(drv):
"""Every `write_current` of this driver and what it said."""
res, real = [], drv.write_current
async def spy(a):
r = await real(a)
res.append((a, r))
return r
drv.write_current = spy
return res
async def part3b():
out = {}
# the charger takes 4 s to show it: the write is still taken (< 10 s)
w = World(setpoint=10)
w.sim.lag_s = 4.0
await w.step(2)
await w.act("car_mode", "manual")
await w.act("car_current", 12)
await w.step(20)
out["lag4"] = (w.writes("current"), w.sim.readback_a,
w.c.car_writer.last_a, w.c.car_writer.gave_up)
# the charger takes 14 s: the write is NOT taken in 10 s, and is not
# retried at once
w = World(setpoint=10)
w.sim.lag_s = 14.0
await w.step(2)
res = spy_on(w.drv)
await w.act("car_mode", "manual")
await w.act("car_current", 12)
await w.step(40)
out["lag14"] = (list(res), w.sim.readback_a, w.c.car_writer.gave_up,
w.c.car_writer.fails, "charger_other" in w.rows())
# the charger ignores it: tried 3 times, a minute apart, then it waits
w = World(setpoint=10)
await w.step(2)
w.sim.refuse = "ignore"
res = spy_on(w.drv)
await w.act("car_mode", "manual")
await w.act("car_current", 12)
await w.step(5)
out["ignore5"] = (list(res), w.c.car_writer.fails)
await w.step(200)
out["ignore"] = (list(res), w.c.car_writer.gave_up, w.rows())
await w.step(600)
out["ignore_later"] = len(res)
w.sim.refuse = None
await w.act("car_current", 13)
await w.step(20)
out["after_user"] = (w.sim.readback_a, w.c.car_writer.gave_up)
# Home Assistant refuses the call outright
w = World(setpoint=10)
await w.step(2)
w.sim.refuse = "error"
res = spy_on(w.drv)
await w.act("car_mode", "manual")
await w.act("car_current", 12)
await w.step(10)
out["error"] = list(res)
return out
o3b = run(part3b())
check("a charger that shows the change 4 s late still took it (read back "
"within 10 s)", len(o3b["lag4"][0]) == 1 and o3b["lag4"][1] == 12
and o3b["lag4"][2] == 12 and not o3b["lag4"][3])
check("a charger that shows it 14 s late did NOT take it: write_current "
"says False, and the add-on does not write again at once",
o3b["lag14"][0] == [(12.0, False)] and o3b["lag14"][2] is False)
check("...and when the late read-back arrives it is adopted, with no 'another "
"writer'", o3b["lag14"][1] == 12 and not o3b["lag14"][4])
check("a charger that ignores it: 3 tries a minute apart, then it stops",
[r for _a, r in o3b["ignore"][0]] == [False, False, False]
and o3b["ignore"][1] is True and o3b["ignore_later"] == 3
and o3b["ignore5"][0] == [(12.0, False)])
check("...and says so: one amber row 'Charger did not take it'",
o3b["ignore"][2].get("charger_refused", {}).get("warn") is True
and o3b["ignore"][2]["charger_refused"]["ok"] is False)
check("...and a new value from the user is tried again (and taken)",
o3b["after_user"] == (13.0, False))
check("Home Assistant refusing the call is a False, not an exception",
o3b["error"] and all(r is False for _a, r in o3b["error"]))
# =========================================================================== #
print("\n4. THE CLAMP: NOTHING ABOVE min(ev_max_a, station, entity range) IS SENT")
# =========================================================================== #
def fast(drv, sim):
"""A driver whose 10 s wait for a read-back costs no real time."""
clock = [0.0]
async def sl(s):
clock[0] += s
sim.tick(s)
drv._sleep, drv._clock = sl, (lambda: clock[0])
return drv
async def clamp_prop():
rnd = random.Random(4)
bad, faults_ok, n = [], 0, 0
for _ in range(80):
station = rnd.choice([6, 10, 13, 16, 20, 25, 32, 40])
max_a = rnd.choice([6, 8, 10, 16, 20, 32, 40])
sim = SimCharger(station_a=station, setpoint_a=min(6, station))
sim.plug_in()
ha = FakeHa(sim)
drv = fast(CH.AlfenHaDriver(SET, max_a).bind(ha), sim)
clamp = min(max_a, station, 40)
for a in (0, 6, clamp - 1, clamp, clamp + 0.1, clamp + 1, 40, 41, 99,
-1, float("nan"), rnd.uniform(0, 80)):
before = len(ha.sets)
ok = await drv.write_current(a)
n += 1
sent = [v for _e, v in ha.sets[before:]]
if any(v > clamp + 1e-9 for v in sent):
bad.append((station, max_a, a, sent))
over = a != a or a < 0 or a > clamp
if over:
if sent or ok:
bad.append(("over was sent or said True", station, max_a,
a, sent, ok))
else:
faults_ok += 1
return bad, faults_ok, n
bad4, faults4, n4c = run(clamp_prop())
check(f"property: over {n4c} writes with random station limits, ev_max_a and "
f"values, nothing above the clamp is ever sent ({bad4[:2]})", not bad4)
check(f"...and every value above the clamp (or negative, or NaN) is a False "
f"and a fault ({faults4} of them)", faults4 > 400)
async def clamp_log():
sim = SimCharger(station_a=16)
sim.plug_in()
ha = FakeHa(sim)
drv = fast(CH.AlfenHaDriver(SET, 16).bind(ha), sim)
LOG.rec.clear()
r = await drv.write_current(17)
return r, ha.sets, LOG.text("ERROR"), drv.clamp_faults
r4, sets4, log4, faults = run(clamp_log())
check("17 A against 16 A: not sent, False, and logged as a software fault with "
"its code, at ERROR", r4 is False and sets4 == []
and "CHARGER_CLAMP" in log4 and "Software fault" in log4)
check("...and the fault is on the driver for the page and the checks",
faults == [(17.0, 16.0)])
async def clamp_world():
# the station limit falls to 10 A after the user set 16 A: the writer never
# asks for more than the charger reports
w = World(setpoint=6)
await w.step(3)
await w.act("car_mode", "manual")
await w.act("car_current", 16)
await w.step(10)
first = w.sim.readback_a
w.sim.station_a = 10.0
await w.act("car_current", 16)
await w.step(10)
return w, first
w4, first4 = run(clamp_world())
check("the user's 16 A is written at 16 A while the station limit is 16 A",
first4 == 16)
check("the station limit falling to 10 A: the next write is 10 A, never 16 A",
w4.sim.readback_a == 10 and w4.drv.sent[-1] == 10.0
and max(v for _e, v in w4.site.sets if "wallbox" in _e) <= 16)
_s40 = SimCharger(station_a=40)
check("the entity's own range (0-40 A) bounds a write too",
run(fast(CH.AlfenHaDriver(SET, 40).bind(FakeHa(_s40)), _s40
).write_current(41)) is False)
# =========================================================================== #
print("\n5. PHASE CHANGES: THE SAFE SEQUENCE")
# =========================================================================== #
async def phase_story(**simkw):
w = World(setpoint=10, phases=1, **simkw)
await w.step(8)
await w.act("car_mode", "manual")
await w.act("car_current", 10)
await w.step(5)
n0 = len(w.writes())
t0 = w.sim.t
await w.act("car_phases", 3)
await w.step(45)
return w, n0, t0
w5, n05, t05 = run(phase_story())
seq5 = w5.writes()[n05:]
check("the sequence is exactly 0 A, phases 3, then the current again "
f"({[(x[1], x[2]) for x in seq5]})",
[(x[1], x[2]) for x in seq5] == [("current", 0.0), ("phases", 3),
("current", 10.0)])
check("the phases were selected only with the car paused: under 100 W "
f"({seq5[1][3]:.0f} W) and the setpoint at 0 A ({seq5[1][4]})",
seq5[1][3] < 100 and seq5[1][4] == 0.0)
check("the current was written again 10 s or more after the phases "
f"({seq5[2][0] - seq5[1][0]:.0f} s)", seq5[2][0] - seq5[1][0] >= 10.0)
check("afterwards the charger is at 10 A on 3 phases and the car draws 3 phases",
w5.sim.readback_a == 10 and w5.sim.phases_allowed == 3
and w5.sim.power_w > 6000)
check("the phases were written exactly once", len(w5.writes("phases")) == 1)
async def phase_gap():
w, n0, _t = await phase_story()
await w.act("car_phases", 1) # one minute later: too soon
await w.step(120)
soon = len(w.writes("phases"))
why = homeview.car_block(w.c, datetime.now(timezone.utc))["why"]
blocked = w.c.car_writer.blocked
await w.step(500) # now more than 10 minutes after
later = len(w.writes("phases"))
return soon, why, blocked, later, w
soon5, why5, blocked5, later5, w5g = run(phase_gap())
check("a second phase change a minute later waits (one per 10 minutes)",
soon5 == 1 and blocked5)
check("...and the card says it waits", "10 minutes" in why5)
check("...and it goes through once 10 minutes have passed, by the same "
"sequence", later5 == 2 and w5g.sim.phases_allowed == 1
and [x[1] for x in w5g.writes()][-3:] == ["current", "phases", "current"])
async def slow_stop():
# the car takes 40 s to stop drawing: the add-on waits at most 20 s
w = World(setpoint=10, phases=1)
w.sim.ramp_w_s = 50.0
w.sim.stop_delay_s = 40.0
await w.step(60)
await w.act("car_mode", "manual")
await w.act("car_current", 10)
await w.step(3)
n0 = len(w.writes())
await w.act("car_phases", 3)
await w.step(60)
return w, n0
w5s, n05s = run(slow_stop())
seq5s = w5s.writes()[n05s:]
check("a car that is slow to stop: the phases are selected after 20 s at most "
f"({seq5s[1][0] - seq5s[0][0]:.0f} s after the 0 A)",
[x[1] for x in seq5s][:2] == ["current", "phases"]
and 19.0 <= seq5s[1][0] - seq5s[0][0] <= 22.0)
async def zero_refused():
# the charger does not take 0 A: the phases are NOT touched
w = World(setpoint=10, phases=1)
await w.step(8)
await w.act("car_mode", "manual")
await w.act("car_current", 10)
await w.step(3)
w.sim.refuse = "ignore"
await w.act("car_phases", 3)
await w.step(80)
return w
w5z = run(zero_refused())
check("a charger that does not take 0 A never gets the phases select",
w5z.writes("phases") == [] and w5z.sim.phases_allowed == 1)
async def shutdown_mid_sequence():
w = World(setpoint=10, phases=1)
w.sim.ramp_w_s = 50.0
w.sim.stop_delay_s = 40.0
await w.step(60)
await w.act("car_mode", "manual")
await w.act("car_current", 10)
await w.step(3)
await w.act("car_phases", 3)
await w.step(4) # 0 A is written, phases not yet
mid = (w.sim.readback_a, w.c.car_writer.seq is not None)
await w.c.car_shutdown()
return mid, w
mid5, w5x = run(shutdown_mid_sequence())
check("the add-on stops in the middle of a phase change: the car gets its "
"10 A back, and nothing is left at 0 A",
mid5 == (0.0, True) and w5x.sim.readback_a == 10
and w5x.c.car_writer.seq is None)
async def other_writer_in_sequence():
w = World(setpoint=10, phases=1)
w.sim.ramp_w_s = 50.0
w.sim.stop_delay_s = 40.0
await w.step(60)
await w.act("car_mode", "manual")
await w.act("car_current", 10)
await w.step(3)
await w.act("car_phases", 3)
await w.step(3) # 0 A written, the car winding down
w.sim.set_current(9) # the automation
await w.step(60)
return w
w5o = run(other_writer_in_sequence())
check("something else raises the current while the car is being paused: the "
"phases are never selected (the car was drawing), the change is given "
"up and the grey row says so",
w5o.writes("phases") == [] and w5o.sim.phases_allowed == 1
and w5o.sim.readback_a == 9 and w5o.c.car_writer.seq is None
and "charger_other" in w5o.rows())
async def phases_in_off():
w = World(setpoint=10, phases=1)
await w.step(5)
await w.act("car_phases", 3)
await w.step(60)
return w
check("in Off a phase change writes nothing either",
run(phases_in_off()).writes() == [])
print("\n5b. ROUND 2: THE SEQUENCE UNDER A RACING WRITER, A REFUSED SELECT, "
"A MODE CHANGE, THE CLAMP")
async def m1_race(lag):
# the writer task finishes between a cycle's read and that cycle's kick
w = World(setpoint=10, phases=1)
w.sim.lag_s = lag
await w.step(8)
await w.act("car_mode", "manual")
await w.act("car_current", 10)
await w.step(10)
n0 = len(w.writes())
await w.act("car_phases", 3)
await w.step_race(60)
seq = [(x[1], x[2]) for x in w.writes()[n0:]]
await w.step_race(300)
return w, seq
for _lag in (0.0, 3.0):
w_m1, seq_m1 = run(m1_race(_lag))
check(f"M1 (read -> writer settles -> cycle, read-back lag {_lag:.0f} s): "
"the phases are selected and the car gets its 10 A back, with no "
f"false 'something else changed the charger' ({seq_m1})",
seq_m1 == [("current", 0.0), ("phases", 3), ("current", 10.0)]
and w_m1.sim.readback_a == 10 and w_m1.sim.phases_allowed == 3
and not w_m1.c.car_writer.hold and "charger_other" not in w_m1.rows()
and w_m1.sim.power_w > 6000)
async def m2_refused():
w = World(setpoint=10, phases=1)
await w.step(8)
await w.act("car_mode", "manual")
await w.act("car_current", 10)
await w.step(5)
sim = w.sim
def deaf(n): # Home Assistant says yes, nothing moves
sim.log.append((sim.t, "phases", n, sim.power_w, sim.setpoint_a))
return True
sim.request_phases = deaf
n0 = len(w.writes())
await w.act("car_phases", 3)
await w.step(3700)
mid = [x for x in w.writes()[n0:]]
ph = [x for x in mid if x[1] == "phases"]
zeros = [x for x in mid if x[1] == "current" and x[2] == 0.0]
out = dict(ph=len(ph), zeros=len(zeros), rb=sim.readback_a,
gave=getattr(w.c.car_writer, "phases_gave_up", None), row=w.rows().get(
"charger_phases"), power=sim.power_w)
await w.act("car_phases", 3) # the user asks again: tried again
await w.step(60)
out["after_user"] = len([x for x in w.writes() if x[1] == "phases"]) - len(ph)
return out
m2 = run(m2_refused())
check("M2: a phase select the charger never takes is tried 3 times (10 minutes "
"apart), not for ever", m2["ph"] == 3 and m2["zeros"] == 3)
check("...each time the car gets its current back on the old phases (10 A, "
"drawing), and at the end it is not left paused", m2["rb"] == 10
and m2["power"] > 2000)
check("...then an amber row says the charger did not take the phases, and "
"the add-on stops trying", m2["gave"] is True
and m2["row"]["ok"] is False and m2["row"]["warn"] is True)
check("...until the user changes something: then it tries again",
m2["after_user"] == 1)
async def l4_late():
# Home Assistant takes the select but the read-back is late: the current
# must not come back before SETTLE_S has passed
w = World(setpoint=10, phases=1)
await w.step(8)
await w.act("car_mode", "manual")
await w.act("car_current", 10)
await w.step(5)
sim = w.sim
def slow(n):
sim.log.append((sim.t, "phases", n, sim.power_w, sim.setpoint_a))
sim._pending.append((sim.t + 12.0, "phases", n))
return True
sim.request_phases = slow
ret = []
real = w.drv.write_phases
async def spy(n):
r = await real(n)
ret.append((sim.t, r)) # model time the select call returned
return r
w.drv.write_phases = spy
n0 = len(w.writes())
await w.act("car_phases", 3)
await w.step(60)
if not ret:
return None, 0.0
t_ret, took = ret[0]
t_back = next((x[0] for x in w.writes()[n0:]
if x[1] == "current" and x[0] > t_ret - 1), None)
return took, (0.0 if t_back is None else t_back - t_ret)
took_l4, gap_l4 = run(l4_late())
check(f"L4: after a phase select the charger did not take in time (read-back "
f"12 s late), the current comes back only 10 s after the select call "
f"returned ({gap_l4:.0f} s)", took_l4 is False and gap_l4 >= 10.0)
async def m3(trigger):
# the shipped shadow_mode: auto (shadow is on whenever control is stopped)
w = World(dict(CAR, shadow_mode="auto"), setpoint=10, phases=1)
w.sim.ramp_w_s = 50.0
w.sim.stop_delay_s = 40.0
await w.step(60)
await w.act("car_mode", "manual")
await w.act("car_current", 10)
await w.step(3)
await w.act("car_phases", 3)
await w.step(3) # 0 A written, the select not yet
n0 = len(w.writes())
mid = (w.sim.readback_a, w.c.car_writer.seq["stage"])
if trigger == "off":
await w.act("car_mode", "off")
elif trigger == "shadow":
w.c.o["shadow_mode"] = "on"
elif trigger == "stop":
await w.c.handle_action("auto_toggle")
elif trigger == "safety":
w.c.inverters[0].sign_wd.tripped = True
await w.step(80)
return w, mid, [(x[1], x[2]) for x in w.writes()[n0:]]
for _trig, _want in (("off", [("current", 10.0)]),
("shadow", [("current", 10.0)]),
("stop", [("current", 10.0)]),
("safety", [("current", 10.0)])):
w_m3, mid_m3, wr_m3 = run(m3(_trig))
check(f"M3 ({_trig} mid-sequence, before the select): no phase switch, "
+ "the old 10 A comes back, and nothing is written after it "
+ f"(N1, shipped shadow_mode auto; {wr_m3})",
mid_m3[0] == 0.0 and wr_m3 == _want and w_m3.writes("phases") == []
and w_m3.sim.readback_a == 10.0 and w_m3.sim.phases_allowed == 1
and w_m3.c.car_writer.seq is None)
async def m4():
w = World(dict(CAR, ev_max_a=10), setpoint=16, phases=1)
w.sim.ramp_w_s = 50.0
w.sim.stop_delay_s = 40.0
await w.step(60)
await w.act("car_mode", "manual")
await w.act("car_phases", 3)
await w.step(4)
prev = w.c.car_writer.seq["prev"]
await w.c.car_shutdown()
return w, prev
w_m4, prev_m4 = run(m4())
check("M4: the old read-back was 16 A (another writer's) against ev_max_a 10; "
"the restore on shutdown is clamped: the car gets 10 A back, no "
"software fault is logged",
prev_m4 == 16.0 and w_m4.sim.readback_a == 10.0
and w_m4.drv.clamp_faults == [] and w_m4.drv.sent[-1] == 10.0)
# --- every write path: who calls the seam, and a fuzz over the lot --------- #
def seam_callers():
"""(file, name) of every call of the charger's write methods in app/."""
import ast
out = []
for f in sorted(os.listdir(os.path.join(HERE, "app"))):
if not f.endswith(".py") or f == "chargers.py":
continue
tree = ast.parse(io.open(os.path.join(HERE, "app", f),
encoding="utf-8").read())
for n in ast.walk(tree):
if isinstance(n, ast.Call) and isinstance(n.func, ast.Attribute) \
and (n.func.attr in ("write_current", "write_phases")
or (n.func.attr == "release"
and "charger" in ast.dump(n.func.value))):
out.append((f, n.func.attr))
return sorted(out)
check("the write paths are exactly these (all in carmode.py): the current "
"(one call), the phases (one call), nothing else "
f"({seam_callers()})",
seam_callers() == [("carmode.py", "write_current"),
("carmode.py", "write_phases")])
async def fuzz(seed):
rnd = random.Random(seed)
w = World(setpoint=rnd.choice([6, 10, 16]), phases=rnd.choice([1, 3]))
w.sim.lag_s = rnd.choice([0.0, 0.0, 3.0, 12.0])
race = seed % 2 == 1 # half the sites run read -> settle -> cycle
bad, seen, others, holds, undos = [], 0, 0, 0, 0
last_switch = None
if rnd.random() < 0.8:
await w.act("car_mode", "manual")
for step in range(400):
c, sim = w.c, w.sim
wr = c.car_writer
stage = wr.seq["stage"] if wr.seq is not None else None
seq = stage is not None
r = rnd.random()
if stage in ("zero", "select") and rnd.random() < 0.15:
# the user, a stop or shadow mode arrives mid-sequence
pick = rnd.choice(["off", "stop", "shadow"])
if pick == "off":
await w.act("car_mode", "off")
elif pick == "stop":
c.auto = False
else:
c.o["shadow_mode"] = "on"
elif r < 0.02:
await w.act("car_mode", rnd.choice(["off", "manual", "manual"]))
elif r < 0.07:
await w.act("car_current", rnd.randint(6, 16))
elif r < 0.09:
await w.act("car_phases", rnd.choice([1, 3]))
elif r < 0.093 and not seq:
sim.go_unavailable(rnd.random() < 0.5)
elif r < 0.096 and not seq:
sim.station_a = float(rnd.choice([10, 13, 16]))
elif r < 0.099 and not seq:
(sim.unplug if sim.state != "A" else sim.plug_in)()
elif r < 0.108:
sim.set_current(rnd.randint(0, 16)) # another writer
others += 1
elif r < 0.112:
sim.refuse = rnd.choice([None, None, "ignore", "error"])
elif r < 0.116:
c.auto = rnd.random() < 0.8
elif r < 0.12:
c.o["shadow_mode"] = rnd.choice(["on", "off", "off"])
mode_now, auto_now, shadow_now = c.car_mode, c.auto, c.shadow
n0, u0 = len(sim.log), getattr(wr, "undone", 0)
await (w.step_race(1) if race else w.step(1))
undone = getattr(wr, "undone", 0) > u0
undos += undone
holds += bool(wr.hold)
for t, what, v, power, sp in sim.log[n0:]:
clamp = min(16.0, sim.station_a)
# a sequence whose select has gone out is finished whatever the
# mode says; one undone before it gives the old current back
exempt = stage == "settle" or undone
if what == "current" and not 0.0 <= v <= clamp + 1e-9:
bad.append((seed, step, "over the clamp", v, clamp))
if what == "current" and mode_now != "manual" and not exempt:
bad.append((seed, step, "written outside Manual", mode_now))
if what in ("current", "phases") and not auto_now and not exempt:
bad.append((seed, step, "written with control stopped"))
if what in ("current", "phases") and shadow_now and not exempt:
bad.append((seed, step, "written in shadow mode"))
if what == "current" and sim.state == "A" and not seq:
bad.append((seed, step, "written with no car"))
if what == "phases":
if mode_now != "manual" or not auto_now or shadow_now:
bad.append((seed, step, "phases selected outside Manual"))
if sp != 0.0:
bad.append((seed, step, "phases with the setpoint up", sp))
if last_switch is not None and t - last_switch < 600.0:
bad.append((seed, step, "two switches inside 10 min",
t - last_switch))
last_switch = t
seen += len(sim.log) - n0
return bad, seen, others, holds, undos
fz_bad, fz_n, fz_o, fz_h, fz_u = [], 0, 0, 0, 0
for _seed in range(14):
_b, _n, _o, _h, _u = run(fuzz(_seed))
fz_bad += _b
fz_n += _n
fz_o += _o
fz_h += _h
fz_u += _u
check(f"fuzz: {fz_n} charger writes over 14 random sites and 5600 steps of "
f"random user changes, outages, unplugs, refusals, shadow and control "
f"stops, in both cycle orders: none over the clamp, none outside "
f"Manual, none with control stopped, in shadow mode or with no car, the "
f"phases never selected outside Manual or with the car drawing, one "
f"switch per 10 minutes ({fz_bad[:3]})", not fz_bad and fz_n > 100)
check(f"fuzz: the other-writer branch runs ({fz_o} other writers made, "
f"{fz_h} steps with the add-on holding off one, {fz_u} sequences undone)",
fz_o > 30 and fz_h > 5 and fz_u > 0)
# =========================================================================== #
print("\n6. SHADOW MODE AND A STOPPED CONTROL WRITE NOTHING")
# =========================================================================== #
async def shadow_story(shadow, auto):
w = World(dict(CAR, shadow_mode=shadow), setpoint=10, phases=1)
w.c.auto = auto
await w.step(5)
await w.act("car_mode", "manual")
await w.act("car_current", 14)
await w.act("car_phases", 3)
await w.step(80)
card = homeview.car_block(w.c, datetime.now(timezone.utc))
return w, card
w6, card6 = run(shadow_story("on", True))
check("shadow mode: no write to the charger at all, although Manual, 14 A and "
"3 phases are set", w6.sim.log == [] and w6.site.charger_writes() == []
and w6.drv.sent == [])
check("shadow mode: the Car card says what it would set",
"would set 14 A" in card6["why"] and "3 phases" in card6["why"])
check("shadow mode: the card is in Manual all the same",
card6["mode"] == "manual")
w6b, card6b = run(shadow_story("off", False))
check("control stopped (shadow off): nothing is written, the card says so",
w6b.sim.log == [] and "stopped" in card6b["why"])
async def shadow_off_then_on():
w, _c = await shadow_story("off", False)
w.c.auto = True
await w.step(60)
return w
w6c = run(shadow_off_then_on())
check("...and when control starts the waiting setting is written (once, by "
"the safe sequence for the phases)",
w6c.sim.readback_a == 14 and w6c.sim.phases_allowed == 3)
# =========================================================================== #
print("\n7. FAIL STATES, THE MANUAL COLUMN")
# =========================================================================== #
async def restart_story(start):
st = _Store()
w = World(dict(CAR, ev_mode_start=start), store=st, setpoint=10, phases=1)
await w.step(3)
await w.act("car_mode", "manual")
await w.act("car_current", 12)
await w.step(20)
before = list(w.sim.log)
# a restart: a new Controller on the same store and the same charger
w.make(dict(CAR, ev_mode_start=start))
await w.step(40)
return w, before
w7, before7 = run(restart_story("keep"))
check("a restart (keep): the charger stays at 12 A and nothing is written, "
"not even 0 A", w7.sim.log == before7 and w7.sim.readback_a == 12
and w7.c.car_mode == "manual")
w7o, before7o = run(restart_story("off"))
check("a restart with 'Mode after a restart: Off': the mode is Off, nothing "
"is written, the current stands (Manual's own column)",
w7o.sim.log == before7o and w7o.sim.readback_a == 12
and w7o.c.car_mode == "off")
async def stop_story():
w = World(setpoint=10, phases=1)
await w.step(3)
await w.act("car_mode", "manual")
await w.act("car_current", 12)
await w.step(10)
n = len(w.sim.log)
await w.c.handle_action("auto_toggle") # the Stop button
await w.step(30)
stopped = (len(w.sim.log) == n, w.sim.readback_a)
# a safety stop: a failsafe latch is up
w.c.auto = True
w.c.inverters[0].sign_wd.tripped = True
await w.step(30)
safety = (len(w.sim.log) == n, w.sim.readback_a)
return stopped, safety
stopped7, safety7 = run(stop_story())
check("control stopped by the button: the current stands, nothing is written",
stopped7 == (True, 12))
check("a safety stop (a failsafe latch): the current stands, nothing is "
"written", safety7 == (True, 12))
async def return_story(other):
w = World(setpoint=10, phases=1)
await w.step(3)
await w.act("car_mode", "manual")
await w.act("car_current", 12)
await w.step(10)
n = len(w.sim.log)
w.sim.go_unavailable()
await w.step(60)
if other:
w.sim.go_unavailable(False)
w.sim.set_current(7) # it came back with another value
else:
w.sim.go_unavailable(False)
await w.step(30)
return w, n
w7a, n7a = run(return_story(False))
check("the charger comes back with the same read-back: nothing is written",
len(w7a.sim.log) == n7a)
w7b, n7b = run(return_story(True))
check("it comes back with a different read-back: the setting is written again, "
"once", len(w7b.sim.log) == n7b + 1 and w7b.sim.readback_a == 12)
async def outage_write():
w = World(setpoint=10, phases=1)
await w.step(3)
await w.act("car_mode", "manual")
await w.step(5)
n0 = len(w.sim.log)
w.sim.go_unavailable()
await w.step(5)
await w.act("car_current", 13) # changed while it is away
await w.step(40)
during = len(w.sim.log) - n0
w.sim.go_unavailable(False)
await w.step(10)
return during, w.sim.readback_a, w.drv.sent
during7, rb7, sent7 = run(outage_write())
check("a value set while the charger is away is written when it answers",
during7 == 0 and rb7 == 13 and sent7[-1] == 13.0)
async def error_story():
w = World(setpoint=10, phases=1)
await w.step(3)
await w.act("car_mode", "manual")
w.sim.error = "17: Overcurrent"
await w.step(5)
await w.act("car_current", 12)
await w.step(10)
return w
w7e = run(error_story())
check("a charger error is shown (a grey row) and the writes go on",
w7e.rows().get("charger_error", {}).get("ok") is True
and "Overcurrent" in w7e.rows()["charger_error"]["text"]
and w7e.sim.readback_a == 12)
async def nocar_story():
w = World(plug=False, setpoint=10, phases=1)
await w.step(5)
await w.act("car_mode", "manual")
await w.act("car_current", 12)
await w.act("car_phases", 3)
await w.step(60)
none_writes = len(w.sim.log)
none_why = homeview.car_block(w.c, datetime.now(timezone.utc))["why"]
w.sim.plug_in()
await w.step(80)
return w, none_writes, none_why
w7n, none7, why7n = run(nocar_story())
check("no car: the current stands and nothing is written (not even for the "
"user's change)", none7 == 0)
check("...and the card says it is set when a car is connected",
"when a car is connected" in why7n)
check("...when the car is plugged in the waiting setting is written",
w7n.sim.readback_a == 12 and w7n.sim.phases_allowed == 3)
async def full_story():
w = World(setpoint=10, phases=1)
await w.step(3)
await w.act("car_mode", "manual")
await w.step(5)
w.sim.car_full()
await w.step(120)
state = w.c.car.status(CLOCK[0])
n = len(w.sim.log)
await w.act("car_current", 14)
await w.step(60)
return state, n, len(w.sim.log)
state7f, n7f, m7f = run(full_story())
check("a full car: the current stands, nothing is written", state7f == "full"
and n7f == m7f)
# =========================================================================== #
print("\n8. ANOTHER WRITER")
# =========================================================================== #
async def writer_story():
w = World(setpoint=10, phases=1)
await w.step(3)
await w.act("car_mode", "manual")
await w.act("car_current", 12)
await w.step(10)
n = len(w.sim.log)
w.sim.set_current(9) # the HA automation
await w.step(20)
early = ("charger_other" in w.rows(), w.c.car_writer.hold, len(w.sim.log))
await w.step(20)
held = ("charger_other" in w.rows(), w.c.car_writer.hold)
row = w.rows().get("charger_other")
await w.step(200)
stays = (len(w.sim.log) == n, w.sim.readback_a)
await w.act("car_current", 14)
await w.step(10)
after = ("charger_other" in w.rows(), w.sim.readback_a, w.c.car_writer.hold)
return early, held, row, stays, after, n, w
early8, held8, row8, stays8, after8, n8, w8 = run(writer_story())
check("a different read-back for under 30 s is not yet 'another writer'",
early8 == (False, False, n8))
check("after 30 s it is: an info row (grey, not amber)",
held8 == (True, True) and row8["ok"] is True and row8["warn"] is True)
check("...and the add-on does not write over it, for minutes", stays8 == (True, 9))
check("...until the user changes a value: then it writes it, and the row goes",
after8 == (False, 14, False))
async def writer_off():
w = World(setpoint=10, phases=1)
await w.step(3)
await w.act("car_mode", "manual")
await w.act("car_current", 12)
await w.step(10)
await w.act("car_mode", "off") # back to Off after the add-on wrote
await w.step(30)
own = "charger_writer" in w.rows()
w.sim.set_current(7) # now somebody else
await w.step(3)
return own, "charger_writer" in w.rows(), len(w.writes())
own8, off8, nw8 = run(writer_off())
check("Manual back to Off: the add-on's own writes do not show as another "
"writer", own8 is False)
check("Off keeps EV-03's grey row for a real other writer", off8 is True
and nw8 == 1)
# =========================================================================== #
print("\n9. THE PEAK GUARD'S ALARM PATH: THE CAR YOU SET IS NOT A FALSE ALARM")
# =========================================================================== #
import ev04_peak as P # noqa: E402
import safety81_sim as s81 # noqa: E402
import opt11_identity as rig # noqa: E402
LOG.rec.clear()
logging.disable(logging.NOTSET)
HOUSE = s81.constant(1100.0)
def alarms(r):
return P.ids(r, *P.ALARMS)
def cardwhy(r):
return homeview.car_block(r["c"], rig.BASE + timedelta(seconds=299))["why"]
r_off = P.drive(HOUSE, dur=240, mode="off")
r_man = P.drive(HOUSE, dur=240)
check("PRECONDITION: Off, an 11 kW car on a 1.1 kW house and a 2 kW battery "
"raises 'Load too high for battery' (the false alarm today)",
len(alarms(r_off)) == 1 and alarms(r_off)[0][1] == "goodwe_peak_saturated")
check("Manual: the same car raises neither 'Load too high' nor 'Battery "
"stopped limiting the peak'", alarms(r_man) == [])
check("Manual: one grey notice 'Car over the peak limit', once",
len(P.ids(r_man, P.OVER)) == 1)
check("...the claim, the floor and the commands are those of Off (the "
"battery gives its 2000 W in both)",
[s[4] for s in r_man["snaps"]] == [s[4] for s in r_off["snaps"]]
and max(s[4] for s in r_man["snaps"]) == 2000.0)
check("the car is never throttled: the add-on wrote nothing to the charger "
"after choosing Manual", r_man["sim"].setpoint_a == 16
and r_man["sim"].writes() == [])
rows_m = {x["id"]: x for x in r_man["c"].checks()}
check("no red row for that cause; the peak row is not an alarm",
rows_m["peak_guard"]["ok"] is True
and not any(x["ok"] is False and not x["warn"] for x in r_man["c"].checks()
if x["id"] in ("peak_guard",)))
check("one grey row says the car charge you set is over the limit",
rows_m.get("car_over", {}).get("ok") is True
and rows_m["car_over"]["warn"] is True)
check("the Car card's Why says it (the batteries give all they can)",
"batteries give all they can" in cardwhy(r_man))
att = homeview.attention(r_man["c"].checks())
check("Needs attention holds the grey note and nothing red",
any(a["id"] == "car_over" and a["severity"] == "info" for a in att)
and not [a for a in att if a["severity"] == "alarm"])
# the batteries at the peak reserve: 'Battery stopped limiting the peak'
r_off_r = P.drive(HOUSE, dur=240, mode="off", soc=15.0)
r_man_r = P.drive(HOUSE, dur=240, soc=15.0)
check("PRECONDITION: Off, batteries at the reserve: 'Battery stopped limiting "
"the peak' fires", [n for _t, n in alarms(r_off_r)] ==
["goodwe_peak_soc_floor"])
check("Manual, batteries at the reserve: no alarm, one grey notice",
alarms(r_man_r) == [] and len(P.ids(r_man_r, P.OVER)) == 1)
check("...and the Why says the batteries are at the reserve",
"at 20 %" in cardwhy(r_man_r))
# once per charging session
def replug(plant, c):
plant.ch.unplug()
def plugin(plant, c):
plant.ch.plug_in()
r_ses = P.drive(HOUSE, dur=400, events={150: replug, 200: plugin})
check("the notice is once per charging session: a second plug-in raises it "
"again, a long charge does not",
len(P.ids(r_ses, P.OVER)) == 2 and alarms(r_ses) == [])
# a car that is not the cause: a house overload on top of a small car
def house_overload(plant, c):
plant.house = lambda at: 9000.0 + plant.ch.power_w
r_both = P.drive(s81.constant(1100.0), dur=240, user_a=6, setpoint=6, phases=1,
events={60: lambda p, c: setattr(
p, "load", lambda at: 9000.0 + p.ch.power_w)})
check("a 1.4 kW car and a house that steps to 9 kW: the car does not explain "
"the excess, so the normal alarm fires",
[n for _t, n in alarms(r_both)] == ["goodwe_peak_saturated"])
# --- a stale or stuck car reading must NOT hide a real house overload ------- #
def stale_then_overload(plant, c):
plant.ch.unplug() # the car goes
plant.ch.go_unavailable() # and the charger stops answering
plant.load = lambda at: 9000.0 + plant.ch.power_w
r_stale = P.drive(HOUSE, dur=300, events={60: stale_then_overload})
check("the charger stops answering and the house steps to 9 kW: the car "
"figure is not used (not fresh), so the normal alarm fires",
[n for _t, n in alarms(r_stale)] == ["goodwe_peak_saturated"]
and 60 < alarms(r_stale)[0][0] < 60 + 15 + 25)
def stuck_then_overload(plant, c):
plant.ch.freeze() # the reading stops moving
plant.ch.unplug() # the car really goes
plant.load = lambda at: 9000.0 + plant.ch.power_w
run_user_change(c)
def run_user_change(c):
asyncio.get_event_loop().create_task(c.handle_action("car_current",
value=10))
r_stuck = P.drive(HOUSE, dur=400, events={60: stuck_then_overload})
at_stuck = alarms(r_stuck)
check("a stuck car figure (11 kW, frozen) and a real house overload: the "
"stuck rule (60 s after the write) lets the normal alarm fire",
[n for _t, n in at_stuck] == ["goodwe_peak_saturated"]
and at_stuck[0][0] < 60 + 60 + 25)
check("...and the amber row 'Charger reading may be stuck' says so",
"charger_stuck" in {x["id"]: x for x in r_stuck["c"].checks()}
and {x["id"]: x for x in r_stuck["c"].checks()}["charger_stuck"]["warn"])
w_ = r_stuck["c"]
check("...while stuck, the car figure is not used by the alarm path",
w_.car.stuck(w_.car_now()) and w_.car_alarm_w() is None)
# a plausible figure is bounded by what the read-back allows (and needs an
# energy meter that agrees with it)
def corr(tr, t):
f = getattr(tr, "corroborated", None)
return f(t) if f else True # an old tree has no such rule
def charging_reading(e_kwh, w=11000.0, a=6.0):
return CH.ChargerReading(available=True, state="C", charging=True,
power_w=w, allowed_a=a, setpoint_a=a,
phases_allowed=1, energy_kwh=e_kwh)
def feed(tr, secs, e_of, w=11000.0, t0=100.0):
for i in range(secs):
tr.observe(charging_reading(e_of(i), w), t0 + i,
datetime(2026, 11, 16, tzinfo=timezone.utc), "2026-11-16")
return t0 + secs - 1
tr = CH.CarTracker()
t_end = feed(tr, 80, lambda i: 1000.0 + i * 11000.0 / 3.6e6)
check("an honest 11 kW figure on a 6 A, 1 phase read-back counts for no more "
"than that allows (1.5 kW), so an old figure cannot cover a house "
"overload", abs(tr.car_w_trusted(t_end) - 6 * 253) < 1
and corr(tr, t_end))
check("...and None when it is not fresh", tr.car_w_trusted(t_end + 16) is None)
tr = CH.CarTracker()
t_end = feed(tr, 20, lambda i: 1000.0)
check("the first minute of readings is believed (a session just began): no "
"false alarm while the meter has had no time to show it",
corr(tr, t_end) and tr.car_w_trusted(t_end) is not None)
t_end = feed(tr, 80, lambda i: 1000.0, t0=t_end + 1)
check("M5: a power figure of 11 kW with an energy meter that does not move "
"is not corroborated after a window: no car figure for the alarms",
not corr(tr, t_end) and tr.car_w_trusted(t_end) is None)
tr = CH.CarTracker()
t_end = feed(tr, 80, lambda i: 1000.0 + i * 1500.0 / 3.6e6)
check("M5: a meter that gains 1.5 kW while the power says 11 kW is not "
"corroborated either", not corr(tr, t_end))
tr = CH.CarTracker()
t_end = feed(tr, 80, lambda i: None)
check("M5: no energy entity: never corroborated, so never used",
not corr(tr, t_end) and tr.car_w_trusted(t_end) is None)
tr = CH.CarTracker()
t_end = feed(tr, 80, lambda i: 1000.0 + i * 5000.0 / 3.6e6, w=5000.0)
t_end = feed(tr, 80, lambda i: 1000.0 + i * 11000.0 / 3.6e6, t0=t_end + 1)
check("a car that really ramps up (5 kW to 11 kW) stays corroborated",
corr(tr, t_end))
# N2: the lowest charge, 6 A on 1 phase (1380 W), honest and frozen
def honest_1380(tr, secs, t0=100.0, e0=1000.0, step_wh=10.0):
"""An honest 1380 W car whose meter shows `step_wh` steps."""
for i in range(secs):
wh = 1380.0 * i / 3600.0
tr.observe(charging_reading((e0 + (wh // step_wh) * step_wh) / 1000.0,
1380.0), t0 + i,
datetime(2026, 11, 16, tzinfo=timezone.utc), "2026-11-16")
return t0 + secs - 1
tr = CH.CarTracker()
t_end = honest_1380(tr, 400)
check("N2: an honest 6 A, 1 phase car (1380 W) with a meter that shows 10 Wh "
"steps is believed, minute after minute",
corr(tr, t_end) and tr.car_w_trusted(t_end) is not None
and all(corr(tr, t) for t in (t_end - 3, t_end - 17)))
ok_all = True
tr = CH.CarTracker()
for i in range(500): # step sizes and phases of the meter vary
wh = 1380.0 * i / 3600.0
step_wh = (10.0, 5.0, 20.0)[i // 170]
tr.observe(charging_reading((1000.0 + (wh // step_wh) * step_wh) / 1000.0,
1380.0), 100.0 + i,
datetime(2026, 11, 16, tzinfo=timezone.utc), "2026-11-16")
ok_all &= corr(tr, 100.0 + i)
check("...at every second of a 500 s charge with 5, 10 and 20 Wh meter steps",
ok_all)
tr = CH.CarTracker()
t_end = honest_1380(tr, 200)
frozen_at, caught = t_end, None
for i in range(1, 200): # now the figure and the meter freeze
tr.observe(charging_reading(tr.reading.energy_kwh, 1380.0), t_end + i,
datetime(2026, 11, 16, tzinfo=timezone.utc), "2026-11-16")
if caught is None and not corr(tr, t_end + i):
caught = i
check(f"N2: a frozen 1380 W figure is caught {caught} s after the freeze "
"(bound: 40 Wh / 1.38 kW = 104 s, and not sooner than the honest run "
"allows)", caught is not None and 60 <= caught <= 110)
# --- M5 end to end: the meter, the plant and the real controller ------------- #
def freeze_all(plant, c):
plant.ch.freeze() # every reading sticks
plant.ch.set_current(0) # the car really stops
plant.load = lambda at: 9000.0 + plant.ch.power_w
def freeze_power_only(plant, c):
plant.ch.freeze_power() # only the power sensor sticks
plant.ch.set_current(6) # the car really draws 1.4 kW
plant.ch.set_phases(1)
plant.load = lambda at: 9000.0 + plant.ch.power_w
r_fz_mid = P.drive(HOUSE, dur=400, events={120: freeze_all})
r_fz_pw = P.drive(HOUSE, dur=400, events={120: freeze_power_only})
r_fz_0 = P.drive(HOUSE, dur=400, events={5: freeze_all})
r_noe = P.drive(HOUSE, dur=240, sim=SimCharger(setpoint_a=16))
for _name, _r, _t0 in (("a freeze in the middle of a session (everything "
"stuck, the car stops)", r_fz_mid, 120),
("only the power sensor sticks while the car draws "
"1.4 kW", r_fz_pw, 120),
("a freeze from the start", r_fz_0, 5)):
_al = alarms(_r)
check(f"M5: {_name} and the house steps to 9 kW: after a window the "
f"normal alarm fires ({_al})",
[n for _t, n in _al] == ["goodwe_peak_saturated"]
and _t0 < _al[0][0] < _t0 + 60 + 25)
def freeze_1380(plant, c):
plant.ch.freeze()
plant.ch.set_current(0) # the car really stops
plant.load = lambda at: 9000.0 + plant.ch.power_w
_s6 = SimCharger(setpoint_a=6)
_s6.phases_allowed = 1
r_fz_6a = P.drive(HOUSE, dur=500, sim=_s6, user_a=6, setpoint=6, phases=1,
events={150: freeze_1380})
_al6 = alarms(r_fz_6a)
check("N2 (probe G): a frozen 6 A, 1 phase figure (1380 W) after the car "
"really stops, and the house steps to 9 kW: the normal alarm fires "
f"within the stated bound ({_al6})",
[n for _t, n in _al6] == ["goodwe_peak_saturated"]
and 150 < _al6[0][0] < 150 + 104 + 10 + 25)
_s6h = SimCharger(setpoint_a=6)
r_6_honest = P.drive(HOUSE, dur=500, sim=_s6h, user_a=6, setpoint=6, phases=1,
opts={"peak_cap_w": 1500})
check("an honest 6 A, 1 phase car on the real controller: the corroboration "
"never turns the figure off (the car stays trusted to the end)",
r_6_honest["c"].car_alarm_w() is not None)
r_honest = P.drive(HOUSE, dur=400)
check("M5: an honest charging car still suppresses the alarms for the whole "
"run, meter and all", alarms(r_honest) == []
and len(P.ids(r_honest, P.OVER)) == 1)
class _NoE(SimCharger):
pass
_sim_noe = SimCharger(setpoint_a=16)
_sim_noe.no_energy = True
r_noe = P.drive(HOUSE, dur=240, sim=_sim_noe)
check("M5: a charger with no energy entity does not suppress: the normal "
"alarm fires and there is no car notice",
[n for _t, n in alarms(r_noe)] == ["goodwe_peak_saturated"]
and P.ids(r_noe, P.OVER) == [])
# =========================================================================== #
print("\n10. DECISION 1: BATTERIES HELP WITH THE PEAK, ON AND OFF")
# =========================================================================== #
r_on = P.drive(HOUSE, dur=240, opts={"ev_batt_cover": True})
r_no = P.drive(HOUSE, dur=240, opts={"ev_batt_cover": False})
check("on (the default): the guard asks the batteries for the car's share "
"(the battery gives 2000 W) and the guard is engaged",
max(s[4] for s in r_on["snaps"]) == 2000.0
and r_on["snaps"][-1][3] is True)
check("off: the guard sees the house without the car, is not engaged, and the "
"batteries keep their charge (0 W)",
max(s[4] for s in r_no["snaps"]) == 0.0
and r_no["snaps"][-1][3] is False)
check("off: the quarter goes over by the car alone, and the add-on says so "
"(one grey notice), with no alarm",
alarms(r_no) == [] and len(P.ids(r_no, P.OVER)) == 1)
check("off: the Why says the guard ignores the car (and promises nothing "
"about the batteries)", "guard ignores the car" in cardwhy(r_no)
and "keep their charge" not in cardwhy(r_no))
check("either way the car is never throttled",
r_on["sim"].writes() == [] and r_no["sim"].writes() == []
and r_no["sim"].setpoint_a == 16 and r_no["sim"].power_w > 10000)
r_no_h = P.drive(HOUSE, dur=300, opts={"ev_batt_cover": False}, user_a=6,
setpoint=6, phases=1,
events={60: lambda p, c: setattr(
p, "load", lambda at: 9000.0 + p.ch.power_w)})
check("off: a real house overload is still an alarm (the car is only left out "
"of the guard's house)", [n for _t, n in alarms(r_no_h)]
== ["goodwe_peak_saturated"])
r_no_s = P.drive(HOUSE, dur=300, opts={"ev_batt_cover": False},
events={60: stale_then_overload})
check("off: a house overload with a car that is no longer read still alarms",
[n for _t, n in alarms(r_no_s)] == ["goodwe_peak_saturated"])
# =========================================================================== #
print("\n11. THE PEAK LINE: SET BY THE CAR, AND THE PEAK CARD'S CAR LINE")
# =========================================================================== #
def unplug_at(plant, c):
plant.ch.unplug()
r_pk = P.drive(HOUSE, dur=1900, events={950: unplug_at})
c_pk = r_pk["c"]
now_pk = rig.BASE + timedelta(seconds=1899)
mp = homeview.month_peak(c_pk, now_pk)
check("PRECONDITION: a quarter was banked as this month's peak, with the car "
"in it", mp["peak_w"] and mp["peak_w"] > 4000 and c_pk.car_peak_q)
check("the Home peak line names the car and the time of that quarter",
mp["set_by"].startswith("Set by the car charge you asked for, at ")
and mp["set_by"].endswith(".") and ":" in mp["set_by"])
with homeview.in_lang("nl"):
mp_nl = homeview.month_peak(c_pk, now_pk)
check("...in Dutch too", mp_nl["set_by"].startswith("Bepaald door de "
"autolading die u vroeg"))
r_pk_off = P.drive(HOUSE, dur=1900, mode="off", events={950: unplug_at})
check("Off: the month's peak is not 'set by the car you asked for'",
homeview.month_peak(r_pk_off["c"], now_pk)["set_by"] == ""
and r_pk_off["c"].car_peak_q == {})
mp_now = homeview.month_peak(r_man["c"], rig.BASE + timedelta(seconds=239))
check("while the car charges and the guard works, the Peak card says what the "
"car takes and the batteries cover",
"The car takes 11.0 kW and the batteries cover 2.0 kW" in mp_now["car_line"])
check("a site with no charger has neither line",
homeview.month_peak(s81.run(HOUSE, dur=60.0)[2],
rig.BASE)["set_by"] == "")
# =========================================================================== #
print("\n12. HOME ASSISTANT ENTITIES, THE PAGE'S ROUTE, STRINGS")
# =========================================================================== #
pl = dict(mqtt.car_payloads((16, (1, 3))))
sel = pl["homeassistant/select/goodwe_ctl_car_mode/config"]
num = pl["homeassistant/number/goodwe_ctl_car_current/config"]
ph = pl["homeassistant/select/goodwe_ctl_car_phases/config"]
check("three entities: select.goodwe_car_mode, number.goodwe_car_current, "
"select.goodwe_car_phases", len(pl) == 3
and sel["object_id"] == "goodwe_car_mode"
and num["object_id"] == "goodwe_car_current"
and ph["object_id"] == "goodwe_car_phases")
check("the mode's labels are English and pinned: Off, Manual (Solar and Night "
"are not offered)", sel["options"] == ["Off", "Manual"])
check("the current is 6 A to the clamp, whole amps", num["min"] == 6
and num["max"] == 16 and num["step"] == 1
and num["unit_of_measurement"] == "A")
check("the phases are 1 and 3 (or the one the installation allows)",
ph["options"] == ["1", "3"]
and dict(mqtt.car_payloads((16, (3,))))[
"homeassistant/select/goodwe_ctl_car_phases/config"][
"options"] == ["3"])
check("commands go to goodwe_ctl/car/<x>/set, HA sends them unretained",
all(x["command_topic"].startswith("goodwe_ctl/car/") and
x["command_topic"].endswith("/set") and x["retain"] is False
for x in (sel, num, ph)))
check("nothing is announced without a charger (and the default announcement "
"is as it was)", mqtt.car_payloads(None) == []
and mqtt.discovery_payloads() == mqtt.discovery_payloads(car=None))
check("the car entities come after every other row",
[t for t, _ in mqtt.discovery_payloads(car=(16, (1, 3)))][-3:]
== [t for t, _ in mqtt.car_payloads((16, (1, 3)))])
cmd = mqtt.parse_car_command
check("a command parses: mode, current, phases",
cmd("goodwe_ctl/car/mode/set", b"Manual", False)
== ("car_mode", "manual", None)
and cmd("goodwe_ctl/car/current/set", b"12", False)
== ("car_current", 12.0, None)
and cmd("goodwe_ctl/car/phases/set", b"3", False)
== ("car_phases", 3, None))
check("a retained command is dropped",
cmd("goodwe_ctl/car/mode/set", b"Manual", True)[2] == "retained")
check("Solar, Night, junk and a long payload are refused",
cmd("goodwe_ctl/car/mode/set", b"Solar", False)[1] is None
and cmd("goodwe_ctl/car/mode/set", b"Night", False)[1] is None
and cmd("goodwe_ctl/car/current/set", b"abc", False)[1] is None
and cmd("goodwe_ctl/car/phases/set", b"2", False)[1] is None
and cmd("goodwe_ctl/car/mode/set", b"x" * 100, False)[2] == "size"
and cmd("goodwe_ctl/car/mode/set", b"\xff\xfe", False)[2] == "encoding"
and cmd("goodwe_ctl/battery/mode/set", b"Manual", False)[2] == "topic")
async def ha_story():
w = World(setpoint=10)
await w.step(3)
await w.c.mqtt_command("goodwe_ctl/car/mode/set", b"Manual", False)
await w.c.mqtt_command("goodwe_ctl/car/current/set", b"13", False)
await w.step(10)
out = {"mode": w.c.car_mode, "a": w.c.car_a, "rb": w.sim.readback_a,
"pub": list(w.c.mqtt.values)[-1]}
await w.c.mqtt_command("goodwe_ctl/car/mode/set", b"Off", True) # retained
await w.c.mqtt_command("goodwe_ctl/car/mode/set", b"Solar", False)
await w.c.mqtt_command("goodwe_ctl/car/current/set", b"99", False)
await w.c.mqtt_command("goodwe_ctl/car/phases/set", b"2", False)
await w.step(5)
out["after"] = (w.c.car_mode, w.c.car_a, w.c.car_n)
await w.step(2)
await w.c.publish_values() if hasattr(w.c, "publish_values") else None
w.c.publish()
out["state"] = {k: v for k, v in w.c.mqtt.values[-1].items()
if k.startswith("car_")}
return out
ha = run(ha_story())
check("HA commands go through handle_action(): Manual and 13 A are applied "
"and written, and the new state is published",
ha["mode"] == "manual" and ha["a"] == 13.0 and ha["rb"] == 13
and ha["pub"] == {"car_mode": "Manual", "car_current": 13,
"car_phases": "1"})
check("a retained command, Solar, 99 A and 2 phases change nothing",
ha["after"] == ("manual", 13.0, 1))
check("the three states are in the published values",
ha["state"].get("car_mode") == "Manual"
and ha["state"].get("car_current") == 13
and ha["state"].get("car_phases") == "1")
class _S:
def __init__(self, d=None):
self.data = dict(d or {})
def set(self, k, v):
self.data[k] = v
from app import main as _main # noqa: E402
st_ = _S()
car_, retract_ = _main.car_announcement(CAR, st_)
check("with a charger the entities are announced and their topics kept",
car_ == (16.0, (1, 3)) and not retract_ and len(
st_.data["mqtt_car_configs"]) == 3)
car2, retract2 = _main.car_announcement(BASE, st_)
check("turning the charger off removes exactly those entities",
car2 is None and sorted(retract2) == sorted(st_.data["mqtt_car_configs"])
and len(retract2) == 3)
st2 = _S()
check("a site that never had a charger publishes nothing and its store is "
"not written",
_main.car_announcement(BASE, st2) == (None, []) and st2.data == {})
async def web_story():
import socket
import aiohttp
from aiohttp import web as aioweb
from app import web as app_web
w = World(setpoint=10)
await w.step(3)
app = app_web.build_app(w.c, selfcfg=object())
runner = aioweb.AppRunner(app)
await runner.setup()
sock = socket.socket()
sock.bind(("127.0.0.1", 0))
port = sock.getsockname()[1]
sock.close()
await aioweb.TCPSite(runner, "127.0.0.1", port).start()
out = {}
try:
async with aiohttp.ClientSession() as s:
root = f"http://127.0.0.1:{port}/"
for key, body in (
("manual", {"action": "car_mode", "value": "manual"}),
("a", {"action": "car_current", "value": 12}),
("n", {"action": "car_phases", "value": 3}),
("solar", {"action": "car_mode", "value": "solar"}),
("big", {"action": "car_current", "value": 40})):
async with s.post(root + "action", json=body) as r:
out[key] = (r.status, await r.json(content_type=None))
for lang in ("en", "nl"):
async with s.get(root + "status?lang=" + lang) as r:
out["status_" + lang] = (await r.json(content_type=None))
async with s.get(root) as r:
out["page"] = await r.text()
finally:
await runner.cleanup()
return out, w
web, ww = run(web_story())
check("POST /action car_mode, car_current and car_phases store and answer",
web["manual"] == (200, {"ok": True, "result": {
"mode": "manual", "current": 6.0, "phases": 1}})
and web["a"][0] == 200 and web["n"][0] == 200)
check("...Solar and 40 A (above the clamp) are a 400 with a plain reason",
web["solar"][0] == 400 and web["solar"][1]["ok"] is False
and web["solar"][1]["error"] == messages.car_refused("value")
and web["big"][0] == 400)
car_s = web["status_en"]["car"]
check("/status gives the page what it needs: the mode, the modes offered (Off "
"and Manual only), the current's range, the phases",
car_s["mode"] == "manual" and car_s["modes"] == ["off", "manual"]
and car_s["current"] == {"value": 12, "min": 6, "max": 16}
and car_s["phases"] == {"value": 3, "choices": [1, 3]})
check("/status in Dutch has the Dutch Why",
web["status_nl"]["car"]["why"].startswith("U stelde 12 A in"))
check("the page has the controls and no Solar or Night button",
'id="car-manual"' in web["page"] and 'id="car-a"' in web["page"]
and "mode_solar" not in web["page"] and "mode_night" not in web["page"])
check("the page names the Manual strings in both languages",
"Handmatig" in web["page"] and "Manual" in web["page"])
en = json.load(io.open(os.path.join(HERE, "app", "ui_text", "en.json"),
encoding="utf-8"))
nl = json.load(io.open(os.path.join(HERE, "app", "ui_text", "nl.json"),
encoding="utf-8"))
def keys(d, pre=""):
out = set()
for k, v in d.items():
out |= keys(v, pre + k + ".") if isinstance(v, dict) else {pre + k}
return out
new_keys = {"home.car.mode_manual", "home.car.help_manual.description",
"home.car.current", "home.car.phases", "home.car.phases_1",
"home.car.phases_3", "home_words.peak.car",
"home_words.peak.set_by_car", "home_words.car.why.manual_set",
"home_words.car.why.manual_cover", "home_words.car.why.manual_over",
"home_words.car.why.manual_full",
"home_words.car.why.manual_nocover",
"home_words.car.why.manual_wait", "home_words.car.why.manual_would",
"home_words.car.why.manual_stopped",
"home_words.car.why.manual_blocked",
"home_words.attn.charger_other", "home_words.attn.charger_stuck",
"home_words.attn.charger_refused", "home_words.attn.charger_error",
"home_words.attn.car_over", "choices.ev_mode_start.keep",
"choices.ev_mode_start.off"}
ke, kn = keys(en), keys(nl)
check("every new Home string exists in English and in Dutch",
new_keys <= ke and new_keys <= kn)
check("the Dutch is not the English for the sentences",
all(en["home_words"]["car"]["why"][k] != nl["home_words"]["car"]["why"][k]
for k in ("manual_set", "manual_cover", "manual_over", "manual_full",
"manual_nocover", "manual_wait", "manual_would",
"manual_stopped", "manual_blocked")))
check("L2: one wording for 'something else changes the charger', in Off and "
"Manual, English and Dutch",
en["home_words"]["attn"]["charger_other"]
== en["home_words"]["attn"]["charger_writer"]
and nl["home_words"]["attn"]["charger_other"]
== nl["home_words"]["attn"]["charger_writer"]
and "changes the charger" in str(messages.row_charger_other())
and "wijzigt de laadpaal" in messages.row_charger_other().nl
and "changed" not in str(messages.row_charger_other()))
check("L3: with Batteries help off the Why promises nothing about the "
"batteries, and DOCS says what it does",
"keep their charge" not in json.dumps(en) + json.dumps(nl)
.replace("houden hun lading", "keep their charge")
and "zero-grid control can still discharge them for the car"
in io.open(os.path.join(HERE, "DOCS.md"), encoding="utf-8").read()
.replace("\n", " ").replace("Normal zero-grid control can still",
"zero-grid control can still"))
check("every new row, notice and refusal is bilingual",
all(getattr(f, "nl", None) for f in (
messages.row_car_over(), messages.row_charger_other(),
messages.row_charger_stuck(), messages.row_charger_refused(),
messages.row_charger_error("x")))
and messages.car_over("16").body_nl)
check("the page shows the option names and choices in Settings, both languages",
messages.LABELS["ev_batt_cover"] and messages.LABELS_NL["ev_mode_start"])
# =========================================================================== #
print("\n13. THE SIMULATOR")
# =========================================================================== #
s = SimCharger(setpoint_a=10)
s.plug_in()
s.lag_s = 3.0
s.request_current(12)
s.tick(2)
check("the model shows a write after its read-back lag, not before",
s.readback_a == 10)
s.tick(1)
check("...and after it", s.readback_a == 12)
s.refuse = "ignore"
check("a refusing charger says yes and does not change",
s.request_current(6) and s.readback_a == 12)
s.refuse = "error"
check("a refusing Home Assistant says no", not s.request_current(6))
s.refuse = None
s.freeze()
s.set_current(7)
check("a frozen model serves the readings of the moment it froze",
s.states()[f"sensor.wallbox_main_active_max_current_socket_1"]["state"]
== "12")
s.freeze(False)
print()
if fails:
print(f"{len(fails)} FAILED")
for f in fails:
print(" -", f)
sys.exit(1)
print("all passed")