"""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)