diff --git a/.gitea/ci/run-tests.sh b/.gitea/ci/run-tests.sh index 82ba2ef..89bb3f7 100755 --- a/.gitea/ci/run-tests.sh +++ b/.gitea/ci/run-tests.sh @@ -49,10 +49,11 @@ SERIAL="test_loop.py test_freeze.py test_safety87.py" # safety119 704, opt34 515, safety126 402, safety125 388, safety126b 364, # modes_p3 377, safety94 360, modes_p4c 291, modes_p4b 238, tariff24_weather 235, # modes_p4d 196, price_run_fixes 197, safety103 189, safety90 185, safety97 163. +# EV-05: ev05_long ~500 and ev05 ~375 alone (the Solar simulations). # CI-18 split test_modes_p4, test_safety126 and test_safety125 so no one file # is much over 400 s; test_opt34 and test_opt36 already fan out inside, and # test_safety119 part 4 is one coupled block, so those three stay whole. -HEAVY="test_opt36.py test_safety119.py test_opt34.py test_safety126.py test_safety125.py test_safety126b.py test_modes_p3.py test_safety94.py test_modes_p4c.py test_modes_p4b.py test_tariff24_weather.py test_modes_p4d.py test_safety125b.py test_price_run_fixes.py test_safety103.py test_safety90.py test_safety97.py test_peakguard.py test_opt20.py test_safety81.py" +HEAVY="test_opt36.py test_safety119.py test_ev05_long.py test_opt34.py test_ev05.py test_safety126.py test_safety125.py test_safety126b.py test_modes_p3.py test_safety94.py test_modes_p4c.py test_modes_p4b.py test_tariff24_weather.py test_modes_p4d.py test_safety125b.py test_price_run_fixes.py test_safety103.py test_safety90.py test_safety97.py test_peakguard.py test_opt20.py test_safety81.py" # JOBS=${CI_JOBS:-10} cd "${TESTS_DIR:-/w/goodwe-addon/goodwe_controller}" diff --git a/goodwe_controller/CHANGELOG.md b/goodwe_controller/CHANGELOG.md index 0d68c33..b9000cd 100644 --- a/goodwe_controller/CHANGELOG.md +++ b/goodwe_controller/CHANGELOG.md @@ -3,6 +3,7 @@ ### Not in a release yet - When the add-on changes the car's phases while the batteries are at the peak reserve, there is no longer a false "Battery stopped limiting the peak" for a moment ([[EV-15]]). +- The car can charge from spare sun only (Solar mode), with the batteries or the car first, and it is cut first when the 15-minute period heads over the peak limit. Three new options with defaults ([[EV-05]]). ## 0.24.0 diff --git a/goodwe_controller/DECISIONS/EV-05-solar-mode.md b/goodwe_controller/DECISIONS/EV-05-solar-mode.md new file mode 100644 index 0000000..1bc86de --- /dev/null +++ b/goodwe_controller/DECISIONS/EV-05-solar-mode.md @@ -0,0 +1,54 @@ +# EV-05 — Solar mode: spare sun to the car + +The design is `reports/EV-01-design-report.md` (sections 2 to 5, decisions 2 and +5) and the EV-05 brief v3 (owner answers Q1 and Q4, 2026-11-17). This record +keeps what the code had to decide. + +## Where it lives + +`carmode.SolarPlan` decides (pure, monotonic clock): what current, on what +phases. `carmode.SolarWriter` makes the charger match it. It is a subclass of +`ManualWriter`, so the write, the read-back, the phase sequence and the +other-writer watch are Manual's and there is still one `write_current` and one +`write_phases` call in `app/` (test_ev04.py's AST check). `ctl_car` builds the +inputs (`car_sun_inputs`) and runs the writer in the same background task. + +## The rules the brief left open + +- **Entering Solar starts at 0 A.** Choosing Solar, a restart in Solar, the + charger or Home Assistant coming back, a charger error or a stuck reading + clearing, and control starting again all reset the plan: 0 A if the charger + shows more, then the start rule. Switching from Manual to Solar therefore + pauses a Manual charge for the start dwell. Simple and on the safe side. +- **The peak cut is what the guard would ask the batteries for.** The excess is + taken off the car only when the guard is engaged and wants a discharge + (`wanted_w > 0`), and by `min(excess, wanted)`. Batteries that only stop + charging in a cloud's first seconds are not "asked", so a cloud does not cut + the car. A partial cut caps the car for the rest of that 15-minute period. +- **The 4.0 to 4.14 kW band on 3 phases.** 3 phases need 4.14 kW at 6 A, the + switch back to 1 phase is under 4.0 kW. Inside that band the car holds 6 A on + 3 phases with no pause count (the hysteresis the design chose). Under 4.0 kW + the down-switch comes after 5 minutes; if the 10-minute gap blocks it, the + pause rule does instead. +- **A phase switch also waits for the 30 s write rule**, so the current set + after a switch is never sooner than 30 s after the one before it. +- **The meter's age.** The spare is not computed from a meter reading older + than `stale_input_s`, also when `meter_max_age_s` (P1) is longer. +- **A stale, stuck or not corroborated charging car makes the spare unknown**: + hold, then 0 A after *Pause after*. A paused or idle car with a fresh reading + counts 0 W (`car_w_trusted` is None outside mode3 C). +- **A stuck reading's 0 A is written whatever the frozen read-back says**, since + that read-back means nothing then. Every other exit skips the write when the + charger already shows 0 A, and never writes over another writer. +- **The guard's alarm path** uses the Solar car like Manual's + (`car_alarm_w`), and Solar's own 0 A (pause, cut, phase change) gets EV-15's + bounded grace (`_car_solar_pause`). A Solar quarter is never banked as "set + by the car", and Solar shows no *Car over the peak limit*. +- **Shadow mode** runs the plan without writing, so the card says what it would + set; the charger got its one 0 A when shadow mode came on. + +## Solar kWh + +Per cycle in Solar: `min(car power, max(0, spare - room))` Batteries first, +`min(car power, max(0, spare))` Car first; never above today's kWh; reset at the +day change; kept in the store (`car_sun`). diff --git a/goodwe_controller/DOCS.md b/goodwe_controller/DOCS.md index 1d358f7..3bbfcb1 100644 --- a/goodwe_controller/DOCS.md +++ b/goodwe_controller/DOCS.md @@ -256,7 +256,10 @@ The label and description each setting shows on the Configuration tab, in tab or | Car charger | Charger limit (A) | `ev_max_a` | The most current the charger may ever be asked for. Never above what the charger reports. Lower it for a weaker fuse or cable. | | Car charger | Phases | `ev_phases` | How many phases the charger may use: 1, 3, or 1 and 3 (auto). | | Car charger | Batteries help with the peak | `ev_batt_cover` | While the car charges. On: the batteries cover it down to the peak reserve. Off: the peak guard leaves the car out, so the car alone can set the peak. | -| Car charger | Mode after a restart | `ev_mode_start` | Keep the last mode, or start in Off. A restart never changes the charger's current. | +| Car charger | Mode after a restart | `ev_mode_start` | Keep the last mode, or start in Off. In Solar a restart sets the charger to 0 A first, other modes leave its current. | +| Car charger | Sun kept back (W) | `ev_margin_w` | Solar: this much spare sun is never given to the car. | +| Car charger | Start after (minutes) | `ev_start_min` | Solar: the car starts after this long with enough spare sun. | +| Car charger | Pause after (minutes) | `ev_pause_min` | Solar: with too little sun the car holds 6 A this long, then pauses. | | Advanced | Start control on boot | `auto_start` | Off by default. Leave it off until the site is commissioned, so someone presses Start after each restart. | | Advanced | Control gain | `gain` | How much of the remaining error control corrects each cycle. Measured on real hardware, do not raise it. | | Advanced | Largest change per cycle (W) | `slew_w` | How far the command may move in one cycle. 0 follows “Inverter rating” and is recommended. | @@ -3278,9 +3281,10 @@ it. ### Car charger The add-on can drive your car charger and shows it on **Home**, on a *Car* card. -The card has two modes in this version: **Off** (the add-on only reads the -charger and writes nothing) and **Manual** (the add-on sets the current and the -phases you choose). Solar and Night modes come in later versions. +The card has three modes in this version: **Off** (the add-on only reads the +charger and writes nothing), **Manual** (the add-on sets the current and the +phases you choose) and **Solar** (the car charges from spare sun only). Night +mode comes in a later version. | option | meaning | |---|---| @@ -3290,6 +3294,9 @@ phases you choose). Solar and Night modes come in later versions. | `ev_phases` | `1`, `3` or `auto` (1 and 3). | | `ev_batt_cover` | On (the default): the batteries help cover the car down to the peak reserve. Off: the car is left out of what the peak guard protects. | | `ev_mode_start` | `keep` (the default) or `off`: the mode after a restart. | +| `ev_margin_w` | Solar: spare sun never given to the car, 0 to 1000 W (default 100). | +| `ev_start_min` | Solar: minutes of enough sun before the car starts, 1 to 30 (default 2). | +| `ev_pause_min` | Solar: minutes the car holds 6 A with too little sun before it pauses, 1 to 30 (default 5). | **What the Car card shows.** The state (Charging, Connected waiting, No car connected, Car is full, Charger not reachable), the power and current, and the @@ -3320,7 +3327,46 @@ checks within 10 seconds that the charger took it. current again only if the charger shows a different one. - Off writes nothing, ever. -**The car is never slowed for the peak limit.** A Manual charge goes on whatever +**Solar mode.** Choose *Solar* on Home (or `Solar` on `select.goodwe_car_mode`) +and where spare sun goes first: **Batteries** or **Car** (`select.goodwe_car_sun_first`). +Both apply at once, with no restart. + +- *Spare sun* is solar production less the house, measured without a solar + sensor: the car's power, plus what the batteries charge, less what the grid + gives. A grid charge of the batteries, or batteries giving more than the house + uses, is never spare sun. +- *Batteries first*: the car gets what is left after the full rating of every + battery that may still charge (switched on, not refusing, not full), less + *Sun kept back*. So the car gets sun only when the batteries charge at full + power or are full. *Car first*: the car gets the spare sun less *Sun kept + back*, and the batteries charge with what it leaves. +- The current is whole amps, rounded down, from 6 A to the charger limit. It + changes at most once per 30 seconds, and only by 1 A or more. +- The car starts after *Start after* (2 minutes) of sun for at least 7 A. With + too little sun it holds 6 A for *Pause after* (5 minutes), from the batteries + where they can, then pauses at 0 A: the card says *Waiting for sun*. +- With `ev_phases` `auto` a start goes on 1 phase. It moves to 3 phases after + 3 minutes at 4.5 kW or more, and back to 1 phase after 5 minutes under 4 kW, + at most once per 10 minutes, always through the safe phase steps above. A car + that draws one phase while three are allowed is counted on one phase. +- **The car is cut first for the peak limit.** When the 15-minute period heads + over the limit and the peak guard would ask the batteries for power, that is + taken off the car first, down to 0 A at once. A Solar charge never sets the + month's peak. +- **Every way out of Solar leaves the charger at 0 A**, written once: a stop or + restart of the add-on (before the inverters go to 0 W), stopping control, a + safety stop, shadow mode turned on, choosing Off, an unplugged car, a charger + error or a stuck reading. After the charger or Home Assistant was away, the + add-on first sets 0 A, then starts again by the rules. A meter that stops + gives a hold for *Pause after*, then 0 A. Choosing Manual leaves it to Manual. +- Another writer stops the add-on's writes after 30 seconds, with an amber row + and a warning, until you press the mode again or the charger shows the + add-on's value again. +- The card shows *{kWh} charged today, {kWh} from the sun*, also as + `sensor.goodwe_car_today_solar_kwh`. Only the sun the car could take counts, + not the battery or grid share of a hold, and not Manual. + +**The car is never slowed for the peak limit in Manual.** A Manual charge goes on whatever the 15-minute peak does. With the default `ev_batt_cover` on, the batteries help cover it down to the peak reserve; a 3-phase 16 A charge (11 kW) can empty two batteries to the reserve in about 1.5 hours, and the month's peak then rises by @@ -3364,9 +3410,10 @@ charger* shows for an hour after a change. That is expected while you migrate. automation **off** (do not delete it). On the card choose **Manual** with the current your helper held (`input_number.ev_manual_current`). Plug in and check the current on the card and on the charger's display. -3. On the next sunny day, choose Solar, with *spare sun goes first to* set as - your priority switch was. (Solar comes in a later version; until then keep - Manual or Off.) +3. On the next sunny day, choose **Solar**, with *Spare sun goes first to* set + as your priority switch was (*Batteries* or *Car*), and *Sun kept back* as + your automation's margin. Watch the card's *Why* through a cloud: the car + holds 6 A for 5 minutes, then waits for the sun. 4. Keep your Home Assistant helpers for a week. To go back, set the add-on mode to Off and switch the automation on. After that you can delete the helpers and the automation. @@ -3377,8 +3424,8 @@ off before you choose Manual, and the add-on off (mode Off) before you turn the automation on. **Home Assistant entities.** With MQTT the add-on adds the sensors -`goodwe_car_power`, `goodwe_car_state` and `goodwe_car_today_kwh`, and the three -controls named above. A saved ("retained") command is never applied, so a +`goodwe_car_power`, `goodwe_car_state`, `goodwe_car_today_kwh` and +`goodwe_car_today_solar_kwh`, and the four controls named above. A saved ("retained") command is never applied, so a restart of Home Assistant cannot change the charger. ### Site @@ -3516,6 +3563,13 @@ their full power. The add-on never slows the car, so this is information, not an alarm. It is raised once per charging session. To stay under the limit, lower the current. +### Charger error, car paused + +In Solar mode the charger reports an error, so the add-on set the car to 0 A +and writes nothing more until the error clears. Then the car starts again by +the Solar rules. Check the charger itself. The notification goes by itself when +the error clears. + ### For installers: notifications A fixed tariff beside the price service raises no notification: it is the diff --git a/goodwe_controller/app/carmode.py b/goodwe_controller/app/carmode.py index 39bf326..febd847 100644 --- a/goodwe_controller/app/carmode.py +++ b/goodwe_controller/app/carmode.py @@ -1,4 +1,5 @@ -"""EV-04: the car charger's Manual mode, the one place the add-on WRITES to it. +"""EV-04 and EV-05: the car charger's Manual and Solar modes, the one place the +add-on WRITES to it. Pure but for the driver it is handed: no clock of its own (`now` is monotonic seconds from the caller), no Home Assistant, no store. DECISIONS/EV-04-manual- @@ -24,21 +25,38 @@ THE RULES, each tested in test_ev04.py: mode or a value again. * A charger that comes back after being unavailable gets the setting again only if its read-back differs. + +EV-05, SOLAR (`SolarPlan` decides, `SolarWriter` writes; test_ev05.py, +DECISIONS/EV-05-solar-mode.md): the car gets the spare sun, `spare = car + +battery charge - grid import`, less the batteries' room (Batteries first) and +the margin. Whole amps rounded down, at most one write per 30 s and only on a +1 A change. Start after `ev_start_min` of enough sun, hold 6 A for +`ev_pause_min` below it, then 0 A. The peak guard's excess is taken off the +car first, at once. Every way out of Solar leaves the charger at 0 A, written +once. Both writers share `ManualWriter._write`, so there is still one +`write_current` and one `write_phases` call in the add-on. """ from __future__ import annotations import logging +import math from . import chargers as CH _LOG = logging.getLogger("goodwe") -OFF, MANUAL = "off", "manual" -#: the modes this card offers. Solar and Night are later cards (EV-05, EV-02). -MODES = (OFF, MANUAL) +OFF, MANUAL, SOLAR = "off", "manual", "solar" +#: the modes offered. Night is a later card (EV-02). +MODES = (OFF, MANUAL, SOLAR) #: Home Assistant's select labels, English and pinned. -MODE_LABELS = {OFF: "Off", MANUAL: "Manual"} +MODE_LABELS = {OFF: "Off", MANUAL: "Manual", SOLAR: "Solar"} +#: EV-05: where the spare sun goes first (`select.goodwe_car_sun_first`). +KEY_FIRST = "car_sun_first" +FIRST_BATT, FIRST_CAR = "batteries", "car" +FIRSTS = (FIRST_BATT, FIRST_CAR) +FIRST_LABELS = {FIRST_BATT: "Batteries", FIRST_CAR: "Car"} +DEFAULT_FIRST = FIRST_BATT START_KEEP, START_OFF = "keep", "off" KEY_MODE, KEY_A, KEY_PHASES = "car_mode", "car_current", "car_phases" @@ -378,3 +396,485 @@ class ManualWriter: self.rev_applied = None return q["t1"] = now - SETTLE_S + 5.0 # again in 5 s + + +# =========================================================================== # +# EV-05: Solar. `SolarPlan` decides what the car should get, `SolarWriter` +# makes the charger match it through ManualWriter's one write site. +# =========================================================================== # +MIN_A = CH.MIN_A +VOLTS = 230.0 # per phase: the amps a figure in watts is worth +SOLAR_WRITE_S = 30.0 # at most one current change per this +SOLAR_STEP_A = 1.0 # ... and only on a change of this or more +UP_W, UP_S = 4500.0, 180.0 # auto phases: to 3 at this for this long +DOWN_W, DOWN_S = 4000.0, 300.0 # ... back to 1 under this for this long +ONE_PHASE_S = 10.0 # one phase drawing while 3 are allowed this long +ONE_PHASE_MIN_W = 500.0 # ... with the car drawing at least this + + +def _num(v): + try: + f = float(v) + except (TypeError, ValueError): + return None + return f if math.isfinite(f) else None + + +def spare_w(car_w, batt_w, grid_w): + """The spare sun, signed and not clipped: what the car takes, plus what the + batteries charge, less what the grid gives. `batt_w` is the add-on's own + battery figure (discharge positive) and `grid_w` the meter (import + positive), so this is `car - batt - grid` = solar production less the + house. A grid charge of the batteries, or batteries giving more than the + house uses, is never spare sun. None when a figure is missing or not a + number.""" + c, b, g = _num(car_w), _num(batt_w), _num(grid_w) + if c is None or b is None or g is None: + return None + return c - b - g + + +def car_target_w(spare, room_w, margin_w, first): + """What the car may take: Batteries first `spare - room - margin`, Car + first `spare - margin`. None while the spare is unknown.""" + s = _num(spare) + if s is None: + return None + room = float(room_w or 0.0) if first == FIRST_BATT else 0.0 + return s - room - float(margin_w) + + +def amps_for(car_w, n, clamp=None): + """Whole amps for `car_w` on `n` phases, ROUNDED DOWN, never above the + clamp. None for a figure that is not a number.""" + w = _num(car_w) + if w is None or n not in (1, 3): + return None + a = math.floor(w / (VOLTS * n) + 1e-9) + hi = CH.ENTITY_MAX_A if _num(clamp) is None else float(clamp) + return float(max(0, min(a, math.floor(hi)))) + + +def solar_option(opts: dict, key: str) -> float: + """`ev_margin_w`, `ev_pause_min` or `ev_start_min` as a number, the shipped + default when it is not one (the validator refuses it anyway).""" + v = _num((opts or {}).get(key)) + return float(CH.EV_OPTION_DEFAULTS[key]) if v is None else v + + +class SunInputs: + """One cycle's inputs for Solar, built by the Controller.""" + + def __init__(self, target_w=None, hold=False, cut_w=0.0, car_w=None, + key=None, auto=True, fixed_n=1, start_s=120.0, + pause_s=300.0, spare_w=None, room_w=0.0, margin_w=100.0, + first=DEFAULT_FIRST): + self.target_w, self.hold, self.cut_w = target_w, hold, cut_w + self.car_w, self.key, self.auto, self.fixed_n = car_w, key, auto, \ + fixed_n + self.start_s, self.pause_s = start_s, pause_s + self.spare_w, self.room_w, self.margin_w = spare_w, room_w, margin_w + self.first = first + + +class SolarPlan: + """What Solar wants set, one `step()` per cycle. Pure: monotonic `now` from + the caller and no driver, so in shadow mode it runs the same and the card + says what it would set. `a` is the current wanted (0: paused), `n` the + phases it is meant for.""" + + def __init__(self, n=1): + self.reset(n) + + def reset(self, n=1, why="paused"): + self.a = 0.0 + self.n = n if n in (1, 3) else 1 + self.set_at = None # when `a` last changed (the 30 s rule) + self.ok_since = None # enough sun to start, since + self.low_since = None # under 6 A worth, holding 6 A, since + self.unknown_since = None # the spare cannot be measured, since + self.up_since = self.down_since = None + self.cap_a = self.cap_key = None # the peak cut, for this period + self.why = self.pause_why = why + self.target_w = None + + def _pause(self, why): + self.a, self.set_at = 0.0, None + self.ok_since = self.low_since = self.unknown_since = None + self.up_since = self.down_since = None + self.why = self.pause_why = why + + def _gate(self, now) -> bool: + return self.set_at is None or now - self.set_at >= SOLAR_WRITE_S + + def _switch(self, n, target_w, now, clamp): + self.n = n + a = amps_for(target_w, n, clamp) or 0.0 + if a >= MIN_A: + self.low_since = None + elif self.low_since is None: + self.low_since = now + a = max(a, MIN_A) + if self.cap_a is not None: + a = max(MIN_A, min(a, self.cap_a)) + self.a, self.set_at = a, now + self.up_since = self.down_since = None + self.why = "running" + + def step(self, now, *, target_w, n_calc, auto, fixed_n, clamp, + start_s, pause_s, hold=False, cut_w=0.0, car_w=None, key=None, + gap_ok=True): + if key != self.cap_key: + self.cap_a = self.cap_key = None + if hold: # readings late, under the stale bound + return + self.target_w = target_w + # The peak guard's excess comes off the car first, at once (no 30 s + # rule, no hold). Nothing starts while the period heads over the aim. + if cut_w and cut_w > 0.0: + self.ok_since = None + if self.a > 0.0: + base = self.a * VOLTS * n_calc + cw = _num(car_w) + if cw is not None: + base = min(base, cw) + new = amps_for(base - float(cut_w), n_calc, clamp) + if new is None or new < MIN_A: + self._pause("cut") + elif new < self.a: + self.a, self.set_at, self.why = new, now, "cut" + self.cap_a, self.cap_key = new, key + return + if target_w is None: # the sun cannot be measured: hold, then 0 A + self.ok_since = None + if self.a > 0.0: + if self.unknown_since is None: + self.unknown_since = now + if now - self.unknown_since >= pause_s: + self._pause("unknown") + else: + self.why = "unknown" + return + self.unknown_since = None + hi = None if _num(clamp) is None else math.floor(float(clamp)) + if self.a <= 0.0: # paused: the start rule + n0 = 1 if auto else fixed_n + if target_w >= (MIN_A + 1.0) * VOLTS * n0: + if self.ok_since is None: + self.ok_since = now + self.why = "start" + if now - self.ok_since >= start_s: + a = amps_for(target_w, n0, clamp) + if a is not None and self.cap_a is not None: + a = min(a, self.cap_a) + if a is not None and a >= MIN_A: + self.a, self.n, self.set_at = a, n0, now + self.ok_since = self.low_since = None + self.up_since = self.down_since = None + self.why = "running" + else: + self.ok_since = None + self.why = self.pause_why + return + if hi is not None and self.a > hi: # the clamp came down + if hi < MIN_A: + self._pause("paused") + return + self.a, self.set_at = float(hi), now + if auto: # auto phases, by their own dwells + if self.n == 1: + self.down_since = None + if target_w >= UP_W: + self.up_since = self.up_since if self.up_since is not None \ + else now + else: + self.up_since = None + if self.up_since is not None and now - self.up_since >= UP_S \ + and gap_ok and self._gate(now): + self._switch(3, target_w, now, clamp) + return + else: + self.up_since = None + if target_w < DOWN_W: + self.down_since = self.down_since \ + if self.down_since is not None else now + else: + self.down_since = None + if self.down_since is not None \ + and now - self.down_since >= DOWN_S and gap_ok and self._gate(now): + self._switch(1, target_w, now, clamp) + return + want = amps_for(target_w, n_calc, clamp) + if want is not None and want >= MIN_A: + self.low_since = None + if self.cap_a is not None: + want = min(want, self.cap_a) + self.why = "running" + if abs(want - self.a) >= SOLAR_STEP_A and self._gate(now): + self.a, self.set_at = want, now + return + if auto and self.n == 3 and target_w >= DOWN_W: + # Inside the phase hysteresis (4.0 kW to 6 A x 690 W): 3 phases at + # 6 A stand, as the switch rule says; no pause count. + self.low_since = None + self.why = "running" + if self.a != MIN_A and self._gate(now): + self.a, self.set_at = MIN_A, now + return + if self.low_since is None: + self.low_since = now + self.why = "hold" + if now - self.low_since >= pause_s: + self._pause("paused") + return + if self.a != MIN_A and self._gate(now): + self.a, self.set_at = MIN_A, now + + +class SolarWriter(ManualWriter): + """What Solar does to the charger, one `step()` per cycle. It shares + ManualWriter's write, phase sequence and other-writer watch; what differs + is that every way out ends at 0 A, written once, and that an interrupted + phase change is never undone to the old current.""" + + def __init__(self): + super().__init__() + self.plan = SolarPlan() + self.engaged = False # Solar has run since it was chosen + self.reinit = True # start again from 0 A and the start rule + self.out = False # not writing: the 0 A has been tried + self.stand = False # no car: the standing 0 A has been tried + self.fault = None # "error" | "stuck" while it holds + self.fault_done = False + self.warned = False # the charger error warning, once + self.single = False # a one-phase car on a 3-phase allowance + self._one_since = None + self.zero_at = None # EV-15: our own latest 0 A, sent then + self.sent_a = None # the current we last decided to write + + # ------------------------------------------------------------------ help + def _mark(self, r, now) -> None: + """A car that draws one phase while 3 are allowed is a one-phase car + for the session: the sun arithmetic then uses 1 phase.""" + if r.state == "A": + self.single, self._one_since = False, None + return + drawing = [x for x in (r.current_a or ()) if x >= CH.IDLE_A] + one = (r.phases_allowed == 3 and r.charging is True + and r.power_w is not None and r.power_w >= ONE_PHASE_MIN_W + and len(r.current_a or ()) >= 3 and len(drawing) == 1) + if not one: + self._one_since = None + return + if self._one_since is None: + self._one_since = now + if now - self._one_since >= ONE_PHASE_S and not self.single: + self.single = True + _LOG.info("The car draws one phase while three are allowed, so " + "the add-on counts one phase for this charge.") + + def _watch(self, cur, now) -> None: + """As Manual's, and in Solar the hold is a warning: the add-on stops + writing until you press the mode or the read-back matches again.""" + was = self.hold + super()._watch(cur, now) + if self.hold and not was: + _LOG.warning("Something else changes the charger, so the add-on " + "stops writing to it: CHARGER_OTHER.") + + @property + def n_calc(self) -> int: + return 1 if self.single else self.plan.n + + def amps_out(self, clamp) -> float: + """The plan's current, never above the clamp; 0 when under 6 A.""" + a = float(self.plan.a) + if _num(clamp) is not None: + a = min(a, float(math.floor(float(clamp)))) + return a if a >= CH.MIN_A else 0.0 + + def user_changed(self) -> None: + """As Manual's, and Solar says its current again (another writer's + hold is lifted by pressing the mode).""" + super().user_changed() + self.sent_a = None + + async def _zero_once(self, drv, cur, now, tracker, force=False) -> None: + """One try of 0 A on the way out. Never over another writer, and not + when the charger already shows 0 A (unless the reading is stuck, so + its 0 A means nothing: `force`).""" + if self.hold or (not force and cur is not None and cur <= TOL_A): + return + self.zero_at, self.sent_a = now, 0.0 + await self._write(drv, 0.0, cur, now, tracker) + + def _leave(self) -> None: + self.engaged, self.seq, self.would = False, None, None + self.out = self.stand = False + self.fault, self.fault_done = None, False + self.reinit = True + self.sent_a = None + self.plan.reset(self.plan.n) + + def _plan_step(self, sun, now, clamp) -> None: + gap = self.last_switch is None or now - self.last_switch >= PHASE_GAP_S + self.plan.step( + now, target_w=sun.target_w, hold=sun.hold, n_calc=self.n_calc, + auto=sun.auto and not self.single, + fixed_n=1 if self.single else sun.fixed_n, clamp=clamp, + cut_w=sun.cut_w, car_w=sun.car_w, key=sun.key, + start_s=sun.start_s, pause_s=sun.pause_s, + gap_ok=gap and not self.phases_gave_up) + + # ------------------------------------------------------------------ step + async def step(self, drv, r, *, mode, sun, clamp, now, tracker, writing, + status, clock=None): + """One cycle. `sun` is `SunInputs`; `writing` is False in shadow mode, + while control is stopped, under a safety stop and while stopping.""" + self._clock = clock or (lambda: now) + if r is None or not r.available: + self.was_available = False # nothing is tried while it is down + return + if self.last_done is not None and tracker is not None \ + and tracker.obs_at is not None \ + and tracker.obs_at <= self.last_done: + return + self._mark(r, now) + if not self.was_available: + self.was_available = True + self.reinit = True # back: 0 A first, then the rules + cur = r.allowed_a if r.allowed_a is not None else r.setpoint_a + if mode != SOLAR: + self.would = None + if not self.engaged: + return + if mode != MANUAL: # Off: 0 A once, then nothing + self.seq = None + await self._zero_once(drv, cur, now, tracker) + self._leave() # Manual writes its own current + return + self.engaged = True + if sun is None: + return + if not writing: + # Shadow, Stop, a safety stop, stopping: 0 A once, then nothing. + # The plan goes on, so the card says what it would set. + self.seq = None + if not self.out: + self.out = True + await self._zero_once(drv, cur, now, tracker) + self._plan_step(sun, now, clamp) + self.would = (self.amps_out(clamp), self.n_calc) + self.reinit = True + return + self.out = False + self.would = None + fault = ("error" if (r.error or r.state in ("E", "F")) else + "stuck" if tracker is not None and tracker.stuck(now) + else None) + if fault is not None: + # 0 A once, then no write until it clears; then the start rule. + self.seq = None + if self.fault != fault: + self.fault, self.fault_done = fault, False + if fault == "error" and not self.warned: + self.warned = True + _LOG.warning("The charger reports an error, so the add-on " + "sets the car to 0 A: CHARGER_ERROR.") + if not self.fault_done: + self.fault_done = True + await self._zero_once(drv, cur, now, tracker, + force=fault == "stuck") + self.plan.reset(self.plan.n, why=fault) + self.reinit = True + return + if self.fault is not None: + self.fault, self.fault_done = None, False + self.warned = False + if r.state == "A" or status == CH.NONE_: + # No car: the standing current is 0 A, written once. + self.seq = None + if not self.stand: + self.stand = True + await self._zero_once(drv, cur, now, tracker) + self.plan.reset(self.plan.n, why="none") + self.reinit = False + return + self.stand = False + if self.reinit: + self.reinit = False + self.seq = None + self.mismatch_since = None + self.sent_a = None + n = r.phases_allowed if r.phases_allowed in (1, 3) else self.plan.n + self.plan.reset(n) + if status == CH.FULL: # the car is full: nothing written + self.plan.why = "full" + return + if self.seq is None: + self._watch(cur, now) + if self.hold: + return + self._plan_step(sun, now, clamp) + if self.seq is not None: + q = self.seq + if self.plan.a < CH.MIN_A: + self.seq = None # paused or cut: it stays at 0 A + return + pf = self.phase_fails + await self._advance(drv, r, cur, now, tracker, self.amps_out(clamp) + or CH.MIN_A, clamp, None) + if self.phase_fails > pf and q.get("from") in (1, 3): + self.plan.n = q["from"] # the select was not taken + if self.seq is None: + self.sent_a = self.last_a + return + want = self.amps_out(clamp) + if want >= CH.MIN_A and not self.single and not self.phases_gave_up \ + and r.phases_allowed in (1, 3) \ + and r.phases_allowed != self.plan.n: + if self.last_switch is not None \ + and now - self.last_switch < PHASE_GAP_S: + self.blocked = True + return + self.blocked = False + self.zero_at, self.sent_a = now, 0.0 + await self._begin(drv, r, cur, self.plan.n, now, tracker) + if self.seq is not None: + self.seq["from"] = r.phases_allowed + return + if self.sent_a is not None and abs(self.sent_a - want) <= TOL_A \ + and self.fail_at is None: + return # nothing new: a read-back that differs is `_watch`'s + if cur is not None and abs(cur - want) <= TOL_A: + self.sent_a = want + self.fails, self.fail_at = 0, None + if self.last_a is None or abs(self.last_a - cur) > TOL_A: + self.last_a = cur + return + if self.gave_up or (self.fail_at is not None + and now - self.fail_at < RETRY_S): + return + if want <= 0.0: + self.zero_at = now + self.sent_a = want + if await self._write(drv, want, cur, now, tracker): + self.fails, self.fail_at = 0, None + else: + self._failed(now) + + async def release(self, drv, r, now, tracker) -> None: + """The add-on stops in Solar: 0 A, once, before the inverters go to + 0 W. A phase change in the middle is not undone to the old current.""" + self.seq = None + if r is not None and r.available: + cur = r.allowed_a if r.allowed_a is not None else r.setpoint_a + else: + cur = None + if self.last_done is not None and tracker is not None \ + and tracker.obs_at is not None \ + and tracker.obs_at <= self.last_done: + cur = self.last_a # the reading predates our own write + self._clock = self._clock or (lambda: now) + await self._zero_once(drv, cur, now, tracker) + self.out = True diff --git a/goodwe_controller/app/chargers.py b/goodwe_controller/app/chargers.py index caa6618..c4207ed 100644 --- a/goodwe_controller/app/chargers.py +++ b/goodwe_controller/app/chargers.py @@ -5,8 +5,8 @@ actuator per site, a census key, a read, a clamped write that says whether the charger took it, and a hand-back. A charger is a modulated actuator with a fail state, not one of DEV-01's on/off loads. -EV-04 IS THE FIRST CARD THAT WRITES TO THE CHARGER, and only in Manual -(`app/carmode.py` is the one caller). `write_current` is clamped to +EV-04 IS THE FIRST CARD THAT WRITES TO THE CHARGER, in Manual and (EV-05) in +Solar (`app/carmode.py` is the one caller). `write_current` is clamped to `min(ev_max_a, the station limit the charger reports, the entity's own range)` and a value above that is NEVER SENT: it is a software fault, logged in the OUTPUT_CLAMP shape. It says True only when the charger's read-back followed @@ -42,7 +42,13 @@ PHASES_CHOICES = ("1", "3", "auto") # config.yaml's shipped defaults, mirrored (test_defaults_pin.py checks it). EV_OPTION_DEFAULTS = {"ev_charger": "off", "ev_current_entity": "", "ev_max_a": 16, "ev_phases": "auto", - "ev_batt_cover": True, "ev_mode_start": "keep"} + "ev_batt_cover": True, "ev_mode_start": "keep", + # EV-05, Solar: the sun kept back, and the two dwells + "ev_margin_w": 100, "ev_pause_min": 5, + "ev_start_min": 2} +#: EV-05: the ranges config.yaml's schema and the validator both hold. +SOLAR_RANGES = {"ev_margin_w": (0, 1000), "ev_pause_min": (1, 30), + "ev_start_min": (1, 30)} def max_a(opts: dict): @@ -553,7 +559,9 @@ class AlfenHaDriver(ChargerDriver): async def release(self, mode: str) -> bool: """The mode's fail state. Manual and Off keep the current (the charger - is a stand-alone device and the current is the user's setting).""" + is a stand-alone device and the current is the user's setting). Solar's + 0 A goes through `carmode` (`SolarWriter.release`), the one write + site, so nothing is written here.""" return True diff --git a/goodwe_controller/app/ctl_car.py b/goodwe_controller/app/ctl_car.py index 41615da..e17620c 100644 --- a/goodwe_controller/app/ctl_car.py +++ b/goodwe_controller/app/ctl_car.py @@ -1,17 +1,21 @@ -"""EV-04: the Controller's side of the car's Manual mode. +"""EV-04 and EV-05: the Controller's side of the car's Manual and Solar modes. The writes themselves are `carmode.ManualWriter`'s; this mixin owns the state (mode, current, phases: runtime state in the store, like OPT-11's modes), the actions, the background step that never holds up a control cycle, and what the car means for the peak guard's ALARM PATH. DECISIONS/EV-04-manual-mode.md. +EV-05 (DECISIONS/EV-05-solar-mode.md): Solar's inputs (`car_sun_inputs`), the +peak guard's excess taken off the car first (`car_cycle`), the 0 A at shutdown +before the inverters, and the solar kWh of today. """ import asyncio import dataclasses import logging +import math from datetime import timezone -from . import carmode, chargers, messages, peakguard +from . import carmode, chargers, messages, packmode, packshare, peakguard from .tariff import QUARTER_S _LOG = logging.getLogger("goodwe") @@ -31,6 +35,10 @@ OVER_OFF_HOLD_S = 180.0 OWN_PAUSE_MAX_S = (carmode.ZERO_WAIT_S + carmode.SETTLE_S + carmode.MAX_TRIES * 15.0 + 10.0) OWN_PAUSE_TAIL_S = chargers.CORR_WINDOW_S +CAR_SUN_KEY = "car_sun" # EV-05: {day, kwh} charged from the sun today +# EV-05: at shutdown the charger's 0 A waits at most this long, then the +# inverters are released whatever the charger did. +RELEASE_WAIT_S = 15.0 class CarMixin: @@ -52,6 +60,25 @@ class CarMixin: self.car_n = n if n in ok else ok[0] self.car_rev = 0 self.car_writer = carmode.ManualWriter() + self.car_solar = carmode.SolarWriter() # EV-05 + first = data.get(carmode.KEY_FIRST) + self.car_first = first if first in carmode.FIRSTS \ + else carmode.DEFAULT_FIRST + self.car_cut_w = 0.0 + self._car_key = None + self._car_late_s = None + self._car_sun_last = None + self._car_error_notified = False + sun = data.get(CAR_SUN_KEY) + self.car_sun = {"day": None, "kwh": 0.0} + if isinstance(sun, dict): + try: + self.car_sun = {"day": sun.get("day"), + "kwh": max(0.0, float(sun.get("kwh") or 0.0))} + except (TypeError, ValueError): + pass + self._car_sun_mono = None + self._car_sun_saved = round(self.car_sun["kwh"], 2) self._car_task = None self._car_step_failed = False self.car_explains = False # the car alone explains the excess @@ -81,6 +108,12 @@ class CarMixin: return (self.charger.configured() and self.car_mode == carmode.MANUAL) + def car_solar_mode(self) -> bool: + """EV-05: a charger is set up and the mode is Solar.""" + ch = getattr(self, "charger", None) + return bool(ch is not None and ch.configured() + and getattr(self, "car_mode", None) == carmode.SOLAR) + def car_clamp(self): return carmode.clamp_for(self.o, self.car.reading) @@ -104,6 +137,17 @@ class CarMixin: return {"error": messages.car_refused("value")} self.car_mode = value self.store.set(carmode.KEY_MODE, value) + elif what == "car_sun_first": + # EV-05: arithmetic only, from the next cycle; not a user change of + # the writers (the 30 s rule and the other-writer hold stand). + if value not in carmode.FIRSTS: + return {"error": messages.car_refused("value")} + self.car_first = value + self.store.set(carmode.KEY_FIRST, value) + self.log_event(f"car sun first set to {value} by operator", + hint=messages.hint("car_sun_first")) + return {"mode": self.car_mode, "current": self.car_a, + "phases": self.car_n, "sun_first": self.car_first} elif what == "car_current": clamp = self.car_clamp() if isinstance(value, bool): @@ -126,6 +170,7 @@ class CarMixin: self.store.set(carmode.KEY_PHASES, value) self.car_rev += 1 self.car_writer.user_changed() + self.car_solar.user_changed() self.log_event(f"car {what[4:]} set to {value} by operator", hint=messages.hint(what)) return {"mode": self.car_mode, "current": self.car_a, @@ -135,7 +180,8 @@ class CarMixin: """The MQTT state of the three car entities.""" return {"car_mode": carmode.MODE_LABELS[self.car_mode], "car_current": round(self.car_a), - "car_phases": str(self.car_n)} + "car_phases": str(self.car_n), + "car_sun_first": carmode.FIRST_LABELS[self.car_first]} # ------------------------------------------------------------- the writer def car_kick(self) -> None: @@ -149,6 +195,15 @@ class CarMixin: return self._car_task = asyncio.ensure_future(self._car_run()) + def _car_hold_kick(self) -> None: + """EV-05: a cycle that holds for a missing or late reading returns + before `car_kick()`. Solar still steps (it holds, counts its dwell from + the first missing reading, and an exit still writes its 0 A); Manual is + left exactly as it was.""" + if self.car_solar_engaged(): + self.car_cut_w = 0.0 + self.car_kick() + async def car_settle(self) -> None: """Wait for the writer step in flight (the checks use it).""" t = self._car_task @@ -171,14 +226,30 @@ class CarMixin: else: self._car_step_failed = False + def car_solar_engaged(self) -> bool: + """EV-05: Solar is the mode, or its 0 A on the way out is still due.""" + w = getattr(self, "car_solar", None) + return bool(self.charger.configured() and w is not None + and (self.car_mode == carmode.SOLAR or w.engaged)) + async def car_shutdown(self) -> None: - """The add-on stops: no new write, and a phase change in the middle is - undone by giving the car its current back. The current stands - otherwise (Manual's fail state).""" + """The add-on stops: no new write. Manual: a phase change in the middle + is undone by giving the car its current back, the current stands + otherwise. Solar (EV-05): 0 A, once, waited for at most + `RELEASE_WAIT_S` (`Controller.shutdown` calls this first in Solar).""" t, self._car_task = getattr(self, "_car_task", None), None if t is not None and not t.done(): t.cancel() await asyncio.gather(t, return_exceptions=True) + if self.car_solar_engaged(): + try: + await asyncio.wait_for(self.car_solar.release( + self.charger, self.car.reading, self.car_now(), self.car), + RELEASE_WAIT_S) + except Exception: # noqa: BLE001 + _LOG.warning("The car charger could not be set to 0 A before " + "the add-on stopped: CHARGER_RELEASE.") + return if not self.charger.configured() \ or getattr(self, "car_writer", None) is None \ or self.car_writer.seq is None: @@ -197,19 +268,144 @@ class CarMixin: if not self.charger.configured(): return now = self.car_now() - await self.car_writer.step( - self.charger, self.car.reading, mode=self.car_mode, - want_a=self.car_a, want_phases=self.car_n, rev=self.car_rev, - clamp=self.car_clamp(), now=now, tracker=self.car, - writing=self.car_writing(), shadow=bool(self.shadow), - status=self.car.status(now, True), clock=self.car_now) + if self.car_mode != carmode.SOLAR: + await self.car_writer.step( + self.charger, self.car.reading, mode=self.car_mode, + want_a=self.car_a, want_phases=self.car_n, rev=self.car_rev, + clamp=self.car_clamp(), now=now, tracker=self.car, + writing=self.car_writing(), shadow=bool(self.shadow), + status=self.car.status(now, True), clock=self.car_now) + w = self.car_solar + if self.car_mode == carmode.SOLAR or w.engaged: + await w.step( + self.charger, self.car.reading, mode=self.car_mode, + sun=(self.car_sun_inputs(now) + if self.car_mode == carmode.SOLAR else None), + clamp=self.car_clamp(), now=now, tracker=self.car, + writing=self.car_writing(), status=self.car.status(now, True), + clock=self.car_now) + + # ------------------------------------------------------- EV-05: Solar + def car_may_charge(self, inv) -> bool: + """May this battery take the sun? On (battery modes), not refusing a + charge, its level read and under full.""" + if self.modes_on and not self.pack_mode(inv).use: + return False + if (inv.refused or 0) < 0 or inv.sign_wd.tripped: + return False + if len(self.inverters) == 1 and (self.batt_refused or 0) < 0: + return False + return inv.soc is not None and float(inv.soc) < packshare.FULL_PCT + + def car_room_w(self) -> float: + """Batteries first: the RATINGS of the batteries that may charge.""" + return float(sum(inv.rating_w() for inv in self.inverters + if self.car_may_charge(inv))) + + def car_spare_w(self, mono): + """The signed spare sun now, or None when it cannot be measured: a + missing meter or battery figure, readings late past the stale bound, + or a charging car whose figure is stale, stuck or not corroborated. A + paused or idle car with a fresh reading counts as 0 W.""" + if not self.inputs_ok: + return None + stale = float(self.o.get("stale_input_s", 15)) + late = self._car_late_s + if late is not None and late >= stale: + return None + if self.p1_enabled: + # The meter's own bound (`meter_max_age_s`) may be longer than + # `stale_input_s`; a car write never comes from an older reading. + age = self.p1.age_s() + if age is None or age > stale: + return None + r = self.car.reading + if r is None or not r.available or not self.car.fresh(mono): + return None + if r.charging is True: + car = self.car.car_w_trusted(mono) + else: + car = 0.0 + return carmode.spare_w(car, self.site_batt_w, self.grid) + + def car_sun_inputs(self, mono) -> "carmode.SunInputs": + o = self.o + spare = self.car_spare_w(mono) + late = self._car_late_s + hold = late is not None and late < float(o.get("stale_input_s", 15)) + room = self.car_room_w() + margin = carmode.solar_option(o, "ev_margin_w") + ph = str(o.get("ev_phases", chargers.EV_OPTION_DEFAULTS["ev_phases"])) + self._car_sun_last = carmode.SunInputs( + target_w=carmode.car_target_w(spare, room, margin, + self.car_first), + hold=hold, cut_w=self.car_cut_w, + car_w=self.car.car_w(mono), key=self._car_key, + auto=ph not in ("1", "3"), fixed_n=3 if ph == "3" else 1, + start_s=60.0 * carmode.solar_option(o, "ev_start_min"), + pause_s=60.0 * carmode.solar_option(o, "ev_pause_min"), + spare_w=spare, room_w=room, margin_w=margin, + first=self.car_first) + return self._car_sun_last + + def _car_sun_tick(self, mono) -> None: + """Solar kWh: per cycle, in Solar only, the car's power up to the sun + it may take (`spare - room` Batteries first, `spare` Car first). The + hold's battery or grid share and Manual do not count.""" + if not self.car_solar_mode(): + self._car_sun_mono = None + return + day = self.car.day + if day is not None and self.car_sun.get("day") != day: + self.car_sun = {"day": day, "kwh": 0.0} + self.store.set(CAR_SUN_KEY, dict(self.car_sun)) + self._car_sun_saved = 0.0 + last, self._car_sun_mono = self._car_sun_mono, mono + if last is None: + return + dt = min(max(mono - last, 0.0), 5.0) + p = self.car.car_w(mono) + spare = self.car_spare_w(mono) + if p is None or spare is None or dt <= 0.0: + return + sun = spare - (self.car_room_w() if self.car_first == carmode.FIRST_BATT + else 0.0) + share = min(float(p), max(0.0, sun)) + if share <= 0.0: + return + self.car_sun["kwh"] += share * dt / 3.6e6 + if round(self.car_sun["kwh"], 2) != self._car_sun_saved: + self._car_sun_saved = round(self.car_sun["kwh"], 2) + self.store.set(CAR_SUN_KEY, {"day": self.car_sun["day"], + "kwh": round(self.car_sun["kwh"], 4)}) + + def car_sun_kwh(self): + """Today's kWh from the sun, never above today's kWh; None without a + reading of today.""" + if self.car.today_kwh is None or self.car_sun.get("day") != self.car.day: + return None if self.car.today_kwh is None else 0.0 + return max(0.0, min(float(self.car_sun["kwh"]), + float(self.car.today_kwh))) + + async def check_car_error(self) -> None: + """EV-05: in Solar a charger error sets the car to 0 A and raises one + warning notification; it is taken down when the error clears.""" + bad = self.car_solar_mode() and self.car_solar.fault == "error" + if bad and not self._car_error_notified: + self._car_error_notified = True + await self.hass.call("persistent_notification", "create", + messages.charger_error().data()) + elif not bad and self._car_error_notified: + self._car_error_notified = False + await self.hass.call("persistent_notification", "dismiss", + messages.charger_error_gone().data()) # ------------------------------------------- the car and the peak guard def car_alarm_w(self): - """The car's power for the guard's alarm path: Manual only, fresh, not - stuck (`CarTracker.car_w_trusted`), and never above what the read-back - allows. None otherwise, and then the normal alarms stand.""" - if not self.car_manual(): + """The car's power for the guard's alarm path: Manual and Solar, fresh, + not stuck (`CarTracker.car_w_trusted`), and never above what the + read-back allows. None otherwise, and then the normal alarms stand.""" + if not (self.car_manual() or self.car_solar_mode()): return None return self.car.car_w_trusted(self.car_now()) @@ -219,6 +415,8 @@ class CarMixin: until the current is set again, then at most one corroboration window. No when it was aborted (Off, Stop, shadow, unplug, another writer), a write was refused, or it ran past its own maximum.""" + if self.car_solar_mode(): + return self._car_solar_pause(mono) wr = getattr(self, "car_writer", None) if wr is None or (wr.seq is None and wr.phase_done_at is None and wr.zero_sent_at is None) or wr.hold: @@ -235,6 +433,28 @@ class CarMixin: <= OWN_PAUSE_MAX_S return 0.0 <= mono - wr.phase_done_at <= OWN_PAUSE_TAIL_S + def _car_solar_pause(self, mono) -> bool: + """EV-05: Solar's own 0 A (a pause, the peak cut, the phase change) + gets EV-15's grace, bounded the same way: from the moment it is sent, + at most `OWN_PAUSE_MAX_S`; a phase change as in Manual. None for Stop, + shadow, an unplugged car or another writer.""" + wr = getattr(self, "car_solar", None) + r = self.car.reading + if wr is None or wr.hold or not self.car_writing() or r is None \ + or not r.available or r.state == "A": + return False + q = wr.seq + if q is not None: + return not q.get("failed") and 0.0 <= mono - q["t0"] \ + <= OWN_PAUSE_MAX_S + if wr.zero_sent_at is not None: + return 0.0 <= mono - wr.zero_sent_at <= OWN_PAUSE_MAX_S + if wr.zero_at is not None and 0.0 <= mono - wr.zero_at \ + <= OWN_PAUSE_MAX_S: + return True + return wr.phase_done_at is not None \ + and 0.0 <= mono - wr.phase_done_at <= OWN_PAUSE_TAIL_S + def _car_quarter(self, proj, w, mono, wg=None) -> None: """The car's energy in the open quarter, for the average the guard's house leaves out and for the peak line. `wg` (EV-15) is the figure for @@ -245,11 +465,15 @@ class CarMixin: last = q["mono"] if key != q["key"]: self._car_bank(q) - q["key"], q["ws"], q["ws_p"] = key, 0.0, 0.0 + q["key"], q["ws"], q["ws_p"], q["ws_b"] = key, 0.0, 0.0, 0.0 if key is not None and last is not None: dt = min(max(mono - last, 0.0), 5.0) if w is not None: q["ws"] += float(w) * dt + if not self.car_solar_mode(): + # EV-05: only a charge you set can be "set by the car"; + # a Solar charge runs on spare sun and is cut first. + q["ws_b"] = q.get("ws_b", 0.0) + float(w) * dt elif wg is not None: q["ws_p"] = q.get("ws_p", 0.0) + float(wg) * dt q["mono"] = mono @@ -259,7 +483,7 @@ class CarMixin: key = q["key"] if key is None: return - avg = q["ws"] / QUARTER_S + avg = q.get("ws_b", q["ws"]) / QUARTER_S if avg < CAR_PEAK_MIN_W: return self.car_peak_q[key.astimezone(timezone.utc).isoformat()] = round(avg) @@ -317,6 +541,22 @@ class CarMixin: """After the guard has decided: does the car alone explain the excess? `real_proj` is the projection WITH the car, whatever the guard saw.""" mono = self.car_now() + # EV-05: the period's own key, and the excess Solar takes off the car + # first (the writer step that follows this cycle acts on it at once). + self._car_key = None if real_proj is None else real_proj.block_start + self.car_cut_w = 0.0 + # What the guard would ASK the batteries to give (`wanted_w`, its floor + # before the rating) is taken off the car instead, up to the excess: + # batteries that only stop charging are not asked for anything. + if self.car_solar_mode() and real_proj is not None \ + and target_w is not None and real_proj.block_start is not None \ + and guard is not None and guard.engaged and guard.blind is None: + ex = peakguard.excess_w(real_proj, target_w) + want = guard.wanted_w + if ex is not None and want is not None and math.isfinite(ex) \ + and math.isfinite(want) and ex > 0.0 and want > 0.0: + self.car_cut_w = float(min(ex, want)) + self._car_sun_tick(mono) w = self.car_alarm_w() # EV-15: the figure for grading only. Our own phase change holds the # car at 0 A and the energy meter cannot corroborate it then, so for @@ -331,7 +571,11 @@ class CarMixin: and real_proj.block_start is not None: # EV-10: every cycle, so the latches do not depend on the option. graded = self._car_explains_alarm(real_proj, guard, target_w, wg) - if self.car_cover: + if self.car_solar_mode(): + # EV-05: Solar is cut first, so it is never "over"; its own + # 0 A must not leave the house's alarm graded with the car. + explains = graded + elif self.car_cover: explains = over = graded elif w is not None: ex = float(real_proj.projected_w) - float(target_w) diff --git a/goodwe_controller/app/ctl_cycle.py b/goodwe_controller/app/ctl_cycle.py index 82c0bab..1f9cdc0 100644 --- a/goodwe_controller/app/ctl_cycle.py +++ b/goodwe_controller/app/ctl_cycle.py @@ -253,6 +253,7 @@ class CycleMixin: stale_after = float(self.o.get("stale_input_s", 15)) late_s = self._readings_late(site_standing) # SAFETY-128 + self._car_late_s = late_s # EV-05: Solar holds, then the stale rule self._late_zero = late_s is not None and late_s >= stale_after # ⚠️ `any`, NOT the sole unit's. The hold exists so a single missed # poll does not become a fault; a LATCHED inverter must still reach the @@ -272,6 +273,7 @@ class CycleMixin: # this cycle's. (DECISIONS/MAIN-orchestration-archive.md) self.why_words = messages.why_waiting(bad_for) self._why_waiting_since = now - timedelta(seconds=bad_for) + self._car_hold_kick() # EV-05: Solar counts from now return if late_s is not None and late_s < stale_after and self.inputs_ok \ and (self.auto or self.shadow) \ @@ -279,6 +281,7 @@ class CycleMixin: and not (n_units > 1 and self.site_sign_wd.tripped): self.reason = f"readings late {late_s:.0f}s" # SAFETY-128: hold self.why_words = messages.why_late() + self._car_hold_kick() # EV-05: Solar holds its current return claims = [] @@ -1065,7 +1068,8 @@ class CycleMixin: await self.check_price_gap() await self.check_charger() await self.check_car_over() - self.car_kick() # EV-04: Manual, in the background + await self.check_car_error() # EV-05: Solar's charger error + self.car_kick() # EV-04/05: in the background await self.check_fixed_note() # SAFETY-31's alarm, and its boundary is the LATCH, not a number: it diff --git a/goodwe_controller/app/ctl_status.py b/goodwe_controller/app/ctl_status.py index 4dda3ec..19ad5ae 100644 --- a/goodwe_controller/app/ctl_status.py +++ b/goodwe_controller/app/ctl_status.py @@ -205,7 +205,20 @@ class StatusMixin: "text": messages.row_charger_unreach( f"{brussels(self.car.bad_since_utc):%H:%M}")}) w = self.car_writer - if self.car_mode == "manual": + sw = self.car_solar + if self.car_mode == "solar": + # EV-05: in Solar another writer stops the add-on's writes: amber, + # the same words as in Manual. + if sw.other: + out.append({"ok": False, "warn": True, "id": "charger_other", + "text": messages.row_charger_other()}) + if sw.gave_up: + out.append({"ok": False, "warn": True, "id": "charger_refused", + "text": messages.row_charger_refused()}) + if sw.phases_gave_up: + out.append({"ok": False, "warn": True, "id": "charger_phases", + "text": messages.row_charger_phases()}) + elif self.car_mode == "manual": # EV-04: in Manual the add-on's own writes are not "another # writer"; its own detector (a read-back that differs from the # last write for 30 s) says so, in grey. @@ -250,6 +263,8 @@ class StatusMixin: or r.power_w is None else round(r.power_w, 1)), "car_today_kwh": (PAYLOAD_NONE if self.car.today_kwh is None else round(self.car.today_kwh, 3)), + "car_today_solar_kwh": (PAYLOAD_NONE if self.car_sun_kwh() is None + else round(self.car_sun_kwh(), 3)), } # -- UI ------------------------------------------------------------------ @@ -922,7 +937,7 @@ class StatusMixin: now = datetime.now(timezone.utc) if what in ("pack_use", "pack_mode", "pack_sell"): return self._pack_action(what, unit, value, now) - if what in ("car_mode", "car_current", "car_phases"): + if what in ("car_mode", "car_current", "car_phases", "car_sun_first"): return self._car_action(what, value, now) if what == "auto_toggle": self.auto = not self.auto diff --git a/goodwe_controller/app/homeview.py b/goodwe_controller/app/homeview.py index 941e941..5e4b775 100644 --- a/goodwe_controller/app/homeview.py +++ b/goodwe_controller/app/homeview.py @@ -1147,7 +1147,8 @@ def month_peak(c, now): # set the month's peak. Both empty without a charger in Manual. out["car_line"] = out["set_by"] = "" if getattr(c, "car_enabled", False) and c.charger.configured(): - w = c.car_alarm_w() + # EV-05: Manual only. A Solar charge is cut first for the peak. + w = c.car_alarm_w() if c.car_manual() else None if pg is not None and w is not None and w >= 500.0 \ and out["period_w"] is not None and (pg.engaged or c.car_over): out["car_line"] = _t("peak.car", kw=_kw(out["period_w"]), @@ -1330,6 +1331,64 @@ def _car_manual_why(c, key): return _t("car.why.manual_set", a=a, phases=car_phases_word(c.car_n)) +def _names(invs) -> str: + names = [str(i.name) for i in invs] + return " " .join(names[:1]) if len(names) == 1 else \ + ", ".join(names[:-1]) + " " + _t("car.and") + " " + names[-1] + + +def _car_solar_why(c, key): + """EV-05: the Why of Solar, from what the plan did this cycle. Plan + lines: two sentences of at most 12 words.""" + w = c.car_solar + p = w.plan + o = getattr(c, "o", {}) or {} + if w.other: + return _t("car.why.solar_other") + if c.shadow: + a, n = w.would if w.would is not None else (0.0, p.n) + if a and a >= 6: + return _t("car.why.manual_would", a=f"{float(a):.0f}", + phases=car_phases_word(n)) + return _t("car.why.solar_would") + if not c.auto or not c.car_writing(): + return _t("car.why.solar_stopped") + if w.fault in ("error", "stuck"): + return _t("car.why.solar_" + w.fault) + if key in ("none", "full"): + return _t("car.why." + key) + why = p.why + if why == "running": + sun = getattr(c, "_car_sun_last", None) + if sun is None or sun.spare_w is None: + return _t("car.why.solar_unknown") + if sun.first == carmode.FIRST_CAR: + return _t("car.why.solar_car", + kw=_kw(max(0.0, sun.spare_w - sun.margin_w)), + phases=car_phases_word(w.n_calc)) + room = [i for i in c.inverters if c.car_may_charge(i)] + full = [i for i in c.inverters if not c.car_may_charge(i) + and i.soc is not None and float(i.soc) >= 100.0] + left = _kw(max(0.0, sun.spare_w - sun.room_w)) + m = watts_text(sun.margin_w) + if room and full: + return _t("car.why.solar_batt", a=_names(room), b=_names(full), + kw=left, m=m) + if room: + return _t("car.why.solar_batt_room", a=_names(room), kw=left, + m=m) + return _t("car.why.solar_batt_full", kw=left, m=m) + mins = {"hold": "ev_pause_min"}.get(why, "ev_start_min") + s = f"{carmode.solar_option(o, mins):.0f}" + if why in ("hold", "start", "cut", "unknown"): + return _t("car.why.solar_" + why, s=s) + return _t("car.why.solar_paused", s=s) + + +def watts_text(w) -> str: + return f"{float(w):.0f} W" + + def car_block(c, now): """The Car card for `/status`, or None when no charger is switched on (the page then draws nothing, as before).""" @@ -1342,12 +1401,22 @@ def car_block(c, now): good = c.car.last_good fresh = configured and c.car.fresh(mono) today = None - if configured and c.car.today_kwh is not None: - today = _t("car.today", kwh=_kwh(c.car.today_kwh)) mode = getattr(c, "car_mode", "off") if configured else "off" + if configured and c.car.today_kwh is not None: + sun = c.car_sun_kwh() if hasattr(c, "car_sun_kwh") else None + today = (_t("car.today_sun", kwh=_kwh(c.car.today_kwh), + sun=_kwh(sun)) + if mode == "solar" and sun is not None + else _t("car.today", kwh=_kwh(c.car.today_kwh))) why = _car_why(key, c, good) if mode == "manual" and key in ("charging", "waiting", "none", "full"): why = _car_manual_why(c, key) + if mode == "solar" and key in ("charging", "waiting", "none", "full", + "fault"): + why = _car_solar_why(c, key) + # EV-05: a car Solar holds at 0 A is waiting for the sun. + if key == "waiting" and c.car_solar.plan.a <= 0.0: + key = "paused" out = { "state": key or "wait", "chip": car_state_word(key), @@ -1360,11 +1429,13 @@ def car_block(c, now): else round(float(r.power_w), 1)), } if configured: - # EV-04: what the page can set. Off and Manual only (Solar and Night - # are later cards, so they are not offered). + # EV-04: what the page can set. EV-05 adds Solar and where its spare + # sun goes first (Night is a later card, so it is not offered). clamp = c.car_clamp() hi = int(clamp) if clamp is not None and clamp >= 6 else 6 - out["modes"] = ["off", "manual"] + out["modes"] = list(carmode.MODES) + out["first"] = {"value": getattr(c, "car_first", carmode.DEFAULT_FIRST), + "choices": list(carmode.FIRSTS)} out["current"] = {"value": round(float(c.car_a)), "min": 6, "max": hi} out["phases"] = {"value": c.car_n, @@ -1883,8 +1954,12 @@ def _samples() -> list: out += [("plan", _t("car.big." + k, t="09:12")) for k in words["car"]["big"]] out += [("plan", _t("car.why." + k, a="10", brand="Alfen", kw="8.6 kW", - pct="20 %", phases=car_phases_word(3))) + pct="20 %", phases=car_phases_word(3), + b="inverter-b", m="100 W", s="5")) for k in words["car"]["why"]] + out += [("plan", _t("car.why.solar_batt", a="inverter-a", + b="inverter-b", kw="2.0 kW", m="100 W")), + ("plan", _t("car.today_sun", kwh="14.2 kWh", sun="3.1 kWh"))] out += [("plan", _t("peak.car", kw="12.1 kW", car="11.0 kW", cov="8.6 kW")), ("plan", _t("peak.set_by_car", t="19:45"))] diff --git a/goodwe_controller/app/main.py b/goodwe_controller/app/main.py index 8b622c9..c35c1b5 100644 --- a/goodwe_controller/app/main.py +++ b/goodwe_controller/app/main.py @@ -1040,8 +1040,14 @@ class Controller(InputsMixin, WritesMixin, TradeMixin, CycleMixin, AlarmsMixin, self.stopping = True _LOG.info(handback.log_shutdown(handback.current()) or "shutting down - commanding 0 W on every inverter") - await self.command_site_release() - await self.car_shutdown() # EV-04: undo a phase change half way + if self.car_solar_engaged(): + # EV-05: Solar's fail state is 0 A, and it goes out BEFORE the + # inverters go to 0 W (bounded by `ctl_car.RELEASE_WAIT_S`). + await self.car_shutdown() + await self.command_site_release() + else: + await self.command_site_release() + await self.car_shutdown() # EV-04: undo a phase change half way self.mqtt.close() diff --git a/goodwe_controller/app/messages.py b/goodwe_controller/app/messages.py index 33ae65e..5d5a1b9 100644 --- a/goodwe_controller/app/messages.py +++ b/goodwe_controller/app/messages.py @@ -190,6 +190,8 @@ T_CHARGER_UNREACH = "Charger not reachable" T_CHARGER_UNREACH_NL = "Laadpaal onbereikbaar" T_CAR_OVER = "Car over the peak limit" T_CAR_OVER_NL = "Auto boven de piekgrens" +T_CHARGER_ERROR = "Charger error, car paused" +T_CHARGER_ERROR_NL = "Laadpaalfout, auto gepauzeerd" T_NO_PRICES = "No prices" T_NO_PRICES_NL = "Prijzen ontbreken" @@ -204,6 +206,7 @@ ID_MAINT_FAILED = "goodwe_maint_failed_{slug}" ID_NO_PRICES = "goodwe_no_prices" ID_CHARGER_UNREACH = "goodwe_charger_unreachable" ID_CAR_OVER = "goodwe_car_over" +ID_CHARGER_ERROR = "goodwe_charger_error" # PRICE-01: an earlier build raised a card with this id. Nothing raises it now; # the add-on only dismisses it at start. OLD_FIXED_CARD_ID = "goodwe_fixed_tariff_unused" @@ -510,6 +513,22 @@ def car_over(a_text) -> Notice: body_nl=f"{T_CAR_OVER_NL}. {nl}") +def charger_error() -> Notice: + """EV-05: in Solar the charger reports an error, so the add-on set the car + to 0 A. Said once per error, taken down when it clears.""" + en = ("The charger reports an error, so the add-on paused the car until " + "it clears.") + nl = ("De laadpaal meldt een fout, dus de add-on pauzeert de auto tot die " + "verdwijnt.") + return Notice(ID_CHARGER_ERROR, WARNING, T_CHARGER_ERROR, en, + body_nl=f"{T_CHARGER_ERROR_NL}. {nl}") + + +def charger_error_gone() -> Dismiss: + """EV-05: takes the 'Charger error, car paused' notification down.""" + return Dismiss(ID_CHARGER_ERROR) + + def row_car_over() -> str: """EV-04: the grey row while the car charge you set is over the peak limit.""" return Bi("The car charge you set takes this 15-minute period over the " @@ -1484,6 +1503,7 @@ HINTS = { "car_mode": "Car mode set", "car_current": "Car current set", "car_phases": "Car phases set", + "car_sun_first": "Where spare sun goes first set", "settings_saved": "Settings saved, they apply after a restart", "restart_requested": "Restart requested from the settings page", "setup_only": "In setup, nothing is sent to any inverter", @@ -1822,6 +1842,7 @@ def samples() -> list: no_prices(), charger_unreachable("09:12"), car_over("16"), + charger_error(), ] @@ -1891,6 +1912,9 @@ LABELS = { "ev_batt_cover": "Batteries help with the peak", "ev_mode_start": "Mode after a restart", "ev_phases": "Phases", + "ev_margin_w": "Sun kept back", + "ev_pause_min": "Pause after", + "ev_start_min": "Start after", } @@ -1977,6 +2001,9 @@ LABELS_NL = { "ev_batt_cover": "Batterijen helpen met de piek", "ev_mode_start": "Modus na een herstart", "ev_phases": "Fasen", + "ev_margin_w": "Zon achtergehouden", + "ev_pause_min": "Pauzeren na", + "ev_start_min": "Starten na", } # The inverter list shows two of them under a shorter name. UNIT_LABELS_NL = {"setpoint_entity": "Setpoint-entiteit", diff --git a/goodwe_controller/app/mqtt.py b/goodwe_controller/app/mqtt.py index be471be..2f0e54a 100644 --- a/goodwe_controller/app/mqtt.py +++ b/goodwe_controller/app/mqtt.py @@ -144,6 +144,8 @@ OPTIONAL_SENSORS = [ ("car_power", "goodwe_car_power", "Car power", "W", "power", "measurement", "mdi:car-electric"), ("car_state", "goodwe_car_state", "Car state", None, None, None, "mdi:ev-station"), ("car_today_kwh", "goodwe_car_today_kwh", "Car energy today", "kWh", "energy", "total_increasing", "mdi:ev-station"), + # EV-05: what of today's charge came from the sun (Solar mode only). + ("car_today_solar_kwh", "goodwe_car_today_solar_kwh", "Car solar energy today", "kWh", "energy", "total_increasing", "mdi:solar-power"), ] # ⚠️ HA's OWN "this sensor has no value" PAYLOAD, and the one place this add-on @@ -200,7 +202,8 @@ def optional_keys(opts: dict) -> tuple: from . import chargers as _ch # EV-03: same reason out = ("pv",) if _pv.entities(opts) else () if _ch.census_entity(opts): - out += ("car_power", "car_state", "car_today_kwh") + out += ("car_power", "car_state", "car_today_kwh", + "car_today_solar_kwh") return out @@ -524,18 +527,24 @@ def mode_payloads(units, modes) -> list: # --- EV-04: the car's mode, current and phases, as HA entities ---------------- # Announced only with a charger switched on, after every other row. A command # goes through Controller.handle_action(); a retained one is dropped. -CAR_MODE_LABELS = {"off": "Off", "manual": "Manual"} # English, pinned +CAR_MODE_LABELS = {"off": "Off", "manual": "Manual", # English, pinned + "solar": "Solar"} # EV-05 +# EV-05: where spare sun goes first; mirrors carmode.FIRST_LABELS (this module +# imports nothing from the package, test_ev05.py checks the two agree). +CAR_FIRST_LABELS = {"batteries": "Batteries", "car": "Car"} CAR_MODES = tuple(CAR_MODE_LABELS) CAR_CONFIGS_KEY = "mqtt_car_configs" CAR_MIN_A = 6 -_CAR_CMD_RE = re.compile(rf"{BASE}/car/(mode|current|phases)/set") +_CAR_CMD_RE = re.compile(rf"{BASE}/car/(mode|current|phases|sun_first)/set") _CAR_CONFIG_RE = re.compile( - rf"homeassistant/(select|number)/{BASE}_car_(mode|current|phases)/config") + rf"homeassistant/(select|number)/{BASE}_car_(mode|current|phases|sun_first)" + rf"/config") # (key, component, name, icon) CAR_ENTITIES = [ ("mode", "select", "Car mode", "mdi:car-electric"), ("current", "number", "Car current", "mdi:current-ac"), ("phases", "select", "Car phases", "mdi:sine-wave"), + ("sun_first", "select", "Car spare sun first", "mdi:solar-power"), # EV-05 ] @@ -560,6 +569,8 @@ def car_payloads(car) -> list: cfg["options"] = list(CAR_MODE_LABELS.values()) elif key == "phases": cfg["options"] = [str(n) for n in phases] + elif key == "sun_first": + cfg["options"] = list(CAR_FIRST_LABELS.values()) else: cfg.update({"min": CAR_MIN_A, "max": int(max_a), "step": 1, "unit_of_measurement": "A", "device_class": "current", @@ -607,6 +618,9 @@ def parse_car_command(topic, payload, retained): None) elif key == "phases": value = {"1": 1, "3": 3}.get(text) + elif key == "sun_first": + value = next((k for k, v in CAR_FIRST_LABELS.items() if v == text), + None) else: try: f = float(text) diff --git a/goodwe_controller/app/static/app.js b/goodwe_controller/app/static/app.js index 82bae51..14617ad 100644 --- a/goodwe_controller/app/static/app.js +++ b/goodwe_controller/app/static/app.js @@ -160,8 +160,9 @@ $("#car-why").textContent = c.why; renderCarControls(c); } - // EV-04: Off and Manual. The mode and the phases send at once; the current - // sends after two seconds of rest. A slider being dragged is left alone. + // EV-04: Off and Manual; EV-05: Solar and where its spare sun goes first. + // The mode, the phases and the choice send at once; the current sends after + // two seconds of rest. A slider being dragged is left alone. let carTouch = 0, carTimer = null, carBusy = false; async function carAct(what, value) { if (carBusy) return; @@ -182,6 +183,13 @@ type: "button", role: "radio", "aria-checked": String(c.mode === m), onclick: () => carAct("car_mode", m) }, t("car.mode_" + m)))); $("#car-help").textContent = t("car.help_" + c.mode + ".description") || ""; + const sol = c.mode === "solar" && !!c.first; + $("#car-solar").hidden = !sol; + if (sol) { + $("#car-first").replaceChildren(...c.first.choices.map((f) => h("button", { + type: "button", role: "radio", "aria-checked": String(c.first.value === f), + onclick: () => carAct("car_sun_first", f) }, t("car.first_" + f)))); + } const on = c.mode === "manual" && !!c.current; $("#car-manual").hidden = !on; if (!on) return; diff --git a/goodwe_controller/app/static/index.html b/goodwe_controller/app/static/index.html index fa2a6fa..78dca29 100644 --- a/goodwe_controller/app/static/index.html +++ b/goodwe_controller/app/static/index.html @@ -52,6 +52,11 @@
+
diff --git a/goodwe_controller/app/ui_text/en.json b/goodwe_controller/app/ui_text/en.json index 0cf0be9..2afce87 100644 --- a/goodwe_controller/app/ui_text/en.json +++ b/goodwe_controller/app/ui_text/en.json @@ -91,7 +91,7 @@ "loading": "Loading the forecast." }, "peak": {"name": "Peak limit", "this_month": "This month's peak", "limit": "Limit", "none": "None recorded yet", "unreadable": "Cannot be read now"}, - "car": {"name": "Car", "mode": "Mode", "mode_off": "Off", "mode_manual": "Manual", "help_off": {"description": "The add-on leaves the charger alone."}, "help_manual": {"description": "Charges at the current you set, whatever the sun or the peak limit do."}, "current": "Current", "phases": "Phases", "phases_1": "1 phase", "phases_3": "3 phases", "why": "Why"}, + "car": {"name": "Car", "mode": "Mode", "mode_off": "Off", "mode_manual": "Manual", "help_off": {"description": "The add-on leaves the charger alone."}, "help_manual": {"description": "Charges at the current you set, whatever the sun or the peak limit do."}, "current": "Current", "phases": "Phases", "phases_1": "1 phase", "phases_3": "3 phases", "why": "Why", "mode_solar": "Solar", "help_solar": {"description": "Charges only from spare sun and pauses when there is too little."}, "first": "Spare sun goes first to", "first_batteries": "Batteries", "first_car": "Car", "first_help": {"description": "Batteries: the car gets sun only when the batteries charge at full power or are full."}}, "attention": {"name": "Needs attention", "nothing": "Nothing to look at", "to_look": "to look at", "details": "Details", "alarm": "Alarm", "warning": "Warning", "info": "Info"}, "control": {"name": "Control", "stop": "Stop control", "start": "Start control", "maint_start": "Start a battery cycle now", "maint_abort": "Stop the battery cycle", "docs": "Add-on documentation", "more": "More actions"}, "details": {"name": "Details for installers", "rows": "Status rows", "checks": "Checks", "event": "Last event"}, @@ -302,11 +302,11 @@ "warning": "See Needs attention below." }, "car": { - "state": {"charging": "Charging", "waiting": "Connected, waiting", "none": "No car connected", "full": "Car is full", "unreach": "Charger not reachable", "setup": "Charger not set up", "fault": "Charger fault", "wait": "No reading yet"}, - "big": {"waiting": "Connected, not charging.", "none": "Nothing to charge.", "full": "The car is full.", "seen": "Last seen at {t}.", "no_reading": "No reading.", "setup": "Not set up.", "fault": "The charger reports a fault.", "wait": "No reading yet."}, + "state": {"charging": "Charging", "waiting": "Connected, waiting", "none": "No car connected", "full": "Car is full", "unreach": "Charger not reachable", "setup": "Charger not set up", "fault": "Charger fault", "wait": "No reading yet", "paused": "Waiting for sun"}, + "big": {"waiting": "Connected, not charging.", "none": "Nothing to charge.", "full": "The car is full.", "seen": "Last seen at {t}.", "no_reading": "No reading.", "setup": "Not set up.", "fault": "The charger reports a fault.", "wait": "No reading yet.", "paused": "Waiting for spare sun."}, "phase_one": "1 phase", "phase_many": "{n} phases", - "today": "{kwh} charged today.", + "today": "{kwh} charged today.", "today_sun": "{kwh} charged today, {sun} from the sun.", "and": "and", "why": { "charging": "The charger is charging the car. The add-on leaves it alone.", "waiting": "The car is connected and not charging. The add-on leaves the charger alone.", @@ -329,7 +329,21 @@ "manual_wait": "You set {a} A. It is set when a car is connected.", "manual_would": "Shadow mode: the add-on would set {a} A, {phases}.", "manual_stopped": "Control is stopped. The charger keeps its last setting.", - "manual_blocked": "The phases change once per 10 minutes at most. This waits." + "manual_blocked": "The phases change once per 10 minutes at most. This waits.", + "solar_batt": "Batteries first: {a} at full power, {b} is full. The car gets the {kw} left, less {m} kept back.", + "solar_batt_room": "Batteries first: {a} at full power. The car gets the {kw} left, less {m} kept back.", + "solar_batt_full": "Batteries first, and the batteries are full. The car gets the {kw} left, less {m} kept back.", + "solar_car": "Car first: the car takes {kw} on {phases}. The batteries get the rest of the sun.", + "solar_hold": "Too little spare sun, so the car holds 6 A for now. It pauses after {s} minutes like this.", + "solar_paused": "Too little spare sun for the car's minimum of 6 A. It starts after {s} minutes of enough sun.", + "solar_start": "There is enough spare sun now. The car starts after {s} minutes of it.", + "solar_cut": "The car was cut first to stay under the peak limit. It starts again after {s} minutes of enough sun.", + "solar_unknown": "The add-on cannot measure the spare sun now. The car pauses if this lasts.", + "solar_would": "Shadow mode: the add-on would keep the car paused.", + "solar_stopped": "Control is stopped, so the add-on paused the car.", + "solar_error": "The charger reports an error, so the add-on paused the car.", + "solar_stuck": "The charger reading may be stuck, so the add-on paused the car.", + "solar_other": "Something else changes the charger, so the add-on leaves it alone." } }, "peak": { diff --git a/goodwe_controller/app/ui_text/nl.json b/goodwe_controller/app/ui_text/nl.json index 975e3dd..4f9b678 100644 --- a/goodwe_controller/app/ui_text/nl.json +++ b/goodwe_controller/app/ui_text/nl.json @@ -88,7 +88,7 @@ "loading": "De prognose wordt geladen." }, "peak": {"name": "Piekgrens", "this_month": "Piek van deze maand", "limit": "Grens", "none": "Nog niets gemeten", "unreadable": "Nu niet leesbaar"}, - "car": {"name": "Auto", "mode": "Modus", "mode_off": "Uit", "mode_manual": "Handmatig", "help_off": {"description": "De add-on laat de laadpaal met rust."}, "help_manual": {"description": "Laadt met de stroom die u instelt, wat de zon of de piekgrens ook doen."}, "current": "Stroom", "phases": "Fasen", "phases_1": "1 fase", "phases_3": "3 fasen", "why": "Waarom"}, + "car": {"name": "Auto", "mode": "Modus", "mode_off": "Uit", "mode_manual": "Handmatig", "help_off": {"description": "De add-on laat de laadpaal met rust."}, "help_manual": {"description": "Laadt met de stroom die u instelt, wat de zon of de piekgrens ook doen."}, "current": "Stroom", "phases": "Fasen", "phases_1": "1 fase", "phases_3": "3 fasen", "why": "Waarom", "mode_solar": "Zon", "help_solar": {"description": "Laadt alleen met zonne-overschot en pauzeert als er te weinig is."}, "first": "Zonne-overschot gaat eerst naar", "first_batteries": "Batterijen", "first_car": "Auto", "first_help": {"description": "Batterijen: de auto krijgt pas zon als de batterijen op vol vermogen laden of vol zijn."}}, "attention": {"name": "Vraagt aandacht", "nothing": "Niets om na te kijken", "to_look": "na te kijken", "details": "Details", "alarm": "Alarm", "warning": "Waarschuwing", "info": "Info"}, "control": {"name": "Regeling", "stop": "Regeling stoppen", "start": "Regeling starten", "maint_start": "Nu een batterijcyclus starten", "maint_abort": "Batterijcyclus stoppen", "docs": "Documentatie van de add-on", "more": "Meer acties"}, "details": {"name": "Details voor installateurs", "rows": "Statusregels", "checks": "Controles", "event": "Laatste gebeurtenis"}, @@ -256,11 +256,11 @@ "pill": {"running": "Actief", "shadow": "Schaduwmodus", "stopped": "Gestopt", "alarm": "Heeft u nu nodig", "waiting": "Wacht op Home Assistant", "warning": "Actief, met een waarschuwing"}, "banner_sub": {"running": "De batterijen volgen het plan hieronder.", "shadow": "De plannen hieronder tonen wat de add-on zou doen.", "stopped": "Start de regeling hieronder als u klaar bent.", "alarm": "Zie Vraagt aandacht hieronder voor wat u moet doen.", "waiting": "De regeling gaat vanzelf verder zodra Home Assistant antwoordt.", "warning": "Zie Vraagt aandacht hieronder."}, "car": { - "state": {"charging": "Laadt", "waiting": "Aangesloten, wacht", "none": "Geen auto aangesloten", "full": "Auto is vol", "unreach": "Laadpaal onbereikbaar", "setup": "Laadpaal niet ingesteld", "fault": "Laadpaalstoring", "wait": "Nog geen meting"}, - "big": {"waiting": "Aangesloten, laadt niet.", "none": "Niets te laden.", "full": "De auto is vol.", "seen": "Laatst gezien om {t}.", "no_reading": "Geen meting.", "setup": "Niet ingesteld.", "fault": "De laadpaal meldt een storing.", "wait": "Nog geen meting."}, + "state": {"charging": "Laadt", "waiting": "Aangesloten, wacht", "none": "Geen auto aangesloten", "full": "Auto is vol", "unreach": "Laadpaal onbereikbaar", "setup": "Laadpaal niet ingesteld", "fault": "Laadpaalstoring", "wait": "Nog geen meting", "paused": "Wacht op zon"}, + "big": {"waiting": "Aangesloten, laadt niet.", "none": "Niets te laden.", "full": "De auto is vol.", "seen": "Laatst gezien om {t}.", "no_reading": "Geen meting.", "setup": "Niet ingesteld.", "fault": "De laadpaal meldt een storing.", "wait": "Nog geen meting.", "paused": "Wacht op zonne-overschot."}, "phase_one": "1 fase", "phase_many": "{n} fasen", - "today": "Vandaag {kwh} geladen.", + "today": "Vandaag {kwh} geladen.", "today_sun": "Vandaag {kwh} geladen, {sun} van de zon.", "and": "en", "why": { "charging": "De laadpaal laadt de auto. De add-on laat haar met rust.", "waiting": "De auto is aangesloten en laadt niet. De add-on laat de laadpaal met rust.", @@ -283,7 +283,21 @@ "manual_wait": "U stelde {a} A in. Het wordt ingesteld zodra een auto is aangesloten.", "manual_would": "Schaduwmodus: de add-on zou {a} A instellen, {phases}.", "manual_stopped": "De regeling is gestopt. De laadpaal houdt haar laatste instelling.", - "manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht." + "manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht.", + "solar_batt": "Eerst de batterijen: {a} op vol vermogen, {b} is vol. De auto krijgt de {kw} die overblijft, min {m} marge.", + "solar_batt_room": "Eerst de batterijen: {a} op vol vermogen. De auto krijgt de {kw} die overblijft, min {m} marge.", + "solar_batt_full": "Eerst de batterijen, en die zijn vol. De auto krijgt de {kw} die overblijft, min {m} marge.", + "solar_car": "Eerst de auto: die neemt {kw} op {phases}. De batterijen krijgen de rest van de zon.", + "solar_hold": "Te weinig zonne-overschot, dus de auto houdt nu 6 A. Na {s} minuten zo pauzeert ze.", + "solar_paused": "Te weinig zonne-overschot voor het minimum van de auto, 6 A. Ze start na {s} minuten genoeg zon.", + "solar_start": "Er is nu genoeg zonne-overschot. De auto start na {s} minuten daarvan.", + "solar_cut": "De auto werd eerst teruggeschroefd voor de piekgrens. Ze start weer na {s} minuten genoeg zon.", + "solar_unknown": "De add-on kan het zonne-overschot nu niet meten. De auto pauzeert als dit duurt.", + "solar_would": "Schaduwmodus: de add-on zou de auto gepauzeerd houden.", + "solar_stopped": "De regeling is gestopt, dus de add-on pauzeert de auto.", + "solar_error": "De laadpaal meldt een fout, dus de add-on pauzeert de auto.", + "solar_stuck": "De laadpaal meet mogelijk niet meer, dus de add-on pauzeert de auto.", + "solar_other": "Iets anders wijzigt de laadpaal, dus de add-on laat haar met rust." } }, "peak": { diff --git a/goodwe_controller/app/uilayout.py b/goodwe_controller/app/uilayout.py index 0bb138a..bedcbc5 100644 --- a/goodwe_controller/app/uilayout.py +++ b/goodwe_controller/app/uilayout.py @@ -234,6 +234,9 @@ GROUPS = ( Field("ev_phases", SEGMENTED, simple=True, show=_CAR), Field("ev_batt_cover", TOGGLE, simple=True, show=_CAR), Field("ev_mode_start", SEGMENTED, simple=True, show=_CAR), + Field("ev_margin_w", SLIDER, "W", step=10, show=_CAR), + Field("ev_start_min", SLIDER, "min", show=_CAR), + Field("ev_pause_min", SLIDER, "min", show=_CAR), )), )), Group("maintenance", ( diff --git a/goodwe_controller/app/validate.py b/goodwe_controller/app/validate.py index 58833ac..c814a7b 100644 --- a/goodwe_controller/app/validate.py +++ b/goodwe_controller/app/validate.py @@ -688,6 +688,17 @@ def _charger_problems(opts: dict, writers: dict) -> list[str]: out.append(f"{S('ev_max_a')} is {messages.shown(opts.get('ev_max_a'))}" f". Set it from {chargers.MIN_A:.0f} to " f"{chargers.ENTITY_MAX_A:.0f} A.") + # EV-05: Solar's sun kept back and its two dwells, each in its range. + for key, (lo, hi) in chargers.SOLAR_RANGES.items(): + raw = opts.get(key, chargers.EV_OPTION_DEFAULTS[key]) + try: + v = float(raw) + ok = not isinstance(raw, bool) and v == v and lo <= v <= hi + except (TypeError, ValueError): + ok = False + if not ok: + out.append(f"{S(key)} is {messages.shown(raw)}. Set it from {lo} " + f"to {hi}.") entity = chargers.census_entity(opts) if entity and drivers.census_key(entity) in writers: out.append(f"{S('ev_current_entity')} is {entity}, which an inverter " diff --git a/goodwe_controller/app/web.py b/goodwe_controller/app/web.py index 3a17a94..81b4745 100644 --- a/goodwe_controller/app/web.py +++ b/goodwe_controller/app/web.py @@ -62,7 +62,7 @@ _LOG = logging.getLogger("goodwe.web") # OPT-11: the per-battery actions, which name a battery and a value. PACK_ACTIONS = ("pack_use", "pack_mode", "pack_sell") -CAR_ACTIONS = ("car_mode", "car_current", "car_phases") +CAR_ACTIONS = ("car_mode", "car_current", "car_phases", "car_sun_first") # MAINT-11: start or stop one battery's maintenance cycle (the unit is optional). MAINT_ACTIONS = ("maint_start", "maint_abort") diff --git a/goodwe_controller/config.yaml b/goodwe_controller/config.yaml index 90cae0d..f1ccdfd 100644 --- a/goodwe_controller/config.yaml +++ b/goodwe_controller/config.yaml @@ -873,20 +873,25 @@ options: shadow_mode: "auto" # ========================================================================== - # CAR CHARGER (EV-03 reads it, EV-04 adds Manual) + # CAR CHARGER (EV-03 reads it, EV-04 adds Manual, EV-05 Solar) # ========================================================================== # `off` is the shipped value and means NO CHANGE AT ALL: nothing is read, # shown or announced, and the House tile and the house profile are as before. # `alfen_ha` drives the charger through its Home Assistant integration. The - # mode (Off or Manual), the current and the phases are runtime state in the - # store, not options. `ev_batt_cover`: the batteries help with the peak while - # the car charges. `ev_mode_start`: the mode after a restart. + # mode (Off, Manual or Solar), the current, the phases and where spare sun + # goes first are runtime state in the store, not options. `ev_batt_cover`: + # the batteries help with the peak while the car charges. `ev_mode_start`: + # the mode after a restart. Solar: `ev_margin_w` sun kept back, and the car + # starts after `ev_start_min` of enough sun and pauses after `ev_pause_min`. ev_charger: "off" ev_current_entity: "" ev_max_a: 16 ev_phases: "auto" ev_batt_cover: true ev_mode_start: "keep" + ev_margin_w: 100 + ev_start_min: 2 + ev_pause_min: 5 # ========================================================================== # ADVANCED - the control law and diagnostics @@ -1266,7 +1271,7 @@ schema: shadow_mode: list(auto|on|off) # ========================================================================== - # CAR CHARGER (EV-03 reads it, EV-04 adds Manual) + # CAR CHARGER (EV-03 reads it, EV-04 adds Manual, EV-05 Solar) # ========================================================================== # `ev_current_entity` is the charger's current setpoint; the other entities # are found from its name. `ev_max_a` may not exceed the charger's own station @@ -1277,6 +1282,9 @@ schema: ev_phases: list(1|3|auto) ev_batt_cover: bool ev_mode_start: list(keep|off) + ev_margin_w: int(0,1000) + ev_start_min: int(1,30) + ev_pause_min: int(1,30) # ========================================================================== # ADVANCED - the control law and diagnostics diff --git a/goodwe_controller/test_ev03.py b/goodwe_controller/test_ev03.py index 905ece4..9292284 100644 --- a/goodwe_controller/test_ev03.py +++ b/goodwe_controller/test_ev03.py @@ -905,16 +905,18 @@ check("it stays for an hour and then goes", # --------------------------------------------------------------------------- # print("\n9. THE MQTT SENSORS") # --------------------------------------------------------------------------- # -check("the three car sensors are announced only with a charger on", +check("the car sensors (EV-05: four, with today's solar kWh) are announced " + "only with a charger on", mqtt.optional_keys(CAR) == ("pv", "car_power", "car_state", - "car_today_kwh") + "car_today_kwh", "car_today_solar_kwh") and mqtt.optional_keys(BASE) == ("pv",)) pl = dict(mqtt.discovery_payloads(include=mqtt.optional_keys(CAR))) names = sorted(k for k in pl if "_car_" in k) -check(f"discovery announces three sensors, goodwe_car_power, " - f"goodwe_car_state and goodwe_car_today_kwh ({names})", +check(f"discovery announces the sensors goodwe_car_power, goodwe_car_state, " + f"goodwe_car_today_kwh and (EV-05) goodwe_car_today_solar_kwh ({names})", [pl[k]["object_id"] for k in names] == [ - "goodwe_car_power", "goodwe_car_state", "goodwe_car_today_kwh"] + "goodwe_car_power", "goodwe_car_state", "goodwe_car_today_kwh", + "goodwe_car_today_solar_kwh"] and all(k.startswith("homeassistant/sensor/") for k in names)) check("...and no command entity (no select, number or switch for the car)", not [k for k in pl if "car" in k and not k.startswith( diff --git a/goodwe_controller/test_ev04.py b/goodwe_controller/test_ev04.py index 1b28031..15490a0 100644 --- a/goodwe_controller/test_ev04.py +++ b/goodwe_controller/test_ev04.py @@ -248,7 +248,7 @@ async def part2(): w = World() out = {} out["manual"] = await w.act("car_mode", "manual") - out["bad_mode"] = await w.act("car_mode", "solar") # not in this card + out["bad_mode"] = await w.act("car_mode", "bogus") # EV-05 accepts Solar out["night"] = await w.act("car_mode", "night") out["a12"] = await w.act("car_current", 12) out["a5"] = await w.act("car_current", 5) @@ -266,7 +266,7 @@ w2, o2 = run(part2()) check("Manual is chosen at once, no restart", o2["manual"] == { "mode": "manual", "current": 6.0, "phases": 1} and w2.c.car_mode == "manual" or w2.c.car_mode == "manual") -check("Solar and Night are not accepted (EV-05, EV-02)", +check("Night (EV-02) and an unknown mode are not accepted", "error" in o2["bad_mode"] and "error" in o2["night"] and w2.c.car_mode == "manual") check("a current between 6 A and the clamp is accepted and stored", @@ -307,7 +307,7 @@ check("ev_phases 1: 3 phases cannot be chosen, 1 can", async def part2c(): out = {} for start, stored in (("keep", "manual"), ("off", "manual"), - ("keep", None), ("keep", "solar")): + ("keep", None), ("keep", "night")): st = _Store() if stored: st.data["car_mode"] = stored @@ -322,7 +322,7 @@ check("ev_mode_start keep: a restart keeps Manual", check("ev_mode_start off: a restart starts in Off and the store says so", o2c[("off", "manual")] == ("off", "off")) check("no stored mode, or one this build does not know, is Off", - o2c[("keep", None)][0] == "off" and o2c[("keep", "solar")][0] == "off") + o2c[("keep", None)][0] == "off" and o2c[("keep", "night")][0] == "off") # =========================================================================== # print("\n3. MANUAL WRITES THE CURRENT ONCE PER USER CHANGE") @@ -1606,13 +1606,14 @@ pl = dict(mqtt.car_payloads((16, (1, 3)))) sel = pl["homeassistant/select/goodwe_ctl_car_mode/config"] num = pl["homeassistant/number/goodwe_ctl_car_current/config"] ph = pl["homeassistant/select/goodwe_ctl_car_phases/config"] -check("three entities: select.goodwe_car_mode, number.goodwe_car_current, " - "select.goodwe_car_phases", len(pl) == 3 +check("four entities: select.goodwe_car_mode, number.goodwe_car_current, " + "select.goodwe_car_phases and (EV-05) select.goodwe_car_sun_first", + len(pl) == 4 and sel["object_id"] == "goodwe_car_mode" and num["object_id"] == "goodwe_car_current" and ph["object_id"] == "goodwe_car_phases") -check("the mode's labels are English and pinned: Off, Manual (Solar and Night " - "are not offered)", sel["options"] == ["Off", "Manual"]) +check("the mode's labels are English and pinned: Off, Manual, Solar (EV-05; " + "Night is not offered)", sel["options"] == ["Off", "Manual", "Solar"]) check("the current is 6 A to the clamp, whole amps", num["min"] == 6 and num["max"] == 16 and num["step"] == 1 and num["unit_of_measurement"] == "A") @@ -1629,7 +1630,7 @@ check("nothing is announced without a charger (and the default announcement " "is as it was)", mqtt.car_payloads(None) == [] and mqtt.discovery_payloads() == mqtt.discovery_payloads(car=None)) check("the car entities come after every other row", - [t for t, _ in mqtt.discovery_payloads(car=(16, (1, 3)))][-3:] + [t for t, _ in mqtt.discovery_payloads(car=(16, (1, 3)))][-4:] == [t for t, _ in mqtt.car_payloads((16, (1, 3)))]) cmd = mqtt.parse_car_command check("a command parses: mode, current, phases", @@ -1641,8 +1642,8 @@ check("a command parses: mode, current, phases", == ("car_phases", 3, None)) check("a retained command is dropped", cmd("goodwe_ctl/car/mode/set", b"Manual", True)[2] == "retained") -check("Solar, Night, junk and a long payload are refused", - cmd("goodwe_ctl/car/mode/set", b"Solar", False)[1] is None +check("Night, an unknown mode, junk and a long payload are refused", + cmd("goodwe_ctl/car/mode/set", b"Bogus", False)[1] is None and cmd("goodwe_ctl/car/mode/set", b"Night", False)[1] is None and cmd("goodwe_ctl/car/current/set", b"abc", False)[1] is None and cmd("goodwe_ctl/car/phases/set", b"2", False)[1] is None @@ -1660,7 +1661,7 @@ async def ha_story(): out = {"mode": w.c.car_mode, "a": w.c.car_a, "rb": w.sim.readback_a, "pub": list(w.c.mqtt.values)[-1]} await w.c.mqtt_command("goodwe_ctl/car/mode/set", b"Off", True) # retained - await w.c.mqtt_command("goodwe_ctl/car/mode/set", b"Solar", False) + await w.c.mqtt_command("goodwe_ctl/car/mode/set", b"Night", False) await w.c.mqtt_command("goodwe_ctl/car/current/set", b"99", False) await w.c.mqtt_command("goodwe_ctl/car/phases/set", b"2", False) await w.step(5) @@ -1678,8 +1679,8 @@ check("HA commands go through handle_action(): Manual and 13 A are applied " "and written, and the new state is published", ha["mode"] == "manual" and ha["a"] == 13.0 and ha["rb"] == 13 and ha["pub"] == {"car_mode": "Manual", "car_current": 13, - "car_phases": "1"}) -check("a retained command, Solar, 99 A and 2 phases change nothing", + "car_phases": "1", "car_sun_first": "Batteries"}) +check("a retained command, Night, 99 A and 2 phases change nothing", ha["after"] == ("manual", 13.0, 1)) check("the three states are in the published values", ha["state"].get("car_mode") == "Manual" @@ -1700,11 +1701,11 @@ st_ = _S() car_, retract_ = _main.car_announcement(CAR, st_) check("with a charger the entities are announced and their topics kept", car_ == (16.0, (1, 3)) and not retract_ and len( - st_.data["mqtt_car_configs"]) == 3) + st_.data["mqtt_car_configs"]) == 4) car2, retract2 = _main.car_announcement(BASE, st_) check("turning the charger off removes exactly those entities", car2 is None and sorted(retract2) == sorted(st_.data["mqtt_car_configs"]) - and len(retract2) == 3) + and len(retract2) == 4) st2 = _S() check("a site that never had a charger publishes nothing and its store is " "not written", @@ -1734,7 +1735,7 @@ async def web_story(): ("manual", {"action": "car_mode", "value": "manual"}), ("a", {"action": "car_current", "value": 12}), ("n", {"action": "car_phases", "value": 3}), - ("solar", {"action": "car_mode", "value": "solar"}), + ("solar", {"action": "car_mode", "value": "night"}), ("big", {"action": "car_current", "value": 40})): async with s.post(root + "action", json=body) as r: out[key] = (r.status, await r.json(content_type=None)) @@ -1753,21 +1754,22 @@ check("POST /action car_mode, car_current and car_phases store and answer", web["manual"] == (200, {"ok": True, "result": { "mode": "manual", "current": 6.0, "phases": 1}}) and web["a"][0] == 200 and web["n"][0] == 200) -check("...Solar and 40 A (above the clamp) are a 400 with a plain reason", +check("...Night and 40 A (above the clamp) are a 400 with a plain reason", web["solar"][0] == 400 and web["solar"][1]["ok"] is False and web["solar"][1]["error"] == messages.car_refused("value") and web["big"][0] == 400) car_s = web["status_en"]["car"] -check("/status gives the page what it needs: the mode, the modes offered (Off " - "and Manual only), the current's range, the phases", - car_s["mode"] == "manual" and car_s["modes"] == ["off", "manual"] +check("/status gives the page what it needs: the mode, the modes offered (Off, " + "Manual and, EV-05, Solar), the current's range, the phases", + car_s["mode"] == "manual" + and car_s["modes"] == ["off", "manual", "solar"] and car_s["current"] == {"value": 12, "min": 6, "max": 16} and car_s["phases"] == {"value": 3, "choices": [1, 3]}) check("/status in Dutch has the Dutch Why", web["status_nl"]["car"]["why"].startswith("U stelde 12 A in")) -check("the page has the controls and no Solar or Night button", +check("the page has the controls and no Night button (EV-05 adds Solar)", 'id="car-manual"' in web["page"] and 'id="car-a"' in web["page"] - and "mode_solar" not in web["page"] and "mode_night" not in web["page"]) + and "mode_night" not in web["page"]) check("the page names the Manual strings in both languages", "Handmatig" in web["page"] and "Manual" in web["page"]) diff --git a/goodwe_controller/test_ev05.py b/goodwe_controller/test_ev05.py new file mode 100644 index 0000000..e18088c --- /dev/null +++ b/goodwe_controller/test_ev05.py @@ -0,0 +1,1508 @@ +"""EV-05: the car's Solar mode. `python3 -B test_ev05.py` + +Spare sun to the car (signed, `car + battery charge - grid`), Batteries or Car +first, whole amps rounded down, the 30 s and 1 A write rule, the start and pause +dwells, auto phases through the safe sequence, the peak guard's excess taken +off the car first, and every way out of Solar ending at 0 A, written once. +The real Controller runs on `tools/ev05_sun.py` (N batteries, P1 meter, the +charger model) at a 1 s cycle. Each test row of reports/EV-05-test-plan.md is +named here by its id (T1 to T53, N1 to N12). +Mutating a module this file grades? Read MUTATION.md first (purge __pycache__). +""" + +import ast +import asyncio +import io +import json +import logging +import math +import os +import random +import sys + +HERE = os.path.dirname(os.path.abspath(__file__)) +sys.path.insert(0, os.path.join(HERE, "tools")) + +from app import carmode, chargers as CH, ctl_car, homeview, messages # noqa: E402 +from app import mqtt, validate # noqa: E402 +import ev05_sun as S # noqa: E402 +from chargersim import SimCharger # noqa: E402 + +fails = [] + + +def check(name, cond): + print(f" {'ok ' if cond else 'FAIL'} {name}") + if not cond: + fails.append(name) + + +class _Log(logging.Handler): + def __init__(self): + super().__init__(logging.DEBUG) + self.rec = [] + + def emit(self, r): + self.rec.append((r.levelname, r.getMessage())) + + def count(self, level, part): + return sum(1 for lv, m in self.rec if lv == level and part in m) + + +LOG = _Log() +logging.getLogger("goodwe").addHandler(LOG) +logging.getLogger("goodwe").setLevel(logging.DEBUG) +for _h in list(logging.getLogger().handlers): + logging.getLogger().removeHandler(_h) + + +def const(w): + return lambda t: float(w) + + +def step(before, after, at): + return lambda t: float(before if t < at else after) + + +def steps(*pairs): + """`steps((0, w0), (t1, w1), ...)`: the value of the last pair at or before t.""" + def f(t): + v = pairs[0][1] + for at, w in pairs: + if t >= at: + v = w + return float(v) + return f + + +def cur(r): + return S.writes(r, "current") + + +def ph(r): + return S.writes(r, "phases") + + +def nonzero(r): + return [(t, v) for t, v in cur(r) if v > 0] + + +def act(what, value): + return lambda p, c: c.handle_action(what, value=value) + + +def seq(*fns): + def f(p, c): + outs = [fn(p, c) for fn in fns] + co = [o for o in outs if asyncio.iscoroutine(o)] + if co: + async def all_(): + for x in co: + await x + return all_() + return f + + +CAR0 = {"ev_margin_w": 0} # Car first, margin 0: target = sun - house +# Both batteries full: they take nothing, so the spare is exactly the sun and +# the timing rows are not moved by a battery ramping (meter/battery skew). +FULL = {"a": 100.0, "b": 100.0} + + +def solar(sun, dur, **kw): + """Car first, margin 0, batteries full, house 0: the car target is `sun`.""" + kw.setdefault("opts", CAR0) + return S.drive(house=const(0.0), sun=sun, first="car", socs=FULL, + dur=dur, **kw) + + +def after_first_write(delay, holder, value): + """An on_cycle hook: `delay` s after the first current write, set + `holder["w"] = value` (a sun function reads it).""" + st = {} + + def f(plant, c, t): + w = plant.ch.writes("current") + if w and "at" not in st: + st["at"] = w[0][0] + delay + if "at" in st and t + 1 >= st["at"] and not st.get("done"): + st["done"] = True + holder["w"] = value + return f +SC2 = dict(house=const(900.0), sun=const(7900.0), socs={"a": 71.0, "b": 100.0}) + +# =========================================================================== # +print("T3. THE SPARE SUN IS SIGNED (N12)") +# =========================================================================== # +# The add-on's battery figure is discharge positive: a charge of 5000 W is -5000. +T3 = {"a": (0.0, -5000.0, -2000.0, 7000.0), + "b": (0.0, -6000.0, 6900.0, -900.0), + "c": (1380.0, 9600.0, -5220.0, -3000.0), + "d": (1380.0, 9600.0, -7220.0, -1000.0), + "e": (0.0, 0.0, -3000.0, 3000.0)} +got3 = {k: carmode.spare_w(c_, b_, g_) for k, (c_, b_, g_, _w) in T3.items()} +check(f"T3 (a)-(e): 7000, -900, -3000, -1000, 3000 W within 1 W ({got3})", + all(abs(got3[k] - T3[k][3]) <= 1.0 for k in T3)) +check("T3/N12: a grid charge (b) and batteries giving more than the house (c) " + "are never sun", got3["b"] < 0 and got3["c"] < 0 and got3["d"] < 0) + + +def _clipped(c_, b_, g_): # what a clipped formula would give + return c_ + max(-b_, 0.0) - max(g_, 0.0) + + +check("T3: a clipped formula would fail (a) and (e): this table catches it", + abs(_clipped(*T3["a"][:3]) - 7000) > 1 and + abs(_clipped(*T3["e"][:3]) - 3000) > 1) +check("T3/T4: a NaN, None or text figure gives no spare", + carmode.spare_w(0, float("nan"), 0) is None + and carmode.spare_w(0, None, 0) is None + and carmode.spare_w(0, 0, "unavailable") is None + and carmode.spare_w(None, 0, 0) is None) + +# =========================================================================== # +print("\nT9, T10. THE MARGIN, AND WHOLE AMPS ROUNDED DOWN (N1)") +# =========================================================================== # +t9 = {m: carmode.car_target_w(2400.0, 5000.0, m, carmode.FIRST_CAR) + for m in (0, 100, 300, 1000)} +a9 = {m: carmode.amps_for(t9[m], 1, 16) for m in t9} +# The plan says "a hold" for margin 1000; 1400 W / 230 = 6.09, which is 6 A, +# the minimum, so it charges at 6 A (dev report: plan arithmetic). 1379 W holds. +check(f"T9: Car first, spare 2400 W, margin 0/100/300/1000: {t9} -> {a9} " + "(10, 10, 9 and 6 A; 1379 W would be under 6 A)", + t9 == {0: 2400.0, 100: 2300.0, 300: 2100.0, 1000: 1400.0} + and a9[0] == 10 and a9[100] == 10 and a9[300] == 9 and a9[1000] == 6 + and carmode.amps_for(1379, 1) < 6) +check("T9: Batteries first takes the room AND the margin, once", + carmode.car_target_w(7000.0, 5000.0, 100, carmode.FIRST_BATT) == 1900.0) +t10 = (carmode.amps_for(1900, 1), carmode.amps_for(2299, 1), + carmode.amps_for(6900, 3), carmode.amps_for(6899, 3)) +check(f"T10: 1900 W/1 = 8, 2299 W/1 = 9 (not 10), 6900/3 = 10, 6899/3 = 9 " + f"({t10})", t10 == (8.0, 9.0, 10.0, 9.0)) +check("T10: ev_max_a 10 with 6.9 kW on 1 phase gives 10 A; a station limit of " + "13 A gives at most 13", + carmode.amps_for(6900, 1, carmode.clamp_for({"ev_max_a": 10}, None)) + == 10.0 and carmode.amps_for( + 6900, 1, carmode.clamp_for({"ev_max_a": 16}, + CH.ChargerReading(station_a=13.0))) == 13) +_rnd = random.Random(10) +_bad = [] +for _i in range(1000): + w = _rnd.choice([float("nan"), -500.0, 1e9, _rnd.uniform(-5000, 30000)]) + n = _rnd.choice([1, 3]) + cl = _rnd.choice([None, 6.0, 10.0, 13.0, 16.0, 32.0]) + a = carmode.amps_for(w, n, cl) + if w != w: + if a is not None: + _bad.append((w, a)) + continue + hi = 40.0 if cl is None else cl + want = max(0, min(math.floor(w / (230.0 * n) + 1e-9), math.floor(hi))) + if a != want or a > hi: + _bad.append((w, n, cl, a)) +check(f"T10 property: 1000 random spares (NaN, negative, 1e9): every answer is " + f"floor(W / (230 x n)) within [0, clamp], NaN gives none ({_bad[:3]})", + not _bad) + +# =========================================================================== # +print("\nT6. SCENARIO 2, BATTERIES FIRST, CLEAR SKY (A1)") +# =========================================================================== # +r6 = S.drive(dur=600, first="batteries", on_cycle="rows", **SC2) +c6 = r6["c"] +w6 = cur(r6) +tr6 = r6["trace"] +check(f"T6: one write, 8 A on 1 phase, after the 120 s start dwell ({w6}, " + f"phases {ph(r6)})", len(w6) == 1 and w6[0][1] == 8.0 + and 120 <= w6[0][0] <= 123 and ph(r6) == [] and r6["sim"].phases_allowed == 1) +last = tr6[-1] +check(f"T6: steady: A charges 5000 +-100 W ({r6['plant'].batt_of('a', 599):.0f})" + f", export about 160 W ({last['grid']:.0f}), B full takes nothing", + abs(r6["plant"].batt_of("a", 599) + 5000) <= 100 + and -260 <= last["grid"] <= -60 and r6["plant"].batt_of("b", 599) == 0) +_sp6 = tr6[-1]["spare"] +check(f"T6: the spare stays 7000 W while the car charges, no drift ({_sp6})", + _sp6 is not None and abs(_sp6 - 7000) <= 60) +check(f"T6: the room is A's rating only (5000 W): {c6.car_room_w()}", + c6.car_room_w() == 5000.0) +why6 = homeview.car_block(c6, None)["why"] +check(f"T6: Why = solar_batt: A at full power, B is full, 2.0 kW, 100 W " + f"({why6!r})", "inverter-a at full power" in why6 + and "inverter-b is full" in why6 and "2.0 kW" in why6 + and "100 W" in why6) +check("T6: the v1 formula (room = rating - charge now) would give 16 A here", + carmode.amps_for(7000 - (5000 - 5000) - 100, 1, 16) == 16.0) +check("T5 (i): the paused car counted as 0 W (car_w_trusted was None then) " + "and the start happened", w6 and w6[0][1] == 8.0) + +# =========================================================================== # +print("\nT7. SCENARIO 2, CAR FIRST") +# =========================================================================== # +r7 = S.drive(dur=700, first="car", **SC2) +w7, p7 = cur(r7), ph(r7) +check(f"T7: the start goes on 1 phase at the clamp, 16 A ({w7[:1]})", + w7 and w7[0][1] == 16.0 and 120 <= w7[0][0] <= 123) +check(f"T7: 180 s at >= 4.5 kW later the safe sequence moves it to 3 phases " + f"at 10 A ({w7}, {p7})", len(p7) == 1 and p7[0][1] == 3 + and [v for _t, v in w7] == [16.0, 0.0, 10.0] + and 180 <= w7[1][0] - w7[0][0] <= 183) +check(f"T7: the batteries then charge about 100 W " + f"({r7['plant'].batt(699):.0f} W)", -150 <= r7["plant"].batt(699) <= -50) +check("T7: Why = solar_car", "Car first" in homeview.car_block( + r7["c"], None)["why"]) + +# =========================================================================== # +print("\nT8. BATTERIES FIRST: THE ROOM") +# =========================================================================== # +r8a = S.drive(house=const(900.0), sun=const(4900.0), socs={"a": 71.0, "b": 100.0}, + dur=500) +check(f"T8 (a): spare 4000, A may charge: 4000 - 5000 - 100 < 0, the car " + f"gets no sun ({cur(r8a)})", nonzero(r8a) == []) +r8b = S.drive(house=const(900.0), sun=const(3900.0), + socs={"a": 100.0, "b": 100.0}, dur=300) +check(f"T8 (b): both full, room 0: 2900 W gives 12 A ({cur(r8b)})", + [v for _t, v in cur(r8b)] == [12.0]) +r8c = S.drive(house=const(900.0), sun=const(7900.0), + socs={"a": 100.0, "b": 60.0}, dur=300) +check(f"T8 (c): A at its ceiling, B may charge (4600): 2300 W gives 10 A " + f"({cur(r8c)})", [v for _t, v in cur(r8c)] == [10.0]) +_st8 = S.rig._Store() +_st8.data["unit/inverter-a/pack_use"] = False + + +def _a_off(p, c): + c.store.data["unit/inverter-a/pack_use"] = False + + +r8o = S.drive(house=const(900.0), sun=const(7900.0), socs={"a": 60.0, "b": 60.0}, + dur=300, events={0: _a_off}) +check(f"T8 (c): A switched Off, B may charge: room 4600, 10 A ({cur(r8o)})", + [v for _t, v in cur(r8o)] == [10.0]) +_inv = r8o["c"].inverters +_inv[1].refused = -1 +check("T8 (c): a battery refusing a charge is not room either", + r8o["c"].car_room_w() == 0.0) +_inv[1].refused = 0 +r8d = S.drive(house=const(900.0), sun=steps((0, 7900.0), (300, 1600.0)), + socs={"a": 71.0, "b": 100.0}, dur=700) +w8d = cur(r8d) +check(f"T8 (d): a cloud in scenario 2 (spare 700): 6 A held, then 0 A 300 s " + f"after it came ({w8d})", [v for _t, v in w8d] == [8.0, 6.0, 0.0] + and 300 <= w8d[2][0] - 300 <= 303) + +# =========================================================================== # +print("\nT11. AT MOST ONE WRITE PER 30 s, ONLY ON A 1 A CHANGE (N5)") +# =========================================================================== # +# Car first, margin 0: 1840 W = 8 A, 2300 W = 10 A, 2047 W = 8.9 A +for race in (False, True): + h11 = {"w": 1840.0} + r11 = solar(lambda t, h=h11: h["w"], 260, race=race, + on_cycle=after_first_write(5, h11, 2300.0)) + w11 = cur(r11) + check(f"T11 (a) {'race' if race else 'step'}: 8 A at t, the spare moves to " + f"10 A worth 5 s later: 10 A comes 30 s after the first write " + f"({w11})", [v for _t, v in w11] == [8.0, 10.0] + and 30 <= w11[1][0] - w11[0][0] <= 31) +r11b = solar(steps((0, 1840.0), (200, 2047.0)), 800) +check(f"T11 (b): 8.9 A worth for 600 s writes nothing more ({cur(r11b)})", + [v for _t, v in cur(r11b)] == [8.0]) + +# =========================================================================== # +print("\nT13. THE START THRESHOLD (N5)") +# =========================================================================== # +r13a = solar(steps((0, 0.0), (30, 1609.0)), 930) +check(f"T13 (a): 1609 W for 900 s: no write ({cur(r13a)})", cur(r13a) == []) +for race in (False, True): + r13b = solar(steps((0, 0.0), (30, 1610.0)), 200, race=race) + w = cur(r13b) + check(f"T13 (b) {'race' if race else 'step'}: 1610 W (7 x 230) gives 7 A " + f"120 s after the sun is seen, not at 119 s ({w})", + [v for _t, v in w] == [7.0] and 150 <= w[0][0] <= 152) +r13c = solar(steps((0, 0.0), (30, 1610.0), (91, 1500.0), (92, 1610.0)), 300) +w = cur(r13c) +check(f"T13 (c): a 1-cycle dip at 60 s starts the count again: written about " + f"181 s after the sun came ({w})", [v for _t, v in w] == [7.0] + and 211 <= w[0][0] <= 214) +r13d = solar(steps((0, 0.0), (30, 6900.0)), 400, phases=1) +w, p = cur(r13d), ph(r13d) +check(f"T13 (d): auto phases, 6900 W: the start goes on 1 phase with no select " + f"before the first current write; the switch comes only by its dwell " + f"({w}, {p})", w and w[0][1] == 16.0 and (not p or p[0][0] > w[0][0]) + and (not p or p[0][0] - w[0][0] >= 180)) +for sun_w, want in ((4829.0, []), (4830.0, [7.0])): + r13e = solar(steps((0, 0.0), (30, sun_w)), 500 if want else 930, + opts=dict(CAR0, ev_phases="3"), phases=3) + w = cur(r13e) + check(f"T13 (e): ev_phases 3, {sun_w:.0f} W: {want} at 120 s ({w})", + [v for _t, v in w] == want and (not w or 150 <= w[0][0] <= 152)) + +# =========================================================================== # +print("\nT14. UNDER 6 A: HOLD 6 A FOR 5 MINUTES, THEN 0 A (N3, N5)") +# =========================================================================== # +for race in (False, True): + h14 = {"w": 1840.0} + r14 = solar(lambda t, h=h14: h["w"], 600, race=race, + on_cycle=after_first_write(40, h14, 1200.0)) + w14 = cur(r14) + t_drop = w14[0][0] + 40 + check(f"T14 (a) {'race' if race else 'step'}: 8 A, the spare drops to " + f"5.2 A worth: 6 A is written, then 0 A once, 300 s after the drop " + f"is seen and not at 299 s ({w14}, drop at {t_drop:.0f})", + [v for _t, v in w14] == [8.0, 6.0, 0.0] + and 300 <= w14[2][0] - t_drop <= 302) +b14 = homeview.car_block(r14["c"], None) +check(f"T14: the card then says Waiting for sun and Why = solar_paused " + f"({b14['chip']!r}, {b14['why']!r})", b14["chip"] == "Waiting for sun" + and b14["why"].startswith("Too little spare sun for the car's minimum")) +h14b = {"w": 1840.0} +st14 = {} + + +def _dip14(plant, c, t): + w = plant.ch.writes("current") + if w and "t0" not in st14: + st14["t0"] = w[0][0] + 40 + if "t0" in st14: + dt = t + 1 - st14["t0"] + h14b["w"] = (1840.0 if dt < 0 else 1200.0 if dt < 299 else + 1840.0 if dt < 340 else 1200.0) + + +r14b = solar(lambda t: h14b["w"], 1000, on_cycle=_dip14) +w14b = cur(r14b) +z14b = [t for t, v in w14b if v == 0.0] +check(f"T14 (b): back to 6 A worth at 299 s, then down again: no 0 A until a " + f"fresh 300 s ({w14b}, second dip at {st14['t0'] + 340:.0f})", + z14b and z14b[0] - (st14["t0"] + 340) >= 299) + +# =========================================================================== # +print("\nT15. THE HOLD WITH THE BATTERIES THAT CANNOT GIVE (N3)") +# =========================================================================== # +# "At the reserve" for the zero-grid loop is the batteries' own cut-out level +# (10 %): the peak reserve binds the peak guard only (SAFETY-25), so a battery +# at 20 % still covers a hold. Cut-out: the grid covers it for 300 s at most. +for name, socs, gmax in (("(a) both at the cut-out", {"a": 10.0, "b": 10.0}, + 116.0), + ("(b) A at the cut-out, B at 60 %", + {"a": 10.0, "b": 60.0}, 10.0)): + h15 = {"w": 1840.0} + r15 = S.drive(house=const(0.0), sun=lambda t, h=h15: h["w"], first="car", + opts=dict(CAR0, peak_cap_w=9000), socs=socs, dur=700, + on_cycle=after_first_write(40, h15, 1000.0)) + w15 = cur(r15) + t0 = w15[0][0] + 40 + wh = sum(max(0.0, x["grid"]) for x in r15["trace"] + if x["t"] >= t0) / 3600.0 + check(f"T15 {name}: the hold lasts 300 s and the grid gives the car " + f"{wh:.0f} Wh (at most {gmax:.0f} Wh: 1380 W x 302 s) ({w15})", + [v for _t, v in w15][-1] == 0.0 and wh <= gmax + and 300 <= w15[-1][0] - t0 <= 302) + +# =========================================================================== # +print("\nT16. THE WALL CLOCK JUMPS; THE DWELLS COUNT MONOTONIC SECONDS") +# =========================================================================== # +for jump in (3600.0, -3600.0): + def _j(p, c, j=jump): + p.utc_off = j + r16 = solar(steps((0, 0.0), (30, 1610.0)), 200, events={90: _j}) + w16 = cur(r16) + h16 = {"w": 1840.0} + r16b = solar(lambda t, h=h16: h["w"], 600, events={200: _j}, + on_cycle=after_first_write(40, h16, 1200.0)) + w16b = cur(r16b) + check(f"T16 UTC {jump:+.0f} s: the start still comes 120 s after the sun " + f"({w16}) and the pause 300 s after the drop ({w16b})", + w16 and 150 <= w16[0][0] <= 152 and [v for _t, v in w16b] + == [8.0, 6.0, 0.0] and 300 <= w16b[2][0] - (w16b[0][0] + 40) <= 302) + +# =========================================================================== # +print("\nT17, T18. AUTO PHASES: 4.5 kW FOR 3 MIN UP, UNDER 4.0 kW FOR 5 MIN " + "DOWN, ONE SWITCH PER 10 MIN (N2)") +# =========================================================================== # + + +def up_run(level, dur): + """1 phase at 3000 W, then `level` from 5 s after the first write.""" + h = {"w": 3000.0} + r = solar(lambda t, h=h: h["w"], dur, on_cycle=after_first_write(5, h, + level)) + return r, cur(r)[0][0] + 5 + + +r17, t17 = up_run(4500.0, 500) +z17 = [t for t, v in cur(r17) if v == 0.0] +check(f"T17: 4500 W for 180 s: the sequence starts (its 0 A) 180 s after, not " + f"179 s ({cur(r17)}, from {t17:.0f})", z17 + and 180 <= z17[0] - t17 <= 182 and ph(r17) and ph(r17)[0][1] == 3) +r17b, _t = up_run(4499.0, 3700) +check(f"T17: 4499 W for 1 h never switches ({ph(r17b)})", ph(r17b) == []) +# Down: from 3 phases (Car first 6900 W, then the level) + + +def down_run(level, dur): + h = {"w": 6900.0} + st = {} + + def f(plant, c, t): + p = plant.ch.writes("phases") + if p and "at" not in st: + st["at"] = p[0][0] + 60 + if "at" in st and t + 1 >= st["at"]: + h["w"] = level + r = solar(lambda t: h["w"], dur, on_cycle=f) + return r, st.get("at") + + +r17c, t17c = down_run(3999.0, 1200) +p17c = ph(r17c) +z17c = [t for t, v in cur(r17c) if v == 0.0 and t > t17c] +check(f"T17: 3999 W on 3 phases switches to 1 phase 300 s later ({p17c}, " + f"0 A at {z17c[:1]}, from {t17c})", len(p17c) == 2 and p17c[1][1] == 1 + and z17c and 300 <= z17c[0] - t17c <= 302) +r17d, _t = down_run(4000.0, 3900) +check(f"T17: 4000 W on 3 phases for 1 h never switches ({ph(r17d)})", + len(ph(r17d)) == 1) +r17e, _t = down_run(4250.0, 3900) +r17f, _t = up_run(4250.0, 3700) +check(f"T17: the 4.0-4.5 kW band for 1 h never switches, from 3 or from 1 " + f"({ph(r17e)}, {ph(r17f)})", len(ph(r17e)) == 1 and ph(r17f) == []) +h18 = {"w": 3000.0} +st18 = {} + + +def _f18(plant, c, t): + w = plant.ch.writes("current") + if w and "t0" not in st18: + st18["t0"] = w[0][0] + if "t0" in st18: + dt = t + 1 - st18["t0"] + h18["w"] = 5000.0 if dt < 200 else 3000.0 if dt < 1100 else 5000.0 + + +r18 = solar(lambda t: h18["w"], 2000, on_cycle=_f18) +p18 = ph(r18) +gaps18 = [b[0] - a[0] for a, b in zip(p18, p18[1:])] +check(f"T18: over 4.5, under 4.0, over 4.5 kW: at most one select per 600 s, " + f"each later one waits for the 600 s ({p18}, gaps {gaps18})", + len(p18) >= 3 and all(g >= 600 for g in gaps18) + and [n for _t, n in p18][:3] == [3, 1, 3]) + +# =========================================================================== # +print("\nT19. EVERY SOLAR PHASE CHANGE IS THE SAFE SEQUENCE (N2)") +# =========================================================================== # + + +def seq_ok(r): + """Every select: a 0 A write before it, the car under 100 W or out of C or + 20 s after the 0 A, then 10 s or more to the next current, which is + floor(car_w / (230 x n)); no other write in between.""" + log = r["sim"].log + state = {x["t"]: x["st"] for x in r["trace"]} + bad = [] + for i, x in enumerate(log): + if x[1] != "phases": + continue + prev = log[i - 1] if i else None + nxt = log[i + 1] if i + 1 < len(log) else None + if prev is None or prev[1] != "current" or prev[2] != 0.0: + bad.append(("no 0 A before", x)) + continue + quiet = (x[3] < 100.0 or state.get(x[0] - 1) != "C" + or x[0] - prev[0] >= 20.0) + if not quiet or x[4] != 0.0: + bad.append(("select under load", x)) + if nxt is not None and (nxt[1] != "current" or nxt[0] - x[0] < 10.0): + bad.append(("current too soon or not next", x, nxt)) + return bad + + +r19 = solar(const(6900.0), 700, sim=SimCharger(setpoint_a=0)) +_s19 = SimCharger(setpoint_a=0) +_s19.stop_delay_s = 15.0 +_s19.ramp_w_s = 200.0 +r19s = solar(const(6900.0), 700, sim=_s19) +check(f"T19: 1 -> 3 with a normal and with a slow car (stop delay 15 s): 0 A, " + f"the select only with the car quiet (or 20 s), 10 s, then 10 A " + f"({seq_ok(r19)}, {seq_ok(r19s)}, {cur(r19s)})", + not seq_ok(r19) and not seq_ok(r19s) and ph(r19s) + and [v for _t, v in cur(r19s)][-2:] == [0.0, 10.0]) +r19a = solar(const(6900.0), 1900, opts=dict(CAR0, ev_phases="1")) +check(f"T19: ev_phases 1 with 6.9 kW for 30 min: no select, 16 A " + f"({cur(r19a)}, {ph(r19a)})", ph(r19a) == [] + and [v for _t, v in cur(r19a)] == [16.0]) +r19b = solar(steps((0, 6000.0), (300, 3000.0)), 800, + opts=dict(CAR0, ev_phases="3"), phases=3) +check(f"T19: ev_phases 3 with 3 kW: no select, hold, then pause " + f"({cur(r19b)}, {ph(r19b)})", ph(r19b) == [] + and [v for _t, v in cur(r19b)] == [8.0, 6.0, 0.0]) + +# =========================================================================== # +print("\nT20. A ONE-PHASE CAR ON A 3-PHASE ALLOWANCE") +# =========================================================================== # +st20 = {} + + +def _f20(plant, c, t): + if c.car_solar.single and "marked" not in st20: + st20["marked"] = t + if t == 400: + plant.ch.unplug() + if t == 405: + st20["after_unplug"] = c.car_solar.single + plant.ch.plug_in(car_phases=3) + + +r20 = S.drive(house=const(0.0), sun=steps((0, 6000.0), (250, 3000.0)), + first="car", socs=FULL, opts=dict(ev_phases="3"), phases=3, + car_phases=1, dur=800, on_cycle=_f20) +w20 = cur(r20) +draw20 = next((x["t"] for x in r20["trace"] if x["car"] > 500), None) +check(f"T20: marked one-phase within 30 s of drawing (draws at {draw20}, " + f"marked at {st20.get('marked')})", st20.get("marked") is not None + and st20["marked"] - draw20 <= 30) +check(f"T20: then 1-phase arithmetic: 16 A from 5.9 kW, and 12 A (2900 W / " + f"230) with spare 3000 W, no pause from the 4.2 A 3-phase figure " + f"({w20})", 16.0 in [v for _t, v in w20] + and [v for t, v in w20 if 250 < t < 400] == [12.0]) +check("T20: the mark clears on unplug, and a 3-phase car after it is never " + "marked", st20.get("after_unplug") is False and not r20["c"].car_solar.single) +r20g = S.drive(house=const(0.0), sun=const(6000.0), first="car", socs=FULL, + opts=dict(ev_phases="3"), phases=3, car_phases=3, dur=400) +check("T20 guard: a balanced 3-phase car is never marked", + not any(x["single"] for x in r20g["trace"])) + +# =========================================================================== # +print("\nT21-T25. THE PEAK: THE CAR IS CUT FIRST (N4, N7)") +# =========================================================================== # +ABLE = {"a": 60.0, "b": 60.0} +CUTOUT = {"a": 10.0, "b": 10.0} # the batteries' own cut-out: no giving + + +def first_cut(r, after): + return next((x for x in r["trace"] if x["t"] >= after and x["cut"] > 0), + None) + + +# Car first, house 500 W, sun 2900 W: 2300 W = 10 A on 1 phase. +# The step: 500 -> 6000 W early in the period, about 800 W over the aim. +r21 = S.drive(house=steps((0, 500.0), (200, 6000.0)), sun=const(2900.0), + first="car", socs=ABLE, dur=260) +x21 = first_cut(r21, 200) +w21 = [(t, v) for t, v in cur(r21) if t >= 200] +lim21 = None if x21 is None else math.floor((2300.0 - x21["cut"]) / 230.0) +check(f"T21: a house step takes the period over the aim with the batteries " + f"able: the car is cut within 1 cycle, to at most floor((2300 - cut) / " + f"230) A (cut {None if x21 is None else round(x21['cut'])} W at " + f"{None if x21 is None else x21['t']}, writes {w21})", + x21 is not None and x21["t"] <= 202 and w21 + and w21[0][0] <= x21["t"] + 1 and w21[0][1] <= max(lim21, 0)) +_after = [x for x in r21["trace"] if x21 and x["t"] == x21["t"] + 5] +check(f"T21: 5 s later, what must still come off the meter is at most the " + f"excess less the cut ({[round(x['excess'] or 0) for x in _after]})", + _after and (_after[0]["excess"] or 0.0) <= max( + 0.0, (x21["excess"] or 0.0) - x21["cut"]) + 60.0) +r22 = S.drive(house=steps((0, 500.0), (200, 7500.0), (260, 500.0)), + sun=const(2900.0), first="car", socs=ABLE, dur=600) +x22 = first_cut(r22, 200) +w22 = [(t, v) for t, v in cur(r22) if t >= 200] +last_cut22 = max((x["t"] for x in r22["trace"] if x["cut"] > 0), default=None) +check(f"T22: an excess of 920 W or more: 0 A at once, no 5-min hold " + f"({w22}, cut {None if x22 is None else round(x22['cut'])})", + x22 is not None and w22 and w22[0] == (w22[0][0], 0.0) + and w22[0][0] <= x22["t"] + 1) +check(f"T22: no restart before the period is under the aim (last cut " + f"{last_cut22}) and the 120 s start rule has run", + last_cut22 is not None and len(w22) >= 2 + and w22[1][0] - last_cut22 >= 120) +# T23: the house alone over the aim, the batteries at their cut-out, the car +# at 6 A (started at 1700 W, then sun 2000, house 500, margin 100: 1400 W). +SUN23 = steps((0, 2300.0), (180, 2000.0)) +r23 = S.drive(house=steps((0, 500.0), (300, 9000.0)), sun=SUN23, + first="car", socs=CUTOUT, dur=420) +r23o = S.drive(house=steps((0, 500.0), (300, 9000.0)), sun=SUN23, + first="car", socs=CUTOUT, dur=420, mode="off") +al23, al23o = S.ids(r23, *S.ALARMS), S.ids(r23o, *S.ALARMS) +w23 = [(t, v) for t, v in cur(r23) if t >= 300] +check(f"T23: the car at 6 A is cut to 0 A at once ({cur(r23)})", + [v for t_, v in cur(r23) if t_ < 300][-1:] == [6.0] + and w23 and w23[0][1] == 0.0 + and w23[0][0] <= 302) +check(f"T23/N7: the house's own alarm is not silenced: " + f"goodwe_peak_soc_floor at the same second as the twin with the car " + f"Off (+2 s) ({al23} vs {al23o})", + al23o and al23 and al23[0][1] == al23o[0][1] + and abs(al23[0][0] - al23o[0][0]) <= 2) +# T24 (a): a cut late in the old period; the new one projects under. So late +# only a large load moves a period's average (the meter reads up to 50 kW), so +# the step is 45 kW for 15 s at :13:40. +r24 = S.drive(house=steps((0, 500.0), (820, 45000.0), (835, 500.0)), + sun=const(2900.0), first="car", socs=CUTOUT, dur=1150) +cuts24 = [x["t"] for x in r24["trace"] if x["cut"] > 0] +w24 = [(t, v) for t, v in cur(r24) if t >= 820] +check(f"T24 (a): cut at :13:4x ({cuts24[:3]}), no further cut from :15:00, " + f"and the restart only by the start rule ({w24})", + cuts24 and all(t < 900 for t in cuts24) and w24 and w24[0][1] == 0.0 + and len(w24) >= 2 and w24[1][0] - max(cuts24) >= 120) +r24b = S.drive(house=steps((0, 500.0), (900, 6500.0)), sun=const(2900.0), + first="car", socs=CUTOUT, dur=960) +c24b = first_cut(r24b, 899) +check(f"T24 (b): the new period heads over from its first second (N=2, " + f"next_quarter): the cut comes in its first cycles " + f"({None if c24b is None else c24b['t']}, {cur(r24b)[-1:]})", + c24b is not None and c24b["t"] <= 902 and cur(r24b)[-1][1] == 0.0) + + +def quarters(r, aim): + """(start, import average, car average) of each whole quarter.""" + out = [] + tr = r["trace"] + for q0 in range(0, int(tr[-1]["t"]) + 1 - 900, 900): + xs = [x for x in tr if q0 <= x["t"] < q0 + 900] + if len(xs) < 890: + continue + g = sum(max(0.0, x["grid"]) for x in xs) / len(xs) + car = sum(x["car"] for x in xs) / len(xs) + out.append((q0, g, car)) + return out + + +def day25(t): + """Clouds and house steps, 2 hours.""" + clouds = [(400, 520), (1500, 1530), (2600, 3100), (4000, 4060), + (5200, 5800)] + sun = 6500.0 + for a, b in clouds: + if a <= t < b: + sun = 900.0 + return sun + + +def house25(t): + for a, b, w in ((1000, 1300, 3500.0), (3300, 3360, 4500.0), + (6000, 6600, 2500.0)): + if a <= t < b: + return w + return 600.0 + + +def _res25(p, c): + p.socs.update({"a": 10.0, "b": 10.0}) # the reserve, then a hold + + +r25 = S.drive(house=house25, sun=lambda t: 1800.0 if 5900 <= t < 7000 + else day25(t), first="car", socs=ABLE, dur=7200, + events={5800: _res25}) +q25 = quarters(r25, 3400.0) +over25 = [(q, round(g), round(car)) for q, g, car in q25 if g > 3410.0 + and g - car <= 3410.0] +check(f"T25: a Solar day with clouds, house steps and a hold at the cut-out: " + f"no quarter over the aim that the car took there ({over25}; " + f"{len(q25)} quarters)", len(q25) >= 7 and not over25) +check(f"T25/N4: no quarter is banked as the car's ({r25['c'].car_peak_q}), " + f"so the month peak is never 'set by the car'", + r25["c"].car_peak_q == {}) +hold25 = [x for x in r25["trace"] if 6000 <= x["t"] < 6600] +check("T25: the hold at the reserve (house 2500 + car 6 A over the aim) is " + "ended by the cut at once: the car draws 0 W in that house step", + hold25 and max(x["car"] for x in hold25[5:]) == 0.0) + +# =========================================================================== # +print("\nT49. EV-15'S SHAPES IN SOLAR: OUR OWN 0 A RAISES NO ALARM (N6, N7)") +# =========================================================================== # +for name, cap, house in (("EV-10 shape: house 3 kW, aim 6 kW", 6050.0, 3000.0), + ("EV-10b shape: a 9411 W limit", 9461.0, 2000.0)): + # 1 -> 3 at 180 s after the start, 3 -> 1 after the sun drops, at the + # reserve (19 %): the Solar sequence twice, and a hold then a pause. + sun49 = steps((0, house + 9000.0), (600, house + 2900.0), + (1300, house + 700.0)) + r49 = S.drive(house=const(house), sun=sun49, first="car", cap=cap, + margin=50, socs={"a": 19.0, "b": 19.0}, dur=1700, + on_cycle="rows") + red49 = [x for x in r49["trace"] if x["red"]] + check(f"T49 {name}: the Solar sequences ({ph(r49)}) and the 0 A pause " + f"({[x for x in cur(r49) if x[1] == 0.0]}) raise no alarm, no " + f"goodwe_peak_soc_floor ({S.ids(r49, *S.ALARMS)}) and no red row " + f"({len(red49)} seconds)", + len(ph(r49)) >= 2 and any(v == 0.0 for _t, v in cur(r49)) + and S.ids(r49, *S.ALARMS) == [] and not red49) +st49 = {} + + +def _ov49(plant, c, t): + if c.car_solar.seq is not None and "t" not in st49: + st49["t"] = t + 6 + + +def _ovh(t): + return 25000.0 if "t" in st49 and t >= st49["t"] else 3000.0 + + +r49o = S.drive(house=_ovh, sun=const(12000.0), first="car", cap=6050.0, + margin=50, socs={"a": 19.0, "b": 19.0}, dur=500, on_cycle=_ov49) +t49 = st49.get("t", 10 ** 6) +r49t = S.drive(house=lambda t: 25000.0 if t >= t49 else 3000.0, + sun=const(12000.0), first="car", cap=6050.0, margin=50, + socs={"a": 19.0, "b": 19.0}, dur=500, mode="off") +a49, a49t = S.ids(r49o, *S.ALARMS), S.ids(r49t, *S.ALARMS) +check(f"T49/N7: a 25 kW house overload 6 s into a Solar sequence (at {t49}) " + f"alarms at the same second as with the car Off ({a49} vs {a49t})", + a49 and a49t and abs(a49[0][0] - a49t[0][0]) <= 2) + +# =========================================================================== # +print("\nT26-T37, T53. EVERY WAY OUT OF SOLAR ENDS AT 0 A, WRITTEN ONCE (N9, N10)") +# =========================================================================== # +RUN10 = dict(house=const(500.0), sun=const(2900.0), first="car", socs=FULL) + + +def after(r, t0, t1=1e9): + return [(t, v) for t, v in cur(r) if t0 <= t < t1] + + +def shutdown_at(rec): + async def f(p, c): + rec["n0"] = len(p.sets) + rec["mono0"] = c.car_now() + await c.shutdown() + rec["mono1"] = c.car_now() + rec["sets"] = p.sets[rec["n0"]:] + return f + + +rec26 = {} +r26 = S.drive(dur=301, events={300: shutdown_at(rec26)}, **RUN10) +s26 = rec26["sets"] +ch26 = [i for i, x in enumerate(s26) if x[1] == S.SET] +inv26 = [i for i, x in enumerate(s26) if x[1].startswith("number.sp_")] +check(f"T26: shutdown in Solar at 10 A: exactly one 0 A, before the first " + f"inverter 0 W ({s26})", [s26[i][2] for i in ch26] == [0.0] + and inv26 and ch26[0] < inv26[0] + and all(s26[i][2] == 0.0 for i in inv26)) +rec26m = {} +r26m = S.drive(dur=301, mode="manual", setpoint=10, + events={300: shutdown_at(rec26m)}, **{k: v for k, v in + RUN10.items()}) +s26m = rec26m["sets"] +check(f"T26 guard: in Manual the order is as before (inverters first, the " + f"current stands) ({s26m})", s26m and all( + x[1].startswith("number.sp_") for x in s26m)) +_sim26 = r26["sim"] +_t26 = _sim26.t +r26k = S.drive(dur=200, plug=False, sim=_sim26, store=r26["store"], **RUN10) +nz26 = [(t, v) for t, v in cur(r26k) if t > _t26 and v > 0] +check(f"T26: restart with ev_mode_start keep: Solar, and no non-zero write for " + f"120 s ({r26k['c'].car_mode}, {nz26})", + r26k["c"].car_mode == "solar" and nz26 and nz26[0][0] - _t26 >= 120) +_t26b = _sim26.t +r26o = S.drive(dur=200, plug=False, sim=_sim26, store=r26["store"], + opts={"ev_mode_start": "off"}, **RUN10) +check(f"T26: restart with ev_mode_start off: Off, nothing written " + f"({r26o['c'].car_mode}, {after(r26o, _t26b + 0.5)})", + r26o["c"].car_mode == "off" and after(r26o, _t26b + 0.5) == []) +rec26u = {} +r26u = S.drive(dur=301, events={299: lambda p, c: p.ch.go_unavailable(), + 300: shutdown_at(rec26u)}, **RUN10) +check(f"T26: the charger unreachable at shutdown: the inverters are released " + f"after at most 15 s ({rec26u['mono1'] - rec26u['mono0']:.0f} s)", + rec26u["mono1"] - rec26u["mono0"] <= 15.0 and any( + x[1].startswith("number.sp_") for x in rec26u["sets"])) +rec26h = {} + + +async def _hang(a): + await asyncio.Event().wait() + + +def _hang_shut(p, c): + c.charger.write_current = _hang + ctl_car.RELEASE_WAIT_S = 0.2 + return shutdown_at(rec26h)(p, c) + + +_wait = ctl_car.RELEASE_WAIT_S +r26h = S.drive(dur=301, events={300: _hang_shut}, **RUN10) +ctl_car.RELEASE_WAIT_S = _wait +check("T26: a charger write that never returns does not hold up the inverters' " + "release (bounded wait)", any(x[1].startswith("number.sp_") + for x in rec26h["sets"])) +rec27 = {} + + +async def _die(p, c): + from app import main as M + + async def boom(): + raise RuntimeError("control task died") + t = asyncio.ensure_future(boom()) + await asyncio.gather(t, return_exceptions=True) + stop = asyncio.Event() + M.control_task_done(t, controller=c, stop=stop, died=[]) + rec27["stop"] = stop.is_set() + await shutdown_at(rec27)(p, c) + + +r27 = S.drive(dur=301, events={300: _die}, **RUN10) +s27 = rec27["sets"] +check(f"T27: the control task dies, then the wind-down: 0 A once, before the " + f"inverters' 0 W ({s27})", rec27["stop"] + and [x[2] for x in s27 if x[1] == S.SET] == [0.0] + and s27[0][1] == S.SET) + + +def solar_exit(trigger, at=300, dur=700, **kw): + ev = {at: trigger} + ev.update(kw.pop("events", {})) + args = dict(RUN10) + args.update(kw) + return S.drive(dur=dur, events=ev, **args) + + +r28 = solar_exit(act("auto_toggle", None), opts={"shadow_mode": "off"}, + events={600: act("auto_toggle", None)}, dur=800) +check(f"T28: Stop (shadow_mode off): 0 A once within 1 cycle, nothing else " + f"while stopped; after Start only the start rule ({after(r28, 300)})", + after(r28, 300, 600) == [(after(r28, 300)[0][0], 0.0)] + and after(r28, 300)[0][0] <= 302 + and after(r28, 600) and after(r28, 600)[0][0] >= 720) +r28a = solar_exit(act("auto_toggle", None), opts={"shadow_mode": "auto"}) +check(f"T28: Stop with the shipped shadow_mode auto: the same ({after(r28a, 300)})", + [v for _t, v in after(r28a, 300)] == [0.0] + and after(r28a, 300)[0][0] <= 302) +for name, fn in (("sign_wd", lambda p, c: setattr(c.inverters[0].sign_wd, + "tripped", True)), + ("site_sign_wd", lambda p, c: setattr(c.site_sign_wd, + "tripped", True)), + ("circ_wd", lambda p, c: setattr(c.circ_wd, "tripped", + True))): + r29 = solar_exit(fn) + check(f"T29: safety stop {name}: 0 A once, nothing else while it stands " + f"({after(r29, 300)})", [v for _t, v in after(r29, 300)] == [0.0] + and after(r29, 300)[0][0] <= 302) +n_err = LOG.count("WARNING", "CHARGER_ERROR") +whys30 = {} + + +def _why30(p, c, t): + if t == 450: + whys30["why"] = homeview.car_block(c, None)["why"] + whys30["rows"] = [x["id"] for x in c.checks()] + + +def _err_on(p, c): + p.ch.error = "12: Socket fault" + + +def _err_off(p, c): + p.ch.error = "0: No Error" + + +r30 = solar_exit(_err_on, events={600: _err_off}, dur=800, on_cycle=_why30) +check(f"T30: charger error: 0 A once, no write during the error, the start " + f"rule after it clears ({after(r30, 300)})", + [v for _t, v in after(r30, 300, 600)] == [0.0] + and after(r30, 300)[0][0] <= 302 and after(r30, 600) + and after(r30, 600)[0][0] >= 720) +check(f"T30: one warning, in the log and as a notification, taken down when it " + f"clears; the card says it ({whys30.get('why')!r})", + LOG.count("WARNING", "CHARGER_ERROR") - n_err == 1 + and [n for _t, n in r30["raised"]].count("goodwe_charger_error") == 1 + and any(n == "goodwe_charger_error" for _t, n in r30["plant"].dismissed) + and "error" in whys30.get("why", "") + and "charger_error" in whys30.get("rows", [])) + + +def _fault_e(p, c): + p.ch.fault("E") + + +def _fault_off(p, c): + p.ch.state = "B" + + +r30e = solar_exit(_fault_e, events={600: _fault_off}, dur=800) +check(f"T30: mode3 E: the same ({after(r30e, 300)})", + [v for _t, v in after(r30e, 300, 600)] == [0.0] + and after(r30e, 600) and after(r30e, 600)[0][0] >= 720) +st31 = {} + + +def _freeze31(p, c, t): + ok = c.car_solar.plan.ok_since + if ok is not None and t == ok + 118 and "fz" not in st31: + st31["fz"] = t + p.ch.freeze() # every reading sticks now + if "fz" in st31 and t == st31["fz"] + 400: + p.ch.freeze(False) + if "fz" in st31 and t == st31["fz"] + 200: + st31["rows"] = [x["id"] for x in c.checks()] + + +r31 = S.drive(dur=900, on_cycle=_freeze31, **RUN10) +w31 = cur(r31) +fz = st31.get("fz", 0) +check(f"T31: a stuck reading after a write that moved the setpoint: 0 A once " + f"about 60 s after that write (+10 s read-back), the amber row, no " + f"write until a reading moves, then the start rule ({w31}, frozen at " + f"{fz})", [v for t, v in w31 if t < fz + 400].count(0.0) == 1 + and any(v == 0.0 and 60 <= t - w31[0][0] <= 75 for t, v in w31) + and "charger_stuck" in st31.get("rows", []) + and all(t >= fz + 400 + 120 for t, v in w31 if v > 0 and t > fz + 100)) +r32 = solar_exit(lambda p, c: p.ch.go_unavailable(), + events={420: lambda p, c: p.ch.go_unavailable(False)}) +check(f"T32: unavailable 120 s at 10 A: nothing tried while down, then 0 A " + f"within 1 cycle of its return, then the start rule ({after(r32, 300)})", + after(r32, 300, 420) == [] and after(r32, 420) + and after(r32, 420)[0] == (after(r32, 420)[0][0], 0.0) + and after(r32, 420)[0][0] <= 422 + and all(t >= after(r32, 420)[0][0] + 120 for t, v in after(r32, 420) + if v > 0)) + + +def _ha(on): + def f(p, c): + p.ha_down = not on + if not on: + return c.mqtt_command("goodwe_ctl/car/current/set", b"12", False) + return f + + +r33 = solar_exit(_ha(False), events={420: _ha(True)}) +check(f"T33: Home Assistant not answering for 120 s: nothing written (a lost " + f"command changes no current); back: 0 A first, then the rules " + f"({after(r33, 300)})", after(r33, 300, 420) == [] and after(r33, 420) + and after(r33, 420)[0][1] == 0.0 + and all(t >= after(r33, 420)[0][0] + 120 for t, v in after(r33, 420) + if v > 0)) + + +def _meter(on): + def f(p, c): + p.meter_on = on + return f + + +r34 = solar_exit(_meter(False), dur=800) +w34 = after(r34, 300) +check(f"T34 (a): the meter stops at 10 A for 400 s: no write until 15 + 300 s, " + f"then 0 A once (+2 s) ({w34})", [v for _t, v in w34] == [0.0] + and 315 <= w34[0][0] - 300 <= 318) +r34b = solar_exit(_meter(False), events={500: _meter(True)}) +check(f"T34 (b): back at 200 s: no 0 A ({after(r34b, 300)})", + 0.0 not in [v for _t, v in after(r34b, 300)]) + + +def _late(fn): + def f(p, c): + c._readings_late = lambda standing, p=p: fn(p.t) + return f + + +r35 = solar_exit(_late(lambda t: 10.0 if t < 330 else None)) +check(f"T35 (a): readings late 10 s, then on time: the current is held and " + f"nothing is written ({after(r35, 300)})", after(r35, 300) == []) +r35b = solar_exit(_late(lambda t: t - 300.0 if t < 700 else None), dur=720) +w35 = after(r35b, 300) +check(f"T35 (b): late past stale_input_s: the hold ends at 15 s and the stale " + f"rule runs: 0 A once by 15 + 300 + 2 s ({w35})", + [v for _t, v in w35] == [0.0] and 300 + 315 <= w35[0][0] <= 300 + 317) + + +def seq_stop(trigger, stage): + """1 -> 3 with a slow car; `trigger` when the sequence is in `stage`.""" + st = {} + sim = SimCharger(setpoint_a=0) + sim.stop_delay_s, sim.ramp_w_s = 15.0, 200.0 + + def f(plant, c, t): + q = c.car_solar.seq + if q is not None and "t0" not in st and q["stage"] == stage: + st["t0"] = t + st["n0"] = len(plant.ch.log) + st["zeros"] = [x for x in plant.ch.log if x[1] == "current" + and x[2] == 0.0] + out = trigger(plant, c) + if asyncio.iscoroutine(out): + st["co"] = out + ev = {} + + def kick(p, c): + co = st.pop("co", None) + return co + r = solar(const(6900.0), 520, sim=sim, on_cycle=f, + events={t: kick for t in range(300, 520)}) + log = r["sim"].log[st.get("n0", 0):] if "t0" in st else None + return r, st, log + + +TRIG36 = (("Off", lambda p, c: c.handle_action("car_mode", value="off")), + ("shadow", lambda p, c: c.o.__setitem__("shadow_mode", "on")), + ("Stop", lambda p, c: c.handle_action("auto_toggle")), + ("safety stop", lambda p, c: setattr(c.circ_wd, "tripped", True)), + ("shutdown", lambda p, c: c.shutdown()), + ("unplug", lambda p, c: p.ch.unplug())) +for stage in ("zero", "settle"): + for name, trig in TRIG36: + r36, st36, log36 = seq_stop(trig, stage) + zeros = [x for x in r36["sim"].log if x[1] == "current" + and x[2] == 0.0] + check(f"T36 {name} at stage {stage}: no select after it, no restore, " + f"the charger ends at 0 A and one 0 A in all " + f"({log36})", log36 is not None + and not [x for x in log36 if x[1] == "phases"] + and not [x for x in log36 if x[1] == "current" and x[2] > 0] + and r36["sim"].setpoint_a == 0.0 and len(zeros) == 1) +r37 = solar_exit(lambda p, c: p.ch.unplug(), events={ + 3920: lambda p, c: p.ch.plug_in()}, dur=4200) +w37 = after(r37, 300) +check(f"T37: unplug at 10 A: one 0 A within 1 cycle, nothing for 3600 s; " + f"replug: nothing before the start rule ({w37})", + w37 and w37[0][1] == 0.0 and w37[0][0] <= 302 + and after(r37, 303, 3920) == [] + and all(t >= 3920 + 120 for t, v in after(r37, 3920))) +r37m = S.drive(dur=600, mode="manual", setpoint=10, + events={300: lambda p, c: p.ch.unplug()}, **RUN10) +check(f"T37 guard: an unplug in Manual writes nothing ({after(r37m, 300)})", + after(r37m, 300) == []) +# T12: each 0 A comes within 1 cycle, also 2 s after a normal write +st12 = {} + + +def t12(trigger): + st = {} + h = {"w": 2900.0} + + def f(plant, c, t): + w = plant.ch.writes("current") + if w and "first" not in st: + st["first"] = w[0][0] + if "first" in st and t == st["first"] + 40: + h["w"] = 3600.0 # a normal write 30 s+ later + nz = [x for x in w if x[2] > 0] + if len(nz) >= 2 and "t2" not in st: + st["t2"] = nz[1][0] + 2 + if "t2" in st and t + 1 == st["t2"]: + st["co"] = trigger(plant, c) + + def kick(p, c): + return st.pop("co", None) + hs = {"w": 500.0} + r = S.drive(house=lambda t: hs["w"] if trigger is not None else 500.0, + sun=lambda t: h["w"], first="car", socs=FULL, dur=400, + on_cycle=f, events={t: kick for t in range(100, 400)}) + return r, st + + +for name, trig in (("Off", lambda p, c: c.handle_action("car_mode", + value="off")), + ("Stop", lambda p, c: c.handle_action("auto_toggle")), + ("unplug", lambda p, c: p.ch.unplug()), + ("charger error", lambda p, c: setattr(p.ch, "error", + "5: fault"))): + r12, s12 = t12(trig) + z12 = [t for t, v in cur(r12) if v == 0.0] + check(f"T12 {name} 2 s after a normal write: the 0 A goes out within 1 " + f"cycle, the 30 s rule does not delay it ({cur(r12)})", + "t2" in s12 and z12 and s12["t2"] <= z12[0] <= s12["t2"] + 1) +r12c = S.drive(house=steps((0, 500.0), (154, 7500.0)), sun=steps( + (0, 2900.0), (150, 3600.0)), first="car", socs=ABLE, dur=260) +_nz12 = [t for t, v in cur(r12c) if v > 0] +_z12 = [t for t, v in cur(r12c) if v == 0.0] +check(f"T12 the peak cut 2 s after a normal write: 0 A within 1 cycle " + f"({cur(r12c)})", len(_nz12) >= 2 and _z12 + and _z12[0] - _nz12[1] <= 4) +for name, trig, zero_after in ( + ("(a) Solar to Off, then a current and phases set while Off", + seq(act("car_mode", "off")), True), + ("(b) shadow on by the option", + lambda p, c: c.o.__setitem__("shadow_mode", "on"), True), + ("(b) shadow on by shadow_mode auto and Stop", + act("auto_toggle", None), True)): + r53 = solar_exit(trig, dur=900, events={ + 310: seq(act("car_current", 14), act("car_phases", 3))}) + w53 = after(r53, 300) + check(f"T53 {name}: exactly one 0 A within 1 cycle, then nothing for " + f"600 s ({w53})", [v for _t, v in w53] == [0.0] + and w53[0][0] <= 302) +st53 = {} + + +def _would53(p, c, t): + if t == 500: + st53["why"] = homeview.car_block(c, None)["why"] + + +solar_exit(lambda p, c: c.o.__setitem__("shadow_mode", "on"), + on_cycle=_would53) +check(f"T53 (b): in shadow mode the card says what it would set " + f"({st53.get('why')!r})", "would set 10 A" in st53.get("why", "")) +for name, trig in (("Off", act("car_mode", "off")), + ("shadow", lambda p, c: c.o.__setitem__("shadow_mode", + "on"))): + r53c = S.drive(house=const(500.0), sun=steps((0, 2900.0), (100, 0.0)), + first="car", socs=FULL, dur=900, events={700: trig}) + check(f"T53 (c) Solar paused at 0 A, then {name}: no write " + f"({after(r53c, 700)})", after(r53c, 700) == []) +for name, trig in (("(d) Manual to Off", act("car_mode", "off")), + ("(e) shadow on in Manual", + lambda p, c: c.o.__setitem__("shadow_mode", "on"))): + r53d = S.drive(dur=600, mode="manual", setpoint=10, events={300: trig}, + **RUN10) + check(f"T53 {name}: no write, as in EV-04 ({after(r53d, 300)})", + after(r53d, 300) == []) +r53f = solar_exit(act("car_mode", "manual"), dur=600) +check(f"T53 (f) Solar to Manual: no Solar 0 A; Manual writes its own current " + f"once ({after(r53f, 300)})", [v for _t, v in after(r53f, 300)] + == [float(r53f["c"].car_a)] and 0.0 not in + [v for _t, v in after(r53f, 300)]) + +# =========================================================================== # +print("\nT1, T2. THE MODE AND WHERE SPARE SUN GOES FIRST: RUNTIME STATE") +# =========================================================================== # +st1 = {} + + +async def _t1(p, c): + st1["page"] = await c.handle_action("car_mode", value="solar") + st1["stored"] = c.store.data.get("car_mode") + await c.handle_action("car_mode", value="off") + await c.mqtt_command("goodwe_ctl/car/mode/set", b"Solar", False) + st1["mqtt"] = c.car_mode + st1["night"] = await c.handle_action("car_mode", value="night") + st1["bogus"] = await c.handle_action("car_mode", value="Bogus") + await c.mqtt_command("goodwe_ctl/car/mode/set", b"Night", False) + st1["after"] = c.car_mode + + +r1 = S.drive(mode="off", dur=200, events={5: _t1}, **SC2) +check(f"T1: Solar from the page's action and from MQTT; stored, run by the next " + f"step with no restart ({st1.get('page')}, {cur(r1)})", + st1.get("stored") == "solar" and st1.get("mqtt") == "solar" + and r1["c"].car_solar.engaged and [v for _t, v in cur(r1)] == [8.0]) +check("T1: Night and Bogus are refused and change nothing", + "error" in st1["night"] and "error" in st1["bogus"] + and st1["after"] == "solar") +_pl = dict(mqtt.car_payloads((16, (1, 3)))) +check("T1: select.goodwe_car_mode offers exactly Off, Manual, Solar", + _pl["homeassistant/select/goodwe_ctl_car_mode/config"]["options"] + == ["Off", "Manual", "Solar"] and "car_sun_first" in __import__( + "app.web", fromlist=["CAR_ACTIONS"]).CAR_ACTIONS) +st2 = {} + + +async def _t2(p, c): + st2["t"] = p.t + st2["r"] = await c.handle_action("car_sun_first", value="car") + await c.mqtt_command("goodwe_ctl/car/sun_first/set", b"Batteries", True) + st2["retained"] = c.car_first + st2["unknown"] = await c.handle_action("car_sun_first", value="Both") + st2["mqtt_bad"] = mqtt.parse_car_command( + "goodwe_ctl/car/sun_first/set", b"Both", False)[1] + + +r2 = S.drive(dur=300, events={150: _t2}, **SC2) +w2 = cur(r2) +check(f"T2: Batteries -> Car: the next write follows the new arithmetic (16 A) " + f"and still the 30 s rule ({w2})", [v for _t, v in w2][:2] == [8.0, 16.0] + and w2[1][0] - w2[0][0] >= 30) +check("T2: a retained command is dropped, an unknown label refused", + st2["retained"] == "car" and "error" in st2["unknown"] + and st2["mqtt_bad"] is None) +check("T2: the choice is in the store and survives a rebuild (below)", + r2["store"].data.get("car_sun_first") == "car") +_s2 = S.rig._Store() +_s2.data["car_sun_first"] = "car" +from app.main import Controller as _C # noqa: E402 +check("T2: a Controller built on that store starts with Car first", + _C(S.rig._options(1, {"ev_charger": "alfen_ha", + "ev_current_entity": S.SET}), S.SunPlant( + const(0), const(0), {"a": 5000.0}, {"a": 50.0}, SimCharger()), + _s2, S.rig._Pub(), stop=asyncio.Event()).car_first == "car") +check("T2: the HA labels mirror carmode's", mqtt.CAR_FIRST_LABELS + == carmode.FIRST_LABELS and mqtt.CAR_MODE_LABELS == carmode.MODE_LABELS) + +# =========================================================================== # +print("\nT4, T5. NO SPARE FROM A BAD FIGURE (N8)") +# =========================================================================== # +for name, bad in (("None", None), ("NaN", "nan")): + def _nan(on, bad=bad): + def f(p, c): + if on: + p.batt_nan.add("a") + else: + p.batt_nan.discard("a") + return f + r4 = solar_exit(_nan(True), at=200, dur=650, + events={201: _nan(False), 300: _nan(True)}) + w4 = after(r4, 200) + check(f"T4 battery figure {name}: one cycle writes nothing; 350 s: the " + f"current is held, then 0 A once at 300 s (+2) ({w4})", + [v for _t, v in w4] == [0.0] and 300 <= w4[0][0] - 300 <= 302) +st5 = {} + + +def _stop5(p, c): + p.ch.stop_delay_s = 1e9 # mode3 stays C: the car really + p.ch.car_full() # stops, the power sticks + p.ch.freeze_power() + + +r5 = solar_exit(_stop5, dur=800) +w5 = after(r5, 300) +# In its first minute the frozen figure is still believed (EV-04's +# corroboration window), so a write may follow it then; after that, no +# non-zero write, and the 0 A by 110 + 300 + 2 s. +z5 = [t for t, v in w5 if v == 0.0] +check(f"T5 (iii): a frozen figure after the car really stopped: once " + f"corroboration fails (<= 110 s) it no longer counts: hold, then 0 A by " + f"110 + 300 + 2 s ({w5})", z5 and 300 + 300 <= z5[0] <= 300 + 412 + and not [t for t, v in w5 if v > 0 and t > 300 + 110]) +r5b = solar_exit(lambda p, c: p.ch.go_unavailable(), dur=800) +check(f"T5 (iv): a charger reading older than 15 s: no spare is computed " + f"(an unreachable charger is also not written to; 0 A on its return, " + f"T32) ({after(r5b, 300)})", after(r5b, 300) == []) + +# =========================================================================== # +print("\nT38. A FULL CAR") +# =========================================================================== # + + +class LowCar(SimCharger): + low = False + + def target_w(self): + t = super().target_w() + return min(t, 150.0) if self.low and t > 0 else t + + +st38 = {} + + +def _st38(p, c, t): + st38[t] = c.car.status(c.car_now(), True) + + +r38 = solar_exit(lambda p, c: p.ch.car_full(), dur=700, on_cycle=_st38) +check(f"T38 (a): mode3 B with 6 A or more allowed for 60 s: Car is full, " + f"nothing written ({after(r38, 300)}, {st38.get(362)})", + after(r38, 300) == [] and st38.get(362) == "full" + and homeview.car_block(r38["c"], None)["chip"] == "Car is full") +st38b = {} +_low = LowCar(setpoint_a=0) + + +def _low_on(p, c): + p.ch.low = True + + +def _low_off(p, c): + p.ch.low = False + + +def _st38b(p, c, t): + st38b[t] = (c.car.status(c.car_now(), True), c.car_solar.plan.why) + + +r38b = solar_exit(_low_on, dur=1100, sim=_low, on_cycle=_st38b, + events={1000: _low_off}) +full_at = min((t for t, v in st38b.items() if v[0] == "full"), default=None) +check(f"T38 (b): C under 200 W at 6 A or more for 600 s: full at 600 s, not " + f"599 ({full_at})", full_at is not None and 599 <= full_at - 301 <= 602) +check(f"T38 (b): when it draws again Solar recomputes ({st38b.get(1050)})", + st38b.get(1050, ("", ""))[0] == "charging" + and st38b.get(1050)[1] == "running" and after(r38b, 300, 1000) == []) + +# =========================================================================== # +print("\nT40. ANOTHER WRITER (N10)") +# =========================================================================== # +n_other = LOG.count("WARNING", "CHARGER_OTHER") +check("T40 guard: the add-on's own 0 A pauses and phase sequences above were " + "never taken for another writer", n_other == 0) +st40 = {} + + +def _st40(p, c, t): + st40[t] = (c.car_solar.hold, [x for x in c.checks() + if x["id"] == "charger_other"]) + + +r40 = solar_exit(lambda p, c: p.ch.set_current(13), dur=900, + events={700: act("car_mode", "solar")}, on_cycle=_st40) +check(f"T40: the add-on stops writing at 30 s, not 29 s, with the amber row " + f"and one warning ({st40.get(328)[0]}, {st40.get(331)[0]}, " + f"{after(r40, 300, 700)})", + not st40[328][0] and st40[331][0] and after(r40, 300, 700) == [] + and st40[331][1] and st40[331][1][0]["ok"] is False + and st40[331][1][0]["warn"] is True + and LOG.count("WARNING", "CHARGER_OTHER") - n_other == 1) +check(f"T40: pressing the mode lifts it: the add-on says its current again " + f"({after(r40, 700)})", after(r40, 700)[:1] == [(after(r40, 700)[0][0], + 10.0)]) +check("T40: the row says 'Something else changes the charger', EN and NL", + "Something else changes the charger" in str(messages.row_charger_other()) + and "Iets anders wijzigt de laadpaal" in messages.row_charger_other().nl) + +# =========================================================================== # +print("\nT41. TODAY'S kWh FROM THE SUN") +# =========================================================================== # + + +def sun_kwh(r): + return r["c"].car_sun_kwh() + + +def car_wh(r, t0, t1, cap=None): + out = 0.0 + for x in r["trace"]: + if t0 <= x["t"] < t1: + out += x["car"] if cap is None else min(x["car"], cap) + return out / 3.6e6 + + +r41a = S.drive(house=const(0.0), sun=const(3000.0), first="car", socs=FULL, + dur=3600) +r41b = S.drive(dur=3600, **SC2) +for name, r, cap in (("(a) Car first, spare 3000, 12 A", r41a, 3000.0), + ("(b) Batteries first, scenario 2", r41b, 2000.0)): + want = car_wh(r, 0, 3600, cap) + check(f"T41 {name}: the sun share is all of the car's energy " + f"({sun_kwh(r):.3f} kWh, the car {want:.3f} kWh, within 10 Wh)", + sun_kwh(r) is not None and abs(sun_kwh(r) - want) <= 0.010 + and want > 1.5) +r41c = S.drive(house=const(0.0), sun=steps((0, 2000.0), (300, 1000.0)), + first="car", socs=FULL, opts={"ev_pause_min": 30}, dur=1800) +want_c = car_wh(r41c, 0, 300, 2000.0) + car_wh(r41c, 300, 1800, 1000.0) +tot_c = car_wh(r41c, 0, 1800) +check(f"T41 (c): a hold (spare 1000 W, car 6 A): only 1000 W of the 1380 W " + f"counts ({sun_kwh(r41c):.3f} of {tot_c:.3f} kWh, expected " + f"{want_c:.3f})", abs(sun_kwh(r41c) - want_c) <= 0.010 + and sun_kwh(r41c) < tot_c - 0.1) +r41d = S.drive(house=const(500.0), sun=const(0.0), first="car", socs=FULL, + dur=900) +r41e = S.drive(house=const(0.0), sun=const(5300.0), first="car", socs=FULL, + mode="manual", setpoint=10, dur=900) +check(f"T41 (d) spare -500 and (e) Manual at 10 A with 3 kW export: 0 kWh from " + f"the sun ({sun_kwh(r41d)}, {sun_kwh(r41e)})", + not sun_kwh(r41d) and not sun_kwh(r41e) + and (r41e["c"].car.today_kwh or 0) > 0.3) +c41 = r41a["c"] +vals41 = c41.car_values() +blk41 = homeview.car_block(c41, None) +check(f"T41: 0 <= sun <= today; the MQTT value and the card show the same " + f"figures ({vals41['car_today_solar_kwh']}, {blk41['today']!r})", + 0 <= sun_kwh(r41a) <= c41.car.today_kwh + and vals41["car_today_solar_kwh"] == round(sun_kwh(r41a), 3) + and blk41["today"] == homeview._t( + "car.today_sun", kwh=homeview._kwh(c41.car.today_kwh), + sun=homeview._kwh(sun_kwh(r41a)))) +c41.car.day = "2099-01-01" +c41._car_sun_tick(c41.car_now() + 1) +check("T41 (f): a new day starts at 0", c41.car_sun["kwh"] == 0.0) + +# =========================================================================== # +print("\nT42, T43. STRINGS, DOCS AND THE OPTIONS") +# =========================================================================== # +_en = json.load(io.open(os.path.join(HERE, "app", "ui_text", "en.json"), + encoding="utf-8")) +_nl = json.load(io.open(os.path.join(HERE, "app", "ui_text", "nl.json"), + encoding="utf-8")) +_keys = [("home_words", "car", "why", k) for k in + ("solar_batt", "solar_car", "solar_paused")] + [ + ("home", "car", "help_solar", "description"), ("home", "car", "first"), + ("home", "car", "first_help", "description"), + ("home_words", "car", "today_sun")] + + +def _get(d, path): + for k in path: + d = d[k] + return d + + +check("T42: why.solar_batt/car/paused, help.solar, first, first.help and the " + "kWh line exist in English and Dutch, and differ", + all(_get(_en, k) and _get(_nl, k) and _get(_en, k) != _get(_nl, k) + for k in _keys)) +_docs = io.open(os.path.join(HERE, "DOCS.md"), encoding="utf-8").read() +check("T42: DOCS has the Solar section and cut-over step 3; DECISIONS/EV-05 " + "and a CHANGELOG line exist", + "**Solar mode.**" in _docs and "3. On the next sunny day, choose " + "**Solar**" in _docs and os.path.exists(os.path.join( + HERE, "DECISIONS", "EV-05-solar-mode.md")) + and "[[EV-05]]" in io.open(os.path.join(HERE, "CHANGELOG.md"), + encoding="utf-8").read().split("## 0.24")[0]) +check("T42: the defaults: ev_margin_w 100, ev_pause_min 5, ev_start_min 2", + (CH.EV_OPTION_DEFAULTS["ev_margin_w"], CH.EV_OPTION_DEFAULTS[ + "ev_pause_min"], CH.EV_OPTION_DEFAULTS["ev_start_min"]) == (100, 5, 2)) +_cy = io.open(os.path.join(HERE, "config.yaml"), encoding="utf-8").read() +check("T43: config.yaml's schema has the same ranges as the validator", + all(f"{k}: int({lo},{hi})" in _cy for k, (lo, hi) in + CH.SOLAR_RANGES.items())) +_base43 = {"ev_charger": "alfen_ha", "ev_current_entity": S.SET} +bad43, good43 = [], [] +for k, vals in (("ev_margin_w", (-1, 1001)), ("ev_pause_min", (0, 31)), + ("ev_start_min", (0, 31))): + for v in vals: + msgs = validate._charger_problems(dict(_base43, **{k: v}), {}) + if not any(f"({k})" in m for m in msgs): + bad43.append((k, v, msgs)) +for k, vals in (("ev_margin_w", (0, 1000, 100)), ("ev_pause_min", (1, 30, 5)), + ("ev_start_min", (1, 30, 2))): + for v in vals: + if validate._charger_problems(dict(_base43, **{k: v}), {}): + good43.append((k, v)) +check(f"T43: -1/1001, 0/31, 0/31 are refused naming the setting; the edges and " + f"the defaults pass ({bad43[:2]}, {good43[:2]})", not bad43 and not good43) + +# =========================================================================== # +print("\nT46-T48, T50-T52. WHAT MUST NOT CHANGE") +# =========================================================================== # + + +def seam_callers(): + out = [] + for f in sorted(os.listdir(os.path.join(HERE, "app"))): + if not f.endswith(".py") or f == "chargers.py": + continue + tree = ast.parse(io.open(os.path.join(HERE, "app", f), + encoding="utf-8").read()) + for n in ast.walk(tree): + if isinstance(n, ast.Call) and isinstance(n.func, ast.Attribute) \ + and (n.func.attr in ("write_current", "write_phases") + or (n.func.attr == "release" + and "charger" in ast.dump(n.func.value))): + out.append((f, n.func.attr)) + return sorted(out) + + +_ch_src = io.open(os.path.join(HERE, "app", "chargers.py"), + encoding="utf-8").read() +_rel = _ch_src.split("async def release(self, mode: str) -> bool:")[2] +check(f"T46: the write sites are still exactly one write_current and one " + f"write_phases, in carmode.py ({seam_callers()}); the driver's release " + f"writes nothing", seam_callers() == [("carmode.py", "write_current"), + ("carmode.py", "write_phases")] + and "write_current" not in _rel.split("class ")[0]) +check("T47: start_mode still maps a mode it does not know to Off", + carmode.start_mode({}, "night") == "off" + and carmode.start_mode({}, "bogus") == "off" + and carmode.start_mode({}, "solar") == "solar") +r48 = S.drive(mode="manual", setpoint=10, first="car", dur=60, + opts={"ev_margin_w": 1000, "ev_start_min": 30, + "ev_pause_min": 1}, house=const(0.0), sun=const(0.0), + socs=FULL) +check(f"T48: Manual ignores where spare sun goes, the margin and the dwells: " + f"it writes its own current at once ({cur(r48)})", + [v for _t, v in cur(r48)] == [float(r48["c"].car_a)] + and cur(r48)[0][0] <= 5) +_c52 = r41a["c"] +check(f"T52: in Solar the House tile and the house profile still leave the car " + f"out: car_term gives the car's own power ({_c52.car_term()})", + _c52.car_term()[1] is False and _c52.car_term()[0] > 2000) + +print("\n(T39, T44, T45, T50 and T51, the long runs, are in test_ev05_long.py)") + +print() +if fails: + print(f"{len(fails)} FAILED") + for f in fails: + print(" -", f) + sys.exit(1) +print("all passed") diff --git a/goodwe_controller/test_ev05_long.py b/goodwe_controller/test_ev05_long.py new file mode 100644 index 0000000..8fbefff --- /dev/null +++ b/goodwe_controller/test_ev05_long.py @@ -0,0 +1,421 @@ +"""EV-05: the car's Solar mode, the long runs. `python3 -B test_ev05_long.py` + +Split from test_ev05.py so CI's parallel batch stays short: the shadow-mode +twin (T39), the acceptance day (T44), the fuzz (T45), and the hour-long +"nothing else changes" comparisons (T50, T51). Same harness, +`tools/ev05_sun.py`; the rows are named by their test-plan id. +Mutating a module this file grades? Read MUTATION.md first (purge __pycache__). +""" + +import logging +import math +import os +import random +import sys + +HERE = os.path.dirname(os.path.abspath(__file__)) +sys.path.insert(0, os.path.join(HERE, "tools")) + +import ev05_sun as S # noqa: E402 +from chargersim import SimCharger # noqa: E402 + +logging.disable(logging.CRITICAL) +fails = [] + + +def check(name, cond): + print(f" {'ok ' if cond else 'FAIL'} {name}") + if not cond: + fails.append(name) + + +def const(w): + return lambda t: float(w) + + +def steps(*pairs): + def f(t): + v = pairs[0][1] + for at, w in pairs: + if t >= at: + v = w + return float(v) + return f + + +def cur(r): + return S.writes(r, "current") + + +def ph(r): + return S.writes(r, "phases") + + +FULL = {"a": 100.0, "b": 100.0} +ABLE = {"a": 60.0, "b": 60.0} + + +def quarters(r, aim): + """(start, import average, car average) of each whole quarter.""" + out = [] + tr = r["trace"] + for q0 in range(0, int(tr[-1]["t"]) + 1 - 900, 900): + xs = [x for x in tr if q0 <= x["t"] < q0 + 900] + if len(xs) < 890: + continue + g = sum(max(0.0, x["grid"]) for x in xs) / len(xs) + car = sum(x["car"] for x in xs) / len(xs) + out.append((q0, g, car)) + return out + + +def seq_ok(r): + """Every select: a 0 A write before it, the car under 100 W or out of C or + 20 s after the 0 A, then 10 s or more to the next current; no other write + in between.""" + log = r["sim"].log + state = {x["t"]: x["st"] for x in r["trace"]} + bad = [] + for i, x in enumerate(log): + if x[1] != "phases": + continue + prev = log[i - 1] if i else None + nxt = log[i + 1] if i + 1 < len(log) else None + if prev is None or prev[1] != "current" or prev[2] != 0.0: + bad.append(("no 0 A before", x)) + continue + quiet = (x[3] < 100.0 or state.get(x[0] - 1) != "C" + or x[0] - prev[0] >= 20.0) + if not quiet or x[4] != 0.0: + bad.append(("select under load", x)) + if nxt is not None and (nxt[1] != "current" or nxt[0] - x[0] < 10.0): + bad.append(("current too soon or not next", x, nxt)) + return bad + + +def inv_sets(r): + return [x for x in r["plant"].sets if x[1].startswith("number.sp_")] + + +# =========================================================================== # +print("\nT39. SHADOW MODE: NOTHING WRITTEN, THE CARD SAYS WHAT IT WOULD SET (N10)") +# =========================================================================== # + + +def cloudy(t): + k = int(t) // 240 + return 900.0 + (2600.0 if k % 3 else 400.0) + 300.0 * (k % 5) + + +twin = S.drive(house=const(500.0), sun=cloudy, first="car", socs=FULL, + opts={"ev_phases": "1"}, dur=3600) +for name, kw in (("on", dict(opts={"ev_phases": "1", "shadow_mode": "on"})), + ("auto, control stopped", + dict(opts={"ev_phases": "1", "shadow_mode": "auto"}, + events={0: lambda p, c: setattr(c, "auto", False)}))): + sh = S.drive(house=const(500.0), sun=cloudy, first="car", socs=FULL, + dur=3600, **kw) + diff = [(a["t"], a["a"], (b["would"] or (None,))[0]) + for a, b in zip(twin["trace"], sh["trace"]) + if b["would"] is not None and a["a"] != b["would"][0]] + check(f"T39 shadow {name}: the charger log is empty for a cloudy hour, and " + f"every second the card's 'would set' is the current of a twin run " + f"without shadow mode ({len(diff)} seconds differ: {diff[:3]})", + sh["sim"].log == [] and not diff + and len({a['a'] for a in twin['trace']}) >= 3) + + +# =========================================================================== # +print("\nT50, T51. NOTHING ELSE CHANGES FOR THE GUARD AND THE ZERO-GRID LOOP") +# =========================================================================== # +h50 = steps((0, 400.0), (600, 2600.0), (900, 800.0), (1800, 4200.0), + (2100, 300.0), (3000, 1500.0)) +r50 = S.drive(house=h50, sun=const(0.0), plug=False, dur=3600) +r50o = S.drive(house=h50, sun=const(0.0), plug=False, dur=3600, + opts={"ev_charger": "off"}) + + +check(f"T50: Solar with no car for an hour: the guard's floor and every battery " + f"command are identical to the run with no charger " + f"({len(inv_sets(r50))} commands)", inv_sets(r50) == inv_sets(r50o) + and [x["floor"] for x in r50["trace"]] + == [x["floor"] for x in r50o["trace"]] and cur(r50) == []) +sun51 = steps((0, 3000.0), (700, 5200.0), (1500, 2500.0)) +r51 = S.drive(house=const(400.0), sun=sun51, first="car", socs=ABLE, + dur=2000) +carp = {int(x["t"]): x["car"] for x in r51["trace"]} +r51o = S.drive(house=lambda t: 400.0 + carp.get(math.ceil(t), 0.0), + sun=sun51, socs=ABLE, dur=2000, opts={"ev_charger": "off"}) +check(f"T51: Car first, the zero-grid loop: the same meter series with the car " + f"as a Solar car and as house load gives the same battery commands " + f"({len(inv_sets(r51))} commands)", inv_sets(r51) == inv_sets(r51o) + and max(carp.values()) > 3000) +check("T51: the batteries charge with what the car leaves (Car first)", + -300 <= r51["plant"].batt(1999) <= 0) +# =========================================================================== # +print("\nT44. THE ACCEPTANCE DAY: 08:00-18:00, CLOUDS, HOUSE STEPS (A2)") +# =========================================================================== # +_rnd44 = random.Random(44) +CLOUDS44 = [] +for _i in range(12): + a = _rnd44.randint(600, 34000) + CLOUDS44.append((a, a + _rnd44.randint(60, 480))) +STEPS44 = [(8000, 8300), (17000, 17300), (26000, 26300)] + + +def sun44(t): + base = max(0.0, 7500.0 * math.sin(math.pi * t / 36000.0)) + return base * (0.15 if any(a <= t < b for a, b in CLOUDS44) else 1.0) + + +def house44(t): + w = 1450.0 + 1050.0 * math.sin(t / 1700.0) + return w + (3000.0 if any(a <= t < b for a, b in STEPS44) else 0.0) + + +long44 = sum(1 for a, b in CLOUDS44 if b - a > 300) +for first, race in (("batteries", False), ("car", True)): + # The batteries' levels move with their charge (A 15.36 kWh, B 20.48 kWh), + # so with Batteries first the car gets sun once they are full. + r44 = S.drive(house=house44, sun=sun44, first=first, socs={"a": 40.0, + "b": 60.0}, + caps={"a": 15.36, "b": 20.48}, dur=36000, race=race) + # On the harness clock, as the trace (the model's own clock runs ahead). + w44 = [(x[0], x[2]) for x in r44["plant"].wlog if x[1] == "current"] + p44 = [(x[0], x[2]) for x in r44["plant"].wlog if x[1] == "phases"] + # A phase change's own 0 A (a select follows within 25 s) is not a pause. + seq0 = {t for t, v in w44 if v == 0.0 and any(0 < pt - t <= 25 + for pt, _n in p44)} + starts, pauses, paused, pause_t = 0, 0, True, [] + for t, v in w44: + if v == 0.0 and t not in seq0: + paused = True + pauses += 1 + pause_t.append(t) + elif v > 0 and paused: + starts += 1 + paused = False + why_at = {x["t"]: x["why"] for x in r44["trace"]} + cut_t = [t for t in pause_t if why_at.get(t) == "cut" + or why_at.get(t - 1) == "cut"] + # Car first: no hold pause from a cloud under 300 s. Batteries first: a + # battery that gave power in the cloud is under 100 % again, so its + # rating is room and the car waits for it (the brief's room rule). + short_hit = [t for t in pause_t if t not in cut_t and first == "car" + and any(a <= t <= b + 2 for a, b in CLOUDS44 if b - a <= 300)] + print(f" pauses (second, why): {[(t, why_at.get(t)) for t in pause_t]}") + # N5 on the whole day: a start 120 s or more after its pause, a hold + # pause after 300 s of holding, non-zero writes 30 s apart. + nz = [t for t, v in w44 if v > 0] + n5 = [("30 s", b) for a, b in zip(nz, nz[1:]) if b - a < 30] + last_p = None + for t, v in w44: + if v == 0.0 and t not in seq0: + last_p = t + elif v > 0 and last_p is not None: + if t - last_p < 120: + n5.append(("start", t)) + last_p = None + for t in pause_t: + if why_at.get(t) == "paused": + run = 0 + while why_at.get(t - 1 - run) == "hold": + run += 1 + if run < 298: + n5.append(("pause", t, run)) + # The loop turns at most `slew_w` per cycle, so for some 15 s after each + # current step, cloud edge and house step the grid covers the change: + # counted apart (dev report). The rest is the car on grid power while + # the loop is settled, outside the holds. + edges = [t for t, v in w44] + [e for ab in CLOUDS44 + STEPS44 for e in ab] + edges.sort() + + def settling(t): + return any(0 <= t - e < 15 for e in edges) + grid_wh = sum(min(x["car"], max(0.0, x["grid"])) for x in r44["trace"] + if x["why"] not in ("hold",) and not settling(x["t"])) / 3600.0 + slew_wh = sum(min(x["car"], max(0.0, x["grid"])) for x in r44["trace"] + if settling(x["t"])) / 3600.0 + steps44 = edges + over44 = [(q, round(g)) for q, g, car in quarters(r44, 3400.0) + if g > 3410.0 and g - car <= 3410.0] + gaps = [b[0] - a[0] for a, b in zip(p44, p44[1:])] + check(f"T44 {first} first ({'race' if race else 'step'}): starts {starts} " + f"(<= 1 + {long44} long clouds + {len(cut_t)} peak cuts, Car first)" + f"; pauses {pauses}; N5 dwells {n5[:3]}; selects {len(p44)} " + f"(gaps >= 600 s: {gaps[:4]}); no pause from a short cloud " + f"{short_hit[:3]}; the car's grid energy outside holds {grid_wh:.1f} " + f"Wh (and {slew_wh:.1f} Wh in the loop's 15 s after " + f"{len(steps44)} steps and edges); quarters over the aim by the car " + f"{over44}", + starts >= 1 and not n5 and all(g >= 600 for g in gaps) + and (first != "car" or starts <= 1 + long44 + len(cut_t)) + and not seq_ok(r44) and not short_hit and grid_wh <= 10.0 + and not over44) + +# =========================================================================== # +print("\nT45. THE FUZZ: 14 SITES, 16800 STEPS (N1-N10)") +# The plan asks 14 x 400 steps; a busy site rarely has the 60 s calm a start +# needs, so each site runs 1200 steps to make enough writes to judge. +# =========================================================================== # + + +def fuzz(seed): + rnd = random.Random(seed) + stations = [10.0, 13.0, 16.0] + st = {"sun": rnd.uniform(0, 9000), "house": rnd.uniform(200, 3000), + "n": {}, "acts": [], "undo": [], "exits": []} + + def exit_check(p, c): + """N9: Solar to Off with the charger above 0 A, reachable, taking + writes and not held by another writer: a 0 A must follow.""" + ch = p.ch + if c.car_mode == "solar" and not c.car_solar.hold \ + and not ch.unavailable and ch.refuse is None \ + and ch.readback_a > 0.5 and not p.ha_down: + st["exits"].append(p.t) + + def later(p, fn): + st["undo"].append((p.t + rnd.randint(10, 40), fn)) + + def ev(p, c): + for due in [u for u in st["undo"] if u[0] <= p.t]: + st["undo"].remove(due) + due[1]() + if st.get("back") is not None and p.t >= st["back"]: + st["back"] = None # the user goes back to Solar + st["acts"].append(p.t) + return c.handle_action("car_mode", value="solar") + if st.get("press") is not None and p.t >= st["press"]: + st["press"] = None # the user presses the mode + st["acts"].append(p.t) + return c.handle_action("car_mode", value=c.car_mode) + r = rnd.random() + ch = p.ch + if r < 0.012: + st["sun"] = rnd.choice([0.0, 1000.0, 2500.0, 5000.0, 8000.0, + 8000.0, 6500.0]) + elif r < 0.02: + st["house"] = rnd.uniform(200, 4000) + elif r < 0.08: + st["sun"] = max(0.0, st["sun"] + rnd.uniform(-600, 600)) + elif r < 0.082: + if ch.state != "A": + ch.unplug() + later(p, ch.plug_in) + st["n"]["plug"] = st["n"].get("plug", 0) + 1 + elif r < 0.084: + ch.go_unavailable(True) + later(p, lambda: ch.go_unavailable(False)) + st["n"]["down"] = st["n"].get("down", 0) + 1 + elif r < 0.087: + ch.set_current(rnd.randint(0, 16)) + st["n"]["other"] = st["n"].get("other", 0) + 1 + st["press"] = p.t + rnd.randint(20, 90) + elif r < 0.089: + ch.refuse = rnd.choice(["ignore", "error"]) + later(p, lambda: setattr(ch, "refuse", None)) + elif r < 0.091: + p.meter_on = False + later(p, lambda: setattr(p, "meter_on", True)) + st["n"]["meter"] = st["n"].get("meter", 0) + 1 + elif r < 0.093: + c.o["shadow_mode"] = "on" + later(p, lambda: c.o.__setitem__("shadow_mode", "off")) + st["n"]["shadow"] = st["n"].get("shadow", 0) + 1 + elif r < 0.095: + c.auto = False + later(p, lambda: setattr(c, "auto", True)) + st["n"]["stop"] = st["n"].get("stop", 0) + 1 + elif r < 0.098: + m = rnd.choice(["solar", "solar", "solar", "off", "manual"]) + st["n"]["mode"] = st["n"].get("mode", 0) + 1 + st["acts"].append(p.t) + if m == "off": + exit_check(p, c) + return c.handle_action("car_mode", value=m) + elif r < 0.1: + ch.station_a = rnd.choice(stations) + elif r < 0.103 and c.car_mode == "solar" and p.ch.readback_a > 0.5 \ + and st.get("back") is None: + exit_check(p, c) # leave Solar while it charges + st["acts"].append(p.t) + st["back"] = p.t + rnd.randint(30, 120) + return c.handle_action("car_mode", value="off") + elif r < 0.2 and c.car_solar.seq is not None: + st["n"]["mid"] = st["n"].get("mid", 0) + 1 + exit_check(p, c) + return c.handle_action("car_mode", value="off") + ctx = [] + + def note(p, c, t): + ctx.append((t, c.car_mode, c.car_writing(), c.car_solar.single, + c.car_solar.hold, p.ch.station_a)) + r = S.drive(house=lambda t: st["house"], sun=lambda t: st["sun"], + first="car", opts={"ev_margin_w": 0, "ev_start_min": 1, + "ev_pause_min": 1}, socs=FULL, dur=1200, + events={t: ev for t in range(1, 1200)}, on_cycle=note, + race=seed % 2 == 1, sim=SimCharger(setpoint_a=rnd.choice( + [0, 10, 16]))) + bad = [] + by_t = {x[0]: x for x in ctx} + log = r["plant"].wlog # on the harness clock + last_sel, last_nz = None, None + for t, what, v, power, sp in log: + # A write logged at second t comes after that second's actions. + x = by_t.get(t) or by_t.get(t - 1) + mode = x[1] if x else "?" + if what == "current" and v > min(16.0, x[5] if x else 16.0) + 1e-9: + bad.append(("N1 over the clamp", t, v)) + if what == "phases": + if sp != 0.0: + bad.append(("N2 select with the setpoint up", t)) + if last_sel is not None and t - last_sel < 600: + bad.append(("N2 two selects in 600 s", t)) + last_sel = t + if what == "current" and mode == "off" and v > 0: + bad.append(("N10 a non-zero write in Off", t, v)) + if what == "current" and x is not None and not x[2] and v > 0 \ + and mode == "solar": + bad.append(("N10 a non-zero Solar write while not writing", t, v)) + if what == "current" and v > 0 and mode == "solar": + near_act = any(abs(t - a) <= 3 for a in st["acts"]) + if last_nz is not None and t - last_nz < 30 and not near_act: + bad.append(("N5 two non-zero writes under 30 s", t, v)) + last_nz = t + for te in st["exits"]: + if not any(x[1] == "current" and x[2] == 0.0 and te <= x[0] <= te + 3 + for x in log): + bad.append(("N9 Solar to Off left the current up", te)) + if r["c"].charger.clamp_faults: + bad.append(("N1 clamp fault", r["c"].charger.clamp_faults)) + st["n"]["exits"] = len(st["exits"]) + return bad, len(log), st["n"] + + +fz_bad, fz_n, fz_counts = [], 0, {} +for _seed in range(14): + _b, _n, _c = fuzz(_seed) + fz_bad += _b + fz_n += _n + for k, v in _c.items(): + fz_counts[k] = fz_counts.get(k, 0) + v +check(f"T45: {fz_n} charger writes over 14 random Solar sites and 16800 steps " + f"(outages, unplugs, refusals, other writers, a silent meter, shadow and " + f"Stop, mode changes, half racing): none over the clamp, no select with " + f"the setpoint up or two in 600 s, every Solar to Off at 0 A (N9), no " + f"non-zero write in Off, in shadow " + f"or stopped, none under 30 s apart ({fz_bad[:3]})", + not fz_bad and fz_n > 100) +check(f"T45: each disturbance happened ({fz_counts})", + all(fz_counts.get(k, 0) > 2 for k in ("plug", "down", "other", "meter", + "shadow", "stop", "mode", + "exits"))) + +print() +if fails: + print(f"{len(fails)} FAILED") + for f in fails: + print(" -", f) + sys.exit(1) +print("all passed") diff --git a/goodwe_controller/tools/ev05_sun.py b/goodwe_controller/tools/ev05_sun.py new file mode 100644 index 0000000..01bed34 --- /dev/null +++ b/goodwe_controller/tools/ev05_sun.py @@ -0,0 +1,290 @@ +#!/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") diff --git a/goodwe_controller/translations/en.yaml b/goodwe_controller/translations/en.yaml index 6ba1f20..1643264 100644 --- a/goodwe_controller/translations/en.yaml +++ b/goodwe_controller/translations/en.yaml @@ -300,7 +300,16 @@ configuration: description: "While the car charges. On: the batteries cover it down to the peak reserve. Off: the peak guard leaves the car out, so the car alone can set the peak." ev_mode_start: name: "Car charger · Mode after a restart" - description: "Keep the last mode, or start in Off. A restart never changes the charger's current." + description: "Keep the last mode, or start in Off. In Solar a restart sets the charger to 0 A first, other modes leave its current." + ev_margin_w: + name: "Car charger · Sun kept back (W)" + description: "Solar: this much spare sun is never given to the car." + ev_start_min: + name: "Car charger · Start after (minutes)" + description: "Solar: the car starts after this long with enough spare sun." + ev_pause_min: + name: "Car charger · Pause after (minutes)" + description: "Solar: with too little sun the car holds 6 A this long, then pauses." auto_start: name: "Advanced · Start control on boot" description: "Off by default. Leave it off until the site is commissioned, so someone presses Start after each restart." diff --git a/goodwe_controller/translations/nl.yaml b/goodwe_controller/translations/nl.yaml index 064fd31..1b8fb00 100644 --- a/goodwe_controller/translations/nl.yaml +++ b/goodwe_controller/translations/nl.yaml @@ -281,7 +281,16 @@ configuration: description: "Terwijl de auto laadt. Aan: de batterijen dekken ze tot de piekreserve. Uit: de piekbewaking laat de auto buiten beschouwing, dus de auto alleen kan de piek bepalen." ev_mode_start: name: "Laadpaal · Modus na een herstart" - description: "De laatste modus houden, of starten in Uit. Een herstart verandert de stroom van de laadpaal nooit." + description: "De laatste modus houden, of starten in Uit. In Zon zet een herstart de laadpaal eerst op 0 A, andere modi laten haar stroom." + ev_margin_w: + name: "Laadpaal · Zon achtergehouden (W)" + description: "Zon: zoveel zonne-overschot krijgt de auto nooit." + ev_start_min: + name: "Laadpaal · Starten na (minuten)" + description: "Zon: de auto start na zo lang genoeg zonne-overschot." + ev_pause_min: + name: "Laadpaal · Pauzeren na (minuten)" + description: "Zon: met te weinig zon houdt de auto zo lang 6 A en pauzeert dan." auto_start: name: "Geavanceerd · Regeling starten bij opstarten" description: "Staat standaard uit. Laat het uit tot de installatie in dienst is, zodat iemand na elke herstart op Start drukt."