Compare commits

..
17 Commits
Author SHA1 Message Date
Claude 9987a32424 EV-14 review: T1 phases check (shadow-over phases come from would)
infra-pin / fresh (pull_request) Waiting to run
checks / unit (pull_request) In progress
Kills the surviving mutant 'shadow-over phases from car_n'.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-22 15:25:32 +01:00
Claude b66ce68d4d EV-14: T33 reads the raw nl words; T29 carries a would
checks / unit (pull_request) Successful in 34m43s
infra-pin / fresh (pull_request) Successful in 1s
2026-11-22 13:50:40 +01:00
Claude d0285470cb EV-14: Car Why says what happens in shadow mode and after a phase change that did not happen
Display only: shadow mode over-limit Why speaks in would-terms; read phases that
differ from the setting say the charger stays; a writer hold says something
else set the charger. EN and NL texts, test_ev14.py.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-22 13:45:30 +01:00
ems-agent c8f529273f Merge pull request 'EV-13: a refused current write shows one amber row' (#269) from EV-13 into release/1.0
infra-pin / fresh (push) Successful in 2s
2026-11-22 12:09:19 +01:00
Claude 6cd775788d EV-13 review round 2: tie the driver's polls to the cycle reading per phase (D1, D2)
checks / unit (pull_request) Successful in 30m36s
infra-pin / fresh (pull_request) Successful in 1s
Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-22 10:45:14 +01:00
Claude 57a9f56a64 EV-13: guard the P4 live check's last sample (test_named_absence)
infra-pin / fresh (pull_request) Successful in 2s
checks / unit (pull_request) Successful in 27m17s
Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-22 07:58:56 +01:00
Claude 0774d1efd5 EV-13 router round 3: N2 names P1/P2; P4 live window dated the send; kills R1
checks / unit (pull_request) Failing after 58m19s
infra-pin / fresh (pull_request) Successful in 2s
Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-22 06:54:30 +01:00
Claude 5ebd830966 EV-13 review: compare phase currents per phase; test a late read-back
checks / unit (pull_request) Successful in 26m23s
infra-pin / fresh (pull_request) Successful in 1s
A phase that drops out or comes back shifted the compressed current_a tuple and
read as life, so a frozen charger never armed. ChargerReading.phase_a keeps
L1/L2/L3 with None for a missing phase and the life test uses it.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w
2026-11-22 05:44:31 +01:00
Claude 1b39f1698a EV-13 router round 1: lapse a refusal's window on unavailable readings; T27, T28 and the N-ids
checks / unit (pull_request) Successful in 31m40s
infra-pin / fresh (pull_request) Successful in 2s
Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w
2026-11-22 03:56:53 +01:00
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
12 changed files with 3287 additions and 32 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)
+120 -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,10 @@ 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
phase_a: tuple = () # EV-13: L1, L2, L3 each, None if not read
def _state_obj(obj):
@@ -280,6 +286,7 @@ def reading_from_states(states: dict) -> ChargerReading:
available=True, state=letter, connected=connected, charging=charging,
power_w=power, energy_kwh=_kwh(states.get("energy")),
current_a=currents, setpoint_a=_amps(states.get("current")),
phase_a=tuple(_amps(states.get(k)) for k in ("l1", "l2", "l3")),
allowed_a=_amps(states.get("readback")),
phases_allowed=_phases(states.get("phases_read")),
station_a=_first(_amps(states.get("station_active")),
@@ -420,6 +427,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 +508,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 +533,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 +542,17 @@ 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:
self.polls.append((self._clock(), ChargerReading(
available=True, power_w=_watts(st.get("power")),
energy_kwh=_kwh(st.get("energy")),
phase_a=tuple(_amps(st.get(k)) for k in ("l1", "l2", "l3")))))
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 +654,31 @@ 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.phase_a or ())
if len(cur) != 3:
# Only `current_a`, which leaves out a phase that is not read: which
# phase is which is then known only when all three are there.
cur = tuple(r.current_a or ())
cur = cur if len(cur) == 3 else (None,) * 3
return (r.energy_kwh, r.power_w) + 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 +711,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
@@ -683,7 +734,10 @@ class CarTracker:
if usable:
self.last_ok = now
self.last_good, self.last_good_utc = r, now_utc
if not r.available:
self._pend_lapse(now)
if r.available:
self._life(r, now)
self._sig(r, now)
self._writer(r, now_utc, now)
self._energy(r, day)
@@ -727,19 +781,78 @@ 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_lapse(self, now: float) -> None:
"""A reading that did not answer shows no life either: once the window
has run out the refusal arms, dated the send, as it did before."""
p = self._pend
if p is not None and now > 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 -2
View File
@@ -1318,14 +1318,34 @@ def _over_why_is_floor(c, pg) -> bool:
return bool(pg is not None and pg.floor_limited and pg.soc is not None)
def _real_phases(c):
"""EV-14: the phases the charger reports (1 or 3), or None: no fresh
reading, or none read. Reads only; unknown is never a difference."""
car = getattr(c, "car", None)
r = getattr(car, "reading", None)
fresh = getattr(car, "fresh", None)
if r is None or fresh is None or not getattr(r, "available", False):
return None
if not fresh(c.car_now()):
return None
n = getattr(r, "phases_allowed", None)
return n if n in (1, 3) else 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."""
Plan lines: two sentences of at most 12 words. EV-14: in shadow mode it
says what the add-on would set; after a phase change that did not happen
it says what the charger does."""
a = f"{float(c.car_a):.0f}"
w = c.car_writer
pct = _pct(c.o.get("peak_soc_floor", peakguard.PEAK_OPTION_DEFAULTS[
"peak_soc_floor"]))
if c.car_over:
if c.shadow:
t, n = w.would if w.would is not None else (c.car_a, c.car_n)
return _t("car.why.manual_shadow_over", a=f"{float(t):.0f}",
phases=car_phases_word(n))
pg = getattr(c, "peak_guard", None)
if not c.car_cover:
return _t("car.why.manual_nocover", a=a)
@@ -1337,6 +1357,8 @@ def _car_manual_why(c, key):
phases=car_phases_word(n))
if not c.auto:
return _t("car.why.manual_stopped")
if w.hold:
return _t("car.why.manual_other")
if key in ("none", "full"):
return _t("car.why.manual_wait", a=a)
if w.blocked:
@@ -1344,6 +1366,11 @@ def _car_manual_why(c, key):
if c.car_cover and peak_engaged(c):
giving = max(0.0, float(c.site_batt_w or 0.0))
return _t("car.why.manual_cover", a=a, kw=_kw(giving), pct=pct)
real = _real_phases(c)
if real is not None and real != c.car_n and w.seq is None:
return _t("car.why.manual_phases", a=a,
phases=car_phases_word(c.car_n),
real=car_phases_word(real))
return _t("car.why.manual_set", a=a, phases=car_phases_word(c.car_n))
@@ -1900,7 +1927,8 @@ def _samples() -> list:
out += [("plan", _t("car.big." + k, t="09:12")) for k in
words["car"]["big"]]
out += [("plan", _t("car.why." + k, a="10", brand="Alfen", kw="8.6 kW",
pct="20 %", phases=car_phases_word(3)))
pct="20 %", phases=car_phases_word(3),
real=car_phases_word(1)))
for k in words["car"]["why"]]
out += [("plan", _t("peak.car", kw="12.1 kW", car="11.0 kW",
cov="8.6 kW")),
+3
View File
@@ -329,6 +329,9 @@
"manual_wait": "You set {a} A. It is set when a car is connected.",
"manual_would": "Shadow mode: the add-on would set {a} A, {phases}.",
"manual_stopped": "Control is stopped. The charger keeps its last setting.",
"manual_shadow_over": "Shadow mode: the add-on would set {a} A, {phases}. This charge would set the peak.",
"manual_phases": "You set {a} A, {phases}. The charger stays on {real}.",
"manual_other": "Something else set the charger. The add-on leaves it until you change something.",
"manual_blocked": "The phases change once per 10 minutes at most. This waits."
}
},
+3
View File
@@ -283,6 +283,9 @@
"manual_wait": "U stelde {a} A in. Het wordt ingesteld zodra een auto is aangesloten.",
"manual_would": "Schaduwmodus: de add-on zou {a} A instellen, {phases}.",
"manual_stopped": "De regeling is gestopt. De laadpaal houdt haar laatste instelling.",
"manual_shadow_over": "Schaduwmodus: de add-on zou {a} A instellen, {phases}. Deze lading zou de piek bepalen.",
"manual_phases": "U stelde {a} A in, {phases}. De laadpaal blijft op {real}.",
"manual_other": "Iets anders heeft de laadpaal ingesteld. De add-on laat dit zo tot u iets wijzigt.",
"manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht."
}
},
+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 "
File diff suppressed because it is too large Load Diff
+832
View File
@@ -0,0 +1,832 @@
"""EV-14: the Car Why says what happens, not only what the user set.
`python3 -B test_ev14.py`
Display only (homeview._car_manual_why, ui_text en/nl):
E1 shadow mode: no Why says "You set"; with the car over the limit it says
what the add-on WOULD set and that this charge would set the peak.
E2 a phase change that did not happen (read phases differ from the setting):
"The charger stays on {real}", never "keeps it".
E3 the writer holds for another writer: "Something else set the charger".
E4 phases equal or unknown, no hold: exactly as before.
E5 texts in en and nl, same keys, UX-08 limits.
N2 the render writes nothing; N3 it never sends to the charger.
Mutants: see the dev report (M1-M14).
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
"""
import asyncio
import copy
import dataclasses
import itertools
import json
import logging
import os
import re
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, ctl_car, homeview, uitext # noqa: E402
from app.carmode import PHASE_GAP_S, ManualWriter # noqa: E402
from app.main import Controller # noqa: E402
from app import freshness # noqa: E402
from chargersim import FakeHa, SimCharger # noqa: E402
from named_absence import nth, present # noqa: E402
fails = []
logging.getLogger("goodwe").setLevel(logging.CRITICAL)
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
def run(coro):
return asyncio.run(coro)
# =========================================================================== #
# The texts the test holds the page to, written out (T34: base is byte-equal).
# =========================================================================== #
BASE_EN = {
"manual_set": "You set {a} A, {phases}. The charger keeps it, whatever the peak limit does.",
"manual_cover": "You set {a} A. The batteries give {kw} and help down to {pct}.",
"manual_over": "You set {a} A. The batteries are at {pct}, so this charge sets the peak.",
"manual_full": "You set {a} A. The batteries give all they can, so this charge sets the peak.",
"manual_nocover": "You set {a} A. The guard ignores the car, so this charge can set the peak.",
"manual_wait": "You set {a} A. It is set when a car is connected.",
"manual_would": "Shadow mode: the add-on would set {a} A, {phases}.",
"manual_stopped": "Control is stopped. The charger keeps its last setting.",
"manual_blocked": "The phases change once per 10 minutes at most. This waits.",
}
BASE_NL = {
"manual_set": "U stelde {a} A in, {phases}. De laadpaal houdt dit aan, wat de piekgrens ook doet.",
"manual_cover": "U stelde {a} A in. De batterijen leveren {kw} en helpen tot {pct}.",
"manual_over": "U stelde {a} A in. De batterijen staan op {pct}, dus deze lading bepaalt de piek.",
"manual_full": "U stelde {a} A in. De batterijen geven alles, dus deze lading bepaalt de piek.",
"manual_nocover": "U stelde {a} A in. De bewaking negeert de auto, dus deze lading kan de piek bepalen.",
"manual_wait": "U stelde {a} A in. Het wordt ingesteld zodra een auto is aangesloten.",
"manual_would": "Schaduwmodus: de add-on zou {a} A instellen, {phases}.",
"manual_stopped": "De regeling is gestopt. De laadpaal houdt haar laatste instelling.",
"manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht.",
}
NEW_KEYS = ("manual_shadow_over", "manual_phases", "manual_other")
LANGS = ("en", "nl")
YOU = {"en": "You set", "nl": "U stelde"}
KEEPS = {"en": "The charger keeps it,", "nl": "De laadpaal houdt dit aan"}
WOULD = {"en": "would set", "nl": "zou"}
PEAK = {"en": "would set the peak", "nl": "zou de piek bepalen"}
STAYS = {"en": "stays on", "nl": "blijft op"}
OTHER = {"en": "Something else set the charger.", "nl": "Iets anders heeft de laadpaal ingesteld."}
def jwords(lang):
return uitext.words(lang)["home_words"]["car"]["why"]
def tx(lang, key, **kw):
"""Render a car.why text the way the page does (a missing key is a text
of its own, so a check on it is a FAIL, not a crash)."""
homeview._LANG[0] = uitext.lang_of(lang)
try:
return homeview._t("car.why." + key, **kw)
except Exception as e: # noqa: BLE001
return f"<EXC {type(e).__name__} {key}>"
finally:
homeview._LANG[0] = "en"
def pw(n):
homeview._LANG[0] = "en"
return homeview.car_phases_word(n)
def pw_l(lang, n):
homeview._LANG[0] = uitext.lang_of(lang)
try:
return homeview.car_phases_word(n)
finally:
homeview._LANG[0] = "en"
# =========================================================================== #
# A stub site for the unit rows: what _car_manual_why reads, nothing else.
# =========================================================================== #
@dataclasses.dataclass
class G:
floor_limited: bool = True
soc: object = 19.0
saturated: bool = False
floor_w: float = 300.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 Car:
def __init__(self, reading, fresh, last_good=None):
self.reading, self._fresh, self.last_good = reading, fresh, last_good
def fresh(self, _now):
return self._fresh
def status(self, *_a):
return "charging"
class U(ctl_car.CarMixin):
"""The attributes `_car_manual_why` and `_car_why_tick` read."""
def __init__(self, **kw):
self.o = {"ev_batt_cover": kw.get("cover", True)}
self._now = 0.0
self.w = 11000.0
self.site_batt_w, self.site_rating_w = 8100.0, 9600.0
self.shadow = kw.get("shadow", False)
self.auto = kw.get("auto", True)
self.peak_guard = kw.get("pg", G(
floor_limited=kw.get("floor", True),
floor_w=300.0 if kw.get("eng") else 0.0))
self.state = "charging"
self.car_init({}, type("St", (), {"data": {}, "set": lambda s, k, v: 0})())
self.car_a = kw.get("a", 10.0)
self.car_n = kw.get("n", 3)
self.car_over = kw.get("over", False)
wr = self.car_writer
wr.hold = wr.other = kw.get("hold", False)
wr.blocked = kw.get("blocked", False)
wr.seq = kw.get("seq", None)
wr.would = kw.get("would", None)
wr.phases_gave_up = kw.get("gave_up", False)
if "car" in kw:
self.car = kw["car"]
else:
real = kw.get("real", None)
rd = CH.ChargerReading(available=True, state="C", power_w=2300.0,
setpoint_a=10.0, allowed_a=10.0,
phases_allowed=real)
self.car = Car(rd, kw.get("fresh", True))
def car_now(self):
return self._now
def snap(c):
"""Everything N2 says a render must not move."""
keep = {k: v for k, v in vars(c).items()
if k.startswith(("car_", "_car")) and k != "car"}
car = getattr(c, "car", None)
return repr((vars(c.car_writer), vars(car) if hasattr(car, "__dict__")
else None, keep, c.shadow, c.auto))
N2_BAD = []
EXC = []
def why(c, lang="en", key="charging"):
"""The Why text; an exception becomes a text; N2 is checked on every call."""
before = snap(c)
homeview._LANG[0] = uitext.lang_of(lang)
try:
out = homeview._car_manual_why(c, key)
except Exception as e: # noqa: BLE001
EXC.append(repr(e))
out = f"<EXC {type(e).__name__} {e}>"
finally:
homeview._LANG[0] = "en"
if snap(c) != before:
N2_BAD.append(out)
return out
def exp(lang, key, **kw):
return tx(lang, key, **kw)
def a_(c):
return f"{float(c.car_a):.0f}"
# --------------------------------------------------------------------------- #
print("1. E1: shadow mode says what the add-on WOULD set")
# --------------------------------------------------------------------------- #
SHADOW_BAD_CASES = {
"T1 floor": dict(floor=True, cover=True),
"T2 full": dict(floor=False, cover=True),
"T3 cover off": dict(floor=True, cover=False),
}
for label, kw in SHADOW_BAD_CASES.items():
for lang in LANGS:
c = U(shadow=True, over=True, a=16.0, n=3, would=(10.0, 3), **kw)
t = why(c, lang)
check(f"{label} ({lang}): would set 10 A and would set the peak; no "
f"'You set', no 16 A: {t!r}",
present(t) and WOULD[lang] in t and "10 A" in t
and PEAK[lang] in t and YOU[lang] not in t and "16 A" not in t)
check(f"{label} ({lang}): exactly the shadow-over text",
t == exp(lang, "manual_shadow_over", a="10",
phases=pw_l(lang, 3)))
for lang in LANGS:
c = U(shadow=True, over=True, a=12.0, n=3, would=None)
t = why(c, lang)
check(f"T4 ({lang}): writer not stepped: falls back to (car_a, car_n), "
f"12 A, 3 phases, no 'You set': {t!r}",
t == exp(lang, "manual_shadow_over", a="12", phases=pw_l(lang, 3))
and YOU[lang] not in t)
# Review: the phases word is the writer's `would`, as manual_would's.
c = U(shadow=True, over=True, a=16.0, n=1, would=(10.0, 3))
check(f"T1 phases ({lang}): the phases come from would, not car_n",
why(c, lang) == exp(lang, "manual_shadow_over", a="10",
phases=pw_l(lang, 3)))
c = U(shadow=True, over=False, a=16.0, n=3, would=(10.0, 3))
check(f"T5 ({lang}): shadow, not over: exactly today's manual_would",
why(c, lang) == BASE_EN["manual_would"].format(
a="10", phases="3 phases") if lang == "en" else
why(c, lang) == BASE_NL["manual_would"].format(
a="10", phases="3 fasen"))
# T6/T7: the EV-16 episode, 5 s cycles, floor flipping every 10 s.
STEP = 5.0
def tick(c, g, t, shadow=None):
c._now = t
c.peak_guard = g
if shadow is not None:
c.shadow = shadow
c._car_why_tick(g, t)
def episode(c, secs, flip=10.0, shadow_off_at=None):
out, t = [], 0.0
while t < secs:
g = G(floor_limited=(int(t // flip) % 2 == 0))
off = shadow_off_at is not None and t >= shadow_off_at
tick(c, g, t, shadow=False if off else None)
out.append((t, why(c)))
t += STEP
return out
c = U(shadow=True, over=True, a=16.0, would=(10.0, 3))
ep = episode(c, 180.0)
texts = {t for _, t in ep}
check(f"T6: shadow over, floor flips for 180 s: one constant text, 0 changes "
f"({len(ep)} cycles)", len(ep) == 36 and len(texts) == 1
and all(PEAK["en"] in t for t in texts))
c = U(shadow=True, over=True, a=16.0, would=(10.0, 3))
ep = episode(c, 180.0, flip=1000.0, shadow_off_at=90.0)
first = [t for tt, t in ep if tt < 90.0]
later = [t for tt, t in ep if tt >= 90.0]
check("T7: shadow switched off mid-episode with the floor held: the shadow "
"text, then exactly today's manual_over (EV-16 hold)",
len(first) == 18 and len(later) == 18 and len(set(first)) == 1
and PEAK["en"] in nth(first)
and set(later) == {BASE_EN["manual_over"].format(a="16", pct=homeview._pct(
c.o.get("peak_soc_floor", 20)))})
# --------------------------------------------------------------------------- #
print("\n2. E2 / E3: units")
# --------------------------------------------------------------------------- #
for lang in LANGS:
c = U(real=1, n=3, a=10.0)
t = why(c, lang)
check(f"T9 ({lang}): 3 set, charger on 1: 'stays on 1 phase', not 'keeps "
f"it': {t!r}",
t == exp(lang, "manual_phases", a="10", phases=pw_l(lang, 3),
real=pw_l(lang, 1))
and STAYS[lang] in t and KEEPS[lang] not in t
and pw_l(lang, 1) in t)
c = U(real=3, n=1, a=10.0)
t = why(c, lang)
check(f"T10 ({lang}): 1 set, charger on 3: 'stays on 3 phases': {t!r}",
t == exp(lang, "manual_phases", a="10", phases=pw_l(lang, 1),
real=pw_l(lang, 3)) and pw_l(lang, 3) in t.split(". ")[-1]
and KEEPS[lang] not in t)
check("T9: the words are the brief's (EN and NL)",
why(U(real=1, n=3)) == "You set 10 A, 3 phases. The charger stays on 1 phase."
and why(U(real=1, n=3), "nl") ==
"U stelde 10 A in, 3 fasen. De laadpaal blijft op 1 fase.")
def sett(lang, c):
return exp(lang, "manual_set", a=a_(c), phases=pw_l(lang, c.car_n))
for lang in LANGS:
c = U(real=1, n=3, auto=False)
check(f"T13a ({lang}): phases differ, control stopped: manual_stopped",
why(c, lang) == exp(lang, "manual_stopped"))
c = U(real=1, n=3, shadow=True, would=(10.0, 3))
check(f"T13b ({lang}): phases differ, shadow: manual_would",
why(c, lang) == exp(lang, "manual_would", a="10",
phases=pw_l(lang, 3)))
for stage in ("zero", "settle"):
c = U(real=1, n=3, seq={"stage": stage})
check(f"T14 ({lang}): phases differ, sequence at {stage}: manual_set",
why(c, lang) == sett(lang, c))
c = U(real=1, n=3, blocked=True)
check(f"T15 ({lang}): phases differ, blocked: manual_blocked",
why(c, lang) == exp(lang, "manual_blocked"))
for key in ("none", "full"):
c = U(real=1, n=3)
check(f"T16 ({lang}): phases differ, key {key}: manual_wait",
why(c, lang, key) == exp(lang, "manual_wait", a="10"))
c = U(real=1, n=3, eng=True)
giving = max(0.0, float(c.site_batt_w))
homeview._LANG[0] = uitext.lang_of(lang)
kw_ = homeview._kw(giving)
pct_ = homeview._pct(20)
homeview._LANG[0] = "en"
check(f"T17 ({lang}): phases differ, cover engaged, not over: manual_cover",
why(c, lang) == exp(lang, "manual_cover", a="10", kw=kw_, pct=pct_))
for label, kw in (("floor", dict(floor=True)), ("full", dict(floor=False)),
("nocover", dict(cover=False))):
c = U(real=1, n=3, over=True, **kw)
want = ("manual_nocover" if label == "nocover" else
"manual_over" if label == "floor" else "manual_full")
check(f"T18 ({lang}): phases differ, car over ({label}): {want}",
why(c, lang) == exp(lang, want, a="10", pct=pct_))
# T19/T20 are in the World section. T21-T26: the hold, units.
for lang in LANGS:
c = U(hold=True, real=1, n=3)
t = why(c, lang)
check(f"T21 ({lang}): hold, phases differ, not given up: the hold text "
f"{t!r}", t == exp(lang, "manual_other") and OTHER[lang] in t
and STAYS[lang] not in t and YOU[lang] not in t)
for key in ("none", "full"):
c = U(hold=True, real=3, n=3)
check(f"T22 ({lang}): hold, key {key}: the hold text, not 'set when a "
f"car is connected'",
why(c, lang, key) == exp(lang, "manual_other"))
c = U(hold=True, blocked=True, real=3, n=3)
check(f"T23a ({lang}): hold with a stale blocked: the hold text",
why(c, lang) == exp(lang, "manual_other"))
c = U(hold=True, real=3, n=3, eng=True)
check(f"T23b ({lang}): hold with the cover engaged: the hold text",
why(c, lang) == exp(lang, "manual_other"))
for label, kw in (("floor", dict(floor=True)), ("full", dict(floor=False)),
("nocover", dict(cover=False))):
c = U(hold=True, over=True, real=3, n=3, **kw)
want = ("manual_nocover" if label == "nocover" else
"manual_over" if label == "floor" else "manual_full")
check(f"T24 ({lang}): hold and car over ({label}): {want}, no hold "
f"text", why(c, lang) == exp(lang, want, a="10", pct=pct_)
and OTHER[lang] not in why(c, lang))
for key in ("charging", "none"):
c = U(hold=True, auto=False, real=3, n=3)
check(f"T25 ({lang}): hold, control stopped, key {key}: manual_stopped",
why(c, lang, key) == exp(lang, "manual_stopped"))
c = U(hold=True, shadow=True, over=False, would=(10.0, 3))
check(f"T26a ({lang}): hold, shadow, not over: manual_would",
why(c, lang) == exp(lang, "manual_would", a="10",
phases=pw_l(lang, 3)))
c = U(hold=True, shadow=True, over=True, would=(10.0, 3))
check(f"T26b ({lang}): hold, shadow, over: the shadow-over text",
why(c, lang) == exp(lang, "manual_shadow_over", a="10",
phases=pw_l(lang, 3)))
# T29-T32: E4.
for lang in LANGS:
for n in (1, 3):
c = U(real=n, n=n, would=(10.0, 3))
want = (BASE_EN if lang == "en" else BASE_NL)["manual_set"].format(
a="10", phases=pw_l(lang, n))
check(f"T29 ({lang}): {n}/{n} phases: byte-identical manual_set",
why(c, lang) == want)
c = U(real=None, n=3)
check(f"T30 ({lang}): phases_allowed None: manual_set, no exception",
why(c, lang) == sett(lang, c))
c = U(real=3, n=1, fresh=False)
check(f"T32 ({lang}): reading not fresh: manual_set (stale is unknown)",
why(c, lang) == sett(lang, c))
c = U(car=Car(None, True))
check("T31a: reading None: today's text, no exception",
why(c) == sett("en", c))
rd = CH.ChargerReading(available=False, phases_allowed=1)
c = U(car=Car(rd, True, last_good=None), n=3)
check("T31b: reading unavailable (phases 1 vs 3): today's text",
why(c) == sett("en", c))
c = U(real=1, n=3, pg=None)
check("T31c: peak_guard None: no exception, the E2 text",
why(c) == exp("en", "manual_phases", a="10", phases="3 phases",
real="1 phase"))
c = U(real=1, n=3)
del c.car
check("T31d: no car object at all: no exception, today's text",
why(c) == sett("en", c))
check("T31: no exception from any of the above", not EXC)
# --------------------------------------------------------------------------- #
print("\n3. E5: the texts")
# --------------------------------------------------------------------------- #
PH = re.compile(r"\{(\w+)\}")
JARGON = {
"en": r"controllers?|control loop|setpoints?|SoC|state of charge|BMS|PV|"
r"failsafe|trip(?:ped)?|parked|discharg\w*|P1 feed|quarter-hour|"
r"payload|endpoint|JSON|API|timeout|boolean|config|commands?|"
r"charge level|ceiling|billed quarter|quarters?|banked|soft limit|"
r"open block|actuator|ESP32|master|meter source|circulating|"
r"sign disagreement|rail",
"nl": r"setpoints?|setpunt\w*|SoC|laadtoestand|BMS|PV|failsafe|regelaar|"
r"regellus|controller|latch|ontlad\w*|payload|endpoint|JSON|API|"
r"time-?out|boolean|config|kwartuur\w*|commando\w*|geparkeerd|"
r"ESP32|master",
}
JARGON = {k: re.compile(r"\b(?:" + v + r")\b", re.I) for k, v in JARGON.items()}
samples = {lang: [t for k, t in homeview.text_samples(lang) if k == "plan"]
for lang in LANGS}
for key in NEW_KEYS:
en_t = uitext.raw("en")["home_words"]["car"]["why"].get(key)
nl_t = uitext.raw("nl")["home_words"]["car"]["why"].get(key)
check(f"T33 {key}: in en.json and nl.json with the same placeholders",
isinstance(en_t, str) and isinstance(nl_t, str)
and set(PH.findall(en_t)) == set(PH.findall(nl_t)))
for lang in LANGS:
raw = jwords(lang).get(key, "")
vals = {k: "10" for k in PH.findall(raw)}
vals.update(phases=pw_l(lang, 3), real=pw_l(lang, 1))
shown = tx(lang, key, **vals)
sents = re.split(r"(?<=[.!?])\s+", shown)
nwords = [len(s.split()) for s in sents]
check(f"T33 {key} ({lang}): in text_samples as a plan line, no '{{', "
f"<=2 sentences of <=12 words ({nwords}), no jargon: {shown!r}",
shown in samples[lang] and "{" not in shown
and len(sents) <= 2 and max(nwords) <= 12
and not JARGON[lang].search(PH.sub("X", shown)))
for lang in LANGS:
base = BASE_EN if lang == "en" else BASE_NL
words = jwords(lang)
check(f"T34 ({lang}): the 9 existing manual_* texts are byte-identical",
all(words.get(k) == v for k, v in base.items()) and len(base) == 9)
# --------------------------------------------------------------------------- #
print("\n4. T35: the property sweep (both languages)")
# --------------------------------------------------------------------------- #
n_calls = 0
viol = {"i": [], "ii": [], "iii": [], "iv": []}
for (sh, ov, cv, fl, hd, au, bl, eg, sq, key, pa, cn, fr) in itertools.product(
(0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1),
(None, {"stage": "zero"}), ("charging", "waiting", "none", "full"),
(None, 1, 3), (1, 3), (0, 1)):
for lang in LANGS:
c = U(shadow=bool(sh), over=bool(ov), cover=bool(cv), floor=bool(fl),
hold=bool(hd), auto=bool(au), blocked=bool(bl), eng=bool(eg),
seq=sq, real=pa,
n=cn, fresh=bool(fr), would=(10.0, 3))
t = why(c, lang, key)
n_calls += 1
if sh and YOU[lang] in t:
viol["i"].append((lang, t))
known = pa is not None and fr
if (not sh and au and not ov
and (hd or (known and pa != cn and sq is None))
and KEEPS[lang] in t):
viol["ii"].append((lang, t))
if "{" in t or "<EXC" in t:
viol["iii"].append((lang, t))
sents = re.split(r"(?<=[.!?])\s+", t)
if len(sents) > 2 or max(len(s.split()) for s in sents) > 12:
viol["iv"].append((lang, t))
check(f"T35 (i): shadow mode, no 'You set' anywhere ({n_calls} calls)",
n_calls == 2 * 24576 and not viol["i"])
check("T35 (ii): no 'keeps it' under hold or a known, fresh phase difference",
not viol["ii"])
check("T35 (iii): no '{' left, no exception", not viol["iii"] and not EXC)
check("T35 (iv): at most 2 sentences of 12 words (the new texts' share)",
not [v for v in viol["iv"]
if any(k in v[1] for k in ("stays on", "blijft op", "Something else",
"Iets anders", "would set the peak",
"zou de piek"))])
check("T35 (vi)/N2: no render changed the writer, the car or the controller "
f"({len(N2_BAD)} did)", not N2_BAD)
# =========================================================================== #
print("\n5. Integration: a real Controller on the charger model")
# =========================================================================== #
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)
CLOCK = [1000.0]
freshness.monotonic = lambda: CLOCK[0]
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, setpoint=10, grid=800.0, phases=1):
self.sim = SimCharger(setpoint_a=setpoint)
self.sim.plug_in()
self.sim.phases_allowed = phases
self.site = Site(self.sim, grid=grid)
self.t = 1000.0
CLOCK[0] = self.t
self.c = Controller(dict(opts), self.site, _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 act(self, what, value):
return await self.c.handle_action(what, value=value)
def writes(self, what=None):
return self.sim.writes(what)
@property
def wr(self):
return self.c.car_writer
W_BAD = []
def block_why(w, lang="en"):
"""car_block's Why, with N2 and N3 held across the call."""
c = w.c
before = (snap(c), len(w.sim.log), list(w.drv.sent),
len(w.site.charger_writes()))
homeview._LANG[0] = uitext.lang_of(lang)
try:
out = homeview.car_block(c, datetime.now(timezone.utc))
t = out["why"] if out else "<no block>"
except Exception as e: # noqa: BLE001
t = f"<EXC {type(e).__name__} {e}>"
finally:
homeview._LANG[0] = "en"
after = (snap(c), len(w.sim.log), list(w.drv.sent),
len(w.site.charger_writes()))
if before != after:
W_BAD.append(t)
return t
def set_text(w, lang="en"):
return exp(lang, "manual_set", a=f"{float(w.c.car_a):.0f}",
phases=pw_l(lang, w.c.car_n))
async def ready(phases, a, to, ramp=200.0, delay=1.0, shadow="off"):
w = World(dict(CAR, shadow_mode=shadow), setpoint=a, phases=phases)
await w.step(8)
await w.act("car_phases", phases)
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
await w.act("car_phases", to)
return w
async def t8():
w = World(dict(CAR, shadow_mode="on"), setpoint=10, phases=3)
await w.step(8)
await w.act("car_phases", 3)
await w.act("car_mode", "manual")
await w.act("car_current", 16)
await w.step(80)
w.c.car_over = True
w.c.peak_guard = G(floor_limited=True)
return w, {lg: block_why(w, lg) for lg in LANGS}
w8, t8w = run(t8())
would_a = nth(w8.wr.would) if w8.wr.would else None
check("T8: shadow world, Manual 16 A, car over: shadow-over text in en and "
f"nl, no 'You set': {t8w}",
w8.c.shadow and present(would_a) and w8.wr.would is not None
and all(PEAK[lg] in t8w[lg] and YOU[lg] not in t8w[lg] for lg in LANGS)
and t8w["en"] == exp("en", "manual_shadow_over",
a=f"{float(w8.wr.would[0]):.0f}",
phases=pw(w8.wr.would[1])))
check("T8/N3: shadow world: no simulator log, no driver send, no charger "
"write", w8.sim.log == [] and w8.drv.sent == []
and w8.site.charger_writes() == [])
async def gave_up(refuse_select):
# 3 phases wanted -> the sim is on 1; or the other way, as EV-28's T11.
w = await ready(3, 16, 1, ramp=(3000.0 if refuse_select else 200.0))
if refuse_select:
w.sim.request_phases = lambda n: False
texts = {}
await w.step(40)
texts["try1"] = (w.wr.phases_gave_up, w.wr.phase_fails, block_why(w))
await w.step(int(PHASE_GAP_S) + 60)
await w.step(int(PHASE_GAP_S) + 60)
texts["end"] = (w.wr.phases_gave_up, w.wr.phase_fails, block_why(w),
block_why(w, "nl"))
return w, texts
for label, refuse in (("T11 the car keeps drawing", False),
("T12 the select is refused", True)):
w_, tt = run(gave_up(refuse))
g1, f1, why1 = tt["try1"]
ge, fe, whye, whyn = tt["end"]
want = exp("en", "manual_phases", a="16", phases="1 phase",
real="3 phases")
check(f"{label}: after the 3rd failed try the Why is the E2 text "
f"{whye!r}", ge and fe == 3 and whye == want
and whyn == exp("nl", "manual_phases", a="16",
phases=pw_l("nl", 1), real=pw_l("nl", 3))
and w_.sim.phases_allowed == 3 and KEEPS["en"] not in whye)
check(f"{label}: before the give-up (gap wait) it is manual_blocked "
f"{why1!r}", not g1 and f1 >= 1
and why1 == exp("en", "manual_blocked"))
# T19: another writer raises the current during a phase change.
async def other_in_seq():
w = World(CAR, 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)
mid = (w.wr.seq is not None, block_why(w))
w.sim.set_current(9)
got = None
for _ in range(60):
await w.step(1)
if w.wr.other:
got = (block_why(w), block_why(w, "nl"))
break
return w, mid, got
w19, mid19, got19 = run(other_in_seq())
check("T19: during the sequence the Why is today's manual_set "
f"{mid19[1]!r}", mid19[0] and mid19[1] == set_text(w19))
check("T19: the first car_block after w.other turns True is the hold text "
f"(en and nl): {got19!r}",
got19 is not None and got19[0] == exp("en", "manual_other")
and got19[1] == exp("nl", "manual_other")
and YOU["en"] not in got19[0] and KEEPS["en"] not in got19[0]
and STAYS["en"] not in got19[0])
async def t27():
w, _m, _g = await other_in_seq()
await w.act("car_current", 12)
await w.step(5)
return w, block_why(w)
w27, why27 = run(t27())
okset = {set_text(w27), exp("en", "manual_blocked"),
exp("en", "manual_phases", a="12", phases="3 phases",
real="1 phase")}
check(f"T27: the user changes the current: the hold is lifted and the hold "
f"text is gone ({why27!r})", not w27.wr.hold
and why27 != exp("en", "manual_other") and why27 in okset)
# T20 / T28: the other writer on equal phases.
async def other_equal():
w = World(CAR, setpoint=10, phases=1)
await w.step(8)
await w.act("car_phases", 1)
await w.act("car_mode", "manual")
await w.act("car_current", 10)
await w.step(10)
pre = block_why(w)
t0 = w.t
w.sim.set_current(8)
before, first, secs = [], None, None
for _ in range(60):
await w.step(1)
if w.wr.other:
first, secs = block_why(w), w.t - t0
break
before.append(block_why(w))
held_for = None
w.sim.set_current(10)
after = []
for _ in range(40):
await w.step(1)
after.append((w.wr.hold, block_why(w)))
if not w.wr.hold:
break
return w, pre, before, first, secs, after
w20, pre20, before20, first20, secs20, after20 = run(other_equal())
check("T20: before the hold the Why is today's manual_set, every step "
f"({len(before20)} steps)", pre20 == set_text(w20) and before20
and all(t == set_text(w20) for t in before20))
check(f"T20: the hold text from the first call after w.other turns True, "
f"{secs20} s after the write (<= WRITER_S + 5 = 35)",
first20 == exp("en", "manual_other") and secs20 is not None
and secs20 <= carmode.WRITER_S + 5.0)
check("T28: the other writer puts the current back: the hold clears and the "
"Why is manual_set in the same step",
len(after20) >= 1 and not after20[-1][0]
and after20[-1][1] == set_text(w20) and len(after20) <= 5)
# N2/N3 over every World call above.
check(f"N2/N3: every car_block call in the World rows changed nothing and "
f"sent nothing ({len(W_BAD)} did)", not W_BAD)
print()
if fails:
print(f"{len(fails)} FAILED")
sys.exit(1)
print("all ok")
+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")