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