Files
goodwe-addon/goodwe_controller/test_ev10.py
T
Claude 8efc385956
checks / unit (pull_request) Failing after 2m13s
infra-pin / fresh (pull_request) Successful in 2s
EV-10, EV-11, EV-12: car-alone peak alarm, steady car-over row, own write not another writer
EV-10: the car is the cause when the period without it (projected minus the car's
fresh, corroborated average) is at or under the aim, also with the projection
still under it. EV-11: car_over stays on until the test has been false for 180 s.
EV-12: the tracker's own-write mute opens before the write and runs 15 s from its
return.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-16 15:27:46 +01:00

447 lines
16 KiB
Python

"""EV-10, EV-11, EV-12: three rig findings of EV-04's test (F-1, F-2, F-3).
`python3 -B test_ev10.py`
1. EV-10: the car alone takes the batteries to the peak reserve while the period
is still projected UNDER the aim: no alarm, one grey notice. A stuck car
figure with a house overload, and a house-only drain, still alarm. Mutant:
an uncorroborated car figure in the "period without the car" test.
2. EV-11: the grey row and the Car Why do not flicker while the car keeps the
period over the limit; a real end clears them after OVER_OFF_HOLD_S. The
alarm decision (`car_explains`) has no hold.
3. EV-12: the add-on's own write, and Off within 15 s of it, is never "another
writer"; a real outside change afterwards still shows the row.
"""
import asyncio
import logging
import os
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 ctl_car, homeview, chargers as CH # noqa: E402
from app.main import Controller # noqa: E402
from app import freshness # noqa: E402
from chargersim import FakeHa, SimCharger # noqa: E402
import ev04_peak as P # noqa: E402
import safety81_sim as s81 # noqa: E402
import opt11_identity as rig # 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()))
LOG = _Log()
_lg = logging.getLogger("goodwe")
_lg.addHandler(LOG)
_lg.setLevel(logging.DEBUG)
_lg.propagate = False
# =========================================================================== #
print("1. EV-10: THE CAR ALONE TAKES THE BATTERIES TO THE RESERVE (F-1)")
# =========================================================================== #
CAP = 4500.0 # the aim is 4450 W (50 W margin)
HOUSE = 1100.0
def at_reserve(plant, c):
"""The batteries reach the peak reserve late in the period, and the house
eases a little: the period is still projected UNDER the aim."""
plant.soc = 19.0
plant.load = lambda at: 780.0 + plant.ch.power_w
def alarms(r):
return P.ids(r, *P.ALARMS)
UNDER = [] # (second, projected W, aim W) while floor-limited
def watch(first, fn):
"""Events for seconds 840 to 894: `fn` at `first`, and a note of every
cycle in which the guard is floor-limited."""
def note(plant, c):
g = c.peak_guard
if g is not None and g.floor_limited:
UNDER.append((plant.t, g.projected_w, g.target_w))
ev = {t: note for t in range(first - 10, 895)}
ev[first] = lambda plant, c: (fn(plant, c), note(plant, c))
return ev
LOG.rec.clear()
r10 = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, events=watch(850, at_reserve))
ERR10 = [m for lv, m in LOG.rec if lv in ("ERROR", "WARNING")]
check("PRECONDITION: the guard was floor-limited with the projection UNDER "
"the aim (the rig's 5888 W against 6000 W)",
any(p < a for _t, p, a in UNDER))
check("the car alone: no 'Load too high', no 'Battery stopped limiting the "
"peak'", alarms(r10) == [])
rows10 = {x["id"]: x for x in r10["c"].checks()}
check("...no red row; the grey 'Car over the peak limit' row says it",
rows10["peak_guard"]["ok"] is True
and not [x for x in r10["c"].checks()
if x["ok"] is False and not x["warn"]]
and rows10.get("car_over", {}).get("ok") is True)
check("...one grey notice for the session", len(P.ids(r10, P.OVER)) == 1)
check("...no ERROR (or WARNING) line was logged for it", ERR10 == [])
def house_stuck(plant, c):
at_reserve(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
asyncio.get_event_loop().create_task(c.handle_action("car_current",
value=10))
r10s = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, events=watch(850, house_stuck))
check("a stuck car figure and a house overload at the reserve: the normal "
"alarm still fires",
[n for _t, n in alarms(r10s)]
and all(n in P.ALARMS for _t, n in alarms(r10s)))
def house_drain(plant, c):
plant.soc = 19.0
plant.load = lambda at: 12000.0 + plant.ch.power_w
r10h = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, user_a=6, setpoint=6,
events=watch(600, house_drain))
check("a house-only drain to the reserve with the car charging little: the "
"normal alarm still fires",
alarms(r10h) != [] and not r10h["c"].car_explains)
r10off = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, mode="off", events=watch(850, at_reserve))
check("PRECONDITION: Off, the same case raises the normal alarm (the false "
"alarm Manual must not make)", alarms(r10off) != [])
# a direct unit of the rule: the car's average, the period without it
class _Car(ctl_car.CarMixin):
def __init__(self, cover=True, w=3700.0):
self.o = {"ev_batt_cover": cover}
self.w = w
self._now = 0.0
self.car_init({}, type("S", (), {"data": {}, "set": lambda s, k, v: 0})())
def car_now(self):
return self._now
def car_alarm_w(self):
return self.w
class car: # noqa: N801
@staticmethod
def status(*_a):
return "charging"
class _Proj:
def __init__(self, proj_w, elapsed=850.0):
self.projected_w, self.elapsed_s, self.held_w = proj_w, elapsed, proj_w
self.block_start = datetime(2026, 11, 16, 20, 0, tzinfo=timezone.utc)
class _G:
def __init__(self, floor=True, sat=False):
self.floor_limited, self.saturated = floor, sat
def explains(proj_w, car_w, *, floor=True, cover=True, car_so_far_w=None):
c = _Car(cover, car_w)
p = _Proj(proj_w)
c._carq = {"key": p.block_start,
"ws": (car_w if car_so_far_w is None else car_so_far_w)
* p.elapsed_s, "mono": 0.0}
c.car_cycle(p, _G(floor), 4450.0, None)
return c.car_explains
check("rule: the period without the car (4468 - 3700 = 768 W) is under the "
"aim: the car explains it, even with the projection under the aim",
explains(4300.0, 3700.0) and explains(4468.0, 3700.0))
check("rule: without the car it is still over the aim: the car does not "
"explain it", not explains(9000.0, 3700.0))
check("rule: no car power, no explanation", not explains(4300.0, 0.0))
check("rule: the guard is not floor-limited or saturated: nothing to explain",
not explains(4300.0, 3700.0, floor=False))
# =========================================================================== #
print("\n2. EV-11: THE 'CAR OVER THE PEAK LIMIT' ROW DOES NOT FLICKER (F-2)")
# =========================================================================== #
# The cause (rig p7off 21:18 to 21:45, plant.csv): after 21:15 the car's own
# quarter (14.0 kW) was the month peak, so the aim was that quarter's average
# and the grid of the next ones (14.04 kW, +-40 W of noise) sat ON it. The
# projection crossed the aim every few seconds, `ex > 0` came and went, and
# `car_over` followed it with no hold on the way off.
def over_run(c, secs, proj_of, w_of=lambda t: 11000.0, t0=0.0, target=14000.0,
cover=False):
"""Run `car_cycle` once a second; returns (car_over, car_explains) per second."""
out = []
for k in range(secs):
t = t0 + k
c._now = t
c.w = w_of(t)
p = _Proj(proj_of(t), elapsed=300.0 + (t % 400))
c._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s,
"mono": t}
c.car_cycle(p, _G(True), target, None)
out.append((c.car_over, c.car_explains))
return out
def noisy(t):
"""The projection straddles the aim: +-40 W, a new value every 7 s."""
return 14000.0 + (40.0 if int(t // 7) % 2 else -40.0) * (1 + (int(t) % 3))
c11 = _Car(cover=False)
o11 = over_run(c11, 1200, noisy)
flips = sum(1 for a, b in zip(o11, o11[1:]) if a[0] != b[0])
check("while the car keeps the period at the limit the row stays on: one "
"switch on in 20 minutes, none off", flips == 1 and o11[-1][0] is True)
check("it turns on after the existing 10 s hold, not later than the first "
"10 s the condition has stood (a gap does not restart the count)",
next((i for i, x in enumerate(o11) if x[0]), 10**6) <= 25)
# the condition on its own, for the PRECONDITION: the same input flips
c11o = _Car(cover=False)
raw = []
for k in range(1200):
c11o._now = float(k)
p = _Proj(noisy(k), elapsed=300.0 + (k % 400))
c11o._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s, "mono": k}
ex = p.projected_w - 14000.0
raw.append(ex > 0.0 and c11o.car_avg_w(p, 11000.0) >= ex)
raw_flips = sum(1 for a, b in zip(raw, raw[1:]) if a != b)
check("PRECONDITION: the condition itself flips many times in those 20 "
"minutes", raw_flips > 20)
# a real end: the car stops (no trusted power) after 600 s
c11e = _Car(cover=False)
o11e = over_run(c11e, 1000, lambda t: 14500.0,
w_of=lambda t: 11000.0 if t < 600 else None)
off_at = next((i for i, x in enumerate(o11e) if i > 600 and not x[0]), -1)
check("a real end: the row stays for OVER_OFF_HOLD_S (180 s) and then goes",
off_at == 600 + int(ctl_car.OVER_OFF_HOLD_S)
and not any(x[0] for x in o11e[off_at:]))
o11r = over_run(c11e, 100, lambda t: 14500.0, t0=1000.0)
check("it comes back after the usual 10 s if the condition returns after "
"it went", o11r[9][0] is False and o11r[10][0] is True)
# the alarm decision has no hold: a real house overload is never delayed
c11a = _Car(cover=True)
o11a = over_run(c11a, 60, lambda t: 4300.0, target=4450.0)
check("decision 1 on: the car explains it at once (no hold)",
o11a[0][1] is True)
c11a.w = None # the figure is not trusted
c11a._now = 61.0
c11a.car_cycle(_Proj(4300.0), _G(True), 4450.0, None)
check("...and the moment the car figure is not trusted it explains nothing, "
"so the normal alarms stand at once (the grey row may stay)",
c11a.car_explains is False)
# the whole thing on the real controller: the Why does not flicker either
def p7_like(plant, c):
plant.load = lambda at: 3000.0 + plant.ch.power_w
r11 = P.drive(s81.constant(HOUSE), dur=700, rating=2000.0, soc=60.0, cap=CAP,
phases=3, opts={"ev_batt_cover": False})
ov = [s[2] for s in r11["snaps"]]
check("real controller, cover off, an 11 kW car: the flag is steady once on",
sum(1 for a, b in zip(ov, ov[1:]) if a != b) <= 1 and ov[-1] is True)
# =========================================================================== #
print("\n3. EV-12: OUR OWN WRITE IS NOT ANOTHER WRITER (F-3)")
# =========================================================================== #
CLOCK = [1000.0]
freshness.monotonic = lambda: CLOCK[0]
SET = "number.wallbox_power_connector_max_current_socket_1"
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"], "ev_charger": "alfen_ha", "ev_max_a": 16,
"ev_phases": "auto", "ev_current_entity": SET}
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 publish(self, v):
pass
def close(self):
pass
class Site(FakeHa):
def __init__(self, charger):
super().__init__(charger, None)
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", 800.0, "W"),
("sensor.soc", 50.0, "%"),
("sensor.batt", 0.0, "W"),
("sensor.pv", 2000.0, "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):
return await super().set_number(entity_id, float(value))
class World:
"""A real Controller on the charger model. While a write waits for its
read-back, the controller's own reading goes on (as in production, where
the cycle runs while the writer task waits): that is how the read-back of
our own write reaches the tracker BEFORE the write returns."""
def __init__(self, setpoint=10):
self.sim = SimCharger(setpoint_a=setpoint)
self.sim.plug_in()
self.sim.lag_s = 2.0 # the rig's read-back lag
self.sim.phases_allowed = 1
self.t = 1000.0
CLOCK[0] = self.t
self.c = Controller(dict(BASE), Site(self.sim), _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
await self.c.read_inputs(now_mono=self.t) # the cycle reads on
async def step(self, n=1):
for _ in range(n):
self.sim.tick(1.0)
self.t += 1.0
CLOCK[0] = self.t
await self.c.read_inputs(now_mono=self.t)
await self.c.cycle()
await self.c.car_settle()
def rows(self):
return {r["id"]: r for r in self.c.checks()}
async def own_then_off(wait):
w = World()
await w.step(3)
await w.c.handle_action("car_mode", value="manual")
await w.c.handle_action("car_current", value=12)
await w.step(wait)
await w.c.handle_action("car_mode", value="off")
await w.step(40)
return w
w12 = asyncio.run(own_then_off(2))
check("PRECONDITION: the add-on wrote 12 A and the charger took it",
w12.sim.readback_a == 12 and len(w12.sim.writes("current")) == 1)
check("our own write, then Off 2 s later: no 'Something else changes the "
"charger'", "charger_writer" not in w12.rows()
and w12.c.car.writer_at_utc is None)
w12b = asyncio.run(own_then_off(14))
check("...and 14 s later (inside the 15 s)", "charger_writer" not in
w12b.rows() and w12b.c.car.writer_at_utc is None)
async def own_then_outside():
w = await own_then_off(2)
w.sim.set_current(7) # somebody else, afterwards
await w.step(3)
early = "charger_writer" in w.rows()
await w.step(30)
return early, "charger_writer" in w.rows()
early12, late12 = asyncio.run(own_then_outside())
check("an outside change after that still shows the row (within 30 s)",
late12 is True)
async def manual_own():
w = World()
await w.step(3)
await w.c.handle_action("car_mode", value="manual")
await w.c.handle_action("car_current", value=12)
await w.step(60)
await w.c.handle_action("car_current", value=8)
await w.step(20)
return w
wm = asyncio.run(manual_own())
check("Manual: two writes of ours, never 'another writer' in the tracker",
wm.c.car.writer_at_utc is None and "charger_other" not in wm.rows())
print()
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
sys.exit(1 if fails else 0)