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>
447 lines
16 KiB
Python
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)
|