#!/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), 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")