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>
This commit is contained in:
Claude (dev)
2026-11-21 11:23:13 +01:00
parent b662d7171b
commit c707eb4776
3 changed files with 134 additions and 55 deletions
+30 -6
View File
@@ -61,8 +61,8 @@ class CarMixin:
self.car_over = False # ... held: the card and row say so
self._car_over_since = None
self._car_over_gone = None
self._car_why_hold = None # EV-16: the held Car Why (display)
self._car_over_ep = 0 # EV-16: bumped by control at each start/end of car_over; the hold is valid for one value
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
@@ -394,16 +394,40 @@ class CarMixin:
if self._car_over_since is None:
self._car_over_since = mono
if mono - self._car_over_since >= OVER_HOLD_S:
if not self.car_over:
self._car_over_ep += 1 # EV-16: a new episode
self.car_over = True
else:
if self._car_over_gone is None:
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: ends the held Why
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
@@ -502,7 +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: ends the held Why
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
+10 -26
View File
@@ -1302,34 +1302,20 @@ def _car_why(key, c, good):
# 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: it changes only when
# the other state has stood for as long as the car_over row's own hold.
# 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". Display only: the
state lives in `c._car_why_hold`, stamped with the episode `c._car_over_ep`
that control bumps; a hold of another episode is never used, so a read
overlapping the end of car_over cannot bring a stale text back."""
mono = c.car_now()
cand = (pg.floor_limited and pg.soc is not None) if pg is not None \
else None
ep = getattr(c, "_car_over_ep", 0) # owned by the control loop
h = getattr(c, "_car_why_hold", None)
if h is not None and h[2] != ep: # a hold of an ended episode
h = None
if h is None:
h = [bool(cand), None, ep] # shown, since when, episode
elif cand is None or cand == h[0]:
h[1] = None
else:
if h[1] is None:
h[1] = mono
if mono - h[1] >= WHY_HOLD_S:
h = [cand, None, ep]
c._car_why_hold = h
return h[0]
"""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):
@@ -1342,11 +1328,9 @@ def _car_manual_why(c, key):
if c.car_over:
pg = getattr(c, "peak_guard", None)
if not c.car_cover:
c._car_why_hold = None
return _t("car.why.manual_nocover", a=a)
return _t("car.why.manual_over" if _over_why_is_floor(c, pg)
else "car.why.manual_full", a=a, pct=pct)
c._car_why_hold = None
if c.shadow:
t, n = w.would if w.would is not None else (c.car_a, c.car_n)
return _t("car.why.manual_would", a=f"{float(t):.0f}",
+94 -23
View File
@@ -2,8 +2,9 @@
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 in `c._car_why_hold`; control never reads it. Control owns
`c._car_over_ep` (bumped at each start and end of car_over); a hold of
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).
@@ -94,13 +95,19 @@ 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:
c._now = t
c.peak_guard = g_of(t - t0)
tick(c, g_of(t - t0), t)
out.append((t, kind(why(c))))
t += STEP
return out
@@ -212,9 +219,8 @@ check("T8 SoC toggling None / 20 % every 10 s, starting unread: one text, "
c = S()
seq = []
for t in range(0, 900, 5):
c._now = float(t)
c.peak_guard = None if 400 <= t < 410 else G(floor_limited=(t // 10) % 2
== 0)
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
@@ -222,8 +228,7 @@ for t in range(0, 900, 5):
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()
c.peak_guard = None
c._now = 0.0
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"))
@@ -239,8 +244,7 @@ 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 %
c._now = 5000.0
c.peak_guard = G(floor_limited=False, soc=60.0)
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")
@@ -253,8 +257,8 @@ for k in range(0, 200):
c.w = None
c.car_cycle(Proj(), G(), 14000.0, None)
c.car_over = True
c._now = 9000.0
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")
@@ -272,8 +276,7 @@ check("T11 after the unplug cycle there is no over wording",
and "set when a car is connected" in homeview._car_manual_why(c, "none"))
c.state = "charging"
c.car_over = True
c.peak_guard = G(floor_limited=False, soc=60.0)
c._now = 400.0
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()
@@ -290,12 +293,11 @@ check("T11 (cont.) the unplug ends the episode (control bumps it)",
c = S()
run(c, 100.0, lambda t: G())
c.o["ev_batt_cover"] = False
c._now = 105.0
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
c.peak_guard = G(floor_limited=False, soc=60.0)
c._now = 110.0
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")
@@ -350,7 +352,7 @@ for lang, over, full in (
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_hold" not in open(os.path.join(
"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")
@@ -358,27 +360,26 @@ print("\n6. EV-16 review round 1: the race, T16, T18, the N-ids")
# its old hold back; the next episode must not show it
c = S()
run(c, 100.0, lambda t: G())
stale = c._car_why_hold
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_hold = stale # the late write-back
c._car_why_rec = stale # the late write-back
c.car_over = True
c._car_over_ep += 1 # what control does on a start
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_hold
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_hold = stale # write-back after an unplug
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)
@@ -449,6 +450,76 @@ check("N7 wording unchanged: the four texts are in the files verbatim",
"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"})
print()
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
sys.exit(1 if fails else 0)