Compare commits
4
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
646f61e730 | ||
|
|
a60342e4e8 | ||
|
|
50d5ae90d2 | ||
|
|
8efc385956 |
@@ -3,6 +3,7 @@
|
||||
### Not in a release yet
|
||||
|
||||
- The *Car* card can now charge: choose **Manual** and set the current (6 A up to the charger limit) and 1 or 3 phases, on Home or from Home Assistant. The car is never slowed for the peak limit, the add-on says so instead of raising false peak alarms, and the batteries help cover it unless you switch that off. Off still writes nothing ([[EV-04]]).
|
||||
- Car charger fixes: when the car alone takes the batteries to the peak reserve, the add-on no longer raises "Battery stopped limiting the peak" (the grey "Car over the peak limit" note says it instead); that note and the Car card's reason stay steady instead of flickering; and switching to Off right after the add-on's own change no longer shows "Something else changes the charger".
|
||||
|
||||
## 0.23.0
|
||||
|
||||
|
||||
@@ -84,6 +84,31 @@ about 0.8 kW (40 Wh over the 180 s kept) the figure is believed; it cannot hide
|
||||
an overload that matters. (Round 2 had a 15 Wh slack that cancelled the 50 % rule
|
||||
up to 1.8 kW; the 40 Wh floor fixes that.)
|
||||
|
||||
## EV-10, EV-11, EV-12: the rig's three findings (EV-04 test F-1 to F-3)
|
||||
|
||||
- **The car is the cause when the alarm's own test says so** (EV-10).
|
||||
`car_cycle` (`_car_explains_alarm`) grades the alarm's test on the period as it
|
||||
is and on the period without the car's fresh, corroborated average
|
||||
(`car_exclude`): the car explains the alarm only if the test is true with it
|
||||
and false without it. The test is the alarm's own landing (`_car_grade`: the
|
||||
batteries give only what they still can, `load_too_high` for a saturated guard
|
||||
and for a floor with other batteries, `misses_aim` for a floor with none), not
|
||||
the plain projection, which still counts the batteries' help. So the car alone
|
||||
taking the batteries to the reserve is silent (rig: 5888 W against 6000 W),
|
||||
while a house-caused drain with a small car still alarms. No minimum car power
|
||||
is needed: a car that changes nothing cannot flip the test. A stale, stuck or
|
||||
uncorroborated figure is `None` and the normal alarms stand.
|
||||
- **Steady row, no hold on the alarm** (EV-11). Cause: after the car's own quarter
|
||||
became the month peak, the aim sat on the grid it made (14.04 kW +-40 W), so
|
||||
the test crossed the aim every few seconds. `car_over` (row, card, notice) now
|
||||
stays on until the test has been false for `OVER_OFF_HOLD_S` = 180 s (longer than
|
||||
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 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.
|
||||
|
||||
## The one write shadow mode allows
|
||||
|
||||
When the add-on has paused the car (0 A) for a phase change and has not yet
|
||||
|
||||
@@ -248,9 +248,14 @@ class ManualWriter:
|
||||
"to it until you change it.", cur, known[0])
|
||||
|
||||
async def _write(self, drv, a, was, now, tracker) -> bool:
|
||||
ok = await drv.write_current(a)
|
||||
self._stamp(now)
|
||||
tracker.begin_write() # EV-12: the read-back is ours
|
||||
try:
|
||||
ok = await drv.write_current(a)
|
||||
finally:
|
||||
self._stamp(now)
|
||||
tracker.end_write(self.last_done)
|
||||
tracker.note_write(now, was, a)
|
||||
tracker.end_write(self.last_done)
|
||||
self.log.append(("current", a, now, ok))
|
||||
if ok:
|
||||
self.last_a = a
|
||||
|
||||
@@ -716,6 +716,17 @@ class CarTracker:
|
||||
return None
|
||||
|
||||
# -- EV-04: the stuck-reading rule -------------------------------------------
|
||||
def begin_write(self) -> None:
|
||||
"""EV-12: a write of ours is in flight. Its read-back can reach the
|
||||
tracker before `note_write` runs (the write waits for it), so the mute
|
||||
is open until `end_write`."""
|
||||
self.mute_until = float("inf")
|
||||
|
||||
def end_write(self, now: float) -> None:
|
||||
"""EV-12: the write returned (or failed). The mute runs
|
||||
`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
|
||||
|
||||
@@ -20,6 +20,10 @@ CAR_PEAK_KEY = "car_peak_q" # {quarter start iso: the car's average W}
|
||||
CAR_PEAK_MIN_W = 50.0 # a quarter the car hardly touched is not kept
|
||||
CAR_PEAK_KEEP = 3200 # about a month of quarters
|
||||
OVER_HOLD_S = peakguard.ALARM_HOLD_S
|
||||
# EV-11: the card, the row and Why stay on this long after the car stops being
|
||||
# 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
|
||||
|
||||
|
||||
class CarMixin:
|
||||
@@ -46,6 +50,9 @@ class CarMixin:
|
||||
self.car_explains = False # the car alone explains the excess
|
||||
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_needed = False # EV-10: SAFETY-126's latch without the car
|
||||
self._car_over_notified = None # the session a notice was raised for
|
||||
self._car_session = 0
|
||||
self._car_prev_state = None
|
||||
@@ -253,28 +260,70 @@ class CarMixin:
|
||||
self._car_quarter(real_proj, w, mono)
|
||||
self._car_session_tick(mono)
|
||||
explains = over = False
|
||||
if w is not None and real_proj is not None and target_w is not None \
|
||||
if real_proj is not None and target_w is not None \
|
||||
and real_proj.block_start is not None:
|
||||
# The car explains the excess when the house alone would land the
|
||||
# period under the aim: what the car takes over the whole period
|
||||
# (`car_avg_w`) is at least how far the projection is over it.
|
||||
ex = float(real_proj.projected_w) - float(target_w)
|
||||
beyond = ex > 0.0 and self.car_avg_w(real_proj, w) >= ex
|
||||
if self.car_cover:
|
||||
explains = bool(
|
||||
beyond and guard is not None
|
||||
and (guard.saturated or guard.floor_limited))
|
||||
# EV-10: the car explains the ALARM (`_car_explains_alarm`).
|
||||
explains = self._car_explains_alarm(real_proj, guard,
|
||||
target_w, w)
|
||||
over = explains
|
||||
else:
|
||||
over = beyond
|
||||
elif w is not None:
|
||||
ex = float(real_proj.projected_w) - float(target_w)
|
||||
over = ex > 0.0 and self.car_avg_w(real_proj, w) >= ex
|
||||
self.car_explains = explains
|
||||
# EV-11: on once the condition has stood for OVER_HOLD_S, a short gap
|
||||
# in it not starting that count again; off only after it has been gone
|
||||
# for OVER_OFF_HOLD_S. `car_explains` (the alarm decision) has no hold.
|
||||
if over:
|
||||
self._car_over_gone = None
|
||||
if self._car_over_since is None:
|
||||
self._car_over_since = mono
|
||||
held = mono - self._car_over_since >= OVER_HOLD_S
|
||||
if mono - self._car_over_since >= OVER_HOLD_S:
|
||||
self.car_over = True
|
||||
else:
|
||||
self._car_over_since, held = None, False
|
||||
self.car_over = held
|
||||
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_gone = None
|
||||
|
||||
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
|
||||
its fresh, corroborated share (`car_exclude`)? The tests are the
|
||||
alarms': a saturated guard and a floor with other batteries left are
|
||||
graded by `load_too_high` on where the period lands (SAFETY-81 / 87); a
|
||||
floor that leaves nothing is graded by `within_aim`, which SAFETY-126
|
||||
latches for the quarter once the batteries at 0 W would miss the aim.
|
||||
`_car_needed` is that latch on the period without the car; an
|
||||
untrusted car figure (`w` None) sets it, so nothing is explained."""
|
||||
batt, prev = self.site_batt_w, self._car_batt_prev
|
||||
self._car_batt_prev = batt
|
||||
wants = bool(guard is not None and guard.engaged
|
||||
and guard.blind is None
|
||||
and (guard.wanted_w or 0.0) > 0.0)
|
||||
if not wants:
|
||||
self._car_needed = False
|
||||
if batt is not None and prev is not None:
|
||||
batt = min(float(batt), float(prev))
|
||||
excl = self.car_exclude(real_proj, w)
|
||||
if wants:
|
||||
self._car_needed = self._car_needed or w is None or batt is None \
|
||||
or peakguard.misses_aim(excl, batt_w=batt, target_w=target_w)
|
||||
if w is None or batt is None or not wants \
|
||||
or not (guard.saturated or guard.floor_limited):
|
||||
return False
|
||||
if guard.saturated:
|
||||
rating = self.site_rating_w
|
||||
elif (guard.floor_w or 0.0) > 0.0 and guard.able_w is not None:
|
||||
rating = guard.able_w
|
||||
else:
|
||||
return bool(not guard.within_aim and not self._car_needed)
|
||||
|
||||
def high(p):
|
||||
return peakguard.load_too_high(
|
||||
p, batt_w=batt, ceiling_w=guard.ceiling_w,
|
||||
achievable_w=rating)
|
||||
return bool(high(real_proj) and not high(excl))
|
||||
|
||||
def _car_session_tick(self, mono) -> None:
|
||||
"""A charging session is a plug-in: the state goes from no car to a
|
||||
@@ -283,6 +332,9 @@ class CarMixin:
|
||||
if s in (chargers.NONE_,) and self._car_prev_state not in (
|
||||
None, chargers.NONE_):
|
||||
self._car_over_notified = None
|
||||
# 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
|
||||
if s not in (chargers.NONE_, None) and self._car_prev_state in (
|
||||
chargers.NONE_, None):
|
||||
self._car_session += 1
|
||||
|
||||
@@ -0,0 +1,522 @@
|
||||
"""EV-10, EV-11, EV-12: three rig findings of EV-04's test (F-1, F-2, F-3).
|
||||
`python3 -B test_ev10.py`
|
||||
|
||||
1. EV-10: the car alone takes the batteries to the peak reserve while the period
|
||||
is still projected UNDER the aim: no alarm, one grey notice. A stuck car
|
||||
figure with a house overload, and a house-only drain, still alarm. Mutant:
|
||||
an uncorroborated car figure in the "period without the car" test.
|
||||
2. EV-11: the grey row and the Car Why do not flicker while the car keeps the
|
||||
period over the limit; a real end clears them after OVER_OFF_HOLD_S. The
|
||||
alarm decision (`car_explains`) has no hold.
|
||||
3. EV-12: the add-on's own write, and Off within 15 s of it, is never "another
|
||||
writer"; a real outside change afterwards still shows the row.
|
||||
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import dataclasses
|
||||
import logging
|
||||
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, homeview, chargers as CH # noqa: E402
|
||||
from app.main import Controller # noqa: E402
|
||||
from app import freshness # noqa: E402
|
||||
from chargersim import FakeHa, SimCharger # noqa: E402
|
||||
import ev04_peak as P # noqa: E402
|
||||
import safety81_sim as s81 # noqa: E402
|
||||
import opt11_identity as rig # 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()))
|
||||
|
||||
|
||||
LOG = _Log()
|
||||
_lg = logging.getLogger("goodwe")
|
||||
_lg.addHandler(LOG)
|
||||
_lg.setLevel(logging.DEBUG)
|
||||
_lg.propagate = False
|
||||
|
||||
# =========================================================================== #
|
||||
print("1. EV-10: THE CAR ALONE TAKES THE BATTERIES TO THE RESERVE (F-1)")
|
||||
# =========================================================================== #
|
||||
CAP = 4500.0 # the aim is 4450 W (50 W margin)
|
||||
HOUSE = 1100.0
|
||||
|
||||
|
||||
def at_reserve(plant, c):
|
||||
"""The batteries reach the peak reserve late in the period, and the house
|
||||
eases a little: the period is still projected UNDER the aim."""
|
||||
plant.soc = 19.0
|
||||
plant.load = lambda at: 780.0 + plant.ch.power_w
|
||||
|
||||
|
||||
def alarms(r):
|
||||
return P.ids(r, *P.ALARMS)
|
||||
|
||||
|
||||
UNDER = [] # (second, projected W, aim W) while floor-limited
|
||||
|
||||
|
||||
def watch(first, fn):
|
||||
"""Events for seconds 840 to 894: `fn` at `first`, and a note of every
|
||||
cycle in which the guard is floor-limited."""
|
||||
def note(plant, c):
|
||||
g = c.peak_guard
|
||||
if g is not None and g.floor_limited:
|
||||
UNDER.append((plant.t, g.projected_w, g.target_w))
|
||||
ev = {t: note for t in range(first - 10, 895)}
|
||||
ev[first] = lambda plant, c: (fn(plant, c), note(plant, c))
|
||||
return ev
|
||||
|
||||
|
||||
LOG.rec.clear()
|
||||
r10 = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
|
||||
cap=CAP, phases=1, events=watch(850, at_reserve))
|
||||
ERR10 = [m for lv, m in LOG.rec if lv in ("ERROR", "WARNING")]
|
||||
check("PRECONDITION: the guard was floor-limited with the projection UNDER "
|
||||
"the aim (the rig's 5888 W against 6000 W)",
|
||||
any(p < a for _t, p, a in UNDER))
|
||||
check("the car alone: no 'Load too high', no 'Battery stopped limiting the "
|
||||
"peak'", alarms(r10) == [])
|
||||
rows10 = {x["id"]: x for x in r10["c"].checks()}
|
||||
check("...no red row; the grey 'Car over the peak limit' row says it",
|
||||
rows10["peak_guard"]["ok"] is True
|
||||
and not [x for x in r10["c"].checks()
|
||||
if x["ok"] is False and not x["warn"]]
|
||||
and rows10.get("car_over", {}).get("ok") is True)
|
||||
check("...one grey notice for the session", len(P.ids(r10, P.OVER)) == 1)
|
||||
check("...no ERROR (or WARNING) line was logged for it", ERR10 == [])
|
||||
|
||||
|
||||
def house_stuck(plant, c):
|
||||
at_reserve(plant, c)
|
||||
plant.ch.freeze() # the reading stops moving
|
||||
plant.ch.unplug() # the car really goes
|
||||
plant.load = lambda at: 9000.0 + plant.ch.power_w
|
||||
asyncio.get_event_loop().create_task(c.handle_action("car_current",
|
||||
value=10))
|
||||
|
||||
|
||||
r10s = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
|
||||
cap=CAP, phases=1, events=watch(850, house_stuck))
|
||||
check("a stuck car figure and a house overload at the reserve: the normal "
|
||||
"alarm still fires",
|
||||
[n for _t, n in alarms(r10s)]
|
||||
and all(n in P.ALARMS for _t, n in alarms(r10s)))
|
||||
|
||||
|
||||
def house_drain(plant, c):
|
||||
plant.soc = 19.0
|
||||
plant.load = lambda at: 12000.0 + plant.ch.power_w
|
||||
|
||||
|
||||
r10h = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
|
||||
cap=CAP, phases=1, user_a=6, setpoint=6,
|
||||
events=watch(600, house_drain))
|
||||
check("a house-only drain to the reserve with the car charging little: the "
|
||||
"normal alarm still fires",
|
||||
alarms(r10h) != [] and not r10h["c"].car_explains)
|
||||
|
||||
|
||||
|
||||
def plug_late(plant, c):
|
||||
plant.ch.plug_in()
|
||||
|
||||
|
||||
def house_reserve(plant, c):
|
||||
plant.soc = 19.0
|
||||
plant.load = lambda at: 3075.0 + plant.ch.power_w
|
||||
|
||||
|
||||
def swapped_events():
|
||||
ev = watch(850, house_reserve)
|
||||
ev[800] = plug_late
|
||||
return ev
|
||||
|
||||
|
||||
def swapped(mode):
|
||||
return P.drive(s81.constant(6000.0), dur=895, rating=12000.0, soc=60.0,
|
||||
cap=CAP, phases=1, user_a=6, setpoint=6, mode=mode,
|
||||
plug=False, events=swapped_events())
|
||||
|
||||
|
||||
r10x = swapped("manual")
|
||||
r10xo = swapped("off")
|
||||
check("PRECONDITION (review): a 6 kW HOUSE drains the batteries, the car "
|
||||
"plugs in late (a small share); the projection is under the aim at the "
|
||||
"reserve, and Off raises the alarm", alarms(r10xo) != []
|
||||
and any(p < a for _t, p, a in UNDER))
|
||||
check("the house drains the batteries and a small car is plugged in: the "
|
||||
"normal alarm still fires in Manual", alarms(r10x) != [])
|
||||
|
||||
r10off = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
|
||||
cap=CAP, phases=1, mode="off", events=watch(850, at_reserve))
|
||||
check("PRECONDITION: Off, the same case raises the normal alarm (the false "
|
||||
"alarm Manual must not make)", alarms(r10off) != [])
|
||||
|
||||
|
||||
# a direct unit of the rule: the car's average, the period without it
|
||||
class _Car(ctl_car.CarMixin):
|
||||
def __init__(self, cover=True, w=3700.0):
|
||||
self.o = {"ev_batt_cover": cover}
|
||||
self.w = w
|
||||
self._now = 0.0
|
||||
self.site_batt_w, self.site_rating_w = 300.0, 5000.0
|
||||
self.car_init({}, type("S", (), {"data": {}, "set": lambda s, k, v: 0})())
|
||||
|
||||
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"
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class _Proj:
|
||||
projected_w: float
|
||||
elapsed_s: float = 850.0
|
||||
held_w: float = 0.0
|
||||
block_start: object = datetime(2026, 11, 16, 20, 0, tzinfo=timezone.utc)
|
||||
|
||||
def __post_init__(self):
|
||||
self.held_w = self.projected_w
|
||||
|
||||
|
||||
class _G:
|
||||
def __init__(self, floor=True, sat=False, within_aim=False):
|
||||
self.floor_limited, self.saturated = floor, sat
|
||||
self.floor_w, self.able_w, self.ceiling_w = 0.0, None, 4500.0
|
||||
self.engaged, self.blind, self.wanted_w = True, None, 300.0
|
||||
self.within_aim = within_aim
|
||||
|
||||
|
||||
def explains(proj_w, car_w, *, floor=True, cover=True, car_so_far_w=None,
|
||||
within_aim=False):
|
||||
c = _Car(cover, car_w)
|
||||
p = _Proj(proj_w)
|
||||
c._carq = {"key": p.block_start,
|
||||
"ws": (car_w if car_so_far_w is None else car_so_far_w)
|
||||
* p.elapsed_s, "mono": 0.0}
|
||||
c.car_cycle(p, _G(floor, within_aim=within_aim), 4450.0, None)
|
||||
return c.car_explains
|
||||
|
||||
|
||||
check("rule: the alarm's test is true with the car (4468 W, the batteries "
|
||||
"at 0 W land 4485 W) and false without it (768 W): the car explains it, "
|
||||
"with the projection under the aim", explains(4468.0, 3700.0))
|
||||
check("rule: where the alarm would not fire anyway nothing is explained",
|
||||
not explains(4300.0, 3700.0, within_aim=True))
|
||||
check("rule: without the car it is still over the aim: the car does not "
|
||||
"explain it", not explains(9000.0, 3700.0))
|
||||
check("rule: no car power, no explanation", not explains(9000.0, 0.0))
|
||||
check("rule: the guard is not floor-limited or saturated: nothing to explain",
|
||||
not explains(4300.0, 3700.0, floor=False))
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n2. EV-11: THE 'CAR OVER THE PEAK LIMIT' ROW DOES NOT FLICKER (F-2)")
|
||||
# =========================================================================== #
|
||||
# The cause (rig p7off 21:18 to 21:45, plant.csv): after 21:15 the car's own
|
||||
# quarter (14.0 kW) was the month peak, so the aim was that quarter's average
|
||||
# and the grid of the next ones (14.04 kW, +-40 W of noise) sat ON it. The
|
||||
# projection crossed the aim every few seconds, `ex > 0` came and went, and
|
||||
# `car_over` followed it with no hold on the way off.
|
||||
|
||||
|
||||
def over_run(c, secs, proj_of, w_of=lambda t: 11000.0, t0=0.0, target=14000.0,
|
||||
cover=False):
|
||||
"""Run `car_cycle` once a second; returns (car_over, car_explains) per second."""
|
||||
out = []
|
||||
for k in range(secs):
|
||||
t = t0 + k
|
||||
c._now = t
|
||||
c.w = w_of(t)
|
||||
p = _Proj(proj_of(t), elapsed_s=300.0 + (t % 400))
|
||||
c._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s,
|
||||
"mono": t}
|
||||
c.car_cycle(p, _G(True), target, None)
|
||||
out.append((c.car_over, c.car_explains))
|
||||
return out
|
||||
|
||||
|
||||
def noisy(t):
|
||||
"""The projection straddles the aim: +-40 W, a new value every 7 s."""
|
||||
return 14000.0 + (40.0 if int(t // 7) % 2 else -40.0) * (1 + (int(t) % 3))
|
||||
|
||||
|
||||
c11 = _Car(cover=False)
|
||||
o11 = over_run(c11, 1200, noisy)
|
||||
flips = sum(1 for a, b in zip(o11, o11[1:]) if a[0] != b[0])
|
||||
check("while the car keeps the period at the limit the row stays on: one "
|
||||
"switch on in 20 minutes, none off", flips == 1 and len(o11) == 1200 and o11[-1][0] is True)
|
||||
check("it turns on after the existing 10 s hold, not later than the first "
|
||||
"10 s the condition has stood (a gap does not restart the count)",
|
||||
next((i for i, x in enumerate(o11) if x[0]), 10**6) <= 25)
|
||||
|
||||
# the condition on its own, for the PRECONDITION: the same input flips
|
||||
c11o = _Car(cover=False)
|
||||
raw = []
|
||||
for k in range(1200):
|
||||
c11o._now = float(k)
|
||||
p = _Proj(noisy(k), elapsed_s=300.0 + (k % 400))
|
||||
c11o._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s, "mono": k}
|
||||
ex = p.projected_w - 14000.0
|
||||
raw.append(ex > 0.0 and c11o.car_avg_w(p, 11000.0) >= ex)
|
||||
raw_flips = sum(1 for a, b in zip(raw, raw[1:]) if a != b)
|
||||
check("PRECONDITION: the condition itself flips many times in those 20 "
|
||||
"minutes", raw_flips > 20)
|
||||
|
||||
# a real end: the car stops (no trusted power) after 600 s
|
||||
c11e = _Car(cover=False)
|
||||
o11e = over_run(c11e, 1000, lambda t: 14500.0,
|
||||
w_of=lambda t: 11000.0 if t < 600 else None)
|
||||
off_at = next((i for i, x in enumerate(o11e) if i > 600 and not x[0]), -1)
|
||||
check("a real end: the row stays for OVER_OFF_HOLD_S (180 s) and then goes",
|
||||
off_at == 600 + int(ctl_car.OVER_OFF_HOLD_S)
|
||||
and not any(x[0] for x in o11e[off_at:]))
|
||||
o11r = over_run(c11e, 100, lambda t: 14500.0, t0=1000.0)
|
||||
check("it comes back after the usual 10 s if the condition returns after "
|
||||
"it went", len(o11r) == 100 and o11r[9][0] is False and o11r[10][0] is True)
|
||||
|
||||
# the alarm decision has no hold: a real house overload is never delayed
|
||||
c11a = _Car(cover=True)
|
||||
o11a = over_run(c11a, 60, lambda t: 4300.0, target=4450.0)
|
||||
check("decision 1 on: the car explains it at once (no hold)",
|
||||
len(o11a) == 60 and o11a[0][1] is True)
|
||||
c11a.w = None # the figure is not trusted
|
||||
c11a._now = 61.0
|
||||
c11a.car_cycle(_Proj(4300.0), _G(True), 4450.0, None)
|
||||
check("...and the moment the car figure is not trusted it explains nothing, "
|
||||
"so the normal alarms stand at once (the grey row may stay)",
|
||||
c11a.car_explains is False)
|
||||
|
||||
# the whole thing on the real controller: the Why does not flicker either
|
||||
def p7_like(plant, c):
|
||||
plant.load = lambda at: 3000.0 + plant.ch.power_w
|
||||
|
||||
|
||||
r11 = P.drive(s81.constant(HOUSE), dur=700, rating=2000.0, soc=60.0, cap=CAP,
|
||||
phases=3, opts={"ev_batt_cover": False})
|
||||
ov = [s[2] for s in r11["snaps"]]
|
||||
check("real controller, cover off, an 11 kW car: the flag is steady once on",
|
||||
sum(1 for a, b in zip(ov, ov[1:]) if a != b) <= 1 and ov[-1] is True)
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n3. EV-12: OUR OWN WRITE IS NOT ANOTHER WRITER (F-3)")
|
||||
# =========================================================================== #
|
||||
CLOCK = [1000.0]
|
||||
freshness.monotonic = lambda: CLOCK[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"], "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):
|
||||
super().__init__(charger, None)
|
||||
|
||||
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", 800.0, "W"),
|
||||
("sensor.soc", 50.0, "%"),
|
||||
("sensor.batt", 0.0, "W"),
|
||||
("sensor.pv", 2000.0, "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):
|
||||
return await super().set_number(entity_id, float(value))
|
||||
|
||||
|
||||
class World:
|
||||
"""A real Controller on the charger model. While a write waits for its
|
||||
read-back, the controller's own reading goes on (as in production, where
|
||||
the cycle runs while the writer task waits): that is how the read-back of
|
||||
our own write reaches the tracker BEFORE the write returns."""
|
||||
|
||||
def __init__(self, setpoint=10):
|
||||
self.sim = SimCharger(setpoint_a=setpoint)
|
||||
self.sim.plug_in()
|
||||
self.sim.lag_s = 2.0 # the rig's read-back lag
|
||||
self.sim.phases_allowed = 1
|
||||
self.t = 1000.0
|
||||
CLOCK[0] = self.t
|
||||
self.c = Controller(dict(BASE), Site(self.sim), _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
|
||||
await self.c.read_inputs(now_mono=self.t) # the cycle reads on
|
||||
|
||||
async def step(self, n=1):
|
||||
for _ in range(n):
|
||||
self.sim.tick(1.0)
|
||||
self.t += 1.0
|
||||
CLOCK[0] = self.t
|
||||
await self.c.read_inputs(now_mono=self.t)
|
||||
await self.c.cycle()
|
||||
await self.c.car_settle()
|
||||
|
||||
def rows(self):
|
||||
return {r["id"]: r for r in self.c.checks()}
|
||||
|
||||
|
||||
async def own_then_off(wait):
|
||||
w = World()
|
||||
await w.step(3)
|
||||
await w.c.handle_action("car_mode", value="manual")
|
||||
await w.c.handle_action("car_current", value=12)
|
||||
await w.step(wait)
|
||||
await w.c.handle_action("car_mode", value="off")
|
||||
await w.step(40)
|
||||
return w
|
||||
|
||||
|
||||
w12 = asyncio.run(own_then_off(2))
|
||||
check("PRECONDITION: the add-on wrote 12 A and the charger took it",
|
||||
w12.sim.readback_a == 12 and len(w12.sim.writes("current")) == 1)
|
||||
check("our own write, then Off 2 s later: no 'Something else changes the "
|
||||
"charger'", "charger_writer" not in w12.rows()
|
||||
and w12.c.car.writer_at_utc is None)
|
||||
w12b = asyncio.run(own_then_off(14))
|
||||
check("...and 14 s later (inside the 15 s)", "charger_writer" not in
|
||||
w12b.rows() and w12b.c.car.writer_at_utc is None)
|
||||
|
||||
|
||||
async def own_then_outside():
|
||||
w = await own_then_off(2)
|
||||
w.sim.set_current(7) # somebody else, afterwards
|
||||
await w.step(3)
|
||||
early = "charger_writer" in w.rows()
|
||||
await w.step(30)
|
||||
return early, "charger_writer" in w.rows()
|
||||
|
||||
|
||||
early12, late12 = asyncio.run(own_then_outside())
|
||||
check("an outside change after that still shows the row (within 30 s)",
|
||||
late12 is True)
|
||||
|
||||
|
||||
async def manual_own():
|
||||
w = World()
|
||||
await w.step(3)
|
||||
await w.c.handle_action("car_mode", value="manual")
|
||||
await w.c.handle_action("car_current", value=12)
|
||||
await w.step(60)
|
||||
await w.c.handle_action("car_current", value=8)
|
||||
await w.step(20)
|
||||
return w
|
||||
|
||||
|
||||
wm = asyncio.run(manual_own())
|
||||
check("Manual: two writes of ours, never 'another writer' in the tracker",
|
||||
wm.c.car.writer_at_utc is None and "charger_other" not in wm.rows())
|
||||
|
||||
|
||||
async def failed_write_then_outside(how):
|
||||
"""A write that RAISES or returns FAILURE must still close the self-mute:
|
||||
a later outside change shows the row."""
|
||||
w = World()
|
||||
await w.step(3)
|
||||
await w.c.handle_action("car_mode", value="manual")
|
||||
|
||||
async def bad(a):
|
||||
await w.sleep(1.0)
|
||||
if how == "raise":
|
||||
raise RuntimeError("the charger link broke")
|
||||
return False
|
||||
w.drv.write_current = bad
|
||||
await w.c.handle_action("car_current", value=12)
|
||||
await w.step(3) # the write is tried
|
||||
await w.c.handle_action("car_mode", value="off")
|
||||
await w.step(20) # past the 15 s mute
|
||||
w.sim.set_current(7) # somebody else
|
||||
await w.step(3)
|
||||
return w
|
||||
|
||||
|
||||
for how in ("raise", "fail"):
|
||||
wf = asyncio.run(failed_write_then_outside(how))
|
||||
check(f"a write that {'raises' if how == 'raise' else 'returns failure'}"
|
||||
": the mute closes within 15 s, and a later outside change shows "
|
||||
"the row", wf.c.car.mute_until < wf.t
|
||||
and "charger_writer" in wf.rows())
|
||||
|
||||
print()
|
||||
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
|
||||
sys.exit(1 if fails else 0)
|
||||
Reference in New Issue
Block a user