Files
goodwe-addon/goodwe_controller/tools/ev05_sun.py
T
ems-agentandClaude 69f58181bc
checks / unit (pull_request) Successful in 24m24s
infra-pin / fresh (pull_request) Successful in 2s
EV-05 round 5: headroom counts only the batteries that can give
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>
2026-11-18 17:27:17 +01:00

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")