563 lines
21 KiB
Python
563 lines
21 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.
|
|
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
|
"""
|
|
|
|
import asyncio
|
|
import dataclasses
|
|
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)
|
|
|
|
|
|
|
|
def plug_late(plant, c):
|
|
plant.ch.plug_in()
|
|
|
|
|
|
def house_reserve(plant, c):
|
|
plant.soc = 19.0
|
|
plant.load = lambda at: 3075.0 + plant.ch.power_w
|
|
|
|
|
|
def swapped_events():
|
|
ev = watch(850, house_reserve)
|
|
ev[800] = plug_late
|
|
return ev
|
|
|
|
|
|
def swapped(mode):
|
|
return P.drive(s81.constant(6000.0), dur=895, rating=12000.0, soc=60.0,
|
|
cap=CAP, phases=1, user_a=6, setpoint=6, mode=mode,
|
|
plug=False, events=swapped_events())
|
|
|
|
|
|
r10x = swapped("manual")
|
|
r10xo = swapped("off")
|
|
check("PRECONDITION (review): a 6 kW HOUSE drains the batteries, the car "
|
|
"plugs in late (a small share); the projection is under the aim at the "
|
|
"reserve, and Off raises the alarm", alarms(r10xo) != []
|
|
and any(p < a for _t, p, a in UNDER))
|
|
check("the house drains the batteries and a small car is plugged in: the "
|
|
"normal alarm still fires in Manual", alarms(r10x) != [])
|
|
|
|
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.site_batt_w, self.site_rating_w = 300.0, 5000.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"
|
|
|
|
|
|
@dataclasses.dataclass
|
|
class _Proj:
|
|
projected_w: float
|
|
elapsed_s: float = 850.0
|
|
held_w: float = 0.0
|
|
block_start: object = datetime(2026, 11, 16, 20, 0, tzinfo=timezone.utc)
|
|
|
|
def __post_init__(self):
|
|
self.held_w = self.projected_w
|
|
|
|
|
|
class _G:
|
|
def __init__(self, floor=True, sat=False, within_aim=False):
|
|
self.floor_limited, self.saturated = floor, sat
|
|
self.floor_w, self.able_w, self.ceiling_w = 0.0, None, 4500.0
|
|
self.engaged, self.blind, self.wanted_w = True, None, 300.0
|
|
self.within_aim = within_aim
|
|
|
|
|
|
def explains(proj_w, car_w, *, floor=True, cover=True, car_so_far_w=None,
|
|
within_aim=False, earlier=(), block=0, c=None, at=0.0):
|
|
"""One cycle of `car_cycle` on a stub; `earlier` are projections of
|
|
cycles before it in the same quarter (they latch SAFETY-126's test)."""
|
|
c = c or _Car(cover, car_w)
|
|
c.w = car_w
|
|
for k, e in enumerate(tuple(earlier) + (proj_w,)):
|
|
p = _Proj(e)
|
|
p.block_start = p.block_start + timedelta(minutes=15 * block)
|
|
c._now = at - len(earlier) + k
|
|
c._carq = {"key": p.block_start,
|
|
"ws": ((car_w or 0.0) if car_so_far_w is None else car_so_far_w)
|
|
* p.elapsed_s, "mono": c._now}
|
|
c.car_cycle(p, _G(floor, within_aim=within_aim), 4450.0, None)
|
|
return c.car_explains
|
|
|
|
|
|
check("rule: the alarm's test is true with the car (4468 W, the batteries "
|
|
"at 0 W land 4485 W) and false without it (768 W): the car explains it, "
|
|
"with the projection under the aim", explains(4468.0, 3700.0))
|
|
check("rule: under the aim, the quarter's test latched by the car's share "
|
|
"(4600 W earlier), the car explains the alarm (the positive under-aim "
|
|
"case; a single 4300 W cycle has no landing miss to explain, so it "
|
|
"needs the earlier cycle)", explains(4300.0, 3700.0, earlier=(4600.0,)))
|
|
check("rule: where the alarm would not fire anyway nothing is explained",
|
|
not explains(4300.0, 3700.0, within_aim=True))
|
|
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: ...also when the test was latched earlier in the quarter",
|
|
not explains(4300.0, 0.0, earlier=(4600.0,))
|
|
and not explains(9000.0, 0.0))
|
|
check("rule: an untrusted car figure (None) explains nothing",
|
|
not explains(4300.0, None, earlier=(4600.0,)))
|
|
# the latches: per quarter, and independent of the cover option
|
|
c4 = _Car(True, 3700.0)
|
|
explains(9000.0, 3700.0, c=c4, block=0) # the house needs it: latched
|
|
check("latch: in the same quarter the house need stays latched, so the car "
|
|
"does not explain", not explains(4300.0, 3700.0, c=c4, block=0, at=10.0))
|
|
check("latch: a new quarter starts clean: the car alone explains it again",
|
|
explains(4300.0, 3700.0, c=c4, block=1, at=1000.0,
|
|
earlier=(4600.0,)))
|
|
c5 = _Car(False, 3700.0) # cover OFF
|
|
explains(9000.0, 3700.0, c=c5, block=0) # the house needs it
|
|
c5.o["ev_batt_cover"] = True # ... and the option flips
|
|
check("latch: the option flipping to ON does not lose a house need seen "
|
|
"while it was off", not explains(4300.0, 3700.0, c=c5, block=0, at=10.0))
|
|
c6 = _Car(True, 3700.0)
|
|
explains(9000.0, 3700.0, c=c6, block=0)
|
|
c6.o["ev_batt_cover"] = False
|
|
explains(4300.0, 3700.0, c=c6, block=0, at=10.0)
|
|
c6.o["ev_batt_cover"] = True
|
|
check("latch: ... nor does flipping it off and on again",
|
|
not explains(4300.0, 3700.0, c=c6, block=0, at=20.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_s=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 len(o11) == 1200 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_s=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", len(o11r) == 100 and 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)",
|
|
len(o11a) == 60 and 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())
|
|
|
|
|
|
async def failed_write_then_outside(how):
|
|
"""A write that RAISES or returns FAILURE must still close the self-mute:
|
|
it ends 15 s after the write returned, and a later outside change shows
|
|
the row."""
|
|
w = World()
|
|
await w.step(3)
|
|
await w.c.handle_action("car_mode", value="manual")
|
|
ret = []
|
|
|
|
async def bad(a):
|
|
await w.sleep(1.0)
|
|
ret.append(w.t) # when the write came back
|
|
if how == "raise":
|
|
raise RuntimeError("the charger link broke")
|
|
return False
|
|
w.drv.write_current = bad
|
|
await w.c.handle_action("car_current", value=12)
|
|
await w.step(3) # the write is tried
|
|
closed = (bool(ret) and w.c.car.mute_until <= ret[-1] + 15.0 + 1e-6)
|
|
await w.c.handle_action("car_mode", value="off")
|
|
await w.step(20) # past the 15 s mute
|
|
w.sim.set_current(7) # somebody else
|
|
await w.step(3)
|
|
return w, closed
|
|
|
|
|
|
for how in ("raise", "fail"):
|
|
wf, closed = asyncio.run(failed_write_then_outside(how))
|
|
check(f"a write that {'raises' if how == 'raise' else 'returns failure'}"
|
|
": the mute ends within 15 s of the write's return, and a later "
|
|
"outside change shows the row",
|
|
closed and "charger_writer" in wf.rows())
|
|
|
|
print()
|
|
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
|
|
sys.exit(1 if fails else 0)
|