Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
8efc385956 | ||
|
|
75ebe22a4d |
@@ -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,25 @@ 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 period without it would not need the
|
||||
batteries** (EV-10). `car_cycle` tests `projected - car_avg_w <= aim` (the car's
|
||||
average over the same window, fresh and corroborated only) instead of
|
||||
`projected > aim`, so it also holds when the car alone has taken the batteries
|
||||
to the reserve and the projection is still under the aim (rig: 5888 W against
|
||||
6000 W). The car must draw at least `CAR_PEAK_MIN_W`. 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 (the rig's
|
||||
longest gap; 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,9 @@ 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 (the rig's off gaps were 20 s to 3 min), or until it really ends.
|
||||
OVER_OFF_HOLD_S = 180.0
|
||||
|
||||
|
||||
class CarMixin:
|
||||
@@ -46,6 +49,7 @@ 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_over_notified = None # the session a notice was raised for
|
||||
self._car_session = 0
|
||||
self._car_prev_state = None
|
||||
@@ -255,26 +259,38 @@ class CarMixin:
|
||||
explains = over = False
|
||||
if w is not None and 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.
|
||||
# The car explains the excess when the period WITHOUT the car
|
||||
# (`projected - car_avg_w`, over the same window) would be at or
|
||||
# under the aim: the car, not the house, needs the batteries. EV-10:
|
||||
# this holds with the projection still under the aim, when the
|
||||
# car alone took the batteries to the reserve.
|
||||
car_avg = self.car_avg_w(real_proj, w)
|
||||
without = float(real_proj.projected_w) - car_avg
|
||||
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
|
||||
car_avg >= CAR_PEAK_MIN_W and without <= float(target_w)
|
||||
and guard is not None
|
||||
and (guard.saturated or guard.floor_limited))
|
||||
over = explains
|
||||
else:
|
||||
over = beyond
|
||||
over = ex > 0.0 and car_avg >= 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_session_tick(self, mono) -> None:
|
||||
"""A charging session is a plug-in: the state goes from no car to a
|
||||
|
||||
@@ -0,0 +1,446 @@
|
||||
"""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.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
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)
|
||||
|
||||
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.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"
|
||||
|
||||
|
||||
class _Proj:
|
||||
def __init__(self, proj_w, elapsed=850.0):
|
||||
self.projected_w, self.elapsed_s, self.held_w = proj_w, elapsed, proj_w
|
||||
self.block_start = datetime(2026, 11, 16, 20, 0, tzinfo=timezone.utc)
|
||||
|
||||
|
||||
class _G:
|
||||
def __init__(self, floor=True, sat=False):
|
||||
self.floor_limited, self.saturated = floor, sat
|
||||
|
||||
|
||||
def explains(proj_w, car_w, *, floor=True, cover=True, car_so_far_w=None):
|
||||
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), 4450.0, None)
|
||||
return c.car_explains
|
||||
|
||||
|
||||
check("rule: the period without the car (4468 - 3700 = 768 W) is under the "
|
||||
"aim: the car explains it, even with the projection under the aim",
|
||||
explains(4300.0, 3700.0) and explains(4468.0, 3700.0))
|
||||
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(4300.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=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 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=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", 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)",
|
||||
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())
|
||||
|
||||
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