Compare commits

...
13 Commits
Author SHA1 Message Date
Claude c3903b796b EV-13: CHANGELOG line and DECISIONS note
checks / unit (pull_request) Successful in 33m25s
infra-pin / fresh (pull_request) Successful in 1s
Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w
2026-11-22 02:23:56 +01:00
Claude c25877fea4 EV-13: a refused current write arms the stuck check only when the charger shows no life
A refused write on a live charger no longer reads as a stuck reading 60 s
later, so a refused write shows one amber row (charger_refused). A frozen
charger still arms and is still caught.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w
2026-11-22 01:50:44 +01:00
ems-agent 76f4de23c7 Merge pull request 'EV-28: no phase select while the car still draws' (#268) from EV-28 into release/1.0
infra-pin / fresh (push) Successful in 1s
2026-11-21 23:28:03 +01:00
Claude (review agent) 4b4a4c1053 EV-28 review: pin the restore step in T17a and the counted failure in T15
checks / unit (pull_request) Successful in 28m34s
infra-pin / fresh (pull_request) Successful in 1s
Review fixes, no logic change:
- T17a now asserts the restore is the first write once the charger is back
  (it was only checked to happen at some point); mutant M3 (restore after
  SETTLE_S) now turns T17a red.
- T15 now asserts the refused restore is counted once (`fails == 1`);
  a mutant without `_failed` there now turns T15 red.
- DECISIONS "The phase sequence" and the carmode docstring reflowed to 79
  columns; DECISIONS says D counts as drawing too, as the code does.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-21 22:58:56 +01:00
Claude (dev agent) 83f114fe08 EV-28: never select the phases while the car still draws
checks / unit (pull_request) Successful in 32m4s
infra-pin / fresh (pull_request) Successful in 1s
Stage zero counted mode3 B as quiet whatever the power and selected at the
20 s timeout under load. A power reading now decides (under 100 W); mode3
(not C, not D) only without one. Still drawing at 20 s: no select, the
current comes back at once, one failed try, next try PHASE_GAP_S later.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-21 21:04:13 +01:00
ems-agent 4eba2d9acf Merge pull request 'CI-20: bump infra-pin to f884612' (#267) from CI-20 into release/1.0
infra-pin / fresh (push) Successful in 2s
2026-11-21 19:37:59 +01:00
Claude af374026b1 CI-20: bump infra-pin to admin/goodwe release/1.0 f884612
checks / unit (pull_request) Successful in 26m51s
infra-pin / fresh (pull_request) Successful in 2s
Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-21 18:33:08 +01:00
admin 00b116e5b2 Merge pull request 'EV-16: hold the Car Why text while the guard floor flag toggles' (#266) from EV-16 into release/1.0
infra-pin / fresh (push) Failing after 1s
2026-11-21 16:08:07 +01:00
EV-16 reviewerandClaude 91cbdf2f43 EV-16 review round 2: pin the unread-SoC rule on the Why's live fallback
checks / unit (pull_request) Successful in 24m26s
infra-pin / fresh (pull_request) Failing after 2s
The fallback (no record yet, or a record of an ended episode) had no check;
reading floor_limited alone there survived test_ev16. Test only.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-21 12:37:06 +01:00
Claude (dev) c707eb4776 EV-16: time the Car Why hold on the control cycle, not on page reads
checks / unit (pull_request) Successful in 24m55s
infra-pin / fresh (pull_request) Failing after 1s
car_cycle ends with _car_why_tick (display only: control writes, never reads);
the Why reads the record. Adds read-gap tests (A, B, cover off/on), a long
guard-None test and a lower bound for the hold.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-21 11:23:13 +01:00
Claude (dev) b662d7171b EV-16: key the held Car Why to the car_over episode; add T16, T18 and N-id checks
checks / unit (pull_request) Successful in 25m43s
infra-pin / fresh (pull_request) Failing after 2s
Control bumps _car_over_ep at each start and end of car_over; the display
ignores a hold of another episode, so a read overlapping the end cannot bring
a stale text back.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-21 10:04:00 +01:00
Claude (dev) 3b1189cdbf EV-16: hold the Car Why text while car_over holds and the guard floor flag toggles
checks / unit (pull_request) Successful in 27m49s
infra-pin / fresh (pull_request) Failing after 2s
Display only: the 'are at' / 'give all they can' text changes only when the
other state has stood for 180 s (the car_over off hold); SoC unread is never
'are at'. Cleared when car_over drops, on unplug and with cover off.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-21 08:54:04 +01:00
admin 8150608317 Merge pull request 'EV-19: no floor alarm when the batteries first reach the reserve early in a Manual car session' (#265) from EV-19 into release/1.0
infra-pin / fresh (push) Failing after 1s
Reviewed-on: #265
2026-11-20 23:42:30 +01:00
11 changed files with 2676 additions and 31 deletions
+1 -1
View File
@@ -1,2 +1,2 @@
# The admin/goodwe commit CI tests against. Bump: set to the full SHA of admin/goodwe release/1.0 HEAD (README.md, "CI and the infra pin").
3b4ff84757f9c2c5b63a4b4a53e593ccaeafb847
f88461234f3a7d53c025a68beda4cb6e4384cebf
+2
View File
@@ -2,6 +2,8 @@
### Not in a release yet
- When the car charger does not take a current setting but is plainly working, you now see one amber row ("did not take the setting"), not a second "reading may be stuck" ([[EV-13]]).
- 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
@@ -30,12 +30,14 @@ 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
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`).
0 A, wait until the charger reports under 100 W (mode3 leaving C and D 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`).
## Another writer
@@ -62,6 +64,16 @@ stops holding late in a period that the car already pushed over, because
`excess_w` grows as the seconds run out; the average form does not, and it is the
same test for a steady car.
**A refused write arms the stuck check only when the charger shows no life
(EV-13).** A charger that ignores a write keeps its old read-back, so the
check would read it as stuck 60 s later and show a second amber row beside
"did not take the setting". A refused write now arms only if, within `TOOK_S`
of the send, the energy, a phase current or the power changed in a sample taken
after the send, against the last value before (`CarTracker.note_write`,
`_alive`). Unchanged, absent before, or taken before the send is no life. No
life arms as before, dated the send. A write that raised, or was accepted, is
unchanged. A frozen charger (every write looks refused) still arms.
**A stale, stuck or frozen car figure must never hide a real overload.** Only
`CarTracker.car_w_trusted` is used: fresh (the EV-03 rules, which also make an
unavailable reading None at once), not stuck after a write (SAFETY-37's shape),
+29 -10
View File
@@ -15,10 +15,11 @@ 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
`PHASE_GAP_S`. A sequence that has begun is always finished, because it
leaves the car at 0 A otherwise.
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
ANOTHER WRITER: an info row, and no write over it until the user changes the
mode or a value again.
@@ -256,7 +257,7 @@ class ManualWriter:
finally:
self._stamp(now)
tracker.end_write(self.last_done)
tracker.note_write(now, was, a)
tracker.note_write(now, was, a, ok, getattr(drv, "polls", ()))
tracker.end_write(self.last_done)
self.log.append(("current", a, now, ok))
if ok:
@@ -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)
+105 -7
View File
@@ -70,6 +70,7 @@ TOOK_S = 10.0 # a write is "taken" when the read-back follows by t
TOOK_TOL_A = 0.5 # ... to within this
STUCK_S = 60.0 # EV-04: power and read-back unchanged after a write
STUCK_MIN_A = 1.0 # ... that moved the setpoint by at least this
LIFE_KEEP_S = 40.0 # EV-13: samples kept to date a refused write's life
OWN_WRITE_MUTE_S = 15.0 # the tracker's two-writer detector ignores our own
# Volts used to bound a car figure by what the read-back allows (a physical
# ceiling for the alarm path, never a setpoint).
@@ -120,6 +121,7 @@ REQUIRED = ("current", "readback", "state", "power")
_SETPOINT_RE = re.compile(r"^number\.(?P<x>.+)_" + SETPOINT_SUFFIX + "$")
_ROLE_ORDER = tuple(ROLES)
_LIFE_ROLES = ("power", "energy", "l1", "l2", "l3") # EV-13
#: power unit -> W. The probe and the reading both use this one table.
_W_PER = {"mW": 0.001, "W": 1.0, "kW": 1000.0, "MW": 1000000.0}
POWER_UNITS = tuple(_W_PER)
@@ -161,6 +163,9 @@ class ChargerReading:
error: str | None = None # None: no error (or not read)
display: str | None = None
why: str = "" # for the log only, "" when available
# EV-13: when the sample was TAKEN, on the tracker's clock. None: the
# caller's `now` (in the cycle that is the read's start, `now_mono`).
taken_at: float | None = None
def _state_obj(obj):
@@ -420,6 +425,9 @@ class AlfenHaDriver(ChargerDriver):
self._clock = time.monotonic
self.clamp_faults = [] # (asked, clamp), newest last, for the log
self.sent = [] # every number value actually sent
# EV-13: what the latest write saw while it waited for the read-back,
# [(time, ChargerReading)]: the cycle's reads do not run inside it.
self.polls = []
@classmethod
def from_options(cls, opts: dict) -> "AlfenHaDriver":
@@ -498,6 +506,7 @@ class AlfenHaDriver(ChargerDriver):
read-back followed within `TOOK_S`. A value above `clamp_a()` is a
SOFTWARE FAULT: nothing is sent, it is logged (the clamp watchdog's
shape) and the answer is False."""
self.polls = []
try:
a = float(a)
except (TypeError, ValueError):
@@ -522,7 +531,8 @@ class AlfenHaDriver(ChargerDriver):
"""Did the read-back follow the write, within `TOOK_S`?"""
t0 = self._clock()
while True:
st = await self._states(("readback", "current"))
st = await self._states(("readback", "current") + _LIFE_ROLES)
self._poll(st)
seen = _first(_amps(st["readback"]), _amps(st["current"]))
if seen is not None and abs(seen - a) <= TOOK_TOL_A:
return True
@@ -530,6 +540,18 @@ class AlfenHaDriver(ChargerDriver):
return False
await self._sleep(1.0)
def _poll(self, st: dict) -> None:
"""EV-13: keep what this wait saw of energy, power and phase currents
(never raises: a write does not depend on it)."""
try:
cur = tuple(a for a in (_amps(st.get(k)) for k in ("l1", "l2", "l3"))
if a is not None)
self.polls.append((self._clock(), ChargerReading(
available=True, power_w=_watts(st.get("power")),
energy_kwh=_kwh(st.get("energy")), current_a=cur)))
except Exception: # noqa: BLE001
pass
async def write_phases(self, n: int) -> bool:
"""Select 1 or 3 phases. ONLY THROUGH `carmode`'s safe sequence: the
setting moves the contactors, so it is touched with the car paused."""
@@ -631,6 +653,26 @@ CHARGING, WAITING, NONE_, FULL, UNREACH, SETUP, FAULT = (
"charging", "waiting", "none", "full", "unreach", "setup", "fault")
def _life_vals(r) -> tuple:
"""EV-13: what shows a charger is alive: energy, power, three phase
currents. None is "not read"."""
cur = tuple(r.current_a or ())[:3]
return (r.energy_kwh, r.power_w) + cur + (None,) * (3 - len(cur))
def _alive(vals: tuple, pre: list) -> bool:
"""A value that is present now, was present before the write, and differs
from every value before it. Present but unchanged, or not there before, is
no life."""
for i, v in enumerate(vals):
if v is None:
continue
old = [p[i] for p in pre if p[i] is not None]
if old and all(v != o for o in old):
return True
return False
@dataclass
class CarTracker:
"""What the cycle learns about the car from the readings. Pure, clocked by
@@ -663,6 +705,9 @@ class CarTracker:
sig: tuple | None = None
stuck_now: bool = False
obs_at: float | None = None # monotonic second of the latest reading
# EV-13: a REFUSED write waits to see if the charger shows life (below)
_pend: dict | None = None
_ring: list = field(default_factory=list) # (taken-at, life values)
_hist: list = field(default_factory=list) # (t, power W, energy Wh)
# today's energy
day: str | None = None
@@ -684,6 +729,7 @@ class CarTracker:
self.last_ok = now
self.last_good, self.last_good_utc = r, now_utc
if r.available:
self._life(r, now)
self._sig(r, now)
self._writer(r, now_utc, now)
self._energy(r, day)
@@ -727,19 +773,71 @@ class CarTracker:
`OWN_WRITE_MUTE_S` from now, not from before the write."""
self.mute_until = now + OWN_WRITE_MUTE_S
def note_write(self, now: float, was_a, to_a) -> None:
"""The add-on wrote the current. Its own change is not "another
writer" for `OWN_WRITE_MUTE_S`, and a write that moved the setpoint by
`STUCK_MIN_A` or more arms the stuck check: power and read-back that
have not changed `STUCK_S` later are a stuck reading, not a car."""
def note_write(self, now: float, was_a, to_a, ok: bool = True,
polls=()) -> None:
"""The add-on wrote the current at `now`. Its own change is not
"another writer" for `OWN_WRITE_MUTE_S`, and a write that moved the
setpoint by `STUCK_MIN_A` or more arms the stuck check: power and
read-back that have not changed `STUCK_S` later are a stuck reading,
not a car.
EV-13: a write the charger REFUSED (`ok` False) arms it only when the
charger shows no life: the energy, a phase current or the power
changed in a sample taken after `now` and within `TOOK_S` of it,
against the last values before. A refused write on a charger that is
plainly alive is not a stuck reading. `polls` are the samples the
write itself saw while it waited, `[(time, ChargerReading)]`."""
self.mute_until = now + OWN_WRITE_MUTE_S
try:
moved = was_a is None or abs(float(to_a) - float(was_a)) \
>= STUCK_MIN_A
except (TypeError, ValueError):
moved = False
if moved and self.armed_at is None:
if self._pend is not None and now > self._pend["t"] + TOOK_S:
self._pend_arm() # the old window ran out
if not moved or self.armed_at is not None:
return
if ok:
self._pend = None
self.armed_at, self.armed_sig = now, self.sig
return
if self._pend is not None:
return # an earlier refusal's window
before = [x for x in self._ring if x[0] <= now]
pre = [max(before, key=lambda x: x[0])[1]] if before else []
self._pend = {"t": now, "pre": pre, "sig": self.sig}
later = [(t, _life_vals(r)) for t, r in polls]
later += [(t, v) for t, v in self._ring if t > now]
for t, v in sorted(later, key=lambda x: x[0]):
self._pend_feed(t, v, t)
def _life(self, r, now: float) -> None:
"""EV-13: file this sample (by when it was TAKEN) and let a refused
write's open window look at it."""
t = now if r.taken_at is None else r.taken_at
v = _life_vals(r)
self._ring.append((t, v))
top = max(x[0] for x in self._ring)
self._ring = [x for x in self._ring if top - x[0] <= LIFE_KEEP_S]
self._pend_feed(t, v, now)
def _pend_feed(self, t: float, vals: tuple, arrival: float) -> None:
p = self._pend
if p is None:
return
if t <= p["t"]:
p["pre"] = (p["pre"] + [vals])[-8:] # taken before the send
elif t <= p["t"] + TOOK_S and _alive(vals, p["pre"]):
self._pend = None # life: nothing to arm
return
if max(t, arrival) > p["t"] + TOOK_S:
self._pend_arm()
def _pend_arm(self) -> None:
"""No life in the window: arm as the write would have, dated its send."""
p, self._pend = self._pend, None
if p is not None and self.armed_at is None:
self.armed_at, self.armed_sig = p["t"], p["sig"]
def _sig(self, r, now: float) -> None:
sig = (r.power_w, r.allowed_a)
+30
View File
@@ -61,6 +61,8 @@ class CarMixin:
self.car_over = False # ... held: the card and row say so
self._car_over_since = None
self._car_over_gone = None
self._car_why_rec = None # EV-16: [shown over, since, episode]
self._car_over_ep = 0 # EV-16: bumped when car_over ends
self._car_batt_prev = self._car_batt_prev2 = None
self._car_hx_prev = None # EV-19: last cycle's (held, car W)
self._car_need_real = self._car_need_excl = False # EV-10 latches
@@ -398,7 +400,34 @@ class CarMixin:
self._car_over_gone = mono
if mono - self._car_over_gone >= OVER_OFF_HOLD_S:
self.car_over, self._car_over_since = False, None
self._car_over_ep += 1 # EV-16: an episode ends
self._car_over_gone = None
self._car_why_tick(guard, mono)
def _car_why_tick(self, guard, mono) -> None:
"""EV-16, display only: control writes `_car_why_rec`, never reads it.
The Car Why text ("are at" / "give all they can") is held: it changes
only when the other state has stood for `OVER_OFF_HOLD_S` of THIS
cycle's clock (so reads of /status do not matter). State: floor-limited
with the SoC read; a guard of None, or unread SoC, never counts as
floor. Cleared when car_over is off or the cover is off."""
if not (self.car_over and self.car_cover):
self._car_why_rec = None
return
cand = None if guard is None else bool(
getattr(guard, "floor_limited", False)
and getattr(guard, "soc", None) is not None)
ep = self._car_over_ep
r = self._car_why_rec
if r is None or r[2] != ep:
self._car_why_rec = [bool(cand), None, ep]
elif cand is None or cand == r[0]:
r[1] = None
else:
if r[1] is None:
r[1] = mono
if mono - r[1] >= OVER_OFF_HOLD_S:
self._car_why_rec = [cand, None, ep]
def _car_explains_alarm(self, real_proj, guard, target_w, w) -> bool:
"""EV-10: is the alarm's own test true with the car and false without
@@ -497,6 +526,7 @@ class CarMixin:
# The session is over: that is a real end, with no hold.
self.car_over = False
self._car_over_since = self._car_over_gone = None
self._car_over_ep += 1 # EV-16: an episode ends
if s not in (chargers.NONE_, None) and self._car_prev_state in (
chargers.NONE_, None):
self._car_session += 1
+18 -1
View File
@@ -1301,6 +1301,23 @@ def _car_why(key, c, good):
return _t("car.why." + (key if key else "wait"))
# EV-16: the Why of "car over the limit" follows the guard's floor flag, which
# toggles cycle by cycle at the reserve. The text is held, on the control
# cycle's clock (`ctl_car.CarMixin._car_why_tick`, display only: control writes
# `_car_why_rec`, never reads it). The Why only reads it.
WHY_HOLD_S = 180.0 # = ctl_car.OVER_OFF_HOLD_S (tested)
def _over_why_is_floor(c, pg) -> bool:
"""True: "are at {pct}"; False: "give all they can". With no valid held
record (not yet ticked, or of an ended episode) the live state, written
nowhere."""
rec = getattr(c, "_car_why_rec", None)
if rec is not None and rec[2] == getattr(c, "_car_over_ep", 0):
return rec[0]
return bool(pg is not None and pg.floor_limited and pg.soc is not None)
def _car_manual_why(c, key):
"""The Why of Manual: what you set, and what the peak limit does about it.
Plan lines: two sentences of at most 12 words."""
@@ -1312,7 +1329,7 @@ def _car_manual_why(c, key):
pg = getattr(c, "peak_guard", None)
if not c.car_cover:
return _t("car.why.manual_nocover", a=a)
return _t("car.why.manual_over" if pg is not None and pg.floor_limited
return _t("car.why.manual_over" if _over_why_is_floor(c, pg)
else "car.why.manual_full", a=a, pct=pct)
if c.shadow:
t, n = w.would if w.would is not None else (c.car_a, c.car_n)
+24 -6
View File
@@ -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 "
+972
View File
@@ -0,0 +1,972 @@
"""EV-13: a refused current write shows ONE amber row, not two.
`python3 -B test_ev13.py`
The bug: `ManualWriter._write` armed the stuck-reading check on every write,
refused or not. A charger that ignores the write keeps its old setpoint, so the
read-back does not move, and 60 s later "Charger reading may be stuck" showed
beside "The charger did not take the setting", and the car figure was not
trusted (EV-15 rig: it latched the quarter).
The rule (owner's delegate, decision (b)): a refused write skips the arm ONLY
when the charger shows life: a change in the energy counter, a phase current or
the power, in a sample taken after the write was sent and within `TOOK_S` of it,
against the last value before. Present but unchanged, absent before, a stale
sample (taken before the send): not life. No life: it arms as before, dated the
send. A frozen charger (every write looks refused) is still caught.
Shapes: S = a tracker fed by a script (the test chooses each sample's values,
taken-at and arrival), W = the real Controller on `chargersim.SimCharger`, C =
`ev04_peak.drive` (the SAFETY-81 plant). Times are model seconds.
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
1. S: what counts as life (T3-T10, T12, T15)
2. W: live refusals, one amber row (T1, T2, T19)
3. W: no life, accepted writes, transitions (T11, T14, T17, T18, T20, T21)
4. W: errors, restart (T13, T25)
5. C: the peak guard (T16, T22-T24)
6. Writes, as on the base (T26)
"""
import asyncio
import dataclasses
import hashlib
import logging
import os
import sys
from datetime import datetime, timezone
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(HERE, "tools"))
from app import carmode, chargers as CH, freshness # noqa: E402
from app.main import Controller # noqa: E402
from chargersim import FakeHa, SimCharger # 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()))
def text(self, level=None):
return "\n".join(m for lv, m in self.rec if level in (None, lv))
LOG = _Log()
logging.getLogger("goodwe").addHandler(LOG)
logging.getLogger("goodwe").setLevel(logging.DEBUG)
logging.getLogger("goodwe").propagate = False
UTC = datetime(2026, 11, 22, tzinfo=timezone.utc)
DAY = "2026-11-22"
TS = 1000.0 # t_s in the S shape
TOOK_S, STUCK_S = CH.TOOK_S, CH.STUCK_S
# =========================================================================== #
print("1. S: WHAT COUNTS AS LIFE")
# =========================================================================== #
def rd(e=1.000, p=11040.0, cur=(16.0, 15.9, 16.0), a=16.0, taken=None,
state="C"):
return CH.ChargerReading(
available=True, state=state, charging=state == "C", power_w=p,
energy_kwh=e, current_a=cur, allowed_a=a, setpoint_a=a,
phases_allowed=3, taken_at=taken)
def steady(changes=None, start=1, end=130, **base):
"""One sample a second from TS+start to TS+end, taken on arrival. `changes`
is {second after TS: kwargs}; each change stays."""
out, kw = [], dict(base)
for s in range(start, end + 1):
kw.update((changes or {}).get(s, {}))
out.append((TS + s, rd(**kw)))
return out
def play(timeline, mode="live", ok=False, was=16.0, to=10.0, pre_end=0,
pre=None, end=TS + 130):
"""The tracker sees the pre-write samples, then the write (refused unless
`ok`), then `timeline` = [(arrival, ChargerReading)].
live: the write returns at once (HA said no), samples come after it.
ring: the write waited TOOK_S; the cycle's samples came meanwhile.
polls: the write waited and saw the samples itself (nothing else did).
Returns (tracker, first second `stuck()` was True, armed_at ever set)."""
tr = CH.CarTracker()
seen = {"armed": False, "first": None}
def obs(at, r):
tr.observe(r, at, UTC, DAY)
seen["armed"] |= tr.armed_at is not None
if seen["first"] is None and tr.stuck(at):
seen["first"] = at
for i in range(-20, pre_end + 1):
obs(TS + i, rd(**(pre or {})))
inside = [x for x in timeline if x[0] <= TS + TOOK_S]
outside = [x for x in timeline if x[0] > TS + TOOK_S]
if mode == "live":
tr.note_write(TS, was, to, ok)
rest = timeline
elif mode == "ring":
for at, r in inside:
obs(at, r)
tr.note_write(TS, was, to, ok)
rest = outside
else:
tr.note_write(TS, was, to, ok, [
(r.taken_at if r.taken_at is not None else at, r)
for at, r in inside])
rest = outside
seen["armed"] |= tr.armed_at is not None
for at, r in sorted(rest, key=lambda x: x[0]):
if at <= end:
obs(at, r)
return tr, seen["first"], seen["armed"]
MODES = ("live", "ring", "polls")
def pend(tr):
"""The refusal window a tracker keeps open (None: none)."""
return getattr(tr, "_pend", None)
def life(name, changes, **kw):
for m in MODES:
tr, first, armed = play(steady(changes), m, **kw)
check(f"{name} [{m}]: not armed, never stuck to TS+130",
tr.armed_at is None and first is None and not armed
and not tr.stuck_now)
def armed(name, tl, at=TS, **kw):
for m in MODES:
tr, first, ever = play(tl, m, **kw)
check(f"{name} [{m}]: armed at the send, stuck at TS+60 (+-1), "
f"not before TS+59 (first {first})",
first is not None and TS + 59 <= first <= TS + 61
and tr.armed_at == at and tr.stuck_now)
life("T3 energy alone steps 10 Wh at +4", {4: dict(e=1.010)})
life("T4 one phase current alone (L2 15.9 -> 16.0) at +4",
{4: dict(cur=(16.0, 16.0, 16.0))})
life("T5 power alone (11040 -> 11080 W) at +4", {4: dict(p=11080.0)})
life("T9 the step at +9, inside the window", {9: dict(e=1.010)})
life("T9 the step exactly at +10 (the edge counts)", {10: dict(e=1.010)})
life("T12(a) power None, state C, energy rising", {4: dict(e=1.010)},
pre=dict(p=None))
armed("T6 present but unchanged: every sample repeats the pre-write values",
steady())
armed("T9 the step at +11 is outside the window; armed_at is the send, not "
"+10 or +11", steady({11: dict(e=1.010)}))
armed("T10 energy absent before, present after: no change against a last "
"value", steady({4: dict(e=1.010)}), pre=dict(e=None))
armed("T12(b) power None, nothing else changes", steady(p=None),
pre=dict(p=None))
# T7: a stale sample: the pre-write sample again, the same taken-at time
for what, e in (("the same values", 1.000), ("changed values", 1.010)):
tl = [(TS + s, rd(e=e, taken=TS - 1.0)) for s in range(1, 131)]
armed(f"T7 stale sample ({what}, taken-at TS-1 again and again)", tl)
# T8: the late pre-write sample (EV-12 ordering): taken TS-1, arrives TS+2
late = [(TS + s, rd(e=1.010, taken=TS - 1.0) if s == 2 else rd(e=1.010))
for s in range(2, 131)]
armed("T8 a sample taken at TS-1 (+10 Wh) arrives at TS+2, nothing changes "
"after it", late, pre_end=-3)
# T15: the STUCK_MIN_A edge is as before
t15 = CH.CarTracker()
t15.observe(rd(), TS, UTC, DAY)
t15.note_write(TS, 10, 10.9)
a09 = t15.armed_at
t15.note_write(TS, 10, 11)
a10 = t15.armed_at
t15b = CH.CarTracker()
t15b.observe(rd(), TS, UTC, DAY)
t15b.note_write(TS, None, 10)
check("T15 a 0.9 A move does not arm, 1.0 A does, an unknown `was` does",
a09 is None and a10 == TS and t15b.armed_at == TS)
t15c = CH.CarTracker()
t15c.observe(rd(), TS, UTC, DAY)
t15c.note_write(TS, 10, 10.9, False)
t15d = CH.CarTracker()
t15d.observe(rd(), TS, UTC, DAY)
t15d.note_write(TS, 10, 11, False)
for i in range(1, 80):
t15d.observe(rd(), TS + i, UTC, DAY)
check("T15 a refused 0.9 A move arms nothing and leaves nothing waiting; a "
"refused 1.0 A move with no life arms",
t15c.armed_at is None and pend(t15c) is None and t15d.armed_at == TS
and t15d.stuck_now)
# the details the plan implies
tr = CH.CarTracker()
tr.observe(rd(), TS, UTC, DAY)
tr.note_write(TS, 16, 10, True)
check("E3: an accepted write arms at once, at the send", tr.armed_at == TS
and pend(tr) is None)
tr = CH.CarTracker()
for i in range(-5, 1):
tr.observe(rd(), TS + i, UTC, DAY)
tr.note_write(TS, 16, 10, False)
tr.observe(rd(), TS + 3, UTC, DAY)
tr.note_write(TS + 5, 10, 8, True)
check("an accepted write while a refusal's window is open arms at the "
"accepted write, and the window is dropped",
tr.armed_at == TS + 5 and pend(tr) is None)
tr = CH.CarTracker()
for i in range(-5, 1):
tr.observe(rd(), TS + i, UTC, DAY)
tr.note_write(TS, 16, 10, False)
tr.note_write(TS + 5, 10, 6, False)
tr.note_write(TS + 10, 6, 5, False)
for i in range(1, 70):
tr.observe(rd(), TS + i, UTC, DAY)
check("T20 shape: refusals 5 s apart with nothing changing arm once, dated "
"the FIRST", tr.armed_at == TS and tr.stuck_now)
tr = CH.CarTracker()
for i in range(-5, 1):
tr.observe(rd(), TS + i, UTC, DAY)
tr.note_write(TS, 16, 10, False)
for i in range(1, 5):
tr.observe(rd(e=1.010), TS + i, UTC, DAY)
tr.note_write(TS + 20, 10, 8, False)
check("a refusal that showed life leaves no window; a later refusal gets "
"its own", pend(tr) is not None and pend(tr)["t"] == TS + 20
and tr.armed_at is None)
# T18 (tracker): an armed check is neither cleared nor delayed by a refusal
tr = CH.CarTracker()
for i in range(-5, 1):
tr.observe(rd(), TS + i, UTC, DAY)
tr.note_write(TS, 16, 10, True)
for i in range(1, 20):
tr.observe(rd(), TS + i, UTC, DAY)
tr.note_write(TS + 20, 10, 8, False)
for i in range(20, 61):
tr.observe(rd(e=1.0 + i / 1000.0), TS + i, UTC, DAY)
check("T18 (tracker) an accepted write armed at TS; a live refusal at TS+20 "
"neither clears nor delays it: stuck at TS+60",
tr.armed_at == TS and tr.stuck_now and pend(tr) is None)
# =========================================================================== #
# W: the real Controller on the charger model
# =========================================================================== #
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 __init__(self):
self.values = []
def publish(self, v):
self.values.append(dict(v))
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))
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"]}
SET = "number.wallbox_power_connector_max_current_socket_1"
CAR = dict(BASE, ev_charger="alfen_ha", ev_max_a=16, ev_phases="auto",
ev_current_entity=SET)
CLOCK = [1000.0]
freshness.monotonic = lambda: CLOCK[0]
class World:
"""A real Controller on the charger model, one clock for all of it."""
def __init__(self, opts=CAR, sim=None, store=None, setpoint=16, phases=3,
grid=800.0, beside=False):
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.off = self.t - self.sim.t # sim time + off = this clock
self.make(opts)
if beside:
self.beside()
def beside(self):
"""The writer runs BESIDE the cycle, as in production: the cycle reads
(and the tracker sees) the charger while a write waits for its
read-back, one poll per cycle."""
gate = asyncio.Event()
async def sleep(_s):
gate.clear()
await gate.wait()
async def settle():
gate.set()
for _ in range(5):
await asyncio.sleep(0)
self.drv._sleep = sleep
self.c.car_settle = settle
def make(self, 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
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):
out = []
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()
tk = self.c.car
out.append((tk.obs_at, tk.armed_at, tk.stuck(self.t)))
return out
async def act(self, what, value):
return await self.c.handle_action(what, value=value)
def rows(self):
return {r["id"]: r for r in self.c.checks()}
def amber(self):
"""The charger's amber rows: not ok, warn."""
return sorted(i for i, r in self.rows().items()
if r["warn"] and not r["ok"] and i.startswith("charger"))
def sends(self):
"""The model seconds (this clock) of every current write received."""
return [x[0] + self.off for x in self.sim.writes("current")]
def run(coro):
return asyncio.run(coro)
SEND = {} # T26: what the charger was sent, per shape
def keep(key, w, res):
"""The writes of one run: the driver's calls (second, value, taken) and
what the model received (model second, kind, value)."""
SEND[key] = ([(round(t), a, r) for t, a, r in res],
[(round(x[0]), x[1], x[2]) for x in w.sim.writes()])
async def live_car(setpoint=16, phases=3, **kw):
"""Manual, the car charging `setpoint` A on `phases`, ramped up."""
w = World(setpoint=setpoint, phases=phases, **kw)
await w.step(6)
await w.act("car_phases", phases) # the wish is what the car has
await w.act("car_mode", "manual")
await w.act("car_current", setpoint)
await w.step(4)
return w
def spy_on(w):
"""[(send time, current, ok)] of every `write_current`."""
res, real = [], w.drv.write_current
async def spy(a):
t = w.t
r = await real(a)
res.append((t, a, r))
return r
w.drv.write_current = spy
return res
def never_stuck(tr, lo=0):
return all(a is None and not s for _t, a, s in tr[lo:])
def first_stuck(tr):
return next((t for t, _a, s in tr if s), None)
# =========================================================================== #
print("\n2. W: LIVE REFUSALS SHOW ONE AMBER ROW")
# =========================================================================== #
# Each W shape runs twice: the writer inside the cycle (the model's own
# waits), and BESIDE it as in production (the cycle reads while a write waits).
SIDES = ((False, "inside"), (True, "beside"))
async def t1(kind, beside):
w = await live_car(beside=beside)
w.sim.refuse = kind
res = spy_on(w)
await w.act("car_current", 10)
tr = await w.step(400)
return w, res, tr
for beside, side in SIDES:
for kind, nm in (("ignore", "T1 the charger ignores it (HA says yes)"),
("error", "T2 HA refuses at once (False at +0)")):
LOG.rec.clear()
w, res, tr = run(t1(kind, beside))
ts = [t for t, _a, _r in res]
keep(f"{nm[:2]}-{kind}-{side}", w, res)
nm = f"{nm} [{side}]"
check(f"{nm}: three tries about a minute apart, all refused, then "
f"it gives up ({[round(x - ts[0]) for x in ts]})",
len(res) == 3 and not any(r for _t, _a, r in res)
and all(55 <= b - a <= 75 for a, b in zip(ts, ts[1:]))
and w.c.car_writer.gave_up)
check(f"{nm}: the car shows life inside each window: never armed, "
"never stuck, to 400 s", never_stuck(tr))
check(f"{nm}: after the 3rd try exactly ONE amber charger row, "
f"charger_refused ({w.amber()})",
w.amber() == ["charger_refused"])
check(f"{nm}: the car figure is still used by the alarm path",
w.c.car_alarm_w() is not None)
check(f"{nm}: N8 one CHARGER_REFUSED warning, no Traceback; N7 no "
"'another writer' row",
LOG.text("WARNING").count("CHARGER_REFUSED") == 1
and "Traceback" not in LOG.text()
and "charger_other" not in w.rows()
and "charger_writer" not in w.rows())
async def t19(beside):
w = await live_car(16, 3, beside=beside)
w.sim.refuse = "ignore"
res = spy_on(w)
await w.act("car_phases", 1)
tr = await w.step(400)
return w, res, tr
for beside, side in SIDES:
LOG.rec.clear()
w, res, tr = run(t19(beside))
keep(f"T19-{side}", w, res)
check(f"T19 [{side}] the 0 A of a phase change is ignored and the car "
"keeps drawing: tried MAX_TRIES times, no select, never armed or "
"stuck", len(res) == carmode.MAX_TRIES
and not any(r for _t, _a, r in res)
and all(a == 0.0 for _t, a, _r in res)
and not w.sim.writes("phases") and never_stuck(tr))
check(f"T19 [{side}] ...and no charger_stuck row; charger_refused shows "
f"({w.amber()})", "charger_refused" in w.amber()
and "charger_stuck" not in w.amber())
# =========================================================================== #
print("\n3. W: NO LIFE, ACCEPTED WRITES, TRANSITIONS")
# =========================================================================== #
async def t11(beside):
w = await live_car(beside=beside)
w.sim.set_current(5) # under 6 A: B, exactly 0 W, waiting
await w.step(8)
w.sim.refuse = "ignore"
res = spy_on(w)
await w.act("car_current", 10)
tr = await w.step(300)
return w, res, tr
for beside, side in SIDES:
LOG.rec.clear()
w, res, tr = run(t11(beside))
keep(f"T11-{side}", w, res)
t_s = res[0][0]
fs = first_stuck(tr)
check(f"T11 [{side}] a paused car (B, 0 W) shows no life: it arms as "
f"today, stuck at t_s+60 ({fs - t_s if fs else None})",
w.sim.state == "B" and w.sim.power_w == 0.0 and fs is not None
and 59 <= fs - t_s <= 61)
check(f"T11 [{side}] ...and after the 3rd try both amber rows show: "
f"{w.amber()}", w.amber() == ["charger_refused", "charger_stuck"])
async def t14():
w = await live_car(beside=True)
w.sim.lag_s = 3.0 # the read-back is seen by the cycle
w.sim.freeze_power() # the power sticks, the rest is live
res = spy_on(w)
await w.act("car_current", 8)
tr = await w.step(100)
return w, res, tr
LOG.rec.clear()
w, res, tr = run(t14())
t_s = res[0][0]
fs = first_stuck(tr)
check(f"T14 an ACCEPTED write (read-back 3 s late) under a frozen power: "
f"stuck at t_s+60 (+-1), as before ({fs - t_s if fs else None})",
res[0][2] is True and fs is not None and 59 <= fs - t_s <= 61
and w.c.car.armed_at == t_s)
check("T14 ...the amber row 'charger_stuck' shows, and the car figure is not "
"trusted while stuck (N4)", "charger_stuck" in w.amber()
and w.c.car.car_w_trusted(w.t) is None and w.c.car_alarm_w() is None)
async def t17():
w = await live_car(beside=True)
w.sim.refuse = "ignore"
res = spy_on(w)
await w.act("car_current", 10)
tr = await w.step(70) # tries at t_s and t_s+60: live
w.sim.refuse = None
w.sim.lag_s = 3.0
w.sim.freeze_power()
await w.act("car_current", 12)
tr += await w.step(120)
return w, res, tr
LOG.rec.clear()
w, res, tr = run(t17())
t_s, t_acc = res[0][0], res[-1][0]
fs = first_stuck(tr)
check(f"T17 live refusals (not armed), then an accepted write at t_s+"
f"{t_acc - t_s:.0f}: not armed before it, stuck at ITS +60 (+-1) "
f"({fs - t_acc if fs else None})",
res[-1][2] is True and t_acc - t_s > 61 and fs is not None
and 59 <= fs - t_acc <= 61
and all(a is None for t, a, _s in tr if t < t_acc))
async def t18():
w = await live_car(beside=True)
w.sim.lag_s = 3.0
w.sim.freeze_power()
res = spy_on(w)
await w.act("car_current", 12) # accepted: arms
tr = await w.step(19)
w.sim.lag_s = 0.0
w.sim.refuse = "ignore"
await w.act("car_current", 10) # a live refusal 20 s later
tr += await w.step(100)
return w, res, tr
LOG.rec.clear()
w, res, tr = run(t18())
t0 = res[0][0]
fs = first_stuck(tr)
check(f"T18 an accepted write armed at t0; a live refusal at t0+"
f"{res[1][0] - t0:.0f} neither clears nor delays it: stuck at t0+60 "
f"({fs - t0 if fs else None}), still dated t0",
len(res) >= 2 and res[1][2] is False and fs is not None
and 59 <= fs - t0 <= 61 and tr[-1][1] == t0
and all(a == t0 for _t, a, _s in tr if a is not None))
async def t21(beside):
w = await live_car(10, 3, beside=beside)
w.sim.lag_s = 14.0
res = spy_on(w)
await w.act("car_current", 12)
tr = await w.step(120)
return w, res, tr
for beside, side in SIDES:
LOG.rec.clear()
w, res, tr = run(t21(beside))
keep(f"T21-{side}", w, res)
check(f"T21 [{side}] HA took it, the read-back comes 14 s late (False at "
"+10): never stuck, no 'another writer' row, 12 A adopted, one "
"write", [(a, r) for _t, a, r in res] == [(12.0, False)]
and not any(st for _t, _a, st in tr)
and "charger_other" not in w.rows()
and "charger_writer" not in w.rows()
and w.c.car_writer.last_a == 12.0 and w.sim.readback_a == 12.0)
async def t20(beside):
"""EV-28 T15 shape: the 0 A is taken and the car stops, the select is
taken, then the restore is refused MAX_TRIES times 5 s apart at 0 W."""
w = await live_car(16, 3, beside=beside)
res = spy_on(w)
await w.act("car_phases", 1)
for _ in range(60):
await w.step(1)
if w.sim.phases_allowed == 1:
break
w.sim.refuse = "error"
tr = await w.step(150)
return w, res, tr
for beside, side in SIDES:
LOG.rec.clear()
w, res, tr = run(t20(beside))
keep(f"T20-{side}", w, res)
rest = [x for x in res if x[1] == 16.0]
fs = first_stuck(tr)
t_r = rest[0][0] if rest else None
check(f"T20 [{side}] the 0 A is taken, the restore is refused "
f"{len(rest)} times at 0 W with nothing changing: it arms as on "
f"the base, dated the first refusal (stuck at +"
f"{fs - t_r if fs and t_r else None})",
len(rest) >= carmode.MAX_TRIES and not any(r for _t, _a, r in rest)
and w.sim.power_w == 0.0 and fs is not None and 59 <= fs - t_r <= 61)
check(f"T20 [{side}] ...no select besides the one made, and the rows "
f"are as on the base ({w.amber()})",
len(w.sim.writes("phases")) == 1
and "charger_stuck" in w.amber())
# =========================================================================== #
print("\n4. W: AN ERROR AND A RESTART")
# =========================================================================== #
async def t13(exc):
w = await live_car()
n0 = len(LOG.rec)
async def boom(a):
await w.sleep(1.0)
raise exc
w.drv.write_current = boom
await w.act("car_current", 10)
tr = await w.step(30)
return w, tr, n0
from app import hass # noqa: E402
for exc in (RuntimeError("the link broke"), hass.ReadOnly("read only")):
LOG.rec.clear()
w, tr, n0 = run(t13(exc))
errs = [m for lv, m in LOG.rec[n0:]
if lv == "ERROR" and "car charger step failed" in m]
check(f"T13 write_current raises {type(exc).__name__}: as on the base: "
"never armed, no window left, no refusal counted, the mute set, "
f"the step error logged once ({len(errs)})",
never_stuck(tr) and pend(w.c.car) is None
and w.c.car_writer.fails == 0 and w.c.car.mute_until > 0
and len(errs) == 1)
async def t25():
w = await live_car()
w.sim.refuse = "ignore"
await w.act("car_current", 10)
await w.step(75) # two tries
fails_before = w.c.car_writer.fails
w.make(CAR) # a restart: a new Controller
return w, fails_before
w, fb = run(t25())
check("T25 a restart after 2 refusals: a fresh tracker and writer, nothing "
"armed, nothing waiting, no failures counted",
fb == 2 and w.c.car.armed_at is None and pend(w.c.car) is None
and not w.c.car.stuck(w.t) and w.c.car_writer.fails == 0)
# =========================================================================== #
print("\n5. C: THE PEAK GUARD (the real Controller on the SAFETY-81 plant)")
# =========================================================================== #
import ev04_peak as P # noqa: E402
import safety81_sim as s81 # noqa: E402
HOUSE = 3000.0
AIM = 6050.0
def drive(events, dur, house=HOUSE, aim=AIM, **kw):
"""P.drive with a trace per second, taken before that second's cycle:
(second, armed_at, stuck, car_alarm_w, the alarms so far)."""
tr = []
def note(plant, c):
tr.append((plant.t, c.car.armed_at, c.car.stuck_now, c.car_alarm_w()))
ev = {t: note for t in range(0, dur)}
for t, fn in events.items():
ev[t] = (lambda p, c, fn=fn: (fn(p, c), note(p, c)))
kw.setdefault("phases", 3)
kw.setdefault("setpoint", 16)
kw.setdefault("user_a", 16)
r = P.drive(s81.constant(house), dur=dur, rating=12000.0, soc=60.0,
cap=aim, events=ev, **kw)
return r, tr
def user_change(a):
def fn(plant, c):
asyncio.get_event_loop().create_task(c.handle_action(
"car_current", value=a))
return fn
def reserve(plant, c):
"""Both units at the peak reserve, the house on, the car 11 kW."""
plant.soc = 19.0
plant.load = lambda t: HOUSE + plant.ch.power_w
def sends(r):
return [(round(x[0]), x[1], x[2]) for x in r["sim"].writes()]
def amber_rows(r):
return sorted(x["id"] for x in r["c"].checks()
if x["warn"] and not x["ok"] and x["id"].startswith("charger"))
ALARMS = P.ALARMS + ("goodwe_peak_floor_limited",)
def alarm_list(r):
return P.ids(r, *P.ALARMS)
# T22: a live refusal under a car-caused overload raises nothing the twin
# does not
def t22_events(change):
ev = {300: lambda p, c: (reserve(p, c), setattr(p.ch, "refuse", "ignore")
if change else None)}
if change:
ev[301] = user_change(10)
return ev
r_ref, tr_ref = drive(t22_events(True), 700)
r_twin, tr_twin = drive(t22_events(False), 700)
w_ref = [x[3] for x in tr_ref if x[0] >= 300]
w_twin = [x[3] for x in tr_twin if x[0] >= 300]
check("T22 PRECONDITION: the refusals happened (3 tries) and the twin wrote "
"nothing", len(r_ref["sim"].writes("current")) == 3
and r_twin["sim"].writes("current") == [])
check("T22 a live refusal under a car-caused overload: the car figure used by "
"the alarm path is the twin's every cycle from 300 to 700 (+-1 W)",
len(w_ref) == len(w_twin) and all(
(a is None and b is None) or (a is not None and b is not None
and abs(a - b) <= 1.0)
for a, b in zip(w_ref, w_twin)))
check(f"T22 ...and the alarms are the twin's ({alarm_list(r_ref)} vs "
f"{alarm_list(r_twin)})", alarm_list(r_ref) == alarm_list(r_twin)
and alarm_list(r_ref) == [])
check("T22 ...never armed, never stuck", all(a is None and not s
for _t, a, s, _w in tr_ref))
# T16: the test_ev04 section 9 shape: everything frozen, the car really goes,
# the user sets 10 A: the write is refused and nothing changes
def freeze_all(plant, c):
plant.ch.freeze() # every reading sticks, the
plant.ch.unplug() # read-back too; the car goes
plant.load = lambda at: 9000.0 + plant.ch.power_w
r16, tr16 = drive({60: lambda p, c: (freeze_all(p, c),
user_change(10)(p, c))}, 400,
house=1100.0, aim=3500.0)
SEND["T16"] = ([], sends(r16))
log16 = [x for x in r16["c"].car_writer.log if x[0] == "current"]
t_s = log16[0][2] if log16 else None
fs = next((t for t, _a, s, _w in tr16 if s), None)
al16 = P.ids(r16, "goodwe_peak_saturated")
check(f"T16 everything frozen, the write is refused: it arms at t_s={t_s} "
f"and is stuck at t_s+60 +-2 (first {fs})",
t_s is not None and fs is not None and 58 <= fs - t_s <= 62
and not any(x[3] for x in log16))
check(f"T16 ...after MAX_TRIES both rows show: {amber_rows(r16)}",
amber_rows(r16) == ["charger_refused", "charger_stuck"])
check("T16 ...the car figure is not used while stuck, and the normal alarm "
f"fires before freeze+60+60+25 ({al16})",
r16["c"].car_alarm_w() is None and len(al16) == 1
and al16[0][0] < 60 + 60 + 25)
# T23 (EV-10 trap): a 6 A, 1 phase car (1.38 kW) takes no energy step inside
# the window, so its refusal arms as today. The house then steps 1.7 kW over
# the aim: the car does not explain it, so the alarm comes at the twins' cycle.
def t23_events(change, t_s=570):
def house_drain(plant, c): # test_ev10's trap shape
plant.soc = 19.0
plant.load = lambda at: 12000.0 + plant.ch.power_w
return {t_s - 1: lambda p, c: (setattr(p.ch, "refuse", "ignore")
if change else None),
t_s: user_change(8) if change else (lambda p, c: None),
t_s + 30: house_drain}
def t23(change, mode="manual"):
return drive(t23_events(change), 800, house=1100.0, aim=4500.0,
phases=1, setpoint=6, user_a=6, mode=mode)
r23, tr23 = t23(True)
r23a, tr23a = t23(False)
r23o, tr23o = t23(False, mode="off")
a23, a23a, a23o = (P.ids(x, *P.ALARMS) for x in (r23, r23a, r23o))
check(f"T23 PRECONDITION: the refusal found no life (6 A, 1.38 kW): it armed "
f"as today, stuck at t_s+60", any(s for _t, _a, s, _w in tr23)
and len(r23["sim"].writes("current")) >= 1)
check(f"T23 the alarm fires at the same second as both twins (refusal "
f"{a23}, no write {a23a}, Off {a23o})", len(a23) == 1
and [n for _t, n in a23] == [n for _t, n in a23a]
and abs(a23[0][0] - a23a[0][0]) <= 1 and a23o
and abs(a23[0][0] - a23o[0][0]) <= 1)
# T24 (EV-18): after a live refusal (not armed) the energy meter stops while
# the power says 11 kW: the figure is contradicted and the quarter latched.
# (The tries are at 300, 360 and 420, each live; the meter stops after them.)
def meter_stops(plant, c):
sim, tick = plant.ch, plant.ch.tick
def stuck_meter(secs=1.0):
kwh = sim.kwh
tick(secs)
sim.kwh = kwh
sim.tick = stuck_meter
def t24(change):
ev = {299: lambda p, c: (reserve(p, c), setattr(p.ch, "refuse", "ignore")
if change else None),
300: user_change(10) if change else (lambda p, c: None),
432: meter_stops} # after the 3rd try's window
seen = []
def watch(plant, c):
seen.append((plant.t, c._car_contradicted(c.car_now()),
c._car_contra_block))
for t in range(300, 700):
prev = ev.get(t)
ev[t] = (lambda p, c, prev=prev: (prev(p, c) if prev else None,
watch(p, c)))
r, tr = drive(ev, 700)
return r, tr, seen
r24, tr24, seen24 = t24(True)
check("T24 PRECONDITION: a live refusal at 300 (not armed)",
len(r24["sim"].writes("current")) >= 1
and all(a is None and not st for t, a, st, _w in tr24))
check("T24 after a live refusal the meter that falls short for a window "
"contradicts the figure and latches the quarter (a refusal hides no "
"contradiction)", any(x[1] for x in seen24)
and seen24[-1][2] is not None)
# =========================================================================== #
print("\n6. WRITES: THE SAME AS ON THE BASE (T26, N3)")
# =========================================================================== #
if os.environ.get("EV13_DUMP"):
for k in sorted(SEND):
print("DUMP", repr(k), repr(SEND[k]))
BASE_SENDS = { # recorded on 76f4de2 (release/1.0 before EV-13)
'T1-ignore-beside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], [(11, 'current', 10.0), (71, 'current', 10.0), (131, 'current', 10.0)]),
'T1-ignore-inside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], [(11, 'current', 10.0), (71, 'current', 10.0), (131, 'current', 10.0)]),
'T11-beside': ([(1019, 10.0, False), (1079, 10.0, False), (1139, 10.0, False)], [(19, 'current', 10.0), (79, 'current', 10.0), (139, 'current', 10.0)]),
'T11-inside': ([(1019, 10.0, False), (1079, 10.0, False), (1139, 10.0, False)], [(19, 'current', 10.0), (79, 'current', 10.0), (139, 'current', 10.0)]),
'T16': ([], [(61, 'current', 10.0), (131, 'current', 10.0), (201, 'current', 10.0)]),
'T19-beside': ([(1011, 0.0, False), (1071, 0.0, False), (1131, 0.0, False)], [(11, 'current', 0.0), (71, 'current', 0.0), (131, 'current', 0.0)]),
'T19-inside': ([(1011, 0.0, False), (1071, 0.0, False), (1131, 0.0, False)], [(11, 'current', 0.0), (71, 'current', 0.0), (131, 'current', 0.0)]),
'T2-error-beside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], []),
'T2-error-inside': ([(1011, 10.0, False), (1071, 10.0, False), (1131, 10.0, False)], []),
'T20-beside': ([(1011, 0.0, True), (1025, 16.0, False), (1030, 16.0, False), (1035, 16.0, False), (1095, 16.0, False), (1155, 16.0, False)], [(11, 'current', 0.0), (15, 'phases', 1)]),
'T20-inside': ([(1011, 0.0, True), (1025, 16.0, False), (1030, 16.0, False), (1035, 16.0, False), (1095, 16.0, False), (1155, 16.0, False)], [(11, 'current', 0.0), (15, 'phases', 1)]),
'T21-beside': ([(1011, 12.0, False)], [(11, 'current', 12.0)]),
'T21-inside': ([(1011, 12.0, False)], [(11, 'current', 12.0)]),
}
for k in sorted(SEND):
check(f"T26 {k}: the writes (second, value, taken) and what the model "
"received are the base's", BASE_SENDS.get(k) == SEND[k])
check("T26 no write above the clamp (16 A), and the one select (T20) came "
"with the car at 0 W", all(a <= 16.0 for v in SEND.values()
for _t, a, _r in v[0])
and sorted(k for k, v in SEND.items()
if any(x[1] == "phases" for x in v[1])) == ["T20-beside",
"T20-inside"])
print()
if fails:
print(f"FAIL: {len(fails)} check(s)")
for f in fails:
print(" -", f)
sys.exit(1)
print("ok: EV-13")
+538
View File
@@ -0,0 +1,538 @@
"""EV-16: the Car Why does not alternate between "are at {pct}" and "give all
they can" while the car-over row holds and the guard's floor flag toggles.
`python3 -B test_ev16.py`
Display only: the text is held by `ctl_car._car_why_tick` on the control
cycle's clock (control writes `_car_why_rec`, never reads it; /status reads do
not move it). `c._car_over_ep` is bumped when car_over ends; a record of
another episode is never used.
Mutant: pick the text from the live `floor_limited` again (T1, T2, T7, T8, T9
go red).
Mutating a module this file grades? Read MUTATION.md first.
"""
import dataclasses
import hashlib
import os
import sys
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
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)
OVER = "are at"
FULL = "give all they can"
Q = 900.0
STEP = 5.0
@dataclasses.dataclass
class G:
floor_limited: bool = True
soc: object = 20.0
saturated: bool = False
floor_w: float = 0.0
able_w: object = None
ceiling_w: float = 4500.0
engaged: bool = True
blind: object = None
wanted_w: float = 300.0
within_aim: bool = False
class Proj:
projected_w = 14500.0
held_w = 14500.0
elapsed_s = 400.0
block_start = None
class S(ctl_car.CarMixin):
def __init__(self, cover=True):
self.o = {"ev_batt_cover": cover}
self._now = 0.0
self.w = 11000.0
self.site_batt_w, self.site_rating_w = 8100.0, 9600.0
self.shadow, self.auto, self.peak_guard = False, True, None
self.state = "charging"
self.car_init({}, type("St", (), {"data": {}, "set": lambda s, k, v: 0})())
self.car_over = True
def car_now(self):
return self._now
def car_alarm_w(self):
return self.w
@property
def car(self):
me = self
class _C:
@staticmethod
def status(*_a):
return me.state
return _C
def why(c):
return homeview._car_manual_why(c, "charging")
def kind(t):
return "over" if OVER in t else "full" if FULL in t else t
def tick(c, g, t):
"""One control cycle's display tick (what car_cycle ends with)."""
c._now = t
c.peak_guard = g
c._car_why_tick(g, t)
def run(c, secs, g_of, t0=0.0):
"""Read the Why once per 5 s cycle; returns [(t, kind)]."""
out = []
t = t0
while t < t0 + secs:
tick(c, g_of(t - t0), t)
out.append((t, kind(why(c))))
t += STEP
return out
def changes(seq):
return [i for i in range(1, len(seq)) if seq[i][1] != seq[i - 1][1]]
def toggle(period, first=True):
return lambda t: G(floor_limited=(int(t // period) % 2 == 0) == first)
HOUSE = s81.constant(1100.0)
def real_run(read, eventful=True):
"""The T1 shape through the real controller: the batteries toggle across
the reserve every 10 s. Returns the control digest, the per-cycle rows and
flags, and the Why texts read (if `read`)."""
texts, rows, flags = [], [], []
def ev(plant, c):
plant.soc = 19.0 if int(plant.t // 10) % 2 == 0 else 60.0
pg = c.peak_guard
flags.append(None if pg is None else pg.floor_limited)
rows.append(tuple((x["id"], x["ok"], x["warn"]) for x in c.checks()
if x["id"] in ("peak_guard", "car_over")))
if read and c.car_over:
texts.append(homeview.car_block(c, None)["why"])
r = P.drive(HOUSE, dur=900, events={k: ev for k in range(0, 900)},
cap=3500.0)
ctl = ([s[1:] for s in r["snaps"]], list(r["raised"]),
r["sim"].writes(), r["sim"].setpoint_a)
return ctl, rows, flags, texts
def digest(x):
return hashlib.sha256(repr(x).encode()).hexdigest()[:16]
if "--digest" in sys.argv:
ctl, rows, flags, _t = real_run(False)
print("DIGEST control", digest(ctl), "rows", digest(rows),
"flags", digest(flags))
sys.exit(0)
print("1. the hold: a toggling flag shows one text")
c = S()
a = run(c, Q, toggle(10.0, True))
check("T1 quarter starts floor-limited, toggles every 10 s: one distinct text",
len({k for _, k in a}) == 1 and a[0][1] == "over")
for per in (20.0, 30.0, 10.0):
c = S()
a = run(c, Q, toggle(per, False))
check(f"T2 starts not limited, toggles every {per:.0f} s: at most one "
f"change, none back", len(changes(a)) <= 1)
c = S()
a = run(c, Q, lambda t: G(floor_limited=False, soc=38.0))
check("T3 never limited: 'give all they can' every cycle, never 'are at'",
{k for _, k in a} == {"full"})
c = S()
a = run(c, Q, lambda t: G())
check("T4 limited and steady: 'are at' 20 % from the first cycle",
{k for _, k in a} == {"over"}
and "20 %" in why(c))
print("\n2. real changes still show")
c = S()
a = run(c, 300.0, lambda t: G(floor_limited=False, soc=30.0))
a += run(c, 600.0, lambda t: G(), t0=300.0)
ch = changes(a)
check("T5 full for 300 s then steady limited: one change, full -> over, "
"within 185 s", len(ch) == 1 and a[ch[0]][1] == "over"
and a[ch[0]][0] - 300.0 <= 185.0)
c = S()
a = run(c, 300.0, lambda t: G())
a += run(c, 600.0, lambda t: G(floor_limited=False, soc=30.0), t0=300.0)
ch = changes(a)
check("T6 limited for 300 s then steady not limited: one change back to "
"'give all they can' within 185 s", len(ch) == 1
and a[ch[0]][1] == "full" and a[ch[0]][0] - 300.0 <= 185.0)
for steady_false in (True, False):
c = S()
a = run(c, Q, toggle(10.0, True))
a += run(c, Q, (lambda t: G(floor_limited=False, soc=30.0))
if steady_false else (lambda t: G()), t0=Q)
ch = changes(a)
first_q = {k for t, k in a if t < Q}
check(f"T7 toggling across the edge, new quarter steady "
f"{'False' if steady_false else 'True'}: nothing before the edge, "
f"at most one change near it, to the new state",
len(first_q) == 1 and len(ch) <= 1
and all(a[i][0] >= Q for i in ch)
and len(a) > 0 and a[-1][1] == ("full" if steady_false else "over"))
near = [i for i in ch if abs(a[i][0] - Q) <= 60.0]
check("T7 (cont.) at most one change in the 60 s around the edge",
len(near) <= 1)
print("\n3. failure modes")
c = S()
a = run(c, Q, lambda t: G(soc=None))
check("T8 SoC unread, guard limited: never 'are at', one text",
{k for _, k in a} == {"full"})
c = S()
a = run(c, Q, lambda t: G(soc=None if int(t // 10) % 2 == 0 else 20.0))
check("T8 SoC toggling None / 20 % every 10 s, starting unread: one text, "
"never 'are at'", {k for _, k in a} == {"full"})
c = S()
seq = []
for t in range(0, 900, 5):
tick(c, None if 400 <= t < 410 else G(floor_limited=(t // 10) % 2
== 0), float(t))
try:
seq.append((t, kind(why(c))))
except Exception as e: # noqa: BLE001
seq.append((t, "TRACE " + repr(e)))
check("T9 guard None for a cycle: no Traceback, one text through it",
not any("TRACE" in k for _, k in seq) and len({k for _, k in seq}) == 1)
c = S()
tick(c, None, 0.0)
check("T9 (cont.) guard None from the very first read: a text, no Traceback",
kind(why(c)) in ("full", "over"))
# T10: the car stops, car_over drops after 180 s, a later episode
c = S()
run(c, 100.0, lambda t: G())
check("T10 held 'are at' to start", kind(why(c)) == "over")
for k in range(0, 200):
c._now = 100.0 + k
c.w = None
c.car_cycle(Proj(), G(), 14000.0, None)
check("T10 car_over dropped after the stop", c.car_over is False)
check("T10 the Why left the over wording", OVER not in why(c)
and FULL not in why(c))
c.car_over = True # a new episode, later, SoC 60 %
tick(c, G(floor_limited=False, soc=60.0), 5000.0)
check("T10 the new episode shows 'give all they can' from its first cycle",
kind(why(c)) == "full")
# T10b: no read between the drop and the new episode (the hold is cleared at
# the drop, not at a read)
c = S()
run(c, 100.0, lambda t: G())
for k in range(0, 200):
c._now = 100.0 + k
c.w = None
c.car_cycle(Proj(), G(), 14000.0, None)
c.car_over = True
c.peak_guard = G(floor_limited=False, soc=60.0)
c._now = 9000.0
check("T10 no /status between the drop and the new episode: still 'full'",
kind(why(c)) == "full")
# T11: unplug
c = S()
run(c, 100.0, lambda t: G())
c._car_prev_state = "charging"
c.state = CH.NONE_
c._now = 105.0
c.car_cycle(Proj(), G(), 14000.0, None)
c.car_over = False
check("T11 after the unplug cycle there is no over wording",
OVER not in homeview._car_manual_why(c, "none")
and FULL not in homeview._car_manual_why(c, "none")
and "set when a car is connected" in homeview._car_manual_why(c, "none"))
c.state = "charging"
c.car_over = True
tick(c, G(floor_limited=False, soc=60.0), 400.0)
check("T11 a replug starts with no held text", kind(why(c)) == "full")
# the hold is also gone when the unplug itself ends car_over (no read between)
c = S()
run(c, 100.0, lambda t: G())
c._car_prev_state = "charging"
c.state = CH.NONE_
c._now = 105.0
ep_before = c._car_over_ep
c.car_cycle(Proj(), G(), 14000.0, None)
check("T11 (cont.) the unplug ends the episode (control bumps it)",
c.car_over is False and c._car_over_ep > ep_before)
# T12: cover off while car_over holds
c = S()
run(c, 100.0, lambda t: G())
c.o["ev_batt_cover"] = False
tick(c, G(), 105.0)
check("T12 cover off: 'ignores the car' at the next read",
"ignores the car" in why(c))
c.o["ev_batt_cover"] = True
tick(c, G(floor_limited=False, soc=60.0), 110.0)
check("T12 cover on again, steady not limited: 'give all they can', not "
"the old 'are at'", kind(why(c)) == "full")
# T13: restart
c = S()
a = run(c, 450.0, toggle(10.0, True))
c2 = S()
b = run(c2, 450.0, toggle(10.0, True), t0=450.0)
check("T13 restart mid-quarter: no Traceback, a text, at most one change "
"after", kind(why(c2)) in ("full", "over") and len(changes(b)) <= 1)
print("\n4. control unchanged; the rows follow the live flag")
ctl1, rows1, flags1, sts = real_run(True)
ctl0, rows0, flags0, _t = real_run(False)
check("T14 reading the Why every cycle changes no command, alarm or row",
ctl1 == ctl0 and rows1 == rows0 and flags1 == flags0)
shown = [t for t in sts if OVER in t or FULL in t]
flips = sum(1 for a, b in zip(flags1, flags1[1:]) if a != b)
BASE_8150608 = ("e6034b0c78f23776", "5ffb80fa428cd6ee", "689a5b0e4bf7c897")
check("T14/T15 commands, alarms, charger writes and the peak_guard/car_over "
"rows equal those of base 8150608 (digests taken there with --digest)",
(digest(ctl1), digest(rows1), digest(flags1)) == BASE_8150608)
check("PRECONDITION: the real guard's floor flag toggles many times and "
"car_over is on for most of the run", flips > 20 and len(shown) > 200)
check("T1/T2 through the real guard: at most one Why change in the quarter",
sum(1 for a, b in zip(shown, shown[1:]) if a != b) <= 1)
check("T15 the peak_guard row follows the live flag (it changes as often as "
"the flag), the hold is only in the Why",
sum(1 for a, b in zip(rows1, rows1[1:]) if a != b) >= 1
and len({r for r in rows1 if r}) >= 1)
print(" DIGEST control", digest(ctl1), "rows", digest(rows1),
"flags", digest(flags1))
print("\n5. text, hold and wiring")
check("the hold equals the car_over row's own off hold",
homeview.WHY_HOLD_S == ctl_car.OVER_OFF_HOLD_S)
src = open(os.path.join(HERE, "app", "homeview.py")).read()
check("the live flag is read only by the hold helper, not by the Why branch",
'pg.floor_limited else' not in src)
import json
for lang, over, full in (
("en", "You set {a} A. The batteries are at {pct}, so this charge "
"sets the peak.",
"You set {a} A. The batteries give all they can, so this charge "
"sets the peak."),
("nl", "U stelde {a} A in. De batterijen staan op {pct}, dus deze "
"lading bepaalt de piek.",
"U stelde {a} A in. De batterijen geven alles, dus deze lading "
"bepaalt de piek.")):
d = json.load(open(os.path.join(HERE, "app", "ui_text", lang + ".json")))
d = d["home_words"]["car"]["why"]
check(f"T17 {lang}.json wording of manual_over / manual_full unchanged",
d["manual_over"] == over and d["manual_full"] == full)
check("a held peak_guard row is not touched: the module still has no hold "
"in ctl_status", "_car_why_rec" not in open(os.path.join(
HERE, "app", "ctl_status.py")).read())
print("\n6. EV-16 review round 1: the race, T16, T18, the N-ids")
# the race: a read takes the hold, control ends the episode, the read writes
# its old hold back; the next episode must not show it
c = S()
run(c, 100.0, lambda t: G())
stale = c._car_why_rec
check("race: the read holds 'are at' before the end", kind(why(c)) == "over")
for k in range(0, 200):
c._now = 100.0 + k
c.w = None
c.car_cycle(Proj(), G(), 14000.0, None)
c._car_why_rec = stale # the late write-back
c.car_over = True
c._now = 6000.0
c.peak_guard = G(floor_limited=False, soc=60.0)
check("N4 race: a read interleaved with the clear cannot bring the old "
"'are at' into the next episode", kind(why(c)) == "full")
c = S()
run(c, 100.0, lambda t: G())
stale = c._car_why_rec
c._car_prev_state = "charging"
c.state = CH.NONE_
c._now = 105.0
c.car_cycle(Proj(), G(), 14000.0, None)
c._car_why_rec = stale # write-back after an unplug
c.state = "charging"
c.car_over = True
c.peak_guard = G(floor_limited=False, soc=60.0)
c._now = 110.0
check("N4 race (unplug): a stale write-back after the unplug is not used",
kind(why(c)) == "full")
# T16: the existing checks this one must leave alone are present and run in CI
for f in ("test_ev04.py", "test_ev10.py", "test_ev10b.py", "test_ev18.py",
"test_ev19.py", "test_home.py", "test_named_absence.py",
"test_bytecode.py"):
check(f"T16 {f} exists (run unchanged by CI's run-tests.sh)",
os.path.exists(os.path.join(HERE, f)))
t04 = open(os.path.join(HERE, "test_ev04.py")).read()
check("T16 test_ev04's Manual Why assertion 'batteries give all they can' "
"is still there", 'batteries give all they can" in cardwhy' in t04)
# T18: the mutant, in process: the live flag picks the text again
real = homeview._over_why_is_floor
homeview._over_why_is_floor = lambda c, pg: bool(
pg is not None and pg.floor_limited)
try:
m = run(S(), Q, toggle(10.0, True))
m8 = run(S(), Q, lambda t: G(soc=None))
finally:
homeview._over_why_is_floor = real
check("T18 mutant (live flag): T1 shape alternates and T8 shows 'are at', so "
"T1, T2, T7 and T8 would go red", len(changes(m)) > 20
and any(k == "over" for _, k in m8))
# the N-ids, by name
a = run(S(), Q, toggle(10.0, True))
check("N1 control: batteries, charger writes and setpoint equal base "
"(digests, section 4)", (digest(ctl1), digest(rows1), digest(flags1))
== BASE_8150608)
check("N2 `floor_limited`, `car_explains`, `car_over`, the peak_guard row "
"are not changed by the hold: the guard flag toggles as in base "
"(flags digest) and the rows digest equals base",
digest(flags1) == BASE_8150608[2] and digest(rows1) == BASE_8150608[1])
n3 = run(S(), Q, lambda t: G(soc=None)) + run(
S(), Q, lambda t: G(floor_limited=False, soc=40.0))
check("N3 never 'are at' with SoC unread or with the guard never limited",
{k for _, k in n3} == {"full"})
c = S()
run(c, 100.0, lambda t: G())
c.car_over = False
n4 = homeview._car_manual_why(c, "charging")
check("N4 no over wording once car_over is off", OVER not in n4
and FULL not in n4)
check("N5 at most one Why change in a quarter while the guard toggles",
len(changes(a)) <= 1)
try:
for g in (None, G(soc=None), G(), G(floor_limited=False, soc=1.0)):
c = S()
c.peak_guard = g
why(c)
n6 = True
except Exception: # noqa: BLE001
n6 = False
check("N6 no Traceback for a guard of None, SoC unread, limited, not "
"limited", n6)
en = open(os.path.join(HERE, "app", "ui_text", "en.json")).read()
nl = open(os.path.join(HERE, "app", "ui_text", "nl.json")).read()
check("N7 wording unchanged: the four texts are in the files verbatim",
"The batteries are at {pct}, so this charge sets the peak." in en
and "The batteries give all they can, so this charge sets the peak."
in en and "De batterijen staan op {pct}, dus deze lading bepaalt de "
"piek." in nl and "De batterijen geven alles, dus deze lading bepaalt "
"de piek." in nl)
print("\n7. EV-16 review round 2: the hold runs on the control clock")
def gap_run(c, g_of, read_at, end=2300.0):
"""Control cycles every 5 s; the Why is read only at the `read_at` times."""
out = []
t = 0.0
while t < end:
tick(c, g_of(t), t)
if any(a <= t < b for a, b in read_at):
out.append((t, kind(why(c))))
t += STEP
return out
pages = ((0, 60), (2000, 2300))
c = S()
r = gap_run(c, lambda t: G(floor_limited=t >= 300.0, soc=20.0), pages)
late = [(t, k) for t, k in r if t >= 2000]
check("review A: drained to the reserve while the page was closed: the "
"first read at t=2000 already shows 'are at'",
len(late) > 0 and late[0][1] == "over" and {k for _, k in late} == {"over"})
c = S()
r = gap_run(c, lambda t: G(floor_limited=t < 300.0,
soc=20.0 if t < 300.0 else 45.0), pages)
late = [(t, k) for t, k in r if t >= 2000]
check("review B: off the reserve while the page was closed: the first "
"read at t=2000 shows 'give all they can', never a false 'are at'",
len(late) > 0 and late[0][1] == "full" and {k for _, k in late} == {"full"})
c = S()
r = []
for t in range(0, 400, 5):
cov = not (100 <= t < 200)
c.o["ev_batt_cover"] = cov
tick(c, G(floor_limited=t < 100, soc=20.0 if t < 100 else 45.0),
float(t))
if t in (95, 205):
r.append(kind(why(c)))
check("review: cover off and on with no read between: back on, the state "
"now not limited shows 'give all they can' at the first read",
r == ["over", "full"])
# lower bound of the hold: a real change is NOT shown before the hold ends
c = S()
r = []
for t in range(0, 600, 5):
tick(c, G(floor_limited=t >= 300.0, soc=20.0), float(t))
r.append((t, kind(why(c))))
check("review: a real change is held for the full 180 s: still the old "
"text 170 s after it, the new one by 185 s",
dict(r)[470] == "full" and dict(r)[485] == "over")
# M7: guard None for 180 s or more under car_over
for steady, want in ((True, "over"), (False, "full")):
c = S()
seq = []
for t in range(0, 1200, 5):
g = G(floor_limited=steady, soc=20.0 if steady else 45.0) \
if t < 100 else None
tick(c, g, float(t))
seq.append(kind(why(c)))
check(f"T9 (long) guard None for 1100 s after a steady "
f"{'limited' if steady else 'not limited'} state: the text stays "
f"'{want}', no flip", set(seq) == {want})
c = S()
seq = []
for t in range(0, 1200, 5):
tick(c, None, float(t))
seq.append(kind(why(c)))
check("T9 (long) guard None from the start for 1200 s: one text, 'full'",
set(seq) == {"full"})
# review round 2: the live fallback (no record yet, or one of an ended
# episode) keeps the unread-SoC rule too
for label, rec in (("no record yet", None),
("a record of an ended episode", [True, None, -1])):
c = S()
c._now = 0.0
c._car_why_rec = rec
c.peak_guard = G(soc=None)
check(f"N3 {label}: limited with SoC unread is not 'are at'",
kind(why(c)) == "full")
c.peak_guard = G()
check(f"N3 {label}: limited with SoC read shows 'are at' (live state)",
kind(why(c)) == "over")
print()
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
sys.exit(1 if fails else 0)
+939
View File
@@ -0,0 +1,939 @@
"""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, the restore on the first available step "
f"({[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
and [x[1:3] for x in first][:1] == [("current", 10.0)])
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 and w.wr.fails == 1,
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, one failed write counted",
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")