Review of 8818768: the headroom test compared the output with the site
rating, which still counted a battery refusing to give (SAFETY-73) or under
a safety stop, so the 15 s wait ran at the real maximum (N4). Now only the
units that can give (above their cut-out, not refusing, not stopped,
switched on) count, in what they give and in their ratings.
Tests: R5a (A refuses, B at full rating, against a car-Off twin: the cut at
910, period 3361 W), R5b (headroom and a slow battery: the cut at exactly
15 s), R5c (floor-limited alone decides: cut at once). DOCS wrapped to 79.
Co-Authored-By: Claude <noreply@anthropic.com>
296 lines
12 KiB
Python
296 lines
12 KiB
Python
#!/usr/bin/env python3
|
|
"""EV-05: the real Controller on a sunny plant with N batteries and a car.
|
|
|
|
python3 tools/ev05_sun.py # mock-up scenario 2, both priorities
|
|
|
|
A 1 s cycle, a P1 meter that publishes 0.3 s before each cycle, N batteries
|
|
each with ITS OWN rating and level (switched On, so the zero-grid loop charges
|
|
them from the export), and `chargersim.SimCharger` behind the same Home
|
|
Assistant. The meter sees `house + car - sun - batteries` (battery discharge
|
|
positive), so the spare sun the add-on computes is `sun - house` whatever it
|
|
does. A battery at 100 % takes no charge. `events` is `{second: fn(plant, c)}`,
|
|
run before that cycle. `race=True` uses the production order (read, the writer
|
|
task settles, then the cycle), as test_ev04.py's `World.step_race`.
|
|
|
|
Used by test_ev05.py and, later, by the rig test."""
|
|
|
|
import asyncio
|
|
import logging
|
|
import os
|
|
import sys
|
|
import tempfile
|
|
from datetime import timedelta
|
|
|
|
HERE = os.path.dirname(os.path.abspath(__file__))
|
|
sys.path.insert(0, HERE)
|
|
|
|
import opt11_identity as rig # noqa: E402
|
|
import main_files # noqa: E402
|
|
from app import packmode # noqa: E402
|
|
from app.main import Controller # noqa: E402
|
|
from app.p1 import make_sample, split_signed # noqa: E402
|
|
from app.store import unit_key # noqa: E402
|
|
from chargersim import SimCharger # noqa: E402
|
|
from app import p1 as _p1 # noqa: E402
|
|
|
|
SET = "number.wallbox_power_connector_max_current_socket_1"
|
|
PHASES = "select.wallbox_installation_max_allowed_phases"
|
|
ALARMS = ("goodwe_peak_saturated", "goodwe_peak_soc_floor")
|
|
RESPONSE_S = 0.5 # a battery reaches its new command this much later
|
|
SAMPLE_LEAD_S = 0.3
|
|
|
|
|
|
class SunPlant:
|
|
"""The house, the sun, N batteries and the charger on one meter."""
|
|
|
|
def __init__(self, house, sun, ratings, socs, charger):
|
|
self.house, self.sun = house, sun
|
|
self.ratings, self.socs = dict(ratings), dict(socs)
|
|
self.ch = charger
|
|
self.t = 0.0
|
|
self.hists = {u: [(-1e9, 0.0)] for u in self.ratings}
|
|
self.notes = [] # (t, notification id) raised
|
|
self.dismissed = []
|
|
self.sets = [] # (t, entity, value): every number write
|
|
# Every charger write the model took, as `SimCharger.log` has it but
|
|
# on THIS clock (the model's own runs ahead while a write waits).
|
|
self.wlog = []
|
|
self.meter = 0.0
|
|
self.meter_on = True # False: the meter stops publishing
|
|
self.batt_nan = set() # units whose battery figure reads None
|
|
self.utc_off = 0.0 # the wall clock jumps, the model clock not
|
|
self.ha_down = False # Home Assistant answers nothing (SAFETY-112)
|
|
self.response_s = RESPONSE_S # a slow battery takes longer
|
|
|
|
def batt_of(self, u, at):
|
|
w = 0.0
|
|
for when, v in self.hists[u]:
|
|
if when <= at:
|
|
w = v
|
|
r = self.ratings[u]
|
|
w = max(-r, min(r, float(round(w))))
|
|
if self.socs[u] >= 100.0 and w < 0.0:
|
|
w = 0.0 # a full battery takes no charge
|
|
return w
|
|
|
|
def batt(self, at):
|
|
return sum(self.batt_of(u, at) for u in self.ratings)
|
|
|
|
def grid(self, at):
|
|
return self.house(at) + self.ch.power_w - self.sun(at) - self.batt(at)
|
|
|
|
# -- Home Assistant -----------------------------------------------------
|
|
async def limits(self, e):
|
|
return (-5000.0, 5000.0, 1.0)
|
|
|
|
async def state(self, entity_id):
|
|
if self.ha_down:
|
|
return None
|
|
return self.ch.states().get(entity_id)
|
|
|
|
async def states(self):
|
|
if self.ha_down:
|
|
return []
|
|
return list(self.ch.states().values())
|
|
|
|
async def call(self, domain, service, data=None):
|
|
if self.ha_down:
|
|
return False
|
|
if service == "create":
|
|
self.notes.append((self.t, (data or {}).get("notification_id")))
|
|
if service == "dismiss":
|
|
self.dismissed.append((self.t, (data or {}).get("notification_id")))
|
|
if domain == "select" and service == "select_option":
|
|
n = 3 if "3" in str((data or {}).get("option")) else 1
|
|
return self._logged("phases", n, self.ch.request_phases)
|
|
return True
|
|
|
|
def _logged(self, what, v, fn):
|
|
n0, row = len(self.ch.log), (self.t, what, v, self.ch.power_w,
|
|
self.ch.setpoint_a)
|
|
ok = fn(v)
|
|
if len(self.ch.log) > n0:
|
|
self.wlog.append(row)
|
|
return ok
|
|
|
|
async def number(self, e, invert=False):
|
|
if self.ha_down:
|
|
return None
|
|
for u in self.ratings:
|
|
if e == "sensor.soc_" + u:
|
|
return self.socs[u]
|
|
if e == "sensor.batt_" + u:
|
|
return None if u in self.batt_nan else self.batt_of(u, self.t)
|
|
if e in ("sensor.grid", "sensor.net"):
|
|
return self.meter
|
|
return None
|
|
|
|
async def set_number(self, e, v):
|
|
if self.ha_down:
|
|
return False
|
|
self.sets.append((self.t, e, float(v)))
|
|
if e == SET:
|
|
return self._logged("current", float(v), self.ch.request_current)
|
|
if e.startswith("number.sp_"):
|
|
self.hists[e[-1]].append((self.t + self.response_s, float(v)))
|
|
return True
|
|
|
|
|
|
def drive(house, sun, *, dur=600.0, ratings=None, socs=None, cap=3500.0,
|
|
margin=100, opts=None, plug=True, setpoint=0, phases=1, mode="solar",
|
|
first="batteries", events=None, sim=None, store=None, race=False,
|
|
on_cycle=None, car_phases=3, t0=0.0, caps=None):
|
|
"""Run it. Returns a dict: plant, controller, charger, notifications with
|
|
their second, and a per-second trace. `caps` ({unit: kWh}) lets each
|
|
battery's level move with what it charges or gives; without it the
|
|
levels stand still."""
|
|
ratings = ratings or {"a": 5000.0, "b": 4600.0}
|
|
socs = socs or {u: 50.0 for u in ratings}
|
|
sim = sim or SimCharger(setpoint_a=setpoint)
|
|
if plug:
|
|
sim.plug_in(car_phases=car_phases)
|
|
sim.phases_allowed = phases
|
|
units = sorted(ratings)
|
|
o = rig._options(len(units), dict({
|
|
"meter_source": "ha_signed", "p1_net_entity": "sensor.net",
|
|
"meter_phases": 1, "peak_cap_w": cap, "peak_margin_w": margin,
|
|
"battery_modes_enabled": True,
|
|
"ev_charger": "alfen_ha", "ev_max_a": 16, "ev_phases": "auto",
|
|
"ev_current_entity": SET}, **(opts or {})))
|
|
if len(units) == 1:
|
|
o["max_w"] = ratings[units[0]]
|
|
else:
|
|
o["inverters"] = [dict(x, max_w=ratings[x["name"][-1]])
|
|
for x in o["inverters"]]
|
|
store = store or rig._Store()
|
|
store.data["car_mode"] = mode
|
|
store.data["car_sun_first"] = first
|
|
for u in units:
|
|
store.data[unit_key("inverter-" + u, packmode.USE_KEY)] = True
|
|
db = os.path.join(tempfile.mkdtemp(prefix="ev5-"), "tariff.db")
|
|
out = {}
|
|
events_in = events or {}
|
|
|
|
async def go():
|
|
plant = SunPlant(house, sun, ratings, socs, sim)
|
|
c = Controller(o, plant, store, rig._Pub(), stop=asyncio.Event(),
|
|
peak_db_path=db)
|
|
for i in c.inverters:
|
|
r = ratings[i.name[-1]] if len(units) > 1 else ratings[units[0]]
|
|
i.dev_min, i.dev_max = -r, r
|
|
c.auto = True
|
|
clock = [t0]
|
|
c.car_now = lambda: clock[0]
|
|
real_time = _p1.time
|
|
|
|
class _Time:
|
|
"""The meter's age on the model clock, so a silent meter goes
|
|
stale in model seconds."""
|
|
def __getattr__(self, k):
|
|
return getattr(real_time, k)
|
|
|
|
@staticmethod
|
|
def monotonic():
|
|
return clock[0]
|
|
_p1.time = _Time()
|
|
if hasattr(c.charger, "_sleep"):
|
|
async def sleep(s):
|
|
sim.tick(s)
|
|
clock[0] += s
|
|
c.charger._sleep = sleep
|
|
c.charger._clock = lambda: clock[0]
|
|
real_dt = main_files.live.datetime
|
|
|
|
class _DT(real_dt):
|
|
@classmethod
|
|
def now(cls, tz=None):
|
|
return rig.BASE + timedelta(seconds=clock[0] + plant.utc_off)
|
|
main_files.live.datetime = _DT
|
|
trace = []
|
|
try:
|
|
t = t0
|
|
while t < t0 + dur:
|
|
plant.t = clock[0] = t
|
|
fn = events_in.get(int(t)) if t == int(t) else None
|
|
if fn is not None:
|
|
r = fn(plant, c)
|
|
if asyncio.iscoroutine(r):
|
|
await r
|
|
sim.tick(1.0)
|
|
ts = t - SAMPLE_LEAD_S
|
|
if plant.meter_on and not plant.ha_down:
|
|
plant.meter = plant.grid(ts)
|
|
imp, exp = split_signed(plant.meter)
|
|
c.p1.submit(make_sample(
|
|
"ha_signed", imp, exp, phases=1,
|
|
ingest_ts=rig.BASE + timedelta(seconds=ts),
|
|
ingest_mono=ts))
|
|
await c.read_inputs(now_mono=t)
|
|
if race:
|
|
await c.car_settle()
|
|
await c.cycle()
|
|
else:
|
|
await c.cycle()
|
|
await c.car_settle()
|
|
w = c.car_solar
|
|
g = c.peak_guard
|
|
trace.append(dict(
|
|
t=t, a=w.plan.a, why=w.plan.why, n=w.plan.n,
|
|
sp=sim.setpoint_a, rb=sim.readback_a,
|
|
ph=sim.phases_allowed, car=sim.power_w, st=sim.state,
|
|
grid=plant.grid(t), batt=plant.batt(t),
|
|
house=plant.house(t), sun=plant.sun(t),
|
|
cut=c.car_cut_w, explains=c.car_explains,
|
|
lim=bool(g is not None and (g.floor_limited
|
|
or g.saturated)),
|
|
floor=(None if g is None else g.floor_w),
|
|
excess=(None if g is None else g.excess_w),
|
|
want=(None if g is None else g.wanted_w),
|
|
since=c._car_want_since,
|
|
able=c._car_batt_able(), socs=dict(plant.socs),
|
|
proj=(None if g is None else g.projected_w),
|
|
target=(None if g is None else g.target_w),
|
|
would=w.would, single=w.single,
|
|
spare=c.car_spare_w(t), ok=w.plan.ok_since,
|
|
red=[x["id"] for x in c.checks()
|
|
if x["ok"] is False and not x["warn"]]
|
|
if on_cycle == "rows" else []))
|
|
if callable(on_cycle):
|
|
on_cycle(plant, c, t)
|
|
for u, kwh in (caps or {}).items():
|
|
# 1 s of W, as a percent of kWh: W / 3600 / (kWh x 1000) x 100
|
|
lv = plant.socs[u] - plant.batt_of(u, t) / 36000.0 / kwh
|
|
plant.socs[u] = max(0.0, min(100.0, lv))
|
|
t += 1.0
|
|
await c.car_settle()
|
|
finally:
|
|
main_files.live.datetime = real_dt
|
|
_p1.time = real_time
|
|
out.update(plant=plant, c=c, sim=sim, trace=trace, store=store,
|
|
raised=list(plant.notes))
|
|
asyncio.run(go())
|
|
return out
|
|
|
|
|
|
def ids(out, *wanted):
|
|
return [(t, n) for t, n in out["raised"] if n in wanted]
|
|
|
|
|
|
def writes(out, what="current"):
|
|
"""(t, value) of every charger write of that kind, in model seconds."""
|
|
return [(x[0], x[2]) for x in out["sim"].writes(what)]
|
|
|
|
|
|
def const(w):
|
|
return lambda t: float(w)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
logging.disable(logging.CRITICAL)
|
|
for first in ("batteries", "car"):
|
|
r = drive(const(900.0), const(7900.0), dur=600, first=first,
|
|
socs={"a": 71.0, "b": 100.0})
|
|
print(f"scenario 2, {first} first: writes {writes(r)} phases "
|
|
f"{writes(r, 'phases')} batteries {r['plant'].batt(599):.0f} W "
|
|
f"grid {r['plant'].grid(599):.0f} W")
|