Files
goodwe-addon/goodwe_controller/tools/ev05_sun.py
T
ems-agentandClaude 29480fda47
checks / unit (pull_request) Failing after 24m58s
infra-pin / fresh (pull_request) Successful in 1s
EV-05: car Solar mode (spare sun to the car, Batteries or Car first, cut first for the peak)
Solar charges the car from the signed spare sun (car + battery charge - grid
import), less the batteries' room (Batteries first) and the sun kept back,
whole amps rounded down, at most one change per 30 s and only on 1 A. It
starts after ev_start_min of enough sun, holds 6 A for ev_pause_min, then 0 A.
Auto phases through EV-04's safe sequence (4.5 kW / 3 min up, 4.0 kW / 5 min
down, one switch per 10 min). What the peak guard would ask the batteries for
is taken off the car first, at once. Every way out of Solar ends at 0 A,
written once; at shutdown before the inverters go to 0 W.

- app/carmode.py: SolarPlan (pure) and SolarWriter (ManualWriter's one write
  site, its sequence and watch); spare_w, car_target_w, amps_for.
- app/ctl_car.py: Solar inputs, the cut, the solar kWh, EV-15's grace for
  Solar's own 0 A, no "set by the car" for Solar; main.py: shutdown order.
- Home card, HA select.goodwe_car_sun_first, sensor car_today_solar_kwh,
  three options with defaults, strings EN/NL, DOCS, DECISIONS, CHANGELOG.
- test_ev05.py, test_ev05_long.py, tools/ev05_sun.py; test_ev03/ev04 checks
  that pinned "Solar is refused" / "three entities" updated.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-17 23:54:06 +01:00

291 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)
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 + 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),
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():
lv = plant.socs[u] - plant.batt_of(u, t) / 36.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")