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>
291 lines
12 KiB
Python
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")
|