Compare commits

...
7 Commits
Author SHA1 Message Date
ems-agentandClaude 12c97b56f4 EV-18: no floor alarm at a quarter's start while the car explains the excess
EV-15 rig F-A: with both batteries at the peak reserve and the car charging,
PEAK_GUARD_FLOOR_LIMITED and goodwe_peak_soc_floor fired at a quarter's start
and stayed red for the quarter, the excess smaller than the car. Two causes,
both held by the per-quarter latch `_car_need_excl`:
- C2: "without the car" assumed the batteries give 0 W from now on, so what
  the loop still gives below the reserve counted as house (T2 red on base);
- C1: one cycle with no trusted car figure latched it for the quarter (T1).

Owner 2026-11-19 (Q1-Q3): without the car the batteries keep giving what they
give now (lower of two readings, every cycle); a house need seen with a
trusted car figure stays latched to the quarter's end (`_car_need_house`); an
unknown car figure keeps the alarm only while it is unknown. A car known to
draw nothing (fresh reading, not charging) still grades the house's own need.
After a restart or a gap only the rest of the quarter is graded without the
car. A 0 W figure explains nothing outside our own pause (EV-15). The guard's
claim, floor, setpoints and charger writes are unchanged (N4: 41 runs, same
command digests as base).

test_ev18.py: the test plan's T1-T18, T2b, T2c, N2-N5 (tools/ev18_peak.py:
the real Controller across one quarter edge, N=2 at the reserve).

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-19 02:59:50 +01:00
admin 9fdce023e9 Merge pull request 'EV-15: the add-on's own phase change at the peak reserve raises no false alarm' (#262) from EV-15 into release/1.0
infra-pin / fresh (push) Successful in 1s
2026-11-17 17:15:51 +01:00
glenn schrooyenandClaude Opus 5.5 7788543e09 EV-15 review: reflow the _car_own_pause docstring (one 123-char line)
checks / unit (pull_request) Successful in 22m10s
infra-pin / fresh (pull_request) Successful in 1s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Bdqr7PiaHcBnzPituu2yTC
2026-11-17 16:51:41 +01:00
glenn schrooyenandClaude 6d7046fc45 EV-15 round 2: the grace opens when the 0 A write is sent
checks / unit (pull_request) Successful in 20m56s
infra-pin / fresh (pull_request) Successful in 1s
The writer runs beside the cycle and the car can stop before the write
returns, so no sequence existed yet and the latch set. Window now opens at
send (zero_sent_at), cleared on return; ends on another writer in the tail too.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-17 15:24:30 +01:00
glenn schrooyenandClaude 07f703d1bc EV-15: test_ev15 guards its own indexing (named absence)
checks / unit (pull_request) Successful in 21m47s
infra-pin / fresh (pull_request) Successful in 1s
Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-17 13:39:11 +01:00
glenn schrooyenandClaude 2cfbc4aec8 EV-15: the add-on's own phase change at the peak reserve raises no false alarm
While the add-on holds the car at 0 A for its own phase change, the car's
figure had no corroboration (not charging), so nothing was explained and the
peak-floor alarm fired once. For grading only, the car's fresh, not stuck
figure now stands in for that sequence (bounded: its own waits plus one
corroboration window), ending at once on Off, Stop, shadow, unplug, another
writer or a refused write. car_exclude, the claim, floor and writes unchanged.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-17 13:26:56 +01:00
admin f66048b287 Merge pull request 'Release 0.24.0' (#260) from release-0.24.0 into release/1.0
infra-pin / fresh (push) Successful in 2s
checks / unit (pull_request) Successful in 21m46s
infra-pin / fresh (pull_request) Successful in 1s
2026-11-17 08:38:29 +01:00
8 changed files with 1420 additions and 38 deletions
+4
View File
@@ -1,5 +1,9 @@
# Changelog
### Not in a release yet
- 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
**A minor bump: the add-on can now charge the car (Manual mode), and a car that alone takes the batteries to the peak reserve no longer raises a false peak alarm. Two new options were added, both with defaults, and none needs setting.**
@@ -97,10 +97,10 @@ up to 1.8 kW; the 40 Wh floor fixes that.)
that latch twice, with and without the car, from the same readings. Both reset
at a new quarter and when the guard stops wanting power, and they run every
cycle, so the cover option does not touch them. This holds with the projection
still under the aim (rig: 5888 W against 6000 W). A car of 0 W makes the two the
same, so it explains nothing; a stale, stuck or uncorroborated figure is `None`,
sets the latch without the car, and the normal alarms stand. There is no minimum
car power: the comparison itself is what separates car from house.
still under the aim (rig: 5888 W against 6000 W). A car of 0 W explains
nothing; a stale, stuck or uncorroborated figure is `None` and the normal
alarms stand while it is (EV-18 below). There is no minimum car power: the
comparison itself is what separates car from house.
- **The period without the car is not clipped at 0 W** (EV-10b). The rig showed
EV-10 failing: house 3 kW, car 11 kW, batteries 8.1 kW, aim 6 kW. The batteries
give more than the house uses, so the house alone is an export; `car_exclude`
@@ -120,6 +120,35 @@ up to 1.8 kW; the 40 Wh floor fixes that.)
the gaps seen on the rig, 150 to 250 s at 50 s sampling, and shorter than a
quarter) and a gap does not restart the 10 s
on-count. `car_explains`, which the alarms read, has no hold.
- **Our own phase change is not a reason to alarm** (EV-15). Rig, twice: at the
reserve, with the car covering, the add-on's 3 -> 1 switch set the car to 0 A.
A car that is not charging has no corroboration (`CarTracker._corr_note` clears
the window, `corroborated` is False), so `car_alarm_w()` was None, the car
explained nothing and `_car_need_excl` latched for the quarter: one
PEAK_GUARD_FLOOR_LIMITED and one `goodwe_peak_soc_floor`. Now, only for grading
(`car_cycle`), `ctl_car._car_own_pause` lets the car's fresh, not stuck figure
(`CarTracker.car_w_paused`, 0 W while paused) stand in without corroboration:
from the moment our 0 A write is SENT (`zero_sent_at`: the cycle runs beside
the writer and the car stops before the write returns), until the current is
set again, at most
`OWN_PAUSE_MAX_S` (85 s, the sequence's own waits), then at most one
corroboration window (60 s). It ends at once on Off, Stop, shadow, unplug,
another writer, or a refused select or write (`seq["failed"]`). The energy it
drew in the pause is kept apart (`ws_p`), so `car_exclude`, the guard's
input, the claim, floor and writes are unchanged. A house overload still fails
the test without the car, so it alarms as on Off.
- **The batteries as they give now, and no latch from an unknown** (EV-18, EV-15
rig F-A). At the reserve the loop still gives some battery power; "without the
car, batteries at 0 W" counted it as house, `_car_need_excl` latched at the
quarter's start and the floor alarm stood for the quarter with the excess
smaller than the car. Owner 2026-11-19: without the car the batteries keep
giving what they give now (the lower of two readings, every cycle); a miss so
(`_car_need_house`) seen with a trusted car figure stays latched to the
quarter's end. The car explains where the period with it misses on the same
batteries (`_car_over_now`), or by the EV-10 test above. A `None` car figure
or battery reading explains nothing in that cycle and latches nothing. After
a restart or a gap the car's share of what is done is unknown (`_carq`
`whole`), so only the rest of the period is graded without the car.
- **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.
+14 -1
View File
@@ -125,6 +125,8 @@ class ManualWriter:
self.phase_fails = 0 # phase selects the charger did not take
self.phases_gave_up = False
self.undone = 0 # sequences undone before the select
self.phase_done_at = None # EV-15: our phase change ended well then
self.zero_sent_at = None # EV-15: our 0 A write is out, not yet back
# ------------------------------------------------------------------ user
def user_changed(self) -> None:
@@ -292,7 +294,14 @@ class ManualWriter:
async def _begin(self, drv, r, cur, n, now, tracker) -> None:
"""Step 1 of the safe sequence: 0 A. A charger that does not take it
stops the sequence before the phases are touched."""
ok = await self._write(drv, 0.0, cur, now, tracker)
self.phase_done_at = None
# EV-15: the car stops while the write waits for its read-back, and the
# cycle runs beside it: the window opens when the write is SENT.
self.zero_sent_at = now
try:
ok = await self._write(drv, 0.0, cur, now, tracker)
finally:
self.zero_sent_at = None
if not ok:
self._failed(now)
return
@@ -336,6 +345,7 @@ class ManualWriter:
self.log.append(("phases", q["n"], now, ok))
q["stage"], q["t1"] = "settle", self.last_done # from its return
if not ok:
q["failed"] = True # EV-15: no grace for the alarm
# The charger did not take it: the car gets its current back
# on the old phases after the same SETTLE_S as a taken select
# (HA may have taken it and only the read-back be late), and
@@ -356,7 +366,10 @@ class ManualWriter:
# still wanted, and one that is in place is adopted.
self.seq, self.rev_applied, self.reapply = None, None, False
self.fails, self.blocked = 0, False
if not q.get("failed"):
self.phase_done_at = self.last_done # EV-15
return
q["failed"] = True # EV-15: a refused write ends it
q["tries"] += 1
if q["tries"] >= MAX_TRIES:
# Left at 0 A is the safe side; the next reading re-applies.
+13 -1
View File
@@ -800,8 +800,20 @@ class CarTracker:
EV-03 rules), not stuck after a write, corroborated by the energy meter
(`corroborated`), and never above what the read-back allows the car to
draw: an old or frozen figure must not hide a house overload."""
return self._capped_w(now, True)
def car_w_paused(self, now: float):
"""EV-15: the same figure as `car_w_trusted` without the energy-meter
corroboration, which a car held at 0 A by the add-on's own phase change
cannot give (the meter's window restarts when it stops charging). Fresh,
not stuck, and capped by the read-back. Only for grading the alarm
during that sequence (`ctl_car._car_own_pause`)."""
return self._capped_w(now, False)
def _capped_w(self, now: float, corroborate: bool):
w = self.car_w(now)
if w is None or self.stuck(now) or not self.corroborated(now):
if w is None or self.stuck(now) \
or (corroborate and not self.corroborated(now)):
return None
r = self.reading
a = r.allowed_a if r.allowed_a is not None else r.setpoint_a
+124 -32
View File
@@ -24,6 +24,13 @@ OVER_HOLD_S = peakguard.ALARM_HOLD_S
# the cause: longer than the gaps seen on the rig (150 to 250 s at 50 s
# sampling) and shorter than a quarter, or until the session really ends.
OVER_OFF_HOLD_S = 180.0
# EV-15: the longest our own phase change can take (0 A wait, settle, three
# tries of a write at 5 s apart and up to 10 s each, the select's own wait);
# the grace for the alarm never outlasts it, and after the current is set
# again it lasts at most one corroboration window.
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
class CarMixin:
@@ -53,11 +60,12 @@ class CarMixin:
self._car_over_gone = None
self._car_batt_prev = None
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
self._car_over_notified = None # the session a notice was raised for
self._car_session = 0
self._car_prev_state = None
self._carq = {"key": None, "ws": 0.0, "mono": None}
self._carq = {"key": None, "ws": 0.0, "ws_p": 0.0, "mono": None}
self._peak_proj_real = None
saved = data.get(CAR_PEAK_KEY)
self.car_peak_q = dict(saved) if isinstance(saved, dict) else {}
@@ -206,17 +214,63 @@ class CarMixin:
return None
return self.car.car_w_trusted(self.car_now())
def _car_quarter(self, proj, w, mono) -> None:
def _car_own_pause(self, mono) -> bool:
"""EV-15: is the car held at 0 A by the add-on's OWN phase change? From
the moment its 0 A write is SENT (the cycle runs beside the write)
until the current is set again, then at most one corroboration window.
No when it was aborted (Off, Stop, shadow, unplug, another writer), a
write was refused, or it ran past its own maximum."""
wr = getattr(self, "car_writer", None)
if wr is None or (wr.seq is None and wr.phase_done_at is None
and wr.zero_sent_at is None) or wr.hold:
return False
r = self.car.reading
if not (self.car_manual() and self.car_writing()
and r is not None and r.available and r.state != "A"):
return False
q = wr.seq
if q is None and wr.zero_sent_at is not None: # sent, not yet back
return 0.0 <= mono - wr.zero_sent_at <= OWN_PAUSE_MAX_S
if q is not None:
return not q.get("failed") and 0.0 <= mono - q["t0"] \
<= OWN_PAUSE_MAX_S
return 0.0 <= mono - wr.phase_done_at <= OWN_PAUSE_TAIL_S
def _car_idle(self, mono) -> bool:
"""EV-18: is the car known to draw nothing? A fresh reading that says
it is not charging (mode3 A or B) at under `CAR_PEAK_MIN_W`. Not an
unknown figure: the house's own need is graded in such a cycle."""
r = getattr(self.car, "reading", None)
if r is None or not r.available or r.charging is not False:
return False
p = self.car.car_w(mono)
return p is not None and p < CAR_PEAK_MIN_W
def _car_quarter(self, proj, w, mono, wg=None) -> None:
"""The car's energy in the open quarter, for the average the guard's
house leaves out and for the peak line."""
house leaves out and for the peak line. `wg` (EV-15) is the figure for
grading during our own pause; its energy is kept apart (`ws_p`) so the
guard's input is unchanged."""
q = self._carq
key = None if proj is None else proj.block_start
last = q["mono"]
if key != q["key"]:
# EV-18: `whole` when the count covers the block: it follows on
# from the block before, or starts in its first seconds (not
# after a restart or a gap).
whole = key is not None and (
float(proj.elapsed_s) <= 5.0 or (
last is not None and q["key"] is not None
and (key - q["key"]).total_seconds() == QUARTER_S))
self._car_bank(q)
q["key"], q["ws"] = key, 0.0
if key is not None and w is not None and last is not None:
q["ws"] += float(w) * min(max(mono - last, 0.0), 5.0)
q["key"], q["ws"], q["ws_p"] = key, 0.0, 0.0
q["whole"] = whole
if key is not None and last is not None:
dt = min(max(mono - last, 0.0), 5.0)
if w is not None:
q["ws"] += float(w) * dt
elif wg is not None:
q["ws_p"] = q.get("ws_p", 0.0) + float(wg) * dt
q["mono"] = mono
def _car_bank(self, q) -> None:
@@ -233,14 +287,17 @@ class CarMixin:
del self.car_peak_q[k]
self.store.set(CAR_PEAK_KEY, dict(self.car_peak_q))
def car_avg_w(self, proj, w) -> float:
def car_avg_w(self, proj, w, graded=False) -> float:
"""The car's average over the whole open quarter: what it drew so far
and `w` for the rest."""
and `w` for the rest. `graded` (EV-15) adds what it drew during our
own pause."""
if proj is None or w is None:
return 0.0
left = max(0.0, QUARTER_S - float(proj.elapsed_s))
so_far = self._carq["ws"] if self._carq["key"] == proj.block_start \
else 0.0
if graded and self._carq["key"] == proj.block_start:
so_far += self._carq.get("ws_p", 0.0)
return (so_far + float(w) * left) / QUARTER_S
def car_exclude(self, proj, w):
@@ -264,7 +321,7 @@ class CarMixin:
the car asked for. Unchanged without a fresh car reading."""
if proj is None or w is None or proj.block_start is None:
return proj
avg = self.car_avg_w(proj, w)
avg = self.car_avg_w(proj, w, graded=True)
left = max(0.0, QUARTER_S - float(proj.elapsed_s))
held = float(proj.held_w)
done_ws = QUARTER_S * float(proj.projected_w) - max(held, 0.0) * left
@@ -280,13 +337,27 @@ class CarMixin:
`real_proj` is the projection WITH the car, whatever the guard saw."""
mono = self.car_now()
w = self.car_alarm_w()
self._car_quarter(real_proj, w, mono)
# EV-15: the figure for grading only. Our own phase change holds the
# car at 0 A and the energy meter cannot corroborate it then, so for
# that bounded time its fresh, not stuck figure stands in.
wg = w
own = (w is None or float(w) <= 0.0) and self._car_own_pause(mono)
if w is None and own:
wg = self.car.car_w_paused(mono)
self._car_quarter(real_proj, w, mono, wg)
self._car_session_tick(mono)
explains = over = False
if real_proj is not None and target_w is not None \
and real_proj.block_start is not None:
# EV-10: every cycle, so the latches do not depend on the option.
graded = self._car_explains_alarm(real_proj, guard, target_w, w)
# EV-18: a car known to draw nothing counts as 0 W for the latches
# (the house's own need); it and a 0 W figure explain nothing,
# but in our own pause (EV-15).
idle = wg is None and self._car_idle(mono)
graded = self._car_explains_alarm(real_proj, guard, target_w,
0.0 if idle else wg)
if idle or (w is not None and float(w) <= 0.0 and not own):
graded = False
if self.car_cover:
explains = over = graded
elif w is not None:
@@ -316,35 +387,41 @@ class CarMixin:
batteries left are graded by `load_too_high` on where the period lands
(SAFETY-81 / 87); a floor that leaves nothing is graded by SAFETY-126's
`misses_aim` (the batteries at 0 W from now on), latched for the
quarter. That latch is kept here twice, on the period as it is
(`_car_need_real`) and without the car (`_car_need_excl`), from the
same `misses_aim` and the same batteries reading. Both reset at a new
quarter and when the guard no longer wants power, whatever the cover
option says (this runs every cycle). A car that is 0 W, or untrusted
(`w` None sets the second latch), makes the two equal and explains
nothing."""
batt, prev = self.site_batt_w, self._car_batt_prev
self._car_batt_prev = batt
quarter (`_car_need_real`, and `_car_need_excl` without the car).
EV-18 (owner 2026-11-19): without the car, the batteries keep giving
what they give now (the lower of two readings), re-checked every cycle;
a miss seen so (`_car_need_house`) never lets the car explain for the
rest of the quarter. The car also explains where the period with it,
on the same batteries, misses (`_car_over_now`). Only a trusted figure
latches: an untrusted car (`w` None) or an unknown battery reading
explains nothing in that cycle only. All reset at a new quarter and
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
self._car_batt_prev = now
wants = bool(guard is not None and guard.engaged
and guard.blind is None
and (guard.wanted_w or 0.0) > 0.0)
if real_proj.block_start != self._car_latch_block:
if real_proj.block_start != self._car_latch_block or not wants:
self._car_latch_block = real_proj.block_start
self._car_need_real = self._car_need_excl = False
if not wants:
self._car_need_real = self._car_need_excl = False
self._car_need_house = self._car_over_now = False
batt = now
if batt is not None and prev is not None:
batt = min(float(batt), float(prev))
excl = self.car_exclude_alarm(real_proj, w)
if wants:
if batt is None:
self._car_need_real = self._car_need_excl = True
else:
self._car_need_real = self._car_need_real or \
peakguard.misses_aim(real_proj, batt_w=batt,
target_w=target_w)
self._car_need_excl = self._car_need_excl or w is None or \
if wants and batt is not None:
self._car_need_real = self._car_need_real or \
peakguard.misses_aim(real_proj, batt_w=batt,
target_w=target_w)
self._car_over_now = self._car_over_now or \
self._car_lands_over(real_proj, now, batt, target_w)
if w is not None:
whole = self._carq.get("whole", True)
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, whole)
if w is None or batt is None or not wants \
or not (guard.saturated or guard.floor_limited):
return False
@@ -354,7 +431,8 @@ class CarMixin:
rating = guard.able_w
else:
return bool(not guard.within_aim and self._car_need_real
and not self._car_need_excl)
and not self._car_need_house
and (self._car_over_now or not self._car_need_excl))
def high(p):
return peakguard.load_too_high(
@@ -362,6 +440,20 @@ class CarMixin:
achievable_w=rating)
return bool(high(real_proj) and not high(excl))
@staticmethod
def _car_lands_over(p, now, gives, target_w, whole=True) -> bool:
"""EV-18: does the period end more than `ALARM_MISS_W` over the aim
with the batteries giving `gives` W from now on (`now`: what they gave
in the meter's figure)? Not `whole`: the car's share of what is done
is not known (a restart, a gap), so only the rest is graded."""
if whole:
return peakguard.load_too_high(p, batt_w=now, ceiling_w=target_w,
achievable_w=gives)
if QUARTER_S - float(p.elapsed_s) <= 0.0:
return False
rest = float(p.held_w) + float(now) - float(gives)
return rest - float(target_w) > peakguard.ALARM_MISS_W
def _car_session_tick(self, mono) -> None:
"""A charging session is a plug-in: the state goes from no car to a
car. The notice is raised once per session."""
+344
View File
@@ -0,0 +1,344 @@
"""EV-15: the add-on's own phase change at the peak reserve raises no alarm.
`python3 -B test_ev15.py`
The rig (EV-10 and EV-10b, F-2): cover on, the batteries at the reserve, the car
charging and explaining the excess. The add-on's own 3 -> 1 phase switch sets
the car to 0 A; with the car not charging its figure is no longer corroborated
(`CarTracker.corroborated`), so `car_alarm_w()` is None, nothing is explained,
and PEAK_GUARD_FLOOR_LIMITED plus `goodwe_peak_soc_floor` fire. The rule: for
the add-on's own sequence only (`ctl_car._car_own_pause`, bounded) the car's
fresh, not stuck figure stands in for grading.
1. The rig shapes end to end through the car cycle: 3 -> 1 and 1 -> 3.
2. A house overload that starts during the sequence still alarms, as on Off.
3. Aborted (Off, Stop, unplug), refused, an outside writer: no grace.
4. The bounds, and the figure that stands in (stale, stuck: nothing).
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
"""
import asyncio
import logging
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, carmode, chargers as CH # noqa: E402
import ev04_peak as P # noqa: E402
import safety81_sim as s81 # noqa: E402
logging.disable(logging.CRITICAL)
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
def at(t, fn):
return {"t": t, "fn": fn}
def beside(plant, c):
"""The writer runs BESIDE the cycle, as in production (`car_kick`): its 1 s
poll for the read-back lands after the cycle's own read, and the cycle does
not wait for the writer (`ev04_peak.drive` does)."""
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)
c.charger._sleep = sleep
c.car_settle = settle
def run(house, cap, t_res, t_sw, new, *, extra=None, mode="manual",
sim_fn=None, dur=895, plug=True, side=False):
"""Reserve at `t_res`, our phase change to `new` at `t_sw`. Returns the
run, a per-second trace (second, own-pause, explains, red rows) and the
alarms."""
tr = []
def note(plant, c):
red = [x["id"] for x in c.checks()
if x["ok"] is False and not x["warn"]] \
if t_sw - 5 <= plant.t <= t_sw + 90 else []
g = c.peak_guard
lim = bool(g is not None and (g.floor_limited or g.saturated))
tr.append((plant.t, getattr(c, "_car_own_pause", lambda _t: False)(c.car_now()), c.car_explains,
red, plant.ch.power_w, plant.ch.state, lim))
def reserve(plant, c):
plant.soc = 19.0
plant.load = lambda t: house + 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, dur)}
ev[t_res] = lambda p, c: (reserve(p, c), note(p, c))
ev[t_sw] = lambda p, c: (switch(p, c), note(p, c))
if side:
ev[t_sw - 2] = lambda p, c: (beside(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 = None
if sim_fn is not None or side:
from chargersim import SimCharger
sim = SimCharger(setpoint_a=16)
sim_fn = sim_fn or (lambda s: None)
sim_fn(sim)
r = P.drive(s81.constant(house), dur=dur, rating=12000.0, soc=60.0,
cap=cap, phases=(3 if new == 1 else 1), user_a=16, setpoint=16,
mode=mode, events=ev, sim=sim, plug=plug)
return r, tr, P.ids(r, *P.ALARMS)
def reds(tr):
return [x for x in tr if x[3]]
# =========================================================================== #
print("1. THE RIG SHAPES THROUGH THE CAR CYCLE")
# =========================================================================== #
SHAPES = (
("EV-10 shape: house 3 kW, car 11 kW, aim 6 kW, 3 -> 1",
3000.0, 6050.0, 300, 600, 1),
("EV-10b shape: a 9411 W limit, 3 -> 1", 2000.0, 9461.0, 300, 600, 1),
("1 -> 3 (the car 3.7 kW, then 11 kW), aim 5 kW", 2500.0, 5050.0,
100, 600, 3),
)
for name, house, cap, t_res, t_sw, new in SHAPES:
r, tr, al = run(house, cap, t_res, t_sw, new)
c, sim = r["c"], r["sim"]
sw = [x for x in sim.writes() if x[1] == "phases"]
check(f"{name}: the car at the reserve covers, and the add-on's own "
f"sequence ran (0 A, select, the current back)",
len(sw) == 1 and [x[2] for x in sim.writes("current")][-2:]
== [0.0, 16.0] and sim.phases_allowed == new)
pause = [x for x in tr if x[1]]
check(f"{name}: the own-pause grace was on during it, and ended",
len(pause) >= 10 and not any(x[1] for x in tr[-1:])
and (pause[-1][0] - pause[0][0])
<= getattr(ctl_car, "OWN_PAUSE_MAX_S", 0)
+ getattr(ctl_car, "OWN_PAUSE_TAIL_S", 0))
check(f"{name}: no PEAK_GUARD_FLOOR_LIMITED / saturated, no "
f"goodwe_peak_soc_floor notification", al == [])
check(f"{name}: no red row in any sample around the switch",
reds(tr) == [])
limited = [x for x in tr if x[1] and x[6]]
check(f"{name}: in every cycle of the sequence in which the guard is "
f"limited (the cycle of the rig's alarm among them) the car "
f"explains it", len(limited) >= 1 and all(x[2] for x in limited)
and any(x[2] for x in tr if x[0] == t_sw + 1))
check(f"{name}: and in every limited cycle after it, to the quarter's end",
all(x[2] for x in tr if x[0] >= t_sw and x[6]))
# =========================================================================== #
print("\n2. A HOUSE OVERLOAD DURING THE SEQUENCE STILL ALARMS")
# =========================================================================== #
def overload(plant, c):
plant.load = lambda t: 25000.0 + plant.ch.power_w
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, extra={606: overload})
ro, tro, alo = run(3000.0, 6050.0, 300, 600, 1, extra={606: overload},
mode="off", plug=False)
rn, trn, aln = run(3000.0, 6050.0, 300, 900, 1, extra={606: overload})
check("PRECONDITION: on Off (no car) the same load alarms, and in Manual "
"with no phase change", alo != [] and aln != [])
check("a 25 kW house overload that starts 6 s into the sequence (the car "
"paused): the alarm fires", al != [])
print(f" alarm seconds: in the sequence {[t for t, _ in al]}, Off without "
f"the car {[t for t, _ in alo]}, Manual with no phase change "
f"{[t for t, _ in aln]}")
check("...at the same second as on Off and as in Manual with no phase change",
bool(al) and bool(alo) and bool(aln)
and al[0][0] == alo[0][0] == aln[0][0])
check("...and the car does not explain it (during the sequence too)",
not any(x[2] for x in tr if 640 <= x[0] <= 660))
# =========================================================================== #
print("\n3. ABORTED, REFUSED, OUTSIDE: NO GRACE AFTER IT")
# =========================================================================== #
def hit(res, t0, secs):
return [x for x in res if t0 <= x[0] <= t0 + secs and x[1]]
def off_now(plant, c):
asyncio.get_event_loop().create_task(c.handle_action("car_mode",
value="off"))
def stop_now(plant, c):
c.auto = False
def unplug(plant, c):
plant.ch.unplug()
slow = lambda s: setattr(s, "stop_delay_s", 8.0) # noqa: E731
for what, fn in (("Off", off_now), ("Stop", stop_now), ("unplug", unplug)):
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, extra={602: fn},
sim_fn=slow)
check(f"{what} 2 s into the sequence: the grace is off from the next "
f"cycle on", not hit(tr, 604, 200)
and any(x[1] for x in tr if 600 <= x[0] <= 602))
def refuse_phases(sim):
sim.request_phases = lambda n: False
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, sim_fn=refuse_phases)
check("the select is refused: the grace ends at once (no cycle of it after "
"the refusal), the current comes back",
len([x for x in r["sim"].writes("current")]) >= 2
and not hit(tr, 606, 200))
def outside_zero(plant, c):
plant.ch.set_current(0.0)
r2, tr2, al2 = run(3000.0, 6050.0, 300, 900, 1, extra={602: outside_zero})
check("an outside writer's 0 A: no grace, and the normal grading (no car "
"power: nothing explained) raises the alarm as before",
not any(x[1] for x in tr2) and not any(x[2] for x in tr2
if 610 <= x[0] <= 700)
and al2 != [])
# =========================================================================== #
print("\n4. THE BOUNDS AND THE FIGURE THAT STANDS IN")
# =========================================================================== #
class _C(ctl_car.CarMixin):
"""The mixin with just what `_car_own_pause` reads."""
def __init__(self):
self.o = {}
self.car_init({}, type("S", (), {"data": {}, "set": lambda s, k, v: 0})())
self.car_mode = carmode.MANUAL
self.auto, self.shadow = True, False
self.inverters, self.site_sign_wd = [], type("W", (), {"tripped": False})()
self.circ_wd = type("W", (), {"tripped": False})()
self.charger = type("H", (), {"configured": lambda s: True})()
self.car = CH.CarTracker()
self.car.reading = CH.ChargerReading(available=True, state="B")
c = _C()
c.car_writer.seq = {"stage": "settle", "t0": 100.0, "n": 1, "tries": 0,
"prev": 16.0}
M = ctl_car.OWN_PAUSE_MAX_S
check("bound: the sequence's own maximum is its waits (0 A wait, settle, "
"three tries at 15 s, the select) and no more",
M == carmode.ZERO_WAIT_S + carmode.SETTLE_S + carmode.MAX_TRIES * 15.0
+ 10.0 and ctl_car.OWN_PAUSE_TAIL_S == CH.CORR_WINDOW_S)
check("bound: on at the 0 A write and up to the maximum",
c._car_own_pause(100.0) and c._car_own_pause(100.0 + M))
check("bound: off one second past it", not c._car_own_pause(101.0 + M))
c.car_writer.seq = None
c.car_writer.phase_done_at = 200.0
T = ctl_car.OWN_PAUSE_TAIL_S
check("bound: after the current is set again it lasts one corroboration "
"window", c._car_own_pause(200.0 + T) and not c._car_own_pause(201.0 + T))
c.car_writer.phase_done_at = None
check("no sequence and none just done: no grace", not c._car_own_pause(100.0))
c.car_writer.seq = {"stage": "settle", "t0": 100.0, "failed": True}
check("a refused write marks the sequence: no grace", not c._car_own_pause(110.0))
c.car_writer.seq = {"stage": "settle", "t0": 100.0}
c.car_mode = carmode.OFF
check("Off: no grace", not c._car_own_pause(110.0))
c.car_mode, c.shadow = carmode.MANUAL, True
check("shadow mode: no grace", not c._car_own_pause(110.0))
c.shadow, c.auto = False, False
check("control stopped: no grace", not c._car_own_pause(110.0))
c.auto = True
c.car_writer.hold = True
check("another writer (hold): no grace", not c._car_own_pause(110.0))
c.car_writer.hold = False
c.car_writer.seq, c.car_writer.zero_sent_at = None, 100.0
check("0 A sent, not yet back: grace from the send, to the maximum, no more",
c._car_own_pause(100.0) and c._car_own_pause(100.0 + M)
and not c._car_own_pause(101.0 + M))
c.car_writer.zero_sent_at = None
c.car_writer.phase_done_at = 200.0
c.car_writer.hold = True
check("another writer in the 60 s after the current is set: no grace",
not c._car_own_pause(210.0))
c.car_writer.hold, c.car_writer.phase_done_at = False, None
c.car_writer.seq = {"stage": "settle", "t0": 100.0}
c.car.reading = CH.ChargerReading(available=True, state="A")
check("unplugged: no grace", not c._car_own_pause(110.0))
c.car.reading = CH.ChargerReading(available=True, state="B")
check("PRECONDITION: the same state is on", c._car_own_pause(110.0))
tk = CH.CarTracker()
tk.reading = CH.ChargerReading(available=True, state="B", power_w=500.0,
allowed_a=16.0, phases_allowed=1)
tk.last_ok = 0.0
check("the stand-in figure is the fresh reading, capped by the read-back",
tk.car_w_paused(5.0) == 500.0 and tk.car_w_trusted(5.0) is None)
check("a stale reading stands in for nothing", tk.car_w_paused(100.0) is None)
tk.stuck_now = True
check("a stuck reading stands in for nothing", tk.car_w_paused(5.0) is None)
# =========================================================================== #
print("\n5. THE WRITER RUNS BESIDE THE CYCLE (review F-1)")
# =========================================================================== #
# The car stops (state B) in the same Home Assistant update as the 0 A
# read-back; the write has not returned yet, so no sequence exists. The window
# opens when the write is SENT (`ManualWriter.zero_sent_at`).
def lagged(lag, delay):
def f(s):
s.lag_s, s.stop_delay_s = lag, delay
return f
for lag, delay in ((2, 0), (0, 0), (2, 3), (5, 2)):
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, side=True,
sim_fn=lagged(lag, delay))
nm = f"beside the cycle, lag {lag} s, stop delay {delay} s"
limited = [x for x in tr if x[0] >= 600 and x[6]]
check(f"{nm}: our sequence ran (select once, then 16 A again)",
len([x for x in r["sim"].writes("phases")]) == 1
and r["sim"].phases_allowed == 1
and [x[2] for x in r["sim"].writes("current")][-2:] == [0.0, 16.0])
check(f"{nm}: no PEAK_GUARD_FLOOR_LIMITED, no goodwe_peak_soc_floor",
al == [])
check(f"{nm}: no red row, and the car explains every limited cycle",
reds(tr) == [] and all(x[2] for x in limited))
def not_taken(plant, c):
plant.ch.refuse = "ignore" # HA accepts, the charger does nothing
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, side=True,
sim_fn=lagged(0, 0), extra={600: not_taken})
check("the 0 A write is not taken (read-back never follows): the window was "
"open while it waited", any(x[1] for x in tr if 600 <= x[0] <= 606))
own = [x[0] for x in tr if x[1]]
runs = 1 + len([1 for a, b in zip(own, own[1:]) if b - a > 1])
check("...and no grace after the refusal (the retry, RETRY_S later, opens it "
"again only while that write waits: at most 3 runs of 11 s), no "
"sequence made", not hit(tr, 613, 40) and r["c"].car_writer.seq is None
and 1 <= runs <= 3 and len(own) <= 3 * 11)
check("...the car went on charging and nothing was written but the 0 A",
r["sim"].power_w > 5000.0 and not r["sim"].writes("phases"))
print()
if fails:
print(f"FAIL: {len(fails)} check(s)")
for f in fails:
print(" -", f)
sys.exit(1)
print("ok: EV-15")
+681
View File
@@ -0,0 +1,681 @@
"""EV-18: no floor alarm at a quarter's start while the car explains the excess
(EV-15 rig F-A). `python3 -B test_ev18.py`
The rig: both batteries at the peak reserve, the car charging, and
PEAK_GUARD_FLOOR_LIMITED + `goodwe_peak_soc_floor` at a quarter's start, red
for most of the quarter, while the grid excess was smaller than the car. Two
causes, both latched for the quarter by `_car_need_excl`:
C1 one cycle with no trusted car figure set the latch (T1);
C2 "without the car" assumed the batteries give 0 W from now on, so what
the loop still gives below the reserve counted as house (T2).
The rule now (owner 2026-11-19, Q1-Q3): without the car the batteries keep
giving what they give now (the lower of the last two readings, re-checked
every cycle); a house need seen with a trusted car figure stays latched to the
quarter's end; an unknown car figure keeps the alarm only while it is unknown.
T-ids are the test plan's (reports/EV-18-test-plan.md). "base" is 9fdce02.
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 chargers as CH, ctl_car, tariff # noqa: E402
from chargersim import SimCharger # noqa: E402
from named_absence import first, nth, present # noqa: E402
import ev04_peak as P # noqa: E402
import ev18_peak as H # noqa: E402
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
AIM = H.AIM
CAR = 1380.0
E = H.E
# Measured on base 9fdce02 with this file's own runs: the seconds of
# goodwe_peak_soc_floor in the honest shapes, which must not come later now. An
# honest shape steps the house at E, and the meter shows it at E+1.
T5_BASE = [E + 1] # also T6 (T5 shape), T8, T9(a), T10(b) T5
T7_BASE = E + 72
T9B_BASE = [] # 400 W real: never uncorroborated (Findings)
T9C_BASE = E + 1 # 100 W real: never trusted at the edge
T10A_T5_BASE = [E + 2] # the guard disengages at E+1 (no battery reading)
T11_BASE = [E + 13] # SAFETY-87: ALARM_HOLD_S after the step
T13_BASE = [E + 301]
T15_T5_BASE = [E + 10] # x10: one cycle
# =========================================================================== #
print("1. UNIT: car_cycle ACROSS A QUARTER EDGE (a real `_carq`, not preset)")
# =========================================================================== #
BS = datetime(2026, 11, 17, 21, 15, tzinfo=timezone.utc) # the edge E
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."""
def __init__(self, wants=True, within_aim=False):
self.floor_limited, self.saturated = True, False
self.floor_w, self.able_w, self.ceiling_w = 0.0, None, AIM + 50.0
self.engaged, self.blind = True, None
self.wanted_w = 300.0 if wants else 0.0
self.within_aim = within_aim
def urun(secs, grid, batt, w, *, x=1, mono_x=None, c=None, guard=None):
"""`car_cycle` once per entry of `secs` (seconds from the edge E, `x` fake
seconds apart). `grid(t)` is the meter (house + car - batteries),
`batt(t)` the site battery reading, `w(t)` the trusted car figure. Returns
(car, {t: car_explains})."""
c = c or _Car()
mono_x = x if mono_x is None else mono_x
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 * x
c._now = 10000.0 + t * mono_x / x
c.w, c.site_batt_w = w(t), batt(t)
c.car_cycle(p, guard(t) if guard else _G(), AIM, None)
out[t] = c.car_explains
return c, out
def const(v):
return lambda t: v
def run_of(d, t0, t1):
return [d[t] for t in sorted(d) if t0 <= t <= t1]
# --- T1: the car figure untrusted for the edge's first cycles --------------- #
def t1(x=1, mono_x=None):
_c, ex = urun(range(-30, 121, x), const(13000.0 + CAR), const(0.0),
lambda t: None if 0 <= t <= 2 * x else CAR, x=x,
mono_x=mono_x)
return ex
ex = t1()
print(f" T1 explains E-1..E+5: {run_of(ex, -1, 5)}")
check("T1 PRECONDITION: before the edge the car (trusted) explains the "
"excess (house 13 000 W, car 1 380 W, grid 14 380 W)",
all(run_of(ex, -30, -1)) and len(run_of(ex, -30, -1)) == 30)
check("T1 (Expected 5): while the car figure is unknown (E+0..E+2) it "
"explains nothing, so the alarm stands", not any(run_of(ex, 0, 2)))
_c1b, ex1b = urun(range(-30, 121), const(12500.0 + CAR - 800.0), const(800.0),
lambda t: None if 0 <= t <= 2 else CAR)
check("T1b (the EV-10 path: the grid lands under the aim, the batteries at "
"0 W would miss; house 12 500 W, b 800 W): unknown E+0..E+2, released "
"at E+3 and explained to E+120",
not any(run_of(ex1b, 0, 2)) and all(run_of(ex1b, 3, 120))
and len(run_of(ex1b, 3, 120)) == 118)
check("T1 (Expected 3): released at the first trusted cycle (E+3) and "
"explained to E+120 (base: latched False to E+120)",
all(run_of(ex, 3, 120)) and len(run_of(ex, 3, 120)) == 118)
# --- T2c: the battery W boundary, graded on the lower of two readings ------- #
def t2c(b_of):
_c, ex = urun(range(0, 6), lambda t: 14000.0 + CAR - b_of(t), b_of,
const(CAR))
return run_of(ex, 0, 5)
e391, e389 = t2c(const(391.0)), t2c(const(389.0))
e395 = t2c(lambda t: 395.0 if t == 0 else 385.0)
print(f" T2c 391 W {e391}, 389 W {e389}, 395 then 385 W {e395}")
check("T2c: b steady at 391 W (house alone with the real batteries lands "
"13 609 W, aim + 9 W): the car explains from E+0", all(e391)
and len(e391) == 6)
check("T2c: b at 389 W (13 611 W, aim + 11 W): it does not, from E+0",
not any(e389) and len(e389) == 6)
check("T2c: readings 395 then 385 W: graded on 385 W, no explanation from "
"the second cycle on", not any(e395[1:]) and len(e395) == 6)
# --- T4: ALARM_MISS_W, batteries at 0 W -------------------------------------- #
e09 = run_of(urun(range(0, 6), const(13609.0 + CAR), const(0.0),
const(CAR))[1], 0, 5)
e11 = run_of(urun(range(0, 6), const(13611.0 + CAR), const(0.0),
const(CAR))[1], 0, 5)
check("T4 unit: the house alone at aim + 9 W: the car explains from E+0; at "
"aim + 11 W it does not", all(e09) and len(e09) == 6 and not any(e11))
# --- T8 / N2: 0 W and tiny cars ---------------------------------------------- #
e0 = run_of(urun(range(-5, 30), const(14000.0 - 800.0), const(800.0),
const(0.0))[1], -5, 29)
e50 = run_of(urun(range(-5, 30), const(14090.0 + 50.0), const(0.0),
const(50.0))[1], -5, 29)
check("T8 unit: a 0 W car never explains, whatever the batteries give (T2 "
"shape, b 800 W)", not any(e0) and len(e0) == 35)
check("T8 unit: a 50 W car with the house at 14 090 W never explains",
not any(e50) and len(e50) == 35)
# N2: a car that drew 11 kW earlier in the quarter and now reports 0 W
c0, ex0 = urun(range(0, 400), lambda t: 2600.0 + (11040.0 if t < 300 else 0.0),
const(0.0), lambda t: 11040.0 if t < 300 else 0.0)
check("N2: a trusted 0 W figure explains nothing, also after the car drew "
"earlier in the quarter", not any(run_of(ex0, 300, 399)))
# --- T8 unit: a car known to draw nothing is not an unknown car ------------- #
class _Tracker:
"""The two things `_car_idle` reads: the reading, and its fresh power."""
def __init__(self, available):
self.reading = CH.ChargerReading(available=available, state="B",
charging=False, power_w=0.0)
def car_w(self, _now):
return 0.0 if self.reading.available else None
@staticmethod
def status(*_a):
return "charging"
def idle_then_charging(available):
c = _Car()
c.car = _Tracker(available)
_c, ex = urun(range(0, 900),
lambda t: 14090.0 if t < 60 else 13000.0 + CAR, const(0.0),
lambda t: None if t < 60 else CAR, c=c)
return ex
exi, exu = idle_then_charging(True), idle_then_charging(False)
check("T8 unit: a car known idle (mode3 B, 0 W, fresh) while the house alone "
"misses (14 090 W): that house need is latched, so the car charging "
"from E+60 does not explain the quarter (test_ev10's `swapped` case)",
not any(run_of(exi, 0, 899)))
check("T8 unit: the same with the charger unavailable (unknown car): the "
"alarm stands while unknown and is released at E+60 (Expected 5)",
not any(run_of(exu, 0, 59)) and all(run_of(exu, 60, 899)))
# --- T10(a) unit: the battery reading lost for one cycle --------------------- #
cA, eA = urun(range(-3, 10), const(14000.0 + CAR - 800.0),
lambda t: None if t == 1 else 800.0, const(CAR))
check("T10(a) unit, T2 shape: the cycle with no battery reading explains "
"nothing (no last-known W credited); the next ones do",
eA.get(1) is False and eA.get(0) is True and all(run_of(eA, 2, 9))
and len(run_of(eA, 2, 9)) == 8)
# --- T13 unit: a house need seen with a trusted car stays latched ----------- #
c13, e13 = urun(range(-5, 1000),
lambda t: (15500.0 if 300 <= t < 360 else 13000.0) + CAR,
const(0.0), const(CAR))
check("T13 unit: the house steps to 15 500 W at E+300 for 60 s (landing "
"without the car 14 667 W): not explained from E+300 to the quarter's "
"end, though the house is back at 13 000 W from E+360",
all(run_of(e13, 0, 299)) and not any(run_of(e13, 300, 899))
and len(run_of(e13, 300, 899)) == 600)
check("T13 unit: ...and released by the new quarter", all(run_of(e13, 900, 999)))
c13g, e13g = urun(range(0, 400),
lambda t: (15500.0 if 100 <= t < 160 else 13000.0) + CAR,
const(0.0), const(CAR),
guard=lambda t: _G(wants=not (t == 250)))
check("T13 unit: ...or by the guard no longer wanting power (EV-10)",
not any(run_of(e13g, 100, 249)) and all(run_of(e13g, 251, 399)))
# --- T14: no flicker --------------------------------------------------------- #
def floor_edges(ex):
"""Per quarter, False -> True edges of the floor alarm the stub implies
(floor-limited, within_aim False, not explained)."""
out, was = {}, False
for t in sorted(ex):
al = not ex[t]
if al and not was:
out[t // 900] = out.get(t // 900, 0) + 1
was = al
return out
_ca, eta = urun(range(0, 1200),
lambda t: 13610.0 + (40.0 if int(t // 7) % 2 else -40.0) + CAR,
const(0.0), const(CAR))
_cb, etb = urun(range(0, 1200),
lambda t: 14000.0 + CAR - (400.0 if int(t // 7) % 2 else 800.0),
lambda t: 400.0 if int(t // 7) % 2 else 800.0, const(CAR))
fa, fb = floor_edges(eta), floor_edges(etb)
print(f" T14 alarm edges per quarter: (a) {fa} (b) {fb}")
check("T14(a): the house alone straddles aim + 10 W by 40 W every 7 s: at "
"most one alarm edge per quarter", all(v <= 1 for v in fa.values()))
check("T14(b): T2 shape with b alternating 400 / 800 W every 7 s: no alarm "
"edge at all (base: one per quarter)", fb == {})
# --- T15 unit: x10 ------------------------------------------------------------ #
ex10 = t1(x=10)
check("T15 unit x10 (wall and mono 10 s a cycle): T1 the same; released "
"within 1 cycle (E+30, the first trusted cycle)",
not any(run_of(ex10, 0, 20)) and all(run_of(ex10, 30, 120))
and all(run_of(ex10, -30, -10)))
ex10m = t1(x=10, mono_x=1)
check("T15 unit, mono x1 and wall x10: the same verdicts (the edge comes from "
"the projection's block_start, not from mono)",
not any(run_of(ex10m, 0, 20)) and all(run_of(ex10m, 30, 120)))
# =========================================================================== #
print("\n2. THE REAL CONTROLLER ACROSS THE EDGE (N=2, both at the reserve)")
# =========================================================================== #
RUNS = [] # (name, alarm edges) of every run, for N5
def summary(name, r, tr):
RUNS.append((name, H.edges(tr)))
w = H.window(tr, E - 120, E + 900)
lim = [x for x in w if x["lim"]]
print(f" {name}: alarms {[t - E for t in H.alarms(r)]} edges "
f"{[t - E for t in H.edges(tr)]} red {len(H.red_secs(tr))} s "
f"(first {[t - E for t in H.red_secs(tr)[:1]]}) errors "
f"{len(H.errors(tr))} limited {len(lim)} explained "
f"{sum(1 for x in lim if x['explains'])} cmd {H.commands(r, tr)}")
return w, lim
def quiet(r, tr):
"""No floor notification, no ERROR, no red peak_guard row, E-120..E+900."""
return H.alarms(r) == [] and H.red_secs(tr) == [] and H.errors(tr) == []
def all_explained(lim, t0=E - 120):
return bool(lim) and all(x["explains"] for x in lim if x["t"] >= t0)
ZERO = const(0.0)
def honest(w):
"""An honest shape steps at the edge, so Off has no alarm before it."""
return H.shape(w, at=E)
# --- T2: the rig F-A shape ---------------------------------------------------- #
r2, tr2 = H.run(H.shape(14000.0), a=ZERO, b=const(800.0))
w2, lim2 = summary("T2", r2, tr2)
check("T2 PRECONDITION: limited at the reserve from the edge, the car trusted, "
"b 800 W, grid excess 980 W < car",
present(first(x for x in w2 if x["t"] == E and x["lim"]))
and all(x["w"] == CAR and x["batt"] == 800.0 for x in lim2))
check("T2: no goodwe_peak_soc_floor, no PEAK_GUARD_FLOOR_LIMITED ERROR, no "
"red peak_guard row in E-120..E+900 (base: alarm at E+0, red to E+900)",
quiet(r2, tr2))
check("T2: the car explains every floor-limited cycle, E+0..E+10 among them",
all_explained(lim2) and len([x for x in lim2 if x["t"] <= E + 10]) == 11)
# --- T2b: the batteries give less later --------------------------------------- #
r2i, tr2i = H.run(H.shape(14000.0), a=ZERO,
b=lambda t: 800.0 if t < E + 300 else 0.0)
summary("T2b(i)", r2i, tr2i)
a2i = H.alarms(r2i)
check("T2b(i): b drops to 0 W at E+300 (landing without the car 13 733 W): "
"the alarm fires within 1 cycle of E+300",
len(a2i) == 1 and E + 300 <= nth(a2i, 0) <= E + 301)
check("T2b(i): ...and stays to the quarter's end (a house need with a "
"trusted car is latched)", all(x["alarm"] and x["red"] for x in
H.window(tr2i, E + 302, E + 899)))
r2ii, tr2ii = H.run(H.shape(14000.0), a=ZERO,
b=lambda t: 800.0 if t < E + 300 else 400.0)
summary("T2b(ii)", r2ii, tr2ii)
check("T2b(ii): b drops to 400 W (landing 13 467 W): no alarm to E+900",
quiet(r2ii, tr2ii))
# --- T3: batteries at 0 W, and the 11 kW car ---------------------------------- #
r3, tr3 = H.run(H.shape(13000.0), a=ZERO, b=ZERO)
w3, lim3 = summary("T3", r3, tr3)
check("T3: batteries 0 W, house 13 000 W, car 1 380 W: no alarm, no red row, "
"the car explains every limited cycle incl. E+0..E+10, one car notice",
quiet(r3, tr3) and all_explained(lim3)
and len(P.ids(r3, P.OVER)) == 1
and all(x["explains"] for x in lim3 if x["t"] <= E + 10))
def plug_at(t0):
return {t0: lambda p, c: p.ch.plug_in()}
r3k, tr3k = H.run(H.shape(2600.0, before=2600.0), a=ZERO, b=ZERO, car_a=16,
phases=3, aim=6344.0, plug=False, extra=plug_at(E - 120))
w3k, lim3k = summary("T3 11 kW", r3k, tr3k)
check("T3 11 kW: house 2 600 W, car 11 kW, aim 6 344 W (base P 21:30): no "
"alarm, the car explains every limited cycle",
quiet(r3k, tr3k) and all_explained(lim3k)
and len(P.ids(r3k, P.OVER)) == 1)
# --- T4 controller ------------------------------------------------------------ #
r409, tr409 = H.run(H.shape(13609.0), a=ZERO, b=ZERO)
summary("T4 13 609", r409, tr409)
check("T4: the house alone at aim + 9 W: no alarm", quiet(r409, tr409))
r411, tr411 = H.run(H.shape(13611.0), a=ZERO, b=ZERO)
r411o, tr411o = H.run(H.shape(13611.0), a=ZERO, b=ZERO, mode="off")
summary("T4 13 611", r411, tr411)
summary("T4 13 611 Off", r411o, tr411o)
check("T4: at aim + 11 W the alarm at the same cycle as Off (and as base, "
"E+0)", H.alarms(r411) == H.alarms(r411o) == [E])
# --- T5: an honest alarm ------------------------------------------------------ #
r5, tr5 = H.run(honest(14090.0), a=ZERO, b=ZERO)
r5o, tr5o = H.run(honest(14090.0), a=ZERO, b=ZERO, mode="off")
summary("T5", r5, tr5)
summary("T5 Off", r5o, tr5o)
check("T5: grid excess 1 870 W > car 1 380 W: the alarm and the ERROR at the "
"same second as Off and as base (E+1, the step's first sample)",
H.alarms(r5) == H.alarms(r5o) == T5_BASE
and nth(H.errors(tr5), 0) == nth(H.errors(tr5o), 0) == E + 1)
check("T5: the car explains no cycle", not any(x["explains"] for x in tr5))
# --- T6: the car figure unknown across the edge ------------------------------- #
def unavailable(t0, t1):
return {t0: lambda p, c: p.ch.go_unavailable(True),
t1: lambda p, c: p.ch.go_unavailable(False)}
r6, tr6 = H.run(H.shape(13000.0), a=ZERO, b=ZERO,
extra=unavailable(E - 20, E + 60))
summary("T6 T3 shape", r6, tr6)
back = first(x["t"] for x in tr6 if x["t"] >= E + 60 and x["w"] is not None)
check("T6 T3 shape: while unknown the car explains nothing and the alarm "
"stands from E+0, as base",
H.alarms(r6) == [E] and not any(
x["explains"] for x in H.window(tr6, E - 5, E + 59))
and all(x["alarm"] for x in H.window(tr6, E, E + 59)))
check("T6 T3 shape: released within 1 cycle of the first trusted cycle after "
"E+60, no new alarm edge to E+900 (base: red to E+900)",
present(back) and all(not x["alarm"] and x["explains"] for x in
H.window(tr6, back + 1, E + 899))
and H.edges(tr6) == [E])
r6h, tr6h = H.run(honest(14090.0), a=ZERO, b=ZERO,
extra=unavailable(E - 20, E + 60))
summary("T6 T5 shape", r6h, tr6h)
check("T6 T5 shape: the alarm at the base second and it stands throughout",
H.alarms(r6h) == T5_BASE and all(x["alarm"] for x in
H.window(tr6h, E + 1, E + 899)))
# --- T7: a frozen car figure, the car really stops ---------------------------- #
def frozen_stop(p, c):
p.ch.freeze()
p.ch.car_full()
r7, tr7 = H.run(honest(14090.0), a=ZERO, b=ZERO, extra={E - 30: frozen_stop})
summary("T7", r7, tr7)
first7 = nth(H.alarms(r7), 0)
untr = first(x["t"] for x in tr7 if x["t"] >= E - 30 and x["w"] is None)
check("T7: the alarm within 114 s of the stop (max(60, 40 Wh / 1.38 kW) "
"+ 10), no later than base",
present(first7) and first7 <= E - 30 + 114 and first7 <= T7_BASE)
check("T7: never explained after the figure goes untrusted",
present(untr) and not any(x["explains"] for x in tr7 if x["t"] >= untr))
# --- T8: a car at 0 W, and a 50 W car ----------------------------------------- #
class Draw(SimCharger):
"""A charger that draws `real_w` while charging and reports `say_w`."""
def __init__(self, real_w, say_w, **kw):
super().__init__(**kw)
self.real_w, self.say_w = real_w, say_w
def target_w(self):
return 0.0 if super().target_w() <= 0.0 else self.real_w
def _build(self):
keep, self._frozen_w = self._frozen_w, self.say_w
try:
return super()._build()
finally:
self._frozen_w = keep
def full(p, c):
p.ch.car_full()
for nm, kw in (("house 14 090 W", dict(house=honest(14090.0), b=ZERO)),
("T2 shape", dict(house=honest(14000.0), b=const(800.0)))):
r8, tr8 = H.run(a=ZERO, extra={1: full}, **kw)
r8o, tr8o = H.run(a=ZERO, extra={1: full}, mode="off", **kw)
summary(f"T8 0 W, {nm}", r8, tr8)
summary(f"T8 0 W, {nm}, Off", r8o, tr8o)
check(f"T8: a car plugged at 0 W, {nm}: the alarm at the same second as "
f"Off, nothing explained", H.alarms(r8) == H.alarms(r8o)
and H.alarms(r8) != [] and not any(x["explains"] for x in tr8))
r8s, tr8s = H.run(honest(14090.0), a=ZERO, b=ZERO,
sim=Draw(50.0, 50.0, setpoint_a=6))
r8so, tr8so = H.run(honest(14090.0), a=ZERO, b=ZERO, mode="off",
sim=Draw(50.0, 50.0, setpoint_a=6))
summary("T8 50 W", r8s, tr8s)
check("T8: a 50 W car, house 14 090 W: the alarm at the same second as Off, "
"nothing explained", H.alarms(r8s) == H.alarms(r8so) == T5_BASE
and not any(x["explains"] for x in tr8s))
# --- T9: a wrong charger reply ------------------------------------------------ #
r9a, tr9a = H.run(honest(13900.0), a=ZERO, b=ZERO,
sim=Draw(1380.0, 11000.0, setpoint_a=6))
summary("T9(a)", r9a, tr9a)
check("T9(a): reports 11 kW, read-back 6 A 1-ph (cap 1 518 W): the house "
"alone misses, the alarm at the base second",
H.alarms(r9a) == T5_BASE and all(x["w"] is None or x["w"] <= 1518.0
for x in tr9a))
r9b, tr9b = H.run(honest(13900.0), a=ZERO, b=ZERO,
sim=Draw(400.0, 1380.0, setpoint_a=6))
summary("T9(b)", r9b, tr9b)
check("T9(b): reports 1 380 W, draws 400 W: the same alarms as base (none: "
"400 W corroborates a 1 380 W figure, CORR_RATIO 0.5; see the dev "
"report's Findings)", H.alarms(r9b) == T9B_BASE)
r9c, tr9c = H.run(honest(13900.0), a=ZERO, b=ZERO,
sim=Draw(100.0, 1380.0, setpoint_a=6))
summary("T9(c)", r9c, tr9c)
a9c = nth(H.alarms(r9c), 0)
check("T9(c): reports 1 380 W, draws 100 W: the first alarm once the figure "
"is uncorroborated, at most 104 s + 10 s after the edge, no later than "
"base", present(a9c) and a9c <= E + 114 and a9c <= T9C_BASE)
print(f" T9(c) alarm edges {[t - E for t in H.edges(tr9c)]} (base: one; "
f"the meter's 10 Wh step re-corroborates the figure every 360 s and "
f"Expected 3/5 release the alarm then: see the dev report)")
# --- T10: a lost battery reading, an unavailable charger ---------------------- #
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
("T5", dict(house=honest(14090.0), b=ZERO))):
r10, tr10 = H.run(a=ZERO, lost={"b": {E + 1}}, **kw)
summary(f"T10(a) {nm}", r10, tr10)
gap = first(x for x in tr10 if x["t"] == E + 1)
nxt = first(x for x in tr10 if x["t"] == E + 2)
check(f"T10(a) {nm}: inverter-b's reading lost at E+1: that cycle grades "
f"nothing (P_SAFETY owns a missing input), the next one grades on "
f"what is measured", present(gap, nxt) and gap["batt"] is None
and nxt["batt"] == (800.0 if nm == "T2" else 0.0))
if nm == "T2":
check("T10(a) T2: no alarm edge (base: E+0)", quiet(r10, tr10))
else:
check("T10(a) T5: the same alarm seconds as base",
H.alarms(r10) == T10A_T5_BASE)
r10b, tr10b = H.run(a=ZERO, extra=unavailable(E + 1, E + 2), **kw)
summary(f"T10(b) {nm}", r10b, tr10b)
if nm == "T2":
check("T10(b) T2: the charger unavailable for one cycle (E+1): the "
"alarm stands for that cycle only (Expected 5)",
H.edges(tr10b) == [E + 1]
and all(not x["alarm"] for x in H.window(tr10b, E + 2, E + 899))
and all(x["explains"] for x in H.window(tr10b, E + 2, E + 899)
if x["lim"]))
else:
check("T10(b) T5: the alarm at the base second and it stands",
H.alarms(r10b) == T5_BASE and all(
x["alarm"] for x in H.window(tr10b, E + 1, E + 899)))
# --- T11: one battery first (SAFETY-87) --------------------------------------- #
for nm, house in (("(i) 17 500 W", 17500.0), ("(ii) 19 000 W", 19000.0)):
r11, tr11 = H.run(honest(house), soc={"a": 19.0, "b": 35.0})
summary(f"T11{nm}", r11, tr11)
if house < 18000.0:
check("T11(i): b able, house 17 500 W, car 1 380 W: no alarm across E",
H.alarms(r11) == [] and P.ids(r11, *P.ALARMS) == [])
else:
check("T11(ii): house 19 000 W: the alarm at the base second",
[t for t, _n in P.ids(r11, *P.ALARMS)] == T11_BASE)
# --- T12 (record only): plug-in at E+0, the reserve at E+180 ------------------ #
def reserve_at(p, c):
p.socs.update({"a": 19.0, "b": 19.0})
r12, tr12 = H.run(H.shape(13000.0), soc={"a": 40.0, "b": 40.0}, plug=False,
extra={E: lambda p, c: p.ch.plug_in(), E + 180: reserve_at})
summary("T12 (record, F-B)", r12, tr12)
# --- T13 controller: the latch is kept ---------------------------------------- #
r13, tr13 = H.run(H.shape(lambda t: 15500.0 if E + 300 <= t < E + 360
else 13000.0), a=ZERO, b=ZERO)
summary("T13", r13, tr13)
check("T13: the house steps to 15 500 W at E+300 for 60 s: the alarm at "
"the base second (E+301, the step's first sample), and red to the "
"quarter's end", H.alarms(r13) == T13_BASE and all(
x["alarm"] and x["red"] for x in H.window(tr13, E + 301, E + 899)))
# --- T16: the edge paths ------------------------------------------------------ #
for nm, kw in (("(a)(b)(c) SAFETY-91 roll, modes on", {}),
("(d) the guard not wanting at the edge",
dict(lost={"b": {E}}))):
r16, tr16 = H.run(H.shape(13000.0), a=ZERO, b=ZERO, **kw)
w16, lim16 = summary(f"T16{nm}", r16, tr16)
f16 = first(x for x in tr16 if x["t"] >= E and x["lim"])
pre = first(x for x in tr16 if x["t"] == E - 1)
check(f"T16{nm}: the car explains from the first limited cycle of the "
f"new block, no alarm, no red row, `_carq` key = block_start",
present(f16) and quiet(r16, tr16) and all(
x["explains"] and x["key"] == x["block"]
for x in tr16 if x["t"] >= f16["t"] and x["lim"]))
if not kw:
print(f" T16(c): within_aim at E-1 {pre['within_aim'] if present(pre) else pre}"
" (SAFETY-126's latch carried; not asserted)")
else:
g0 = first(x for x in tr16 if x["t"] == E)
check("T16(d) PRECONDITION: the guard did not want power at E+0",
present(g0) and not g0["wants"])
# --- T17: a restart ----------------------------------------------------------- #
def restart_at(t0):
return {t0: lambda p, c: H.restart(c)}
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
("T3", dict(house=H.shape(13000.0), b=ZERO)),
("T5", dict(house=honest(14090.0), b=ZERO))):
rr0, tr0 = H.run(a=ZERO, **kw)
for at in (E + 2, E + 300):
rr, trr = H.run(a=ZERO, extra=restart_at(at), **kw)
summary(f"T17 {nm} restart at E+{at - E}", rr, trr)
if nm == "T5":
check(f"T17 T5, restart at E+{at - E}: the alarm at the base "
f"second and again on the first cycle after the restart, "
f"as base; red throughout",
H.alarms(rr) == T5_BASE + [at] and len(H.red_secs(trr))
== len(H.red_secs(tr0)))
else:
check(f"T17 {nm}, restart at E+{at - E}: the same as without "
f"(no floor notice, no ERROR, no red row)",
quiet(rr, trr) and quiet(rr0, tr0))
print(f" T17 {nm} car-over notices: twin "
f"{[t - E for t, _n in P.ids(rr0, P.OVER)]}, restarted "
f"{[t - E for t, _n in P.ids(rr, P.OVER)]} (EV-11's "
f"once-per-session state does not survive a restart, as on "
f"base)")
# --- T15 controller: x10 ------------------------------------------------------ #
# F2 (out of scope, filed apart): `_car_quarter` caps a cycle's dt at 5 s, so at
# 10 s a cycle half the car's energy is counted, and late in the quarter the
# house alone seems to miss the aim (T2 from about E+540, T3 E+820, as on base
# for T3). The x10 verdicts are graded to E+500; what comes after is printed.
F2_FROM = E + 500
for nm, kw, want in (
("T2", dict(house=H.shape(14000.0), b=const(800.0)), "quiet"),
("T3", dict(house=H.shape(13000.0), b=ZERO), "quiet"),
("T5", dict(house=honest(14090.0), b=ZERO), "alarm"),
("T6", dict(house=H.shape(13000.0), b=ZERO,
extra=unavailable(E - 20, E + 60)), "release")):
rx, trx = H.run(a=ZERO, x=10, **kw)
summary(f"T15 x10 {nm}", rx, trx)
early = [x for x in trx if x["t"] < F2_FROM]
print(f" T15 x10 {nm}: alarms after E+500 (F2) "
f"{[t - E for t in H.alarms(rx) if t >= F2_FROM]}")
if want == "quiet":
check(f"T15 x10 {nm}: no alarm, no red row, every limited cycle "
f"explained, E-120..E+500",
not [t for t in H.alarms(rx) if t < F2_FROM]
and H.red_secs(trx, t1=F2_FROM - 1) == []
and all_explained([x for x in early if x["lim"]]))
elif want == "alarm":
check("T15 x10 T5: the alarm at the base second (E+10, one cycle)",
H.alarms(rx) == T15_T5_BASE)
else:
bk = first(x["t"] for x in trx if x["t"] >= E + 60
and x["w"] is not None)
check("T15 x10 T6: the alarm while unknown, released within 1 cycle "
"(10 fake s) of the first trusted one, no new edge to E+500",
present(bk) and bk <= E + 70
and all(not x["alarm"] for x in H.window(trx, bk, F2_FROM - 1))
and [t for t in H.edges(trx) if t < F2_FROM] == [E])
# --- N4: the alarm decision changes no command -------------------------------- #
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
("T5", dict(house=honest(14090.0), b=ZERO))):
ra, tra = H.run(a=ZERO, **kw)
rb, trb = H.run(a=ZERO, explain_off=True, **kw)
check(f"N4 {nm}: the claim, the floor, the battery setpoints and the "
f"charger writes are identical whether the car explains or not",
H.commands(ra, tra) == H.commands(rb, trb))
# --- N5: at most one floor-alarm edge per quarter ---------------------------- #
def per_quarter(ts):
out = {}
for t in ts:
out[(t - E) // 900] = out.get((t - E) // 900, 0) + 1
return out
many = [(nm, ts) for nm, ts in RUNS
if not nm.startswith("T9(c)")
and any(v > 1 for v in per_quarter(
[t for t in ts if not nm.startswith("T15 x10") or t < F2_FROM])
.values())]
check(f"N5: at most one floor-alarm edge per quarter in every run "
f"({len(RUNS)} runs; T9(c) apart, x10 to E+500): {many}", many == [])
print()
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
sys.exit(1 if fails else 0)
+207
View File
@@ -0,0 +1,207 @@
"""EV-18: the real Controller across one quarter edge `E`, N=2, both units at
the peak reserve and the car charging (`ev04_peak.drive`). Used by test_ev18.py.
The run starts `E` s before an edge (rig.BASE is moved back for the run), with
a light house so the first quarter does not raise the month's peak (the aim
stays `AIM`). At `E - 120` the house steps to the shape, so the guard first
wants power at the edge, as on the rig (EV-15 F-A). `force` makes a unit give
what the loop gives below the reserve whatever it is told; `lost` drops its
reading for some seconds (the grid still sees it). The trace is one dict per
cycle, taken after it.
"""
import hashlib
import logging
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 opt11_identity as rig # noqa: E402
import safety81_sim as s81 # noqa: E402
from app import peakguard # noqa: E402
E = 150 # the edge, in run seconds
AIM = 13600.0
MARGIN = 50.0
PRE_W = 5000.0 # the first quarter's house: under the cap
FLOOR = "goodwe_peak_soc_floor"
OPTS = {"peak_soc_floor": 20, "inverters": [
{"name": "inverter-a", "setpoint_entity": "number.sp_a",
"soc_entity": "sensor.soc_a", "batt_entity": "sensor.batt_a",
"max_w": 5000, "bms_soc_floor": 10},
{"name": "inverter-b", "setpoint_entity": "number.sp_b",
"soc_entity": "sensor.soc_b", "batt_entity": "sensor.batt_b",
"max_w": 4600, "bms_soc_floor": 10}]}
class _Errors(logging.Handler):
def __init__(self):
super().__init__(logging.ERROR)
self.rec = []
def emit(self, r):
self.rec.append(r.getMessage())
ERR = _Errors()
_lg = logging.getLogger("goodwe")
_lg.addHandler(ERR)
_lg.setLevel(logging.ERROR)
_lg.propagate = False
class Plant(P.CarPlantN):
force = {}
lost = {}
def batt_of(self, u, at):
f = self.force.get(u)
if f is not None:
return float(f(at))
return super().batt_of(u, 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
return await super().number(e, invert)
def shape(after, before=PRE_W, at=None):
"""The house: `before` until `at` (E - 120), then `after` (W or fn(t))."""
at = E - 120 if at is None else at
return lambda t: before if t < at else (after(t) if callable(after)
else after)
def run(house, *, a=None, b=None, lost=None, car_a=6, phases=1, aim=AIM,
mode="manual", dur=None, extra=None, sim=None, soc=None, plug=True,
x=1, mono_x=None, explain_off=False):
"""One run; returns (run, trace). `x`: fake seconds per cycle (wall and
monotonic both; `mono_x` sets the monotonic rate apart). `explain_off`:
the car never explains (for the control-identity check)."""
force = {}
if a is not None:
force["a"] = a
if b is not None:
force["b"] = b
cls = type("Plant", (Plant,), {"force": force, "lost": lost or {}})
tr = []
n_err = [len(ERR.rec)]
dur = E + 900 if dur is None else dur
def hook(plant, c):
orig = c.car_settle
if explain_off:
c._car_explains_alarm = 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 = []
if plant.t >= E - 130:
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 ERR.rec[n_err[0]:]
if "may not draw the battery lower" in m]
n_err[0] = len(ERR.rec)
cl = peakguard.claim(g) if g is not None else None
tr.append({
"t": plant.t, "explains": c.car_explains,
"lim": bool(g is not None and (g.floor_limited
or g.saturated)),
"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),
"alarm": c._peak_floor_limited, "red": red, "err": errs,
"w": c.car_alarm_w(), "batt": c.site_batt_w,
"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
ev = {0: hook}
for t, fn in (extra or {}).items():
if t == 0:
ev[0] = (lambda p, c, fn=fn: (hook(p, c), fn(p, c)))
else:
ev[t] = fn
socs = soc or {"a": 19.0, "b": 19.0}
s = sim
if s is None:
from chargersim import SimCharger
s = SimCharger(setpoint_a=car_a)
if x != 1:
tick = s.tick
s.tick = lambda secs=1.0: tick(secs * x)
base, step = rig.BASE, s81.TICK
rig.BASE, s81.TICK = base - timedelta(seconds=E), float(x)
try:
r = P.drive(house, dur=dur, rating=5000.0, soc=socs,
cap=aim + MARGIN, phases=phases, n=2, plant_cls=cls,
opts=OPTS, dev_w=5000.0, setpoint=car_a, user_a=car_a,
mode=mode, events=ev, sim=s, plug=plug)
finally:
rig.BASE, s81.TICK = base, step
return r, tr
def alarms(r):
"""Seconds of each goodwe_peak_soc_floor notification."""
return [t for t, n in r["raised"] if n == FLOOR]
def window(tr, t0, t1):
return [x for x in tr if t0 <= x["t"] <= t1]
def edges(tr):
"""Seconds at which the floor alarm goes False -> True."""
out, was = [], False
for x in tr:
if x["alarm"] and not was:
out.append(x["t"])
was = x["alarm"]
return out
def red_secs(tr, t0=None, t1=None):
t0 = E - 120 if t0 is None else t0
t1 = E + 900 if t1 is None else t1
return [x["t"] for x in window(tr, t0, t1) if x["red"]]
def errors(tr):
return [x["t"] for x in tr if x["err"]]
def commands(r, tr):
"""A digest of every command: the units' setpoints, the charger's writes,
and the guard's floor and claim per cycle (N4)."""
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 restart(c):
"""A restart as the car side sees it: a fresh `car_init` and an empty
corroboration history, and no floor alarm standing."""
mode, n, a = c.car_mode, c.car_n, c.car_a
c.car_init(c.o, c.store)
c.car_mode, c.car_n, c.car_a = mode, n, a
c.car._hist.clear()
c._peak_floor_limited = False