Compare commits

...
17 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
ems-agentandClaude 77684ecfad EV-19 review round 2: pin the 50 W blind band and the car term of the stillness test
checks / unit (pull_request) Successful in 25m14s
infra-pin / fresh (pull_request) Failing after 1s
Test-only. Two unit checks in test_ev19.py: an honest step with a burst
that moves the meter's house side +/-60 W alarms in base's cycle, and
inside the band (0 W) the car explains at most the step's own cycle;
a car step offset by a burst at the meter is not discounted. They kill
RISE_STILL_W = 500 W and a stillness test without the car term.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w
2026-11-20 23:14:09 +01:00
ems-agentandClaude c2bb32ec93 EV-19 review round 1: discount a battery rise only while the meter has not moved
checks / unit (pull_request) Successful in 31m32s
infra-pin / fresh (pull_request) Failing after 1s
[Major] The rise discount applied to any rise, also one the meter
already shows, so an honest house step answered by one cycle of battery
power alarmed one cycle after base (review repro: T6 step + burst, R+6
instead of R+5). Now a reading above both earlier ones is discounted only
while the meter's house side (held - car; held alone when a car figure is
unknown) moved no more than RISE_STILL_W (50 W) since the last cycle.

Tests: the burst shapes (unit, meter in step and one cycle late;
controller, step at R+5 and R+30, 3 000 / 4 600 W) at base's second; the
"N6 unit" check tightened to the rise cycle; the RISE_STILL_W boundary;
a pin on EV-18's `_car_over_now` (mC); T10 restarts at R-1 and R (mE).
test_ev19: 144 of 144 here, 52 red on 43b0db7.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w
2026-11-20 22:13:19 +01:00
ems-agentandClaude 4950a2374f EV-19: no floor alarm when the batteries first reach the reserve early in a Manual car session
checks / unit (pull_request) Successful in 25m47s
infra-pin / fresh (pull_request) Failing after 2s
EV-15 rig F-B, reproduced on 43b0db7 (tools/ev19_reserve.py, T1 grid). At
the reserve inverter-b goes on following the house, so its output rises
in that cycle. The battery reading shows the rise one cycle before the P1
sample does, and EV-18's house figure (held - car + now - min(now, prev))
counted the new battery power as house load. `_car_need_house` latched:
one PEAK_GUARD_FLOOR_LIMITED ERROR and goodwe_peak_soc_floor at R+1, red
until the guard stopped wanting power.

ctl_car._car_explains_alarm: for the house latch only, a reading above
both earlier readings counts as house only up to the higher of them. The
credit stays the lower of the last two readings. The claim, floor,
setpoints and charger writes are unchanged (342 runs, same digests).

test_ev19.py: T1-T17, T20, N1-N6 of reports/EV-19-test-plan.md; 49
checks red on 43b0db7, 124 of 124 green here.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w
2026-11-20 20:16:25 +01:00
ems-agent 43b0db73d2 Merge pull request 'EV-18: no floor alarm at a quarter's start while the car explains the excess' (#264) from EV-18 into release/1.0
infra-pin / fresh (push) Successful in 1s
2026-11-19 15:13:33 +01:00
13 changed files with 4144 additions and 33 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),
@@ -152,6 +164,17 @@ up to 1.8 kW; the 40 Wh floor fixes that.)
whole window and fell short; an unknown reading is no contradiction) grades
no alarm to the quarter's end; the guard's input keeps it. After a restart
or a gap the car's earlier energy is not known, so it counts as house.
- **A battery rise the meter has not shown is not house yet** (EV-19, EV-15
rig F-B). At the reserve inverter-b goes on following the house, so its
output rises; the reading shows it one cycle before P1 does, and the house
figure (meter + battery) counted that power as house. `_car_need_house`
latched and the alarm stood. Now, while the meter's house side (held - car)
moved no more than `RISE_STILL_W` since the last cycle, a reading above both
earlier ones counts only up to the higher of them. A meter that moved shows
the rise (an honest step with a battery burst alarms at once, as before). A
rise the meter does not move with at all is graded as F-B: the one case the
readings cannot tell apart. The credit stays the lower of the last two
readings; `_car_over_now` is unchanged.
- **Our own write is ours until its mute ends** (EV-12). The mute of the tracker's
own detector opens before the write and runs 15 s from when it returns, because
the read-back reaches the cycle while the write still waits for it.
+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)
+54 -2
View File
@@ -31,6 +31,9 @@ OVER_OFF_HOLD_S = 180.0
OWN_PAUSE_MAX_S = (carmode.ZERO_WAIT_S + carmode.SETTLE_S
+ carmode.MAX_TRIES * 15.0 + 10.0)
OWN_PAUSE_TAIL_S = chargers.CORR_WINDOW_S
# EV-19: the meter's house side (held - car) moved no more than this since the
# last cycle: it has not shown a battery rise the reading already shows.
RISE_STILL_W = 50.0
class CarMixin:
@@ -58,7 +61,10 @@ 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_batt_prev = 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
self._car_need_house = self._car_over_now = False # EV-18 latches
self._car_latch_block = None
@@ -394,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
@@ -414,6 +447,7 @@ class CarMixin:
when the guard no longer wants power, whatever the cover option says
(this runs every cycle). DECISIONS/EV-04-manual-mode.md (EV-18)."""
now, prev = self.site_batt_w, self._car_batt_prev
prev2, self._car_batt_prev2 = self._car_batt_prev2, prev
self._car_batt_prev = now
wants = bool(guard is not None and guard.engaged
and guard.blind is None
@@ -426,6 +460,23 @@ class CarMixin:
if batt is not None and prev is not None:
batt = min(float(batt), float(prev))
excl = self.car_exclude_alarm(real_proj, w)
# EV-19: the reading can show a rise one cycle before the meter does
# (the batteries pick up the house at the reserve). While the meter's
# house side (held - car; held alone when a car figure is unknown) has
# not moved, a reading above both earlier ones is not yet counted as
# house; a meter that moved shows it (no discount).
held = float(real_proj.held_w)
hp, self._car_hx_prev = self._car_hx_prev, (held, w)
still = False
if hp is not None:
moved = held - hp[0]
if w is not None and hp[1] is not None:
moved -= float(w) - float(hp[1])
still = abs(moved) <= RISE_STILL_W
seen = now
if still and now is not None and prev is not None \
and prev2 is not None:
seen = min(float(now), max(float(prev), float(prev2)))
if wants and batt is not None:
self._car_need_real = self._car_need_real or \
peakguard.misses_aim(real_proj, batt_w=batt,
@@ -436,7 +487,7 @@ class CarMixin:
self._car_need_excl = self._car_need_excl or \
peakguard.misses_aim(excl, batt_w=batt, target_w=target_w)
self._car_need_house = self._car_need_house or \
self._car_lands_over(excl, now, batt, target_w)
self._car_lands_over(excl, seen, batt, target_w)
if w is None or batt is None or not wants \
or not (guard.saturated or guard.floor_limited):
return False
@@ -475,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)
+654
View File
@@ -0,0 +1,654 @@
"""EV-19: no floor alarm when the batteries first reach the peak reserve early
in a Manual car session (EV-15 rig F-B). `python3 -B test_ev19.py`
The rig: one PEAK_GUARD_FLOOR_LIMITED ERROR, one `goodwe_peak_soc_floor` and
one red sample the moment the batteries reached the reserve, while the excess
was smaller than the car. Reproduced (T1): at the reserve inverter-b goes on
following the house, so its output RISES in that cycle. The battery reading
shows the rise one cycle before the P1 sample does, and EV-18's "house"
(meter + what the batteries give now) counted the new battery power as house
load. That latched `_car_need_house` for the quarter: the alarm stood until
the guard stopped wanting power. Now a rise the reading shows above both
earlier readings is not counted as house until a second reading confirms it.
The credit stays the lower of the last two readings.
T-ids are the test plan's (reports/EV-19-test-plan.md). "base" is 43b0db7.
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
"""
import os
import sys
from datetime import datetime, timedelta, timezone
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(HERE, "tools"))
from app import ctl_car, tariff # noqa: E402
from named_absence import first, nth, present # noqa: E402
import ev19_reserve as V # noqa: E402
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
AIM = V.AIM
CAR = V.CAR
# =========================================================================== #
print("1. UNIT: car_cycle in the reserve cycle (a real `_carq`)")
# =========================================================================== #
BS = datetime(2026, 11, 20, 20, 30, tzinfo=timezone.utc) # a quarter edge
class _Car(ctl_car.CarMixin):
def __init__(self):
self.o = {"ev_batt_cover": True}
self.w = CAR
self._now = 0.0
self.site_batt_w, self.site_rating_w = 0.0, 9600.0
self.store = type("S", (), {"data": {}, "set": lambda s, k, v: 0})()
self.car_init({}, self.store)
def car_now(self):
return self._now
def car_alarm_w(self):
return self.w
class car: # noqa: N801
@staticmethod
def status(*_a):
return "charging"
class _G:
"""Floor-limited, the floor leaves nothing (floor_w 0), wants power."""
floor_limited, saturated = True, False
floor_w, able_w, ceiling_w = 0.0, None, AIM + 50.0
engaged, blind, wanted_w, within_aim = True, None, 300.0, False
def urun(secs, grid, batt, w=lambda t: CAR):
"""`car_cycle` once per second of `secs` (seconds from the edge). `grid(t)`
is the meter, `batt(t)` the site battery reading. {t: car_explains}."""
c = _Car()
done, out = {}, {}
for t in secs:
q = t // 900
bs, el = BS + timedelta(seconds=900 * q), t - 900 * q
g = float(grid(t))
d = done.get(bs, g * el)
p = tariff.Projection(
projected_w=(d + g * (900 - el)) / 900.0,
elapsed_w=(d / el if el else g), elapsed_s=float(el),
covered_frac=1.0, complete=False, block_start=bs, held_w=g)
done[bs] = d + g
c._now = 10000.0 + t
c.w, c.site_batt_w = w(t), batt(t)
c.car_cycle(p, _G(), AIM, None)
out[t] = c.car_explains
return out
def run_of(d, t0, t1):
return [d[t] for t in sorted(d) if t0 <= t <= t1]
def rise(at, lo, hi):
"""A battery reading that steps from `lo` to `hi` at `at`."""
return lambda t: lo if t < at else hi
def meter(house, b, lag=1):
"""The P1 figure: house + car - what the batteries gave `lag` cycles ago
(the reading leads the meter by that much)."""
return lambda t: house + CAR - b(t - lag)
HB = AIM + 520.0 - CAR # F-B: house + car at batteries 0 W = aim + 520
b2 = rise(1, 0.0, 4600.0)
u2 = urun(range(-5, 61), meter(HB, b2), b2)
print(f" T2 unit E-1..E+3: {run_of(u2, -1, 3)}")
check("T2 unit: b starts following the house at the reserve (0 -> 4 600 W) "
"and the reading shows it one cycle before the meter: the car explains "
"every cycle, the rise cycle E+1 among them (base: not from E+1)",
all(run_of(u2, 0, 60)) and len(run_of(u2, 0, 60)) == 61)
u2s = urun(range(-5, 61), meter(HB, b2, lag=0), b2)
check("T2 unit: the same rise with the meter in step: explained every cycle",
all(run_of(u2s, 0, 60)) and len(run_of(u2s, 0, 60)) == 61)
# T4: the landing without the car at aim + 9 / + 11 W in the rise cycle. The
# rise is at the edge, so with the lower reading credited (0 W) the house
# alone lands at exactly `house`.
b4 = rise(0, 0.0, 800.0)
u409 = urun(range(-3, 10), meter(AIM + 9.0, b4), b4)
u411 = urun(range(-3, 10), meter(AIM + 11.0, b4), b4)
print(f" T4 unit +9 {run_of(u409, 0, 3)} +11 {run_of(u411, 0, 3)}")
check("T4 unit: the house alone at aim + 9 W in the rise cycle: the car "
"explains from E+0 (base: no)", all(run_of(u409, 0, 9))
and len(run_of(u409, 0, 9)) == 10)
check("T4 unit: at aim + 11 W it does not, from E+0 (as base)",
not any(run_of(u411, 0, 9)) and len(run_of(u411, 0, 9)) == 10)
# N6 / T7(a): an unknown reading credits nothing; the lower reading is
# credited, not the higher or the last known one.
b7 = lambda t: None if t == 1 else b2(t) # noqa: E731
u7 = urun(range(-5, 30), meter(HB, b2), b7)
check("T7(a) unit: the battery reading unknown in the rise cycle: nothing "
"explained in that cycle (no last-known W), explained from the next",
u7.get(1) is False and u7.get(0) is True and all(run_of(u7, 2, 29)))
u6 = urun(range(-5, 30), meter(AIM + 11.0 + 400.0, lambda t: 400.0, lag=0),
lambda t: 800.0 if t == 3 else 400.0)
check("N6 unit: b at 400 W, the house alone with it at aim + 11 W, one "
"reading of 800 W at E+3: not explained in any cycle",
not any(run_of(u6, 0, 29)))
# A house step that comes with a battery rise: b steps to 800 W and the
# meter, one cycle late, shows a house of aim + 811 W, so with b's 800 W the
# house alone misses by 11 W. The meter moved, so nothing is discounted.
b8 = rise(5, 0.0, 800.0)
u8 = urun(range(0, 30), lambda t: (AIM - 500.0 if t < 5 else AIM + 811.0)
+ CAR - b8(t - 1), b8)
print(f" N6 unit house step with a rise E+4..E+8: {run_of(u8, 4, 8)}")
check("N6 unit: a house step that comes with a battery rise is latched in "
"the rise cycle (E+5, as base), and stays latched",
all(run_of(u8, 0, 4)) and not any(run_of(u8, 5, 29)))
# Review round 1 (Major): an honest house step at E+5 answered by ONE reading
# of battery power, the meter in step (it shows the burst too) or one cycle
# late. Not explained from E+5, the step's own cycle, as base.
for H, burst, lag in ((2000.0, 4600.0, 0), (1900.0, 3000.0, 0),
(5000.0, 4600.0, 0), (2000.0, 4600.0, 1),
(1900.0, 3000.0, 1)):
hs = (lambda t, H=H: AIM - 500.0 if t < 5 else AIM + H)
bb = (lambda t, burst=burst: burst if t == 5 else 0.0)
ub = urun(range(0, 15), lambda t, hs=hs, bb=bb, lag=lag:
hs(t) + CAR - bb(t - lag), bb)
check(f"RB unit: house -> aim + {H:.0f} W at E+5 with one {burst:.0f} W "
f"reading, meter {'in step' if lag == 0 else 'one cycle late'}: "
f"explained to E+4, not from E+5 (base: the same)",
ub.get(4) is True and not any(run_of(ub, 5, 14))
and len(run_of(ub, 5, 14)) == 10)
# The discount needs a still meter: the F-B rise (T2 unit) with the house
# side of the meter moving by RISE_STILL_W -/+ 10 W in the rise cycle.
STILL = getattr(ctl_car, "RISE_STILL_W", 50.0) # 43b0db7 has none
for d, want in ((STILL - 10.0, True), (STILL + 10.0, False)):
ud = urun(range(-5, 10), lambda t, d=d: HB + (d if t >= 1 else 0.0)
+ CAR - b2(t - 1), b2)
check(f"RISE_STILL_W: the meter's house side moves {d:.0f} W in the rise "
f"cycle: {'still, the rise is not yet house (explained)' if want else 'moved, the rise counts as house (not explained, as base)'}",
ud.get(1) is want and ud.get(0) is True)
# Review round 2: the blind band in absolute W (the owner's 50 W; change this
# check with the owner). An honest step at E+5 (house aim - 500 -> aim + 1 900
# W, more than the car) with one burst that leaves the meter's house side
# moving d W: at |d| = 60 the alarm cycle is base's (E+5); inside the band
# (d = 0) the car explains at most the step's own cycle, never from E+6.
for dd in (60.0, -60.0, 0.0):
hb = (lambda t: AIM - 500.0 if t < 5 else AIM + 1900.0)
bd = (lambda t, B=2400.0 - dd: B if t == 5 else 0.0)
ubd = urun(range(0, 15), lambda t, hb=hb, bd=bd: hb(t) + CAR - bd(t), bd)
print(f" band d={dd:+.0f} W E+4..E+8: {run_of(ubd, 4, 8)}")
t0 = 5 if dd else 6
check(f"band: an honest step whose burst moves the meter's house side "
f"{dd:+.0f} W: not explained from E+{t0}",
ubd.get(4) is True and not any(run_of(ubd, t0, 14))
and len(run_of(ubd, t0, 14)) == 15 - t0)
# Review round 2: the stillness test uses the house side (held - car). The car
# steps 1 380 -> 2 760 W, the house aim - 500 -> aim + 3 000 W (more than the
# car) and b gives one reading of 4 880 W, all at E+5, meter in step: the
# meter's total stays, its house side drops 1 380 W, so nothing is discounted.
hc = (lambda t: AIM - 500.0 if t < 5 else AIM + 3000.0)
wc = (lambda t: CAR if t < 5 else 2 * CAR)
bc5 = (lambda t: 4880.0 if t == 5 else 0.0)
ucw = urun(range(0, 15), lambda t: hc(t) + wc(t) - bc5(t), bc5, w=wc)
check("car term: the car steps up with the house and a burst, the meter's "
"total still: not explained from E+5 (as base)",
ucw.get(4) is True and not any(run_of(ucw, 5, 14))
and len(run_of(ucw, 5, 14)) == 10)
# Review round 1 (mC): EV-18's `_car_over_now` keeps the reading as it is. b
# gives 2 000 W, the house alone with it lands under the aim and the period
# with the car too, so nothing explains; b rises to 4 000 W at E+5 one cycle
# before the meter: the period with the car on the reading as it is lands
# over, so the car explains from E+5.
bc = rise(5, 2000.0, 4000.0)
uc = urun(range(0, 15), lambda t: AIM + 500.0 + CAR - bc(t - 1), bc)
print(f" over_now unit E+3..E+7: {run_of(uc, 3, 7)}")
check("over_now unit: `_car_over_now` grades the undiscounted reading: not "
"explained E+0..E+4, explained from the rise cycle E+5",
not any(run_of(uc, 0, 4)) and all(run_of(uc, 5, 14))
and len(run_of(uc, 5, 14)) == 10)
# =========================================================================== #
print("\n2. THE REAL CONTROLLER AT THE RESERVE (N=2, tools/ev19_reserve.py)")
# =========================================================================== #
JOBS = V.jobs()
RES = V.run_many(JOBS)
def res(name):
return RES[name]
def trusted(x):
return x["w"] is not None and x["w"] > 0.0 and not x["contra"]
def bad(x):
return bool(x["alarm"] or x["red"] or x["err"])
def hits(r, t0=-10, t1=60):
"""T1's reproduction: an alarm, red sample or ERROR in R-10..R+60 in a
cycle where the car figure is trusted (every T1 shape lands under the aim
without the car, so the car explains there)."""
return [int(x["t"] - r.R) for x in r.win(t0, t1) if bad(x) and trusted(x)]
def show(name):
r = res(name)
print(f" {name}: alarms {r.rel_alarms()} edges {r.edges()} errors "
f"{r.errors()} red {len(r.red())} s cmd {r.cmd}")
# Measured on base 43b0db7 with this file's own runs: the seconds from R of
# goodwe_peak_soc_floor in the honest shapes, which must not come later now.
BASE_ALARMS = {
"T4 +11 manual": [0, 857], "T5 t1 manual": [2], "T5 t4 manual": [11],
"T5 tau5 manual": [2], "T6 step R+0 manual": [2],
"T6 step R+1 manual": [2], "T6 step R+5 manual": [6],
"T7(a) T5": [2], "T7(b) T5": [2], "T8(c) frozen, the car stops": [2],
"T9(a) T5 b lost at R": [2], "T9(a) T5 b lost at R-1": [2],
"T9(b) T5 P1 5 s late at R": [5], "T10 T5 twin": [2],
"T10 T5 restart R-2": [2], "T10 T5 restart R+2": [2],
"T10 T5 restart R-1": [2], "T10 T5 restart R+0": [2],
"T10 T2 restart R+0": [1],
"T11 T5 R=E-1": [2], "T11 T5 R=E+0": [0, 2], "T11 T5 R=E+1": [0, 2],
"T11 T5 R=E+43": [2], "T12 T5 1->3 at R-15": [2],
"T12 T5 1->3 at R+5": [2], "T13(a) draws 100 W manual": [0, 857],
"T14(c) N=1 T5": [2], "T15 honest manual": [13],
"T16 x10 T5 manual": [20], "T16 x10 T6 manual": [20],
"T16 mono1 T5 manual": [20], "T16 mono1 T6 manual": [20],
"T16 x10 T11 T5 R=E-10": [20], "T16 x10 T11 T5 R=E+0": [0, 20],
"T16 x10 T11 T5 R=E+10": [0, 20], "T16 x10 T11 T5 R=E+40": [20],
"T16 mono1 T11 T5 R=E-10": [20], "T16 mono1 T11 T5 R=E+0": [0, 20],
"T16 mono1 T11 T5 R=E+10": [0, 20], "T16 mono1 T11 T5 R=E+40": [20],
"T16 mono1 T3 t1 bw=0": [600], "T16 mono1 T3 t1 bw=2000": [700],
"T16 mono1 T3 t1 bw=4250": [800], "T16 mono1 T3 t4 bw=0": [600],
"T16 mono1 T3 t4 bw=2000": [700], "T16 mono1 T3 t4 bw=4250": [800],
}
# The T1 cells that reproduce F-B on base (G0): b following the house from R.
BASE_REPRO = [f"T1 core bw={bw} t2 rp={rp}" for bw in (0, 400, 800)
for rp in (30, 100, 110, 180, 600)] + [
"T1 d: x10 wall+mono t2 bw=1200", "T1 d: x10 wall, mono x1 t2 bw=1200"]
def as_base(k):
"""The same alarm seconds as base."""
return res(k).rel_alarms() == BASE_ALARMS[k]
# --- T1: the reproduction grid ------------------------------------------------ #
T1 = sorted(k for k in JOBS if k.startswith("T1 "))
C5 = [k for k in T1 if k.startswith("T1 b: energy")]
rep = {k: hits(res(k)) for k in T1}
print(f" T1 cells {len(T1)}; reproducing on this tree: "
f"{sorted(k for k in T1 if rep[k])}")
check("T1: no grid cell reproduces F-B: no notice, ERROR or red sample in "
"R-10..R+60 while the car figure is trusted (base: the "
f"{len(BASE_REPRO)} tau2 cells with b at 0-800 W at R)",
not [k for k in T1 if rep[k]])
for k in C5:
show(k)
check("T1 C5 cells (the energy meter late or never stepping): the figure is "
"untrusted (contradicted or unknown) wherever the alarm stands, as EV-18 "
"Expected 5 wants", all(not trusted(x) for k in C5
for x in res(k).win(-10, 60) if bad(x)))
# --- T2: THE red-before test -------------------------------------------------- #
T2 = BASE_REPRO
for k in T2:
r = res(k)
lim = [x for x in r.win(0, 60) if x["floor_lim"]]
check(f"T2 {k[3:]}: no notice, no ERROR, no red sample R-60..R+900; the "
f"car explains every floor-limited cycle of R..R+60",
r.quiet(-60, 900) and bool(lim) and all(x["explains"] for x in lim))
check("T2 PRECONDITION: every reproducing cell is in the grid (b at 0, 400, "
"800 W x 5 plug-in times; x10 and mono x1 with b at 1 200 W)",
len(T2) == 17 and all(k in RES for k in T2))
r2 = res("T1 core bw=0 t2 rp=180")
x1 = r2.at(1)
check("T2 PRECONDITION: in the rise cycle the reading shows b's 4 600 W, the "
"guard is floor-limited and wants power",
present(x1) and x1["batt"] == 4600.0 and x1["floor_lim"]
and x1["wants"])
# --- T3: the battery W sweep --------------------------------------------------- #
T3 = sorted(k for k in JOBS if k.startswith("T3 "))
loud = [k for k in T3 if not res(k).quiet(-60, 900)]
print(f" T3 cells {len(T3)}, with an alarm or red sample: {loud}")
check("T3: tau1 and tau2, b at R 0..4 600 W in 200 W steps and 9 600 W "
"(tau5): no alarm and no red sample in any cell", loud == [])
# --- T4 controller ------------------------------------------------------------- #
for k in ("T4 +9 manual", "T4 +11 manual", "T4 +11 off"):
show(k)
check("T4: the house alone at aim + 9 W, b following the house from R: no "
"alarm (base: R+1)", res("T4 +9 manual").quiet(-60, 900))
check("T4: at aim + 11 W the alarm in the same cycle as base and as Off "
"(R+0)", as_base("T4 +11 manual")
and res("T4 +11 manual").rel_alarms()[:1]
== res("T4 +11 off").rel_alarms()[:1] == [0])
# --- T5 / T6: honest alarms ---------------------------------------------------- #
def same_as_off(k):
on, off = res(f"{k} manual"), res(f"{k} off")
show(f"{k} manual")
show(f"{k} off")
a = on.rel_alarms()
return (bool(a) and a == off.rel_alarms()
and on.errors() == off.errors())
for k in ("T5 t1", "T5 t4", "T5 tau5"):
check(f"{k}: the excess is more than the car: PEAK_GUARD_FLOOR_LIMITED, "
f"the ERROR and the notice at the same second as Off and as base",
same_as_off(k) and as_base(f"{k} manual"))
check(f"{k}: the car explains no cycle",
not any(x["explains"] for x in res(f"{k} manual").tr))
for n in (0, 1, 5):
k = f"T6 step R+{n}"
show(f"{k} manual")
check(f"{k}: the house steps to aim + 1 900 W at R+{n}: the alarm and "
f"the ERROR at the same second as base, R+{BASE_ALARMS[k + ' manual'][0]}"
f" (no grace, no hold; Off alarms from R+0, where the car explains)",
as_base(f"{k} manual") and res(f"{k} manual").errors()
== BASE_ALARMS[f"{k} manual"])
# --- T7: unknown values -------------------------------------------------------- #
def only_while_unknown(r, t0=-60, t1=900):
"""Every alarm / red cycle has an untrusted car figure in it or in the
cycle before (the alarm clears within 1 cycle of the first trusted one)."""
prev = None
for x in r.win(t0, t1):
if bad(x) and trusted(x) and (prev is None or trusted(prev)):
return False
prev = x
return True
show("T7(a) T2")
check("T7(a) T2: inverter-a's reading unknown at R and R+1: no alarm",
res("T7(a) T2").quiet(-60, 900))
check("T7(a) T5: the alarm at the same second as base and as Off (the "
"guard grades nothing without the reading)", as_base("T7(a) T5")
and res("T7(a) T5").rel_alarms() == res("T7(a) T5 off").rel_alarms())
show("T7(b) T2")
check("T7(b) T2: the charger unavailable at R: an alarm only while the "
"figure is unknown, cleared within 1 cycle of the first trusted one",
only_while_unknown(res("T7(b) T2")))
check("T7(b) T5: the alarm at the same second as base and as Off",
as_base("T7(b) T5")
and res("T7(b) T5").rel_alarms() == res("T7(b) T5 off").rel_alarms())
# --- T8: a stale car figure ---------------------------------------------------- #
r8a = res("T8(a) Off 120 s, Manual R-5")
show("T8(a) Off 120 s, Manual R-5")
check("T8(a): nothing before Manual is trusted (car_alarm_w None)",
all(x["w"] is None for x in r8a.tr if x["t"] < r8a.R - 5))
check("T8(a): after Manual, as T2: no alarm R-60..R+900",
r8a.quiet(-60, 900))
r8b = res("T8(b) stale R-5..R+20")
show("T8(b) stale R-5..R+20")
check("T8(b) PRECONDITION: the figure goes untrusted (older than 15 s)",
any(x["w"] is None for x in r8b.win(0, 25)))
check("T8(b): the alarm only while the figure is stale, cleared within 1 "
"cycle of the first fresh one", only_while_unknown(r8b))
r8c, r8co = res("T8(c) frozen, the car stops"), res("T8(c) off")
show("T8(c) frozen, the car stops")
a8 = nth(r8c.rel_alarms(), 0)
untr = first(int(x["t"] - r8c.R) for x in r8c.tr
if x["t"] >= r8c.R - 30 and not trusted(x))
check("T8(c): the alarm at base's second, as Off, within 114 s of the stop",
present(a8) and a8 <= -30 + 114
and as_base("T8(c) frozen, the car stops")
and r8c.rel_alarms() == r8co.rel_alarms())
check("T8(c): never explained after the figure goes untrusted",
present(untr) and not any(x["explains"] for x in r8c.tr
if x["t"] >= r8c.R + untr))
# --- T9: comms ------------------------------------------------------------------ #
for nm in ("T2", "T5"):
for k in (f"T9(a) {nm} b lost at R", f"T9(a) {nm} b lost at R-1",
f"T9(b) {nm} P1 5 s late at R"):
show(k)
r = res(k)
if nm == "T2":
check(f"{k}: no alarm edge", r.edges() == [])
else:
check(f"{k}: the alarm at the base second "
f"(R+{BASE_ALARMS[k][0]})", as_base(k))
# --- T10: a restart ------------------------------------------------------------ #
for nm in ("T2", "T5"):
tw = res(f"T10 {nm} twin")
for k in (-2, -1, 0, 2):
r = res(f"T10 {nm} restart R{k:+d}")
show(f"T10 {nm} restart R{k:+d}")
if nm == "T2" and k == 0:
# the rise cycle R+1 has no reading from two cycles back: nothing
# is discounted (the old behaviour), so the alarm is base's
check("T10 T2 restart at R+0: no reading two cycles back in the "
"rise cycle, so no discount: the alarm as base (R+1)",
as_base("T10 T2 restart R+0"))
elif nm == "T2":
check(f"T10 T2 restart at R{k:+d}: no notice, no red sample, as "
f"the unrestarted twin", r.quiet(-60, 900)
and tw.quiet(-60, 900))
else:
check(f"T10 T5 restart at R{k:+d}: the alarm at the base second "
f"and the twin's, red as the twin",
as_base(f"T10 T5 restart R{k:+d}") and as_base("T10 T5 twin")
and len(r.red()) == len(tw.red()))
# --- Review round 1 (Major), controller: the T6 step with a one-cycle burst ---- #
for k in (5, 30):
for hi in (1900, 2500):
for burst in ("3000", "4600"):
nm = f"RB step R+{k} aim+{hi} burst {burst} manual"
r = res(nm)
show(nm)
check(f"{nm[:-7]}: P1 and the reading both show the burst: the "
f"notice, the ERROR and the first red sample at the step, "
f"R+{k}, as base", r.rel_alarms() == [k]
and r.errors() == [k] and r.red()[:1] == [k])
# --- T11: the quarter edge ------------------------------------------------------ #
for rr in (-1, 0, 1, 43):
r = res(f"T11 T2 R=E{rr:+d}")
show(f"T11 T2 R=E{rr:+d}")
wa = [(int(x["t"] - r.E), x["within_aim"]) for x in r.tr
if r.E - 1 <= x["t"] <= r.E]
print(f" T11 T2 R=E{rr:+d}: within_aim at E-1/E+0 {wa} (F1, not "
f"asserted)")
check(f"T11 T2 R=E{rr:+d}: no alarm across the edge", r.quiet(-60, 900))
check(f"T11 T5 R=E{rr:+d}: the alarm at the same seconds as base and "
f"as Off", as_base(f"T11 T5 R=E{rr:+d}")
and res(f"T11 T5 R=E{rr:+d}").rel_alarms()
== res(f"T11 T5 R=E{rr:+d} off").rel_alarms())
pre = res("T11 C4 T2 R=E+1")
show("T11 C4 T2 R=E+1")
wa = [(int(x["t"] - pre.E), x["within_aim"]) for x in pre.tr
if pre.E - 1 <= x["t"] <= pre.E]
print(f" T11 C4: within_aim at E-1/E+0 {wa} (F1, not asserted)")
check("T11 C4 PRECONDITION: the guard wants power in the last 60 s of the "
"old quarter (house 13 350 W all along, car 1 380 W)",
all(x["wants"] for x in pre.tr if pre.E - 60 <= x["t"] < pre.E))
sat = [x for x in pre.win(-60, -1) if x["red"]]
print(f" T11 C4: red before R {[int(x['t'] - pre.R) for x in sat]} (near "
f"the old quarter's end, the guard saturated: SAFETY-81's row)")
check("T11 C4: SAFETY-126's latch carried over the edge, the reserve at "
"E+1: no floor notice or ERROR R-60..R+900, no red sample from R; "
"before R red only where the guard is saturated (not the floor alarm)",
pre.quiet(0, 900) and not [t for t in pre.rel_alarms() if t >= -60]
and all(x["lim"] and not x["floor_lim"] and not x["alarm"]
for x in sat))
# --- T12: our own phase change -------------------------------------------------- #
for k in (-15, 5):
r = res(f"T12 T2 1->3 at R{k:+d}")
show(f"T12 T2 1->3 at R{k:+d}")
check(f"T12 T2, 1->3 at R{k:+d}: no alarm during our own pause or after",
r.quiet(-60, 900))
on, off = res(f"T12 T5 1->3 at R{k:+d}"), res(f"T12 T5 1->3 at R{k:+d} off")
show(f"T12 T5 1->3 at R{k:+d}")
a, ao = nth(on.rel_alarms(), 0), nth(off.rel_alarms(), 0)
check(f"T12 T5, 1->3 at R{k:+d}: the alarm at base's second, no later "
f"than Off's and within OWN_PAUSE_MAX_S "
f"({ctl_car.OWN_PAUSE_MAX_S:.0f} s) of the request",
present(a, ao) and a <= ao and as_base(f"T12 T5 1->3 at R{k:+d}")
and a <= max(k, 0) + ctl_car.OWN_PAUSE_MAX_S)
# --- T13: a wrong charger reply ------------------------------------------------- #
r13 = res("T13(a) draws 400 W manual")
show("T13(a) draws 400 W manual")
check("T13(a) 400 W: the energy meter never contradicts a 1 380 W figure "
"when 400 W is drawn (CORR_RATIO 0.5 and its slack; EV-18 T9(b)), so "
"nothing is uncorroborated and the figure explains; base's R+1 alarm "
"was F-B", not any(x["contra"] for x in r13.tr)
and all(x["w"] == CAR for x in r13.win(-60, 60)))
r13c = res("T13(a) draws 100 W manual")
show("T13(a) draws 100 W manual")
show("T13(a) draws 100 W off")
c0 = first(x["t"] for x in r13c.tr if x["contra"])
a13 = nth(r13c.rel_alarms(), 0)
check("T13(a) 100 W PRECONDITION: the energy meter contradicts the figure "
"within 104 + 10 s of the plug-in (R-180)",
present(c0) and c0 <= r13c.R - 180 + 114)
check("T13(a) 100 W: the alarm at base's second and Off's, and never "
"explained after the contradiction in that quarter",
present(a13) and as_base("T13(a) draws 100 W manual")
and r13c.rel_alarms() == res("T13(a) draws 100 W off").rel_alarms()
and not any(x["explains"] for x in r13c.tr
if present(c0) and x["t"] >= c0
and x["block"] == r13c.at(0)["block"]))
for k in ("T13(b) the write ignored, 0 A", "T14(a) 0 W in C",
"T14(a) idle B"):
show(f"{k} manual")
check(f"{k}: the car at 0 W explains nothing: the alarm as Off",
same_as_off(k) and not any(
x["explains"] for x in res(f"{k} manual").tr))
# --- T14: configuration -------------------------------------------------------- #
show("T14(b) ev_charger off")
check("T14(b) ev_charger off: no explanation, the alarm as Off",
res("T14(b) ev_charger off").rel_alarms()
== res("T14(b) off").rel_alarms() != []
and not any(x["explains"] for x in res("T14(b) ev_charger off").tr))
for tj in ("t1", "t4"):
show(f"T14(c) N=1 anchor {tj}")
check(f"T14(c) N=1 anchor {tj}: no alarm",
res(f"T14(c) N=1 anchor {tj}").quiet(-60, 900))
check("T14(c) N=1 T5: the alarm at the same second as base and as Off",
as_base("T14(c) N=1 T5") and res("T14(c) N=1 T5").rel_alarms()
== res("T14(c) N=1 T5 off").rel_alarms())
# --- T15: one battery first ----------------------------------------------------- #
for k in ("T15 anchor manual", "T15 honest manual", "T15 honest off"):
show(k)
check("T15 anchor: a at the reserve at R, b at R+360: no alarm",
res("T15 anchor manual").quiet(-60, 900))
check("T15 honest (house 19 000 W): the alarm after ALARM_HOLD_S at the "
"base second (R+13; Off R+11, as base)", as_base("T15 honest manual"))
# --- T16: x10 -------------------------------------------------------------------- #
for xn in ("x10", "mono1"):
r = res(f"T16 {xn} T2")
show(f"T16 {xn} T2")
check(f"T16 {xn} T2 PRECONDITION: the rise cycle reads b's 4 600 W",
present(r.at(10)) and r.at(10)["batt"] == 4600.0)
check(f"T16 {xn} T2: no alarm (base: R+10, 10 red cycles)",
r.quiet(-60, 900))
t3 = sorted(k for k in JOBS if k.startswith(f"T16 {xn} T3 "))
print(f" T16 {xn} T3 alarms "
f"{[(k[10:], res(k).rel_alarms()) for k in t3]}")
check(f"T16 {xn} T3 ({len(t3)} cells): no alarm R-60..R+300",
all(res(k).quiet(-60, 300) for k in t3))
# mono x1 / wall x10: the car's energy is counted on the monotonic clock,
# a tenth of the wall's, so its share of the quarter is short and the
# house latch sets late in the quarter (EV-18 F2, out of scope), as base.
check(f"T16 {xn} T3: any later alarm at base's second (EV-18 F2)",
all(as_base(k) if k in BASE_ALARMS else res(k).quiet(-60, 900)
for k in t3))
for k in ("T5", "T6"):
show(f"T16 {xn} {k} manual")
check(f"T16 {xn} {k}: the alarm at the base second",
as_base(f"T16 {xn} {k} manual"))
check(f"T16 {xn} T7(b) T2: an alarm only while the figure is unknown",
only_while_unknown(res(f"T16 {xn} T7(b) T2")))
for rr in (-10, 0, 10, 40):
check(f"T16 {xn} T11 T2 R=E{rr:+d}: no alarm",
res(f"T16 {xn} T11 T2 R=E{rr:+d}").quiet(-60, 900))
check(f"T16 {xn} T11 T5 R=E{rr:+d}: the alarm at the base seconds",
as_base(f"T16 {xn} T11 T5 R=E{rr:+d}"))
# --- T17: no flicker -------------------------------------------------------------- #
r17 = res("T17 flicker")
print(f" T17 alarm edges per quarter {r17.edges_per_quarter()}")
check("T17: the house alone straddles aim + 10 W, the batteries cross the "
"reserve 3 times: at most one alarm edge per quarter",
all(v <= 1 for v in r17.edges_per_quarter().values()))
# --- N2: the car explains only with a trusted, non-zero figure ----------------- #
bad2 = sorted(k for k, r in RES.items()
if any(x["explains"] and not trusted(x) for x in r.tr))
check(f"N2: car_explains never True with car_alarm_w None, 0 W or "
f"contradicted, in any of the {len(RES)} runs: {bad2}", bad2 == [])
for k in ("N2 no energy entity", "N2 reports 11 kW at 6 A"):
show(f"{k} manual")
check(f"{k}: the figure is not trusted for the alarm (no corroboration, "
f"or capped by the read-back): nothing explained, the alarm as Off",
same_as_off(k) and not any(
x["explains"] for x in res(f"{k} manual").tr))
check("N2 PRECONDITION: the charger without an energy entity reports a "
"fresh 1 380 W", all(x["car_raw"] == CAR for x in
res("N2 no energy entity manual").win(-60, 60)))
# --- N4 / T20: no control change --------------------------------------------- #
for nm in ("T2", "T5"):
a = res("T1 core bw=0 t2 rp=180") if nm == "T2" else res("T10 T5 twin")
check(f"N4 {nm}: the claim, the floor, the setpoints and the charger "
f"writes are those of the same run with the car never explaining",
a.cmd == res(f"N4 {nm} explain off").cmd)
# --- N5: at most one floor-alarm edge per quarter ------------------------------ #
# Base 43b0db7 has 2 edges in the first quarter of these runs: the guard lets
# go for one cycle at R+1 (the battery reads 0 W, the meter does not show it
# yet), in Off and in the C5 cells too. Not EV-19's; head must not add one.
BASE_TWO = ["T1 b: energy first step late", "T1 b: energy never steps",
"T11 T5 R=E+0", "T11 T5 R=E+0 off", "T11 T5 R=E+1",
"T11 T5 R=E+1 off", "T16 mono1 T11 T5 R=E+0",
"T16 mono1 T11 T5 R=E+10", "T16 mono1 T6 off",
"T16 x10 T11 T5 R=E+0", "T16 x10 T11 T5 R=E+10", "T16 x10 T6 off",
"T6 step R+0 off", "T6 step R+1 off", "T6 step R+5 off"] + [
f"RB step R+{k} aim+{hi} burst {b} off" for k in (5, 30)
for hi in (1900, 2500) for b in (3000, 4600)]
many = sorted(k for k, r in RES.items()
if any(v > (2 if k in BASE_TWO and q == 0 else 1)
for q, v in r.edges_per_quarter().items()))
check(f"N5: at most one floor-alarm edge per quarter in every run, and no "
f"more than base where base has two ({len(RES)} runs): {many}",
many == [])
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")
+779
View File
@@ -0,0 +1,779 @@
"""EV-19: the real Controller, N=2, when the batteries first reach the peak
reserve `R` early in a Manual car session (EV-15 F-B). Used by test_ev19.py.
python3 tools/ev19_reserve.py # the T1 grid, one row per cell
The units stand at 21 % and give `bw` W (`force`) until `R`, where both read
19 %; after `R` they follow the trajectory `traj`. The house is set so that
house + car with the batteries at 0 W lands at aim + `over` W (F-B: +520 W,
less than the 1 380 W car). Manual is set, then the car plugs in, `rp` s
before `R`. The run starts `E` s before a quarter edge (rig.BASE moved back),
so `R = E + r_rel`. One dict per cycle, taken after it.
Trajectories after R: t1 both 0 W; t2 a 0 W, b follows the house (the loop
below the reserve covers house + car, up to b's rating); t3 both ramp to 0 W
over 3 cycles; t4 as t1, but every battery reading is 10 s old (the rig reads
battery W every 10 fake s, P1 every 5) while P1 is fresh; t4r as t1, but P1
is 5 s late while the battery reading is fresh.
"""
import hashlib
import os
import sys
from datetime import timedelta
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
import ev04_peak as P # noqa: E402
import ev18_peak as H # noqa: E402
import opt11_identity as rig # noqa: E402
import safety81_sim as s81 # noqa: E402
from app import peakguard # noqa: E402
from chargersim import SimCharger # noqa: E402
AIM = H.AIM
CAR = 1380.0
FLOOR = H.FLOOR
RATE = {"a": 5000.0, "b": 4600.0}
OPTS = H.OPTS
OPTS1 = {"peak_soc_floor": 20, "inverters": [OPTS["inverters"][0]]}
class Meter(SimCharger):
"""A charger whose energy meter shows no 10 Wh step until `hold_until`
(sim seconds; None: always live, float('inf'): never)."""
hold_until = None
_held = None
def _build(self):
if self.hold_until is None or self.t >= self.hold_until:
self._held = None
return super()._build()
if self._held is None:
self._held = self.kwh
keep, self.kwh = self.kwh, self._held
try:
return super()._build()
finally:
self.kwh = keep
class Draw(Meter):
"""A charger that draws `real_w` while charging and reports `say_w`
(as test_ev18's). `c_at_0`: it stays in mode3 C while drawing 0 W."""
def __init__(self, real_w, say_w, c_at_0=False, **kw):
super().__init__(**kw)
self.real_w, self.say_w, self.c_at_0 = real_w, say_w, c_at_0
def target_w(self):
if super().target_w() <= 0.0:
return 0.0
return self.real_w
def tick(self, seconds=1.0):
super().tick(seconds)
if self.c_at_0 and self.state == "B" and not self.full:
self.state = "C"
def _build(self):
keep, self._frozen_w = self._frozen_w, self.say_w
try:
return super()._build()
finally:
self._frozen_w = keep
class Plant(H.Plant):
"""`batt_lag`: every battery reading is that many s old. `p1_lag` with
`p1_from`: P1 that many s late from that second on."""
batt_lag = 0.0
p1_lag = 0.0
p1_from = 0.0
house = None
def batt_of(self, u, at):
f = self.force.get(u)
if f is not None:
return float(f(at, self))
return P.CarPlantN.batt_of(self, u, at)
def grid(self, at):
if self.p1_lag and at >= self.p1_from:
at = at - self.p1_lag
return super().grid(at)
async def number(self, e, invert=False):
for u, secs in self.lost.items():
if e == "sensor.batt_" + u and int(self.t) in secs:
return None
if self.batt_lag and e.startswith("sensor.batt_") \
and e[-1] in self.socs:
return self.batt_of(e[-1], self.t - self.batt_lag)
return await P.CarPlantN.number(self, e, invert)
def split(bw, units="ab"):
"""`bw` over the units, each capped at its rating."""
if len(units) == 1:
return {units: min(bw, RATE[units])}
a = min(RATE["a"], bw / 2.0)
b = min(RATE["b"], bw - a)
a = min(RATE["a"], bw - b)
return {"a": a, "b": b}
def traj_fn(u, traj, before, R, house, step=1):
"""Unit `u`'s W at time `at`: `before` until the first cycle after R
(R + `step`), then the trajectory. P1 is sampled 0.3 s before each cycle,
so the battery reading shows a change one cycle before the meter does."""
def f(at, plant):
if at < R + step:
return before
if traj in ("t1", "t4", "t4r"):
return 0.0
if traj == "t2":
if u == "a":
return 0.0
return min(RATE["b"], house(at) + plant.ch.power_w)
if traj == "t3":
k = int((at - R) // step)
return before * max(0.0, (3 - k) / 3.0)
if traj == "keep":
return before
raise ValueError(traj)
return f
def run(*, bw=4250.0, traj="t1", rp=180, r_rel=43, order="manual",
energy="ok", x=1, mono_x=None, aim=AIM, over=520.0, house_w=None,
house_fn=None, car_a=6, n=2, extra=None, rel=None, lost=None,
after=900,
soc_after=None, soc0=21.0, mode="manual", sim=None,
explain_off=False, latch_off=False, force=None, plug_at=None,
man_at=None, opts=None, pre_w=H.PRE_W):
"""One run; returns (run, trace, meta). `over`: house + car at batteries
0 W lands at aim + `over` W (ignored with `house_w`). `order`: 'manual'
(Manual at plug-in - 3 s), 'plug' (plug-in at R-185, Manual at R-180),
'off120' (plug-in and charging in Off from R-180, Manual at R-60).
`energy`: 'ok', 'late' (first 10 Wh step at plug-in + 150 s), 'never'.
`mode`: 'manual' or 'off' (Off throughout: the base for honest alarms).
`house_fn`: fn(t, R) for the house after the step. `extra`: events at
run seconds, `rel`: at seconds from R. `lost`: {unit: seconds from R}.
`plug_at` / `man_at`: plug-in / Manual at these seconds from R (override
`order`). `force`: {unit: fn(at, plant) or None (the unit obeys)}.
`opts`: added to the options. `pre_w`: the house before its step."""
units = "ab" if n == 2 else "a"
step = int(x)
if order == "plug":
lead = 185
elif order == "off120":
lead = 180
else:
lead = rp + 3
if plug_at is not None or man_at is not None:
lead = -min(v for v in (plug_at, man_at) if v is not None)
E = 150
while E + r_rel - lead - 2 * step < 10:
E += 150
E = int(-(-E // step) * step)
R = E + r_rel
if x != 1:
R = int(-(-R // step) * step)
hw = (aim + over - CAR) if house_w is None else house_w
t_house = min(E - 120, R - lead - step)
if x != 1:
t_house = int(t_house // step * step)
def house(t):
if t < t_house:
return pre_w
if house_fn is not None:
return house_fn(t, R)
return hw
sp = split(bw, units)
frc = {u: traj_fn(u, traj, sp[u], R, house, step) for u in units}
frc.update(force or {})
soc_after = soc_after or {u: 19.0 for u in units}
lagb = 10.0 if traj == "t4" else 0.0
cls = type("Plant", (Plant,), {
"force": frc, "batt_lag": lagb, "R": R,
"lost": {u: {R + k for k in v} for u, v in (lost or {}).items()},
"p1_lag": 5.0 if traj == "t4r" else 0.0, "p1_from": float(R)})
s = sim or Meter(setpoint_a=car_a)
if energy == "never":
s.hold_until = float("inf")
if x != 1:
tick = s.tick
s.tick = lambda secs=1.0: tick(secs * x)
if order == "plug":
t_plug, t_man = R - 185, R - 180
elif order == "off120":
t_plug, t_man = R - 180, R - 60
else:
t_plug, t_man = R - rp, R - rp - 3
if plug_at is not None:
t_plug = R + plug_at
if man_at is not None:
t_man = R + man_at
if x != 1:
t_plug = int(t_plug // step * step)
t_man = int(t_man // step * step)
if t_man == t_plug and order != "plug":
t_man -= step
tr = []
n_err = [len(H.ERR.rec)]
def hook(plant, c):
orig = c.car_settle
if explain_off:
c._car_explains_alarm = lambda *a_, **k_: False
if latch_off:
c._car_contradicted = lambda *a_, **k_: False
if mono_x is not None and mono_x != x:
c.car_now = (lambda f=c.car_now: f() * mono_x / x)
async def settle():
await orig()
g = c.peak_guard
red = [r_["id"] for r_ in c.checks()
if r_["ok"] is False and not r_["warn"]
and r_["id"] == "peak_guard"]
errs = [m for m in H.ERR.rec[n_err[0]:]
if "may not draw the battery lower" in m]
n_err[0] = len(H.ERR.rec)
cl = peakguard.claim(g) if g is not None else None
mono = c.car_now()
tr.append({
"t": plant.t, "explains": c.car_explains,
"lim": bool(g is not None and (g.floor_limited
or g.saturated)),
"floor_lim": bool(g is not None and g.floor_limited),
"within_aim": bool(g is not None and g.within_aim),
"wants": bool(g is not None and g.engaged
and (g.wanted_w or 0.0) > 0.0),
"wanted": None if g is None else g.wanted_w,
"target": None if g is None else g.target_w,
"alarm": c._peak_floor_limited, "red": red, "err": errs,
"w": c.car_alarm_w(), "car_raw": c.car.car_w(mono),
"batt": c.site_batt_w,
"true_batt": plant.batt(plant.t),
"need_real": c._car_need_real, "need_excl": c._car_need_excl,
"need_house": c._car_need_house, "over_now": c._car_over_now,
"contra": c._car_contra_block is not None and (
c._peak_proj_real is not None
and c._car_contra_block
== c._peak_proj_real.block_start),
"idle": c._car_idle(mono), "peak_needed": c._peak_needed,
"key": c._carq["key"],
"block": (c._peak_proj_real.block_start
if c._peak_proj_real is not None else None),
"floor_w": g.floor_w if g is not None else None,
"lo": getattr(cl, "lo", None),
"sp": tuple(i.last_write for i in c.inverters)})
c.car_settle = settle
def set_manual(p, c):
c._car_action("car_mode", "manual", c.car_now())
def plug(p, c):
p.ch.plug_in()
if energy == "late":
p.ch.hold_until = p.ch.t + 150.0
def reserve(p, c):
p.socs.update(soc_after)
ev = {}
def add(t, fn):
t = int(t)
old = ev.get(t)
ev[t] = fn if old is None else (
lambda p, c, a_=old, b_=fn: (a_(p, c), b_(p, c)))
add(0, hook)
add(t_plug, plug)
if mode == "manual":
add(t_man, set_manual)
add(R, reserve)
for t, fn in (extra or {}).items():
add(t, fn)
for t, fn in (rel or {}).items():
add(R + t, fn)
base, tick0 = rig.BASE, s81.TICK
rig.BASE, s81.TICK = base - timedelta(seconds=E), float(x)
o = dict(OPTS if n == 2 else OPTS1, **(opts or {}))
try:
r = P.drive(house, dur=R + after + step, rating=5000.0,
soc={u: soc0 for u in units}, cap=aim + H.MARGIN,
phases=1, n=n, plant_cls=cls, opts=o, dev_w=5000.0,
setpoint=car_a, user_a=car_a, mode="off", events=ev,
sim=s, plug=False)
finally:
rig.BASE, s81.TICK = base, tick0
meta = {"E": E, "R": R, "t_plug": t_plug, "t_man": t_man,
"t_house": t_house, "house_w": hw, "step": step}
return r, tr, meta
# ---------------------------------------------------------- event helpers
# For `rel` (seconds from R) or `extra` (run seconds).
def p1_gap(t0, secs):
"""No P1 sample reaches the add-on for `secs` from `t0` (it is late)."""
def off(p, c):
c.p1._ev19_submit = c.p1.submit
c.p1.submit = lambda *a, **k: None
def on(p, c):
c.p1.submit = c.p1._ev19_submit
return {t0: off, t0 + secs: on}
def stale(t0, t1):
"""The charger's readings stop reaching the car tracker from t0 to t1:
its figure ages past `stale_s`."""
def off(p, c):
c.car._ev19_observe = c.car.observe
c.car.observe = lambda *a, **k: None
def on(p, c):
c.car.observe = c.car._ev19_observe
return {t0: off, t1: on}
def unavailable(t0, t1):
return {t0: lambda p, c: p.ch.go_unavailable(True),
t1: lambda p, c: p.ch.go_unavailable(False)}
def restart(t0):
return {t0: lambda p, c: H.restart(c)}
def phases(t0, n=3):
"""The user asks for `n` phases (the add-on's own 0 A pause follows)."""
return {t0: lambda p, c: c._car_action("car_phases", n, c.car_now())}
def socs(t0, **s):
return {t0: lambda p, c: p.socs.update(s)}
def merge(*evs):
out = {}
for e in evs:
for t, fn in e.items():
old = out.get(t)
out[t] = fn if old is None else (
lambda p, c, a_=old, b_=fn: (a_(p, c), b_(p, c)))
return out
# --------------------------------------------------------------- grading
def window(tr, t0, t1):
return [x for x in tr if t0 <= x["t"] <= t1]
def alarms(r):
return H.alarms(r)
def edges(tr):
return H.edges(tr)
def bad(x):
"""An alarm, red sample or ERROR in this cycle."""
return bool(x["alarm"] or x["red"] or x["err"])
def repro(r, tr, meta, t0=-10, t1=60):
"""T1's definition: a floor notice, ERROR or red sample in R-10..R+60 in
a cycle where the car figure is trusted (the shape lands under the aim
without the car, so the car explains). Returns (cycles, C5-only cycles)."""
R = meta["R"]
w = window(tr, R + t0, R + t1)
notes = [t for t in alarms(r) if R + t0 <= t <= R + t1]
hit = [x["t"] for x in w if bad(x) and x["w"] is not None
and x["w"] > 0.0]
c5 = [x["t"] for x in w if bad(x) and not (x["w"] is not None
and x["w"] > 0.0)]
return hit, c5, notes
def quiet(r, tr, t0, t1):
return (not [t for t in alarms(r) if t0 <= t <= t1]
and not any(bad(x) for x in window(tr, t0, t1)))
def commands(r, tr):
h = hashlib.sha256()
for u in sorted(r["plant"].hists):
h.update(repr((u, r["plant"].hists[u])).encode())
h.update(repr(r["sim"].writes()).encode())
h.update(repr([(x["t"], x["floor_w"], x["lo"], x["sp"])
for x in tr]).encode())
return h.hexdigest()[:16]
def row(name, r, tr, meta):
hit, c5, notes = repro(r, tr, meta)
R = meta["R"]
first = hit[:1]
cause = ""
if first:
x = next(y for y in tr if y["t"] == first[0])
cause = (f"w={x['w']:.0f} batt={x['batt']} true={x['true_batt']:.0f}"
f" real={x['need_real']:d} excl={x['need_excl']:d} "
f"house={x['need_house']:d} over={x['over_now']:d} "
f"contra={x['contra']:d} pn={x['peak_needed']:d} "
f"wa={x['within_aim']:d} wanted={x['wanted']:.0f}")
return (f"{name:42s} R={R:5d} notes {[t - R for t in notes]} "
f"hit {[t - R for t in hit][:6]}{'...' if len(hit) > 6 else ''}"
f" n={len(hit)} c5 {len(c5)} err "
f"{len([x for x in window(tr, R - 10, R + 60) if x['err']])} "
f"red900 {len([x for x in window(tr, R - 60, R + 900) if x['red']])}"
f" {cause}")
def t2_shape(**kw):
"""The reproducing shape (T2): b follows the house from R, 0 W before."""
return dict(dict(bw=0.0, traj="t2"), **kw)
def t5_shape(**kw):
"""The honest shape (T5): the house alone misses the aim by 1 680 W, more
than the 1 380 W car; the batteries give 4 250 W until R."""
return dict(dict(bw=4250.0, traj="t1", house_w=AIM + 1680.0), **kw)
def flicker_force(bw=2000.0):
"""T17: each unit gives bw/2 above its reserve and ramps to 0 W over 3
cycles once at it (tau3); back above it, it gives bw/2 again at once."""
def mk(u):
st = {"since": None}
def f(at, plant):
if plant.socs[u] >= 20.0:
st["since"] = None
return bw / 2.0
if st["since"] is None:
st["since"] = at
k = int(at - st["since"])
return bw / 2.0 * max(0.0, (3 - k) / 3.0)
return f
return {"a": mk("a"), "b": mk("b")}
def _step_house(k, lo=AIM + 520.0 - CAR, hi=AIM + 1900.0):
return lambda t, R: lo if t < R + k else hi
def _burst(k, w):
"""Inverter-b: 2 125 W until R+1, then `w` for 0.5 s before the cycle at
R+k (P1, sampled 0.3 s before it, and the reading both show it), else
0 W."""
def f(at, plant):
if at < plant.R + 1:
return 4250.0 / 2.0
return w if plant.R + k - 0.5 <= at <= plant.R + k else 0.0
return f
def _ignoring():
"""The charger accepts the 6 A write and ignores it: the car stays at
0 A."""
s = Meter(setpoint_a=0)
s.refuse = "ignore"
return s
def _full_at_plug(p, c):
"""The car is full (after the plug-in at R-180): mode3 B, 0 W."""
p.ch.car_full()
def _no_energy(p, c):
"""The charger has no energy entity."""
p.ch.no_energy = True
def _freeze_stop(p, c):
p.ch.freeze()
p.ch.car_full()
def jobs():
"""Every controller run test_ev19.py grades: {name: kwargs}."""
j = {}
for name, kw in grid():
j["T1 " + name] = kw
# T3: the battery W sweep
for tj in ("t1", "t2"):
for bw in range(0, 4601, 200):
j[f"T3 {tj} bw={bw}"] = dict(bw=float(bw), traj=tj)
j[f"T3 {tj} tau5"] = dict(bw=9600.0, traj=tj, aim=6000.0,
house_w=5200.0)
# T4: the landing without the car at aim + 9 / + 11 W
for d in (9, 11):
for md in ("manual", "off"):
j[f"T4 +{d} {md}"] = t2_shape(house_w=AIM + d, mode=md)
# T5: honest at the reserve
for tj in ("t1", "t4"):
for md in ("manual", "off"):
j[f"T5 {tj} {md}"] = t5_shape(traj=tj, mode=md)
for md in ("manual", "off"):
j[f"T5 tau5 {md}"] = dict(bw=9600.0, traj="t1", aim=6000.0,
house_w=7700.0, mode=md)
# T6: the honest step in the reserve cycle
for k in (0, 1, 5):
for md in ("manual", "off"):
j[f"T6 step R+{k} {md}"] = dict(bw=4250.0, traj="t1", mode=md,
house_fn=_step_house(k))
# T7: unknown values
for nm, sh in (("T2", t2_shape), ("T5", t5_shape)):
j[f"T7(a) {nm}"] = sh(lost={"a": {0, 1}})
j[f"T7(b) {nm}"] = sh(rel=unavailable(0, 1))
j["T7(a) T5 off"] = t5_shape(lost={"a": {0, 1}}, mode="off")
j["T7(b) T5 off"] = t5_shape(rel=unavailable(0, 1), mode="off")
# T8: a stale car figure
j["T8(a) Off 120 s, Manual R-5"] = t2_shape(plug_at=-125, man_at=-5)
j["T8(b) stale R-5..R+20"] = t2_shape(rel=stale(-5, 20))
j["T8(c) frozen, the car stops"] = t5_shape(rel={-30: _freeze_stop})
j["T8(c) off"] = t5_shape(rel={-30: _freeze_stop}, mode="off")
# T9: comms
for nm, sh in (("T2", t2_shape), ("T5", t5_shape)):
j[f"T9(a) {nm} b lost at R"] = sh(lost={"b": {0}})
j[f"T9(a) {nm} b lost at R-1"] = sh(lost={"b": {-1}})
j[f"T9(b) {nm} P1 5 s late at R"] = sh(rel=p1_gap(0, 5))
# T10: a restart
for nm, sh in (("T2", t2_shape), ("T5", t5_shape)):
j[f"T10 {nm} twin"] = sh()
for k in (-2, 2):
j[f"T10 {nm} restart R{k:+d}"] = sh(rel=restart(k))
# T11: the quarter edge
for rr in (-1, 0, 1, 43):
j[f"T11 T2 R=E{rr:+d}"] = t2_shape(r_rel=rr)
j[f"T11 T5 R=E{rr:+d}"] = t5_shape(r_rel=rr)
j[f"T11 T5 R=E{rr:+d} off"] = t5_shape(r_rel=rr, mode="off")
# C4: the old quarter heads over the aim (the house high all along), so the
# guard wants power in its last 60 s and SAFETY-126's latch is carried
j["T11 C4 T2 R=E+1"] = t2_shape(r_rel=1, house_w=13350.0, pre_w=13350.0)
# T12: our own phase change
for k in (-15, 5):
j[f"T12 T2 1->3 at R{k:+d}"] = t2_shape(rel=phases(k))
j[f"T12 T5 1->3 at R{k:+d}"] = t5_shape(rel=phases(k))
j[f"T12 T5 1->3 at R{k:+d} off"] = t5_shape(rel=phases(k),
mode="off")
# T13: a wrong charger reply
# (a): the house + the 400 W it really draws lands at aim + 520 W, so the
# house alone misses by 120 W; (b) and T14(a): the car draws 0 W and the
# house alone lands at aim + 520 W. An alarm is due in each.
for md in ("manual", "off"):
j[f"T13(a) draws 400 W {md}"] = t2_shape(
sim=Draw(400.0, CAR, setpoint_a=6), house_w=AIM + 120.0, mode=md)
j[f"T13(a) draws 100 W {md}"] = t2_shape(
sim=Draw(100.0, CAR, setpoint_a=6), house_w=AIM + 420.0, mode=md)
j[f"T13(b) the write ignored, 0 A {md}"] = t2_shape(
sim=_ignoring(), house_w=AIM + 520.0, mode=md)
# T14: configuration
j[f"T14(a) 0 W in C {md}"] = t2_shape(
sim=Draw(0.0, 0.0, c_at_0=True, setpoint_a=6),
house_w=AIM + 520.0, mode=md)
j[f"T14(a) idle B {md}"] = t2_shape(
house_w=AIM + 520.0, mode=md, rel={-179: _full_at_plug})
j["T14(b) ev_charger off"] = t2_shape(opts={"ev_charger": "off"})
j["T14(b) off"] = t2_shape(mode="off")
for tj in ("t1", "t4"):
j[f"T14(c) N=1 anchor {tj}"] = dict(n=1, bw=4250.0, traj=tj)
j["T14(c) N=1 T5"] = t5_shape(n=1)
j["T14(c) N=1 T5 off"] = t5_shape(n=1, mode="off")
# T15: one battery first (SAFETY-87)
for nm, hw in (("anchor", AIM + 520.0 - CAR), ("honest", 19000.0)):
for md in ("manual", "off"):
j[f"T15 {nm} {md}"] = dict(
bw=4250.0, traj="t1", house_w=hw, mode=md,
force={"b": None}, soc_after={"a": 19.0, "b": 35.0},
rel=socs(360, b=19.0))
# T16: x10 (wall and mono), and mono x1 / wall x10
for xn, xk in (("x10", dict(x=10)), ("mono1", dict(x=10, mono_x=1))):
xk = dict(xk, r_rel=40)
# x10: b at 1 200 W before R (at 0 W, which the forced unit holds
# against the guard's floor, SAFETY-37's gate reads it as frozen)
xk2 = dict(xk, bw=1200.0)
j[f"T16 {xn} T2"] = t2_shape(**xk2)
for tj in ("t1", "t4"):
for bw in (0.0, 2000.0, 4250.0):
j[f"T16 {xn} T3 {tj} bw={bw:.0f}"] = dict(bw=bw, traj=tj,
**xk)
for md in ("manual", "off"):
j[f"T16 {xn} T5 {md}"] = t5_shape(mode=md, **xk)
j[f"T16 {xn} T6 {md}"] = dict(bw=4250.0, traj="t1", mode=md,
house_fn=_step_house(0), **xk)
j[f"T16 {xn} T7(b) T2"] = t2_shape(rel=unavailable(0, 10), **xk2)
for rr in (-10, 0, 10, 40):
j[f"T16 {xn} T11 T2 R=E{rr:+d}"] = t2_shape(
**dict(xk2, r_rel=rr))
j[f"T16 {xn} T11 T5 R=E{rr:+d}"] = t5_shape(**dict(xk, r_rel=rr))
# T17: no flicker
j["T17 flicker"] = dict(
force=flicker_force(), after=1200,
rel=merge(socs(300, a=21.0, b=21.0), socs(600, a=19.0, b=19.0)),
house_fn=lambda t, R: AIM + 10.0 + (40.0 if int(t // 7) % 2
else -40.0))
# N2: figures only `car_w_trusted` keeps out of the alarm path: no energy
# entity (never corroborated, never contradicted) and 11 kW reported at
# a 6 A read-back (capped at 1 518 W; the house alone misses by 1 680 W)
for md in ("manual", "off"):
j[f"N2 no energy entity {md}"] = t2_shape(extra={0: _no_energy},
mode=md)
j[f"N2 reports 11 kW at 6 A {md}"] = t5_shape(
sim=Draw(CAR, 11000.0, setpoint_a=6), mode=md)
# Review round 1: an honest house step answered by ONE cycle of inverter-b
# power that P1 and the reading both show (the meter in step), after the
# T6 shape (4 250 W until R, then 0 W).
for k in (5, 30):
for hi in (1900, 2500):
for burst in (3000.0, 4600.0):
for md in ("manual", "off"):
j[f"RB step R+{k} aim+{hi} burst {burst:.0f} {md}"] = dict(
bw=4250.0, traj="t1", mode=md,
house_fn=_step_house(k - 0.5, hi=AIM + hi),
force={"b": _burst(k, burst)})
# T10 (mE): restarts at R-1 and R, so the rise cycle has no reading from
# two cycles back
for nm, sh in (("T2", t2_shape), ("T5", t5_shape)):
for k in (-1, 0):
j[f"T10 {nm} restart R{k:+d}"] = sh(rel=restart(k))
# T20 / N4: the same runs with the car never explaining
j["N4 T2 explain off"] = t2_shape(explain_off=True)
j["N4 T5 explain off"] = t5_shape(explain_off=True)
return j
def grid():
"""The T1 cells: (name, kwargs)."""
cells = []
for bw in (0.0, 400.0, 800.0, 2000.0, 4250.0, 9600.0):
for tj in ("t1", "t2", "t3", "t4", "t4r"):
for rp in (30, 100, 110, 180, 600):
kw = dict(bw=bw, traj=tj, rp=rp)
if bw == 9600.0:
kw.update(aim=6000.0, house_w=5200.0)
cells.append((f"core bw={bw:.0f} {tj} rp={rp}", kw))
cells.append(("a: plug R-185, Manual R-180", dict(order="plug")))
cells.append(("a: Off 120 s, Manual R-60", dict(order="off120")))
cells.append(("b: energy first step late", dict(energy="late")))
cells.append(("b: energy never steps", dict(energy="never")))
for rr in (-60, 0, 1, 43, 450, 890):
cells.append((f"c: R=E{rr:+d}", dict(r_rel=rr)))
cells.append(("d: x10 wall+mono", dict(x=10, r_rel=40)))
cells.append(("d: x10 wall, mono x1", dict(x=10, mono_x=1, r_rel=40)))
for tj, bw in (("t4", 4250.0), ("t2", 4250.0), ("t2", 1200.0)):
cells.append((f"d: x10 wall+mono {tj} bw={bw:.0f}",
dict(x=10, r_rel=40, traj=tj, bw=bw)))
cells.append((f"d: x10 wall, mono x1 {tj} bw={bw:.0f}",
dict(x=10, mono_x=1, r_rel=40, traj=tj, bw=bw)))
return cells
class Res:
"""What a check needs from one run, picklable: the notices (`raised`,
seconds and ids), the trace, the command digest and the run's times."""
def __init__(self, r, tr, meta):
self.raised = list(r["raised"])
self.tr, self.meta = tr, meta
self.cmd = commands(r, tr)
self.R, self.E = meta["R"], meta["E"]
def alarms(self):
return [t for t, n in self.raised if n == FLOOR]
def rel_alarms(self):
return [int(t - self.R) for t in self.alarms()]
def edges(self):
return [int(t - self.R) for t in edges(self.tr)]
def errors(self):
return [int(x["t"] - self.R) for x in self.tr if x["err"]]
def red(self, t0=-60, t1=900):
return [int(x["t"] - self.R) for x in
window(self.tr, self.R + t0, self.R + t1) if x["red"]]
def at(self, k):
return next((x for x in self.tr if x["t"] == self.R + k), None)
def win(self, t0, t1):
return window(self.tr, self.R + t0, self.R + t1)
def quiet(self, t0=-60, t1=900):
return quiet({"raised": self.raised}, self.tr,
self.R + t0, self.R + t1)
def edges_per_quarter(self):
"""False -> True edges of the floor alarm per quarter (N5)."""
out = {}
for t in edges(self.tr):
q = int((t - self.E) // 900)
out[q] = out.get(q, 0) + 1
return out
def summary(self):
return {"alarms": self.rel_alarms(), "edges": self.edges(),
"errors": self.errors(), "red": len(self.red()),
"cmd": self.cmd}
_JOBS = {}
def _job(name):
import logging
logging.disable(logging.WARNING)
return name, Res(*run(**_JOBS[name]))
def run_many(jobs, procs=None):
"""{name: kwargs} -> {name: Res}, `procs` runs at a time (fork: the
kwargs may hold functions)."""
import multiprocessing
_JOBS.clear()
_JOBS.update(jobs)
procs = procs or int(os.environ.get("EV19_JOBS", "0")) \
or min(8, os.cpu_count() or 1)
ctx = multiprocessing.get_context("fork")
with ctx.Pool(procs) as pool:
return dict(pool.imap_unordered(_job, list(jobs), chunksize=1))
def _one(cell):
import logging
logging.disable(logging.WARNING)
name, kw = cell
try:
r, tr, meta = run(**kw)
except Exception as e: # noqa: BLE001
import traceback
return name, f"{name:42s} Traceback {e!r}\n{traceback.format_exc()}"
return name, row(name, r, tr, meta)
if __name__ == "__main__":
import multiprocessing
cells = grid()
if len(sys.argv) > 1:
cells = [c for c in cells if any(a in c[0] for a in sys.argv[1:])]
with multiprocessing.Pool(int(os.environ.get("EV19_JOBS", "8"))) as pool:
for _name, line in pool.imap(_one, cells):
print(line, flush=True)