From 29480fda4754231621329c0e4527152ecfef1ab4 Mon Sep 17 00:00:00 2001 From: ems-agent Date: Tue, 17 Nov 2026 23:54:06 +0100 Subject: [PATCH] EV-05: car Solar mode (spare sun to the car, Batteries or Car first, cut first for the peak) Solar charges the car from the signed spare sun (car + battery charge - grid import), less the batteries' room (Batteries first) and the sun kept back, whole amps rounded down, at most one change per 30 s and only on 1 A. It starts after ev_start_min of enough sun, holds 6 A for ev_pause_min, then 0 A. Auto phases through EV-04's safe sequence (4.5 kW / 3 min up, 4.0 kW / 5 min down, one switch per 10 min). What the peak guard would ask the batteries for is taken off the car first, at once. Every way out of Solar ends at 0 A, written once; at shutdown before the inverters go to 0 W. - app/carmode.py: SolarPlan (pure) and SolarWriter (ManualWriter's one write site, its sequence and watch); spare_w, car_target_w, amps_for. - app/ctl_car.py: Solar inputs, the cut, the solar kWh, EV-15's grace for Solar's own 0 A, no "set by the car" for Solar; main.py: shutdown order. - Home card, HA select.goodwe_car_sun_first, sensor car_today_solar_kwh, three options with defaults, strings EN/NL, DOCS, DECISIONS, CHANGELOG. - test_ev05.py, test_ev05_long.py, tools/ev05_sun.py; test_ev03/ev04 checks that pinned "Solar is refused" / "three entities" updated. Co-Authored-By: Claude --- .gitea/ci/run-tests.sh | 3 +- goodwe_controller/CHANGELOG.md | 1 + .../DECISIONS/EV-05-solar-mode.md | 54 + goodwe_controller/DOCS.md | 74 +- goodwe_controller/app/carmode.py | 510 +++++- goodwe_controller/app/chargers.py | 16 +- goodwe_controller/app/ctl_car.py | 282 ++- goodwe_controller/app/ctl_cycle.py | 6 +- goodwe_controller/app/ctl_status.py | 19 +- goodwe_controller/app/homeview.py | 89 +- goodwe_controller/app/main.py | 10 +- goodwe_controller/app/messages.py | 27 + goodwe_controller/app/mqtt.py | 22 +- goodwe_controller/app/static/app.js | 12 +- goodwe_controller/app/static/index.html | 5 + goodwe_controller/app/ui_text/en.json | 24 +- goodwe_controller/app/ui_text/nl.json | 24 +- goodwe_controller/app/uilayout.py | 3 + goodwe_controller/app/validate.py | 11 + goodwe_controller/app/web.py | 2 +- goodwe_controller/config.yaml | 18 +- goodwe_controller/test_ev03.py | 12 +- goodwe_controller/test_ev04.py | 48 +- goodwe_controller/test_ev05.py | 1508 +++++++++++++++++ goodwe_controller/test_ev05_long.py | 421 +++++ goodwe_controller/tools/ev05_sun.py | 290 ++++ goodwe_controller/translations/en.yaml | 11 +- goodwe_controller/translations/nl.yaml | 11 +- 28 files changed, 3410 insertions(+), 103 deletions(-) create mode 100644 goodwe_controller/DECISIONS/EV-05-solar-mode.md create mode 100644 goodwe_controller/test_ev05.py create mode 100644 goodwe_controller/test_ev05_long.py create mode 100644 goodwe_controller/tools/ev05_sun.py 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."