diff --git a/goodwe_controller/CHANGELOG.md b/goodwe_controller/CHANGELOG.md index 0d68c33..bf5a514 100644 --- a/goodwe_controller/CHANGELOG.md +++ b/goodwe_controller/CHANGELOG.md @@ -2,6 +2,7 @@ ### Not in a release yet +- The add-on no longer changes the car's phases while the car still draws: it waits until the charger reads under 100 W, and if the car is still drawing after 20 s it gives the current back and tries again after 10 minutes ([[EV-28]]). - When the add-on changes the car's phases while the batteries are at the peak reserve, there is no longer a false "Battery stopped limiting the peak" for a moment ([[EV-15]]). ## 0.24.0 diff --git a/goodwe_controller/DECISIONS/EV-04-manual-mode.md b/goodwe_controller/DECISIONS/EV-04-manual-mode.md index 4fb034b..607569f 100644 --- a/goodwe_controller/DECISIONS/EV-04-manual-mode.md +++ b/goodwe_controller/DECISIONS/EV-04-manual-mode.md @@ -30,9 +30,11 @@ code had to decide that the design left open. ## The phase sequence -0 A, wait until the charger reports under 100 W or mode3 leaves C (20 s at most), -select the phases, wait 10 s, write the current. One switch per 10 minutes. A -charger that does not take the 0 A never gets the phases select. A sequence that +0 A, wait until the charger reports under 100 W (mode3 leaving C counts only +when there is no power reading; 20 s at most), select the phases, wait 10 s, write the current. One switch per 10 minutes. A +charger that does not take the 0 A never gets the phases select. A car still +drawing after 20 s gets no select: its current comes back and it counts as a +failed try (EV-28). A sequence that has begun is finished whatever the mode, because it leaves the car at 0 A otherwise; a stop of the add-on in the middle gives the car its current back (`car_shutdown`). diff --git a/goodwe_controller/app/carmode.py b/goodwe_controller/app/carmode.py index 39bf326..dbaafb0 100644 --- a/goodwe_controller/app/carmode.py +++ b/goodwe_controller/app/carmode.py @@ -15,8 +15,9 @@ THE RULES, each tested in test_ev04.py: reports, the entity's own range)`. The driver refuses anything above it; this module never asks for more. * Phases change only through the SAFE SEQUENCE: 0 A, wait until the charger - reports under `QUIET_W` or mode3 leaves C (at most `ZERO_WAIT_S`), select the - phases, wait `SETTLE_S`, write the current again. At most one switch per + reports under `QUIET_W` (mode3 leaving C only without a power reading; at + most `ZERO_WAIT_S`, then the current comes back and it counts as a failed + try), select the phases, wait `SETTLE_S`, write the current again. At most one switch per `PHASE_GAP_S`. A sequence that has begun is always finished, because it leaves the car at 0 A otherwise. * A read-back that differs from the add-on's own last write for `WRITER_S` is @@ -333,11 +334,29 @@ class ManualWriter: "phase change, so the phases were not touched.") return if q["stage"] == "zero": - quiet = ((r.power_w is not None and r.power_w < QUIET_W) - or (r.state is not None and r.state != "C")) - if not quiet and now - q["t0"] < ZERO_WAIT_S: - return - q["stage"] = "select" + # A power reading decides; only without one does mode3 (not C, + # not D) say the car is quiet. Still drawing at the timeout: no + # select, the current comes back (EV-28). + if r.power_w is not None: + quiet = r.power_w < QUIET_W + else: + quiet = r.state is not None and r.state not in ("C", "D") + if not quiet: + if now - q["t0"] < ZERO_WAIT_S: + return + self.last_switch = now + self.phase_fails += 1 + q["failed"] = True # EV-15: no grace for the alarm + q["stage"], q["t1"] = "settle", now - SETTLE_S # restore now + _LOG.warning("The car kept drawing, so the phases were not " + "changed.") + if self.phase_fails >= MAX_TRIES: + self.phases_gave_up = True + _LOG.warning("The charger did not take the phases, so the " + "add-on stops trying until you change " + "something: CHARGER_PHASES.") + else: + q["stage"] = "select" if q["stage"] == "select": ok = await drv.write_phases(q["n"]) self._stamp(now) diff --git a/goodwe_controller/test_ev04.py b/goodwe_controller/test_ev04.py index 1b28031..fdc83e7 100644 --- a/goodwe_controller/test_ev04.py +++ b/goodwe_controller/test_ev04.py @@ -613,10 +613,15 @@ async def slow_stop(): 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) +# EV-28: a car still drawing at 20 s gets no select; the current comes back +rest5s = [x for x in seq5s if x[1] == "current" and x[2] == 10.0] +check("a car that is slow to stop (about 1300 W after 20 s): the phases are " + "NOT selected, the add-on gives up at 20 s, the 10 A come back at once " + f"({[(x[1], x[2]) for x in seq5s]}), one failed try", + [x[1] for x in seq5s].count("phases") == 0 + and [x[2] for x in seq5s if x[1] == "current"][:2] == [0.0, 10.0] + and rest5s and 20.0 <= rest5s[0][0] - seq5s[0][0] <= 21.0 + and w5s.sim.phases_allowed == 1 and w5s.c.car_writer.phase_fails == 1) async def zero_refused(): @@ -890,9 +895,11 @@ check("the write paths are exactly these (all in carmode.py): the current " ("carmode.py", "write_phases")]) -async def fuzz(seed): +async def fuzz(seed, slow=False): rnd = random.Random(seed) w = World(setpoint=rnd.choice([6, 10, 16]), phases=rnd.choice([1, 3])) + if slow: # EV-28: the car's power ramps down slowly + w.sim.ramp_w_s, w.sim.stop_delay_s = 200.0, float(seed % 2) 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 @@ -961,6 +968,9 @@ async def fuzz(seed): bad.append((seed, step, "phases selected outside Manual")) if sp != 0.0: bad.append((seed, step, "phases with the setpoint up", sp)) + if power >= carmode.QUIET_W: # EV-28 (N1) + bad.append((seed, step, "phases selected under load", + power)) if last_switch is not None and t - last_switch < 600.0: bad.append((seed, step, "two switches inside 10 min", t - last_switch)) @@ -977,7 +987,15 @@ for _seed in range(14): fz_o += _o fz_h += _h fz_u += _u -check(f"fuzz: {fz_n} charger writes over 14 random sites and 5600 steps of " +for _seed in range(100, 104): # EV-28: ramp 200 W/s, B after 0 or 1 s + _b, _n, _o, _h, _u = run(fuzz(_seed, slow=True)) + fz_bad += _b + fz_n += _n + fz_o += _o + fz_h += _h + fz_u += _u +check(f"fuzz: {fz_n} charger writes over 18 random sites (4 of them with a " + f"car that stops at 200 W/s) and 7200 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 " diff --git a/goodwe_controller/test_ev28.py b/goodwe_controller/test_ev28.py new file mode 100644 index 0000000..378c3a1 --- /dev/null +++ b/goodwe_controller/test_ev28.py @@ -0,0 +1,936 @@ +"""EV-28: the phases are never selected while the car still draws. +`python3 -B test_ev28.py` + +The stage "zero" of the phase sequence counted mode3 B as quiet whatever the +power, and selected anyway after ZERO_WAIT_S. Now: a power reading decides +(under QUIET_W); mode3 (not C, not D) only without one; a car still drawing at +the timeout gets NO select, its current back at once, and one failed try. + +U = the ManualWriter on a stub driver (exact seconds). W = the real Controller +on the charger model (`chargersim`, power ramps down at `ramp_w_s`). + +1. U: what counts as quiet (T1, T3, T4, T6, T7, T8). +2. W: the rig shapes (T2, T5, T9, T10, T16, T17). +3. W: tries, the amber row, the log (T11, T12, T13). +4. W: the other ends of a sequence and the alarm (T14, T15, T18-T21). +5. W: the digests of the quiet shapes, from 4eba2d9 (T22). +6. Docs and the module docstring (T25). T23 is in test_ev04 (slow_stop), T24 + its fuzz. Mutants (T26): see the dev report. +Mutating a module this file grades? Read MUTATION.md first (purge __pycache__). +""" + +import asyncio +import hashlib +import logging +import os +import sys +from datetime import datetime + +HERE = os.path.dirname(os.path.abspath(__file__)) +sys.path.insert(0, os.path.join(HERE, "tools")) + +from app import carmode, chargers as CH, ctl_car # noqa: E402 +from app.carmode import ManualWriter, QUIET_W, ZERO_WAIT_S # noqa: E402 +from app.carmode import SETTLE_S, PHASE_GAP_S, MAX_TRIES # noqa: E402 +from app.main import Controller # noqa: E402 +from app import freshness # noqa: E402 +from named_absence import nth # noqa: E402 +from chargersim import FakeHa, SimCharger # noqa: E402 +import ev04_peak as P # noqa: E402 +import safety81_sim as s81 # noqa: E402 + +fails = [] + + +def check(name, cond): + print(f" {'ok ' if cond else 'FAIL'} {name}") + if not cond: + fails.append(name) + + +class _Cap(logging.Handler): + def __init__(self): + super().__init__(logging.DEBUG) + self.rec = [] + + def emit(self, r): + self.rec.append((r.levelno, r.getMessage())) + + def loud(self, since=0): + """INFO and above from `since` on.""" + return [m for lv, m in self.rec[since:] if lv >= logging.INFO] + + +CAP = _Cap() +logging.getLogger("goodwe").addHandler(CAP) +logging.getLogger("goodwe").setLevel(logging.DEBUG) + + +def run(coro): + return asyncio.run(coro) + + +# =========================================================================== # +# U: the writer on a stub driver +# =========================================================================== # +class Drv: + def __init__(self, phases=1, a=10.0, ok_phases=True): + self.log, self.now, self.phases, self.a = [], 0.0, phases, a + self.ok_phases = ok_phases + + async def write_current(self, a): + self.log.append((self.now, "current", float(a))) + self.a = float(a) + return True + + async def write_phases(self, n): + self.log.append((self.now, "phases", n)) + if self.ok_phases: + self.phases = n + return self.ok_phases + + +class Trk: + obs_at = None + + def begin_write(self): + pass + + def end_write(self, *_a): + pass + + def note_write(self, *_a): + pass + + +async def unit(fn, times=None, want_phases=3, want_a=10.0, clamp_fn=None, + n_phases=1, a0=10.0, ok_phases=True): + """0 A is written at t=0. `fn(dt)` is (mode3, power_w) `dt` s later, or None + (unavailable). Returns (writer, driver, abandon time or None).""" + w, d = ManualWriter(), Drv(phases=n_phases, a=a0, ok_phases=ok_phases) + trk = Trk() + + async def step(t, state, power): + d.now = float(t) + a = d.a + r = CH.ChargerReading(available=state is not None, state=state, + power_w=power, setpoint_a=a, allowed_a=a, + phases_allowed=d.phases) + await w.step(d, r, mode="manual", want_a=want_a, + want_phases=want_phases, rev=1, + clamp=clamp_fn(t) if clamp_fn else 16.0, now=float(t), + tracker=trk, writing=True, status="charging", + clock=lambda: float(t)) + await step(0.0, "C", 2300.0) + aband = None + for t in (times if times is not None else range(1, 41)): + x = fn(t) + if x is None: + await step(t, None, None) + else: + await step(t, x[0], x[1]) + if aband is None and w.seq is not None \ + and w.seq["stage"] == "settle" and w.seq.get("failed") \ + and not d.log[-1][1] == "phases": + aband = t + if aband is None and w.seq is None and w.phase_fails: + aband = t + return w, d, aband + + +def phases_at(d): + return [x for x in d.log if x[1] == "phases"] + + +print("1. U: WHAT COUNTS AS QUIET") +for p in (600.0, 1200.0, 2152.0, 2200.0): + w, d, ab = run(unit(lambda t, p=p: ("B", p), range(1, 20))) + check(f"T1: B with {p:.0f} W for 19 s: no select ({d.log})", + not phases_at(d) and w.seq is not None + and w.seq["stage"] == "zero") + +w, d, ab = run(unit(lambda t: ("B", 40.0 if t >= 10 else 2152.0), + range(1, 15))) +sel = [x[0] for x in phases_at(d)] +check(f"T3: the live Alfen shape (B, 2152 W to t0+9, 40 W at t0+10): select " + f"at t0+10 and not before ({sel})", sel == [10.0]) + +w, d, ab = run(unit(lambda t: ("B", 100.0), range(1, 20))) +check("T4: exactly 100.0 W with B: not quiet, no select (strict <)", + not phases_at(d)) +for p, st in ((99.9, "C"), (0.0, "B"), (-5.0, "C")): + w, d, ab = run(unit(lambda t, p=p, st=st: (st, p), range(1, 4))) + check(f"T4: {p} W with {st}: select on the first step ({d.log})", + [x[0] for x in phases_at(d)] == [1.0]) + +w, d, ab = run(unit(lambda t: ("B", 30.0) if t >= 20 else ("C", 2000.0), + [19.9, 20.0, 21.0])) +check(f"T6: quiet first seen at exactly t0+20: select at 20 ({d.log})", + [x[0] for x in phases_at(d)] == [20.0]) +w, d, ab = run(unit(lambda t: ("B", 500.0), [19.9, 20.0, 21.0])) +check("T6: still drawing at 19.9: waits; at 20.0: no select, abandoned " + f"({d.log}, abandon {ab})", + not phases_at(d) and ab == 20.0 and w.phase_fails == 1 + and d.log[-1] == (20.0, "current", 10.0)) +w, d, ab = run(unit(lambda t: ("B", 500.0), [19.9])) +check("T6: at 19.9 s the sequence still waits", + w.seq is not None and w.seq["stage"] == "zero" and w.phase_fails == 0) + +w, d, ab = run(unit(lambda t: ("B", None), range(1, 4))) +check("T7: no power reading and B: select on the first step, as before", + [x[0] for x in phases_at(d)] == [1.0]) +w, d, ab = run(unit(lambda t: ("D", None), range(1, 30))) +check("T7/Expected 2: no power reading and D (charging with ventilation) is " + "not quiet: no select", not phases_at(d)) +# state None needs an available reading with state None: own helper +async def unit_blind(state): + w, d = ManualWriter(), Drv() + trk = Trk() + for t in range(0, 26): + d.now = float(t) + a = d.a + r = CH.ChargerReading(available=True, state=("C" if t == 0 else state), + power_w=2300.0 if t == 0 else None, + setpoint_a=a, allowed_a=a, + phases_allowed=d.phases) + await w.step(d, r, mode="manual", want_a=10.0, want_phases=3, rev=1, + clamp=16.0, now=float(t), tracker=trk, writing=True, + status="charging", clock=lambda: float(t)) + return w, d + + +for st in ("C", None): + w, d = run(unit_blind(st)) + check(f"T8: no power reading, state {st}: no select ever, abandon at " + f"t0+20, one restore, one failed try ({d.log})", + not phases_at(d) and w.phase_fails == 1 and w.seq is None + and d.log == [(0.0, "current", 0.0), (20.0, "current", 10.0)]) + +# the abandon is immediate: no SETTLE_S wait (brief answer 1) +w, d, ab = run(unit(lambda t: ("C", 900.0), range(1, 26))) +check(f"Expected 3: the current comes back at the abandon step itself, not " + f"after SETTLE_S ({d.log})", + d.log == [(0.0, "current", 0.0), (20.0, "current", 10.0)] + and w.last_switch == 20.0) +w, d, ab = run(unit(lambda t: ("C", 900.0), range(1, 26), + clamp_fn=lambda t: 16.0 if t < 10 else 8.0, want_a=16.0)) +check(f"N2: the restore is clamped at the abandon ({d.log[-1]})", + d.log[-1] == (20.0, "current", 8.0)) + +# =========================================================================== # +# W: the real Controller on the charger model +# =========================================================================== # +freshness.monotonic = lambda: CLOCK[0] +CLOCK = [1000.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"]} +CAR = dict(BASE, 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, 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)) + + +class World: + def __init__(self, opts=CAR, sim=None, store=None, setpoint=10, grid=800.0, + phases=1): + self.sim = sim or SimCharger(setpoint_a=setpoint) + self.sim.plug_in() + self.sim.phases_allowed = phases + self.site = Site(self.sim, grid=grid) + self.store = store or _Store() + self.t = 1000.0 + CLOCK[0] = self.t + self.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): + 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()} + + @property + def wr(self): + return self.c.car_writer + + +async def ready(phases=1, a=10, to=3, ramp=200.0, delay=1.0, opts=CAR, + station=None): + """The car draws `a` A on `phases`; the add-on is in Manual at `a`; the + sim's power then falls at `ramp` W/s and B comes `delay` s after 0 A.""" + w = World(opts, setpoint=a, phases=phases) + if station: + w.sim.station_a = float(station) + await w.step(8) + await w.act("car_phases", phases) # the wish is what the car has + await w.act("car_mode", "manual") + await w.act("car_current", a) + await w.step(8) + w.sim.ramp_w_s, w.sim.stop_delay_s = ramp, delay + w.n0 = len(w.writes()) + MARK[0] = len(CAP.rec) + await w.act("car_phases", to) + return w + + +def t_zero(w): + z = [x for x in w.writes("current")[w.n0 // 1:] if x[2] == 0.0] + z = [x for x in w.writes("current") if x[2] == 0.0] + return z[-1][0] if z else None + + +def seqw(w): + return [(x[1], x[2]) for x in w.writes()[w.n0:]] + + +print("\n2. W: THE RIG SHAPES") + + +MARK = [0] + + +async def t2(): + w = await ready(1, 10, 3) + await w.step(60) + return w + + +w = run(t2()) +t0 = t_zero(w) +ph = w.writes("phases") +check(f"T2: 1 ph 10 A at 2300 W -> 3 ph: writes are exactly [0, phases 3, " + f"10] ({seqw(w)})", seqw(w) == [("current", 0.0), ("phases", 3), + ("current", 10.0)]) +check(f"T2: select with power under 100 W ({ph[0][3]:.0f}) and the setpoint " + f"at 0 A, at t0+{ph[0][0] - t0:.0f} s", + ph[0][3] < QUIET_W and ph[0][4] == 0.0 and 11 <= ph[0][0] - t0 <= 15) +check("T2: ends on 3 phases, 10 A, the car draws", + w.sim.phases_allowed == 3 and w.sim.readback_a == 10 + and w.sim.power_w > 6000) +check(f"T13: a clean change logs nothing at INFO or above ({CAP.loud(MARK[0])})", + CAP.loud(MARK[0]) == []) + + +async def t5a(): + w = await ready(1, 16, 3) + await w.step(60) + return w + + +w = run(t5a()) +t0, ph = t_zero(w), w.writes("phases") +check(f"T5a: 1 ph 16 A 3680 W -> 3 ph: select at t0+{ph[0][0] - t0:.0f} s " + f"with {ph[0][3]:.0f} W, then 16 A ({seqw(w)})", + 17 <= ph[0][0] - t0 <= 20 and ph[0][3] < QUIET_W + and seqw(w)[-1] == ("current", 16.0) and w.sim.phases_allowed == 3) + + +async def t5b(): + w = await ready(3, 6, 1) + await w.step(60) + return w + + +w = run(t5b()) +t0 = t_zero(w) +rest = [x for x in w.writes("current") if x[2] == 6.0 and x[0] > t0] +check(f"T5b: 3 ph 6 A 4140 W -> 1 ph: still 140 W at t0+20: no select, " + f"abandon at t0+{nth(rest)[0] - t0:.0f}, restore to 6 A", + not w.writes("phases") and 20 <= nth(rest)[0] - t0 <= 21 + and w.sim.readback_a == 6 and w.wr.phase_fails == 1) + + +async def t9(extra=None, steps=70, **kw): + w = await ready(3, 16, 1, **kw) + await w.step(steps) + return w + + +w9 = run(t9()) +t0 = t_zero(w9) +cw = [x for x in w9.writes("current")] +rest = [x for x in cw if x[0] > t0] +check(f"T9: 3 ph 16 A -> 1 ph, car still ~7 kW at t0+20: no phases write, " + f"abandon at t0+{nth(rest)[0] - t0:.0f}, one restore of 16 A " + f"({seqw(w9)})", + not w9.writes("phases") and 20 <= nth(rest)[0] - t0 <= 21 + and seqw(w9) == [("current", 0.0), ("current", 16.0)] + and nth(rest)[0] <= t0 + 20 + SETTLE_S + 2) +check("T9: phases stay 3, the car draws again, one failed try, not given up, " + "no amber row, sequence over", + w9.sim.phases_allowed == 3 and w9.sim.power_w > 6000 + and w9.wr.phase_fails == 1 and not w9.wr.phases_gave_up + and "charger_phases" not in w9.rows() and w9.wr.seq is None) +check("Expected 3: the next try counts PHASE_GAP_S from the abandon", + w9.wr.last_switch is not None + and abs(w9.wr.last_switch - (nth(rest)[0] + w9.t - w9.sim.t)) <= 1.5) + + +async def t10(): + w = await ready(3, 16, 1) + await w.step(10) + w.sim.station_a = 10.0 + await w.step(60) + return w + + +w = run(t10()) +t0 = t_zero(w) +after = [x for x in w.writes("current") if x[0] > t0] +check(f"T10/N2: the station limit drops to 10 A during zero: the restore is " + f"10 A and nothing above it ({[x[2] for x in after]})", + after and after[0][2] == 10.0 and all(x[2] <= 10.0 for x in after) + and not w.writes("phases")) + + +async def t16(): + w = await ready(1, 10, 3) + await w.step(1) # 0 A is written, the car at 2300 W + w.sim.freeze_power() + await w.step(60) + return w + + +w = run(t16()) +t0 = t_zero(w) +rest = [x for x in w.writes("current") if x[0] > t0] +check(f"T16/N5: the power sensor stuck at 2300 W while the car stops: no " + f"select, abandon at t0+{nth(rest)[0] - t0:.0f}, restore 10 A", + not w.writes("phases") and 20 <= nth(rest)[0] - t0 <= 21 + and nth(rest)[2] == 10.0 and w.wr.phase_fails == 1) + + +async def t17(ramp): + w = await ready(1, 10, 3, ramp=ramp, delay=1.0) + await w.step(1) + w.sim.go_unavailable() + n = len(w.sim.log) + await w.step(28) # t0+2 .. t0+30 + during = len(w.sim.log) - n + w.sim.go_unavailable(False) + n1 = len(w.writes()) + await w.step(3) + first = w.writes()[n1:] + await w.step(40) + return w, during, first + + +w, during, first = run(t17(50.0)) +check(f"T17a: back after 30 s at ~800 W: no write while unavailable, no " + f"select, then the restore ({[x[1:3] for x in first]})", + during == 0 and not w.writes("phases") and w.sim.readback_a == 10 + and w.wr.phase_fails == 1) +w, during, first = run(t17(200.0)) +ph = w.writes("phases") +check(f"T17b: back at 0 W: the select at the first available step " + f"({first[0][1:3] if first else None}), power {ph[0][3]:.0f} W", + during == 0 and first and first[0][1] == "phases" + and ph[0][3] < QUIET_W and w.sim.phases_allowed == 3) + +print("\n3. W: TRIES, THE AMBER ROW, THE LOG") + + +async def t11(): + w = await ready(3, 16, 1) + mark = len(CAP.rec) + await w.step(1900) + zeros = [x[0] for x in w.writes("current") if x[2] == 0.0] + rests = [x[0] for x in w.writes("current") if x[2] == 16.0 + and x[0] > nth(zeros)] + out = dict(zeros=zeros, rests=rests, ph=len(w.writes("phases")), + gave=w.wr.phases_gave_up, row=w.rows().get("charger_phases"), + loud=CAP.loud(mark), w=w) + await w.step(1200) + out["more"] = len([x for x in w.writes("current") if x[2] == 0.0]) + n = len([x for x in w.writes("current") if x[2] == 0.0]) + await w.act("car_phases", 1) # same wish, a user change + await w.act("car_phases", 3) + await w.act("car_phases", 1) + await w.step(60) + out["after_user"] = len([x for x in w.writes("current") + if x[2] == 0.0]) - n + return out + + +o = run(t11()) +z, rs = o["zeros"], o["rests"] +check(f"T11: 3 zero writes, 0 phases writes, 3 restores ({len(z)}, {o['ph']}," + f" {len(rs)})", len(z) == 3 and o["ph"] == 0 and len(rs) == 3) +check("T11: the 2nd and 3rd 0 A come PHASE_GAP_S after the abandon of the " + "one before", + len(z) == 3 and len(rs) == 3 and all(z[i] - z[i - 1] >= PHASE_GAP_S + and z[i] <= rs[i - 1] + PHASE_GAP_S + SETTLE_S + 2 + for i in (1, 2))) +check("T11: after the 3rd the add-on gives up: amber row, no 4th 0 A in " + "1200 s", o["gave"] and o["row"] is not None and o["row"]["ok"] is False + and o["row"]["warn"] is True and o["more"] == 3) +check("T11: a user change after the give-up tries again at once (one 0 A)", + o["after_user"] == 1) +check(f"T13: one 'kept drawing' line per abandon (3) plus the one " + f"CHARGER_PHASES warning, nothing else, no ERROR ({o['loud']})", + len(o["loud"]) == 4 and sum("CHARGER_PHASES" in m for m in o["loud"]) == 1 + and not [1 for lv, _m in CAP.rec if lv >= logging.ERROR]) + + +async def t12(): + w = await ready(3, 16, 1) + await w.step(40) # try 1: abandoned + real = w.sim.request_phases + w.sim.ramp_w_s = 3000.0 + w.sim.request_phases = lambda n: False # refused select + await w.step(int(PHASE_GAP_S) + 60) # try 2 + mid = w.wr.phase_fails + w.sim.request_phases = real + w.sim.ramp_w_s = 200.0 + await w.step(int(PHASE_GAP_S) + 60) # try 3: abandoned + n = len(w.writes("current")) + await w.step(1500) + return w, mid, len(w.writes("current")) - n + + +w, mid, extra = run(t12()) +check(f"T12: abandon, refused select, abandon share one count: 2 after try 2 " + f"({mid}), given up after try 3, amber row, no 4th try", + mid == 2 and w.wr.phases_gave_up and w.wr.phase_fails == 3 + and "charger_phases" in w.rows() and extra == 0) + +print("\n4. W: THE OTHER ENDS OF A SEQUENCE, THE ALARM") + + +async def t18(): + w = await ready(3, 16, 1) + await w.step(5) + await w.c.car_shutdown() + n = len(w.writes()) + mark = w.writes()[w.n0:] + st = (w.wr.seq, w.wr.phase_fails, w.sim.readback_a) + w.make(w.opts) + await w.step(60) + return w, st, mark, w.writes()[n:] + + +w, st, mark, later = run(t18()) +check(f"T18: shutdown at t0+5 with the car drawing: one clamped restore (16 " + f"A), no select, sequence over, no failed try ({mark})", + [(x[1], x[2]) for x in mark] == [("current", 0.0), ("current", 16.0)] + and st == (None, 0, 16.0)) +ok = True +for i, x in enumerate(later): + if x[1] == "phases": + ok = ok and any(y[1] == "current" and y[2] == 0.0 + for y in later[:i]) and x[3] < QUIET_W +check(f"T18: after the restart no select unless a new 0 A came first and the " + f"car was quiet ({[x[1:3] for x in later]})", ok) + + +async def t19(how): + w = await ready(3, 16, 1) + await w.step(5) + n = len(w.writes()) + mark = len(CAP.rec) + if how == "off": + await w.act("car_mode", "off") + elif how == "stop": + w.c.auto = False + else: + w.c.o["shadow_mode"] = "on" + await w.step(80) + return w, w.writes()[n:], CAP.loud(mark) + + +for how in ("off", "stop", "shadow"): + w, after, loud = run(t19(how)) + check(f"T19: {how} at t0+5 with the car drawing: `_undo` as before: one " + f"restore, no select, nothing after it, not a failed try " + f"({[x[1:3] for x in after]})", + [(x[1], x[2]) for x in after] == [("current", 16.0)] + and not w.writes("phases") and w.wr.phase_fails == 0 + and not [m for m in loud if "drawing" in m.lower()]) + + +async def t20(): + w = await ready(3, 16, 1) + await w.step(5) + mark = len(CAP.rec) + n = len(w.writes()) + w.sim.set_current(9) + await w.step(80) + return w, w.writes()[n:], CAP.loud(mark) + + +w, after, loud = run(t20()) +check(f"T20: another writer sets 9 A at t0+5: hold, grey row, no select, no " + f"restore by the add-on, no failed try, no abandon line ({after})", + not w.writes("phases") and after == [] and w.wr.hold + and "charger_other" in w.rows() and w.wr.phase_fails == 0 + and not [m for m in loud if "drawing" in m.lower()]) + + +async def t21(): + w = await ready(3, 16, 1) + await w.step(5) + await w.act("car_phases", 3) # back to what the car has + await w.act("car_current", 12) + await w.step(80) + return w + + +w = run(t21()) +bad = [x for x in w.writes("phases") if x[3] >= QUIET_W] +check(f"T21: the user changes phases back and the current at t0+5: no select " + f"under load, the new current ends up, nothing above the clamp " + f"({seqw(w)})", + not bad and w.sim.readback_a == 12 and w.sim.phases_allowed == 3 + and all(x[2] <= 16.0 for x in w.writes("current")) and w.wr.seq is None) + + +async def t15(): + w = await ready(3, 16, 1) + calls = [] + real = w.drv.write_current + + async def spy(a): + r = await real(a) + calls.append((w.sim.t, a, r)) + return r + w.drv.write_current = spy + await w.step(19) + w.sim.refuse = "error" + await w.step(40) + mid = (list(calls), w.wr.seq is None, bool(w.writes("phases"))) + w.sim.refuse = None + await w.step(int(carmode.RETRY_S) + 10) + return w, mid + + +w, (calls, over, anyph) = run(t15()) +tries = [c for c in calls if c[1] == 16.0] +gaps = [round(b[0] - a[0]) for a, b in zip(tries, tries[1:])] +check(f"T15: the restore is refused: tried {len(tries)} times ~5 s apart " + f"({gaps}), no select, sequence ends", + len(tries) == MAX_TRIES and all(4 <= g <= 6 for g in gaps) and over + and not anyph and not w.writes("phases")) +check("T15: after the refusal ends the current is back at 16 A, never a " + "select", w.sim.readback_a == 16 and not w.writes("phases")) + + +# --- T14: the controller level (the EV-15 harness) ------------------------- # +def ctl(extra=None, t_sw=600, new=1): + tr = [] + + def note(plant, c): + tr.append((plant.t, c._car_own_pause(c.car_now()), c.car_explains, + c.car_writer.phase_done_at, plant.ch.power_w, + c.car_writer.phase_fails)) + + def reserve(plant, c): + plant.soc = 19.0 + plant.load = lambda t: 3000.0 + plant.ch.power_w + + def switch(plant, c): + asyncio.get_event_loop().create_task( + c.handle_action("car_phases", value=new)) + ev = {t: note for t in range(0, 720)} + ev[300] = lambda p, c: (reserve(p, c), note(p, c)) + ev[t_sw] = lambda p, c: (switch(p, c), note(p, c)) + for t, fn in (extra or {}).items(): + prev = ev.get(t, note) + ev[t] = (lambda p, c, prev=prev, fn=fn: (fn(p, c), prev(p, c))) + sim = SimCharger(setpoint_a=16) + sim.ramp_w_s, sim.stop_delay_s = 200.0, 1.0 + r = P.drive(s81.constant(3000.0), dur=720, rating=12000.0, soc=60.0, + cap=6050.0, phases=3, user_a=16, setpoint=16, mode="manual", + events=ev, sim=sim) + return r, tr, P.ids(r, *P.ALARMS) + + +logging.disable(logging.CRITICAL) +r, tr, al = ctl() +logging.disable(logging.NOTSET) +ab = [x[0] for x in tr if x[0] > 600 and x[5] == 1] +a0 = ab[0] if ab else None +check(f"T14: the car keeps drawing: abandon at {a0}; the own-pause grace is " + f"on before it and off from the abandon step on, phase_done_at stays " + f"None", a0 is not None and any(x[1] for x in tr if 602 <= x[0] < a0) + and not any(x[1] for x in tr if x[0] >= a0) + and all(x[3] is None for x in tr) and not r["sim"].writes("phases")) + + +def overload(plant, c): + plant.load = lambda t: 25000.0 + plant.ch.power_w + + +logging.disable(logging.CRITICAL) +r2, tr2, al2 = ctl(extra={640: overload}) +r3, tr3, al3 = ctl(extra={640: overload}, t_sw=900) # no phase change +logging.disable(logging.NOTSET) +check(f"T14: a house overload after the abandon alarms, as with no car " + f"change ({[t for t, _ in al2]} vs {[t for t, _ in al3]}), and the car " + f"does not explain it", + bool(al2) and bool(al3) and al2[0][0] == al3[0][0] + and not any(x[2] for x in tr2 if x[0] >= 642)) + +# =========================================================================== # +print("\n5. W: THE DIGESTS OF THE QUIET SHAPES, PINNED FROM 4eba2d9") +# =========================================================================== # + + +async def d_story(lag=0.0, race=False): + 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(5) + await w.act("car_phases", 3) + await (w.step_race(60) if race else w.step(60)) + return w + + +async def d_gap(): + w = await d_story() + await w.act("car_phases", 1) + await w.step(620) + return w + + +async def d_zero_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(3) + w.sim.refuse = "ignore" + await w.act("car_phases", 3) + await w.step(80) + return w + + +async def d_m2(): + 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): + sim.log.append((sim.t, "phases", n, sim.power_w, sim.setpoint_a)) + return True + sim.request_phases = deaf + await w.act("car_phases", 3) + await w.step(3700) + return w + + +async def d_l4(): + 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 + await w.act("car_phases", 3) + await w.step(60) + return w + + +async def d_mid(kind): + """The slow-stop car (ramp 50 W/s, C held 40 s) cut short before 20 s.""" + w = World(dict(CAR, shadow_mode="auto"), setpoint=10, phases=1) + w.sim.ramp_w_s, w.sim.stop_delay_s = 50.0, 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) + if kind == "off": + await w.act("car_mode", "off") + elif kind == "shadow": + w.c.o["shadow_mode"] = "on" + elif kind == "stop": + await w.c.handle_action("auto_toggle") + elif kind == "shutdown": + await w.c.car_shutdown() + elif kind == "other": + w.sim.set_current(9) + await w.step(80) + return w + + +async def d_off(): + w = World(setpoint=10, phases=1) + await w.step(5) + await w.act("car_phases", 3) + await w.step(60) + return w + + +def digest(w): + s = repr([(x[0], x[1], x[2]) for x in w.sim.log]) + return hashlib.sha256(s.encode()).hexdigest()[:12] + + +SHAPES = [("phase_story", lambda: d_story()), + ("phase_story lag 3", lambda: d_story(lag=3.0)), + ("m1 race", lambda: d_story(race=True)), + ("phase_gap", d_gap), ("zero_refused", d_zero_refused), + ("m2_refused", d_m2), ("l4_late", d_l4), ("phases_in_off", d_off)] \ + + [(f"mid {k}", (lambda k=k: d_mid(k))) + for k in ("off", "shadow", "stop", "shutdown", "other")] +# Pinned from 4eba2d9 (python3 -B on the base tree). Two shapes CHANGE by +# design, because the base selected under load in them: `phase_gap` (second +# switch: base selected at t0+1 with 3900 W, now t0+3 under 100 W, the same +# writes otherwise) and `mid shutdown` (the restarted sequence met a car at +# 1250 W: base selected at the timeout, now abandons and restores). Their pins +# are the new digests; the facts are asserted below. +PINS = {"phase_story": "9e7d818e1304", "phase_story lag 3": "13bba7ca8427", + "m1 race": "0f845c466111", "phase_gap": "467fad0b4ebe", + "zero_refused": "041e96466f8e", "m2_refused": "5ea1b28f8c3a", + "l4_late": "50248d297e1d", "phases_in_off": "4f53cda18c2b", + "mid off": "b62df7ce65eb", "mid shadow": "b62df7ce65eb", + "mid stop": "b62df7ce65eb", "mid shutdown": "5cae419f3e9f", + "mid other": "0f43ad8a061a"} +got = {name: digest(run(fn())) for name, fn in SHAPES} +_g = run(d_gap()) +_p = _g.writes("phases") +check("T22: the changed shapes are changed only where base selected under " + f"load: phase_gap's 2nd select is under 100 W ({_p[1][3]:.0f} W)", + len(_p) == 2 and _p[1][3] < QUIET_W) +check("T22: digests: " + ", ".join(f"{k}={v}" for k, v in got.items()), + all(PINS.get(k) == v for k, v in got.items()) and set(PINS) == set(got)) + +# =========================================================================== # +print("\n6. DOCS (T25)") +# =========================================================================== # +doc = open(os.path.join(HERE, "DECISIONS", "EV-04-manual-mode.md"), + encoding="utf-8").read() +phase = doc.split("## The phase sequence")[1].split("\n## ")[0] +flat = " ".join(phase.split()) +check("T25: DECISIONS says: under 100 W with a power reading, mode3 leaving C " + "only without one, still drawing at 20 s gives the current back and " + "counts as a failed try", + "under 100 W" in flat and "no power reading" in flat + and "failed try" in flat and "current comes back" in flat + and "or mode3 leaves C (20 s at most)" not in flat) +src = carmode.__doc__ +check("T25: the module docstring matches (power reading first, then mode3, " + "then the failed try)", + "without a power reading" in " ".join(src.split()) + and "failed" in src and "or mode3 leaves C" not in src) + +print() +if fails: + print(f"FAIL: {len(fails)} check(s)") + for f in fails: + print(" -", f) + sys.exit(1) +print("ok: EV-28")