Compare commits
11
Commits
EV-04
...
release-0.24.0
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
9a355144fc | ||
|
|
628bde8013 | ||
|
|
ff2eebe28b | ||
|
|
b12776c705 | ||
|
|
b86c0153cf | ||
|
|
269b89d6b0 | ||
|
|
646f61e730 | ||
|
|
a60342e4e8 | ||
|
|
50d5ae90d2 | ||
|
|
8efc385956 | ||
|
|
75ebe22a4d |
@@ -1,8 +1,124 @@
|
||||
# Changelog
|
||||
|
||||
### Not in a release yet
|
||||
## 0.24.0
|
||||
|
||||
- The *Car* card can now charge: choose **Manual** and set the current (6 A up to the charger limit) and 1 or 3 phases, on Home or from Home Assistant. The car is never slowed for the peak limit, the add-on says so instead of raising false peak alarms, and the batteries help cover it unless you switch that off. Off still writes nothing ([[EV-04]]).
|
||||
**A minor bump: the add-on can now charge the car (Manual mode), and the car alone no longer raises false peak alarms. Two new options were added, both with defaults, and none needs setting.**
|
||||
Two options were added (`ev_batt_cover` and `ev_mode_start`), none was removed or renamed, and no default changed (92 options, 90 before). **Existing installs need no option change:** the new options have defaults, and `ev_charger` is still off, so an install that does not use the car charger runs as 0.23.0 did. It is a minor bump because it adds a feature and new options; every saved setting still starts.
|
||||
|
||||
**The add-on can now charge the car.** This is the first version that writes to the car charger. On the *Car* card, choose **Manual** and set the current (6 A up to the charger limit) and 1 or 3 phases, on Home or from Home Assistant. **Off writes nothing.** The car is never slowed for the peak limit; the batteries help cover it unless you switch *Batteries help with the peak* off. **If your own automation in Home Assistant writes the same charger, switch it off before you choose Manual:** two writers fight over one setting. See "Car charger" in DOCS ([[EV-04]]).
|
||||
|
||||
**Car charger fixes.** When the car alone takes the batteries to the peak reserve, the add-on no longer says "Battery stopped limiting the peak"; a grey "Car over the peak limit" note says it instead, and the note stays steady instead of flickering. A change the add-on makes itself is no longer shown as "Something else changes the charger". A real overload of the house still raises the normal alarm ([[EV-10]], [[EV-11]], [[EV-12]]).
|
||||
|
||||
Contents of this release, in merge order since 0.23.0 (`b656091`):
|
||||
|
||||
| | |
|
||||
|---|---|
|
||||
| `75ebe22` | The add-on can charge the car: choose Manual on the *Car* card and set the current (6 A up to the charger limit) and 1 or 3 phases. Off writes nothing, the car is never slowed for the peak limit, and the batteries help cover it unless you switch that off. This is the first version that writes to the charger, so switch off any other automation that writes it ([[EV-04]], #257) |
|
||||
| `b86c015` | When the car alone takes the batteries to the peak reserve, there is no false "Battery stopped limiting the peak". The "Car over the peak limit" note stays steady, and the add-on's own change is not shown as "Something else changes the charger" ([[EV-10]], [[EV-11]], [[EV-12]], #258) |
|
||||
| `628bde8` | The false "Battery stopped limiting the peak" is now gone also when the batteries cover the car down to the reserve: the check counts the house alone. A real overload of the house still raises the alarm ([[EV-10]], #259, called EV-10b) |
|
||||
|
||||
|
||||
### Known issues
|
||||
|
||||
- A false "Battery is not keeping up" can still show when the peak guard pauses a maintenance charge ([[SAFETY-92]]).
|
||||
- A battery capped at a low limit with a perfectly flat reading can still trip the stale check ([[SAFETY-74]]).
|
||||
- A battery whose reading at rest is beyond about ±175 W is still not caught when it refuses ([[SAFETY-97]]).
|
||||
- The peak guard can still back off near the end of a 15-minute period when a meter reading is late, by less than 30 s. This is about the guard's discharge only; a grid charge is cut back since 0.19.2 ([[SAFETY-99]]).
|
||||
- Two inverters: the maintenance charge can switch on and off while the house is above the peak aim ([[SAFETY-88]]).
|
||||
- Two inverters: the "circulating" figure counts a battery's reading at rest ([[SAFETY-98]]).
|
||||
- Two inverters: a drain that starts during a big step in house use can send the other battery to full power, and about 1 kW goes to the grid for about 10 s ([[SAFETY-104]]).
|
||||
- Two inverters: when a battery comes back during a maintenance charge, the grid can step by several kW at once ([[SAFETY-101]]).
|
||||
- Two inverters: when a battery drops out during a solar surplus, the others can swing by up to 1.5 kW in a simulation ([[SAFETY-105]]).
|
||||
- Two inverters: after a drain ends, a change in house use can go unanswered for about 9 s, because some readings are old ([[SAFETY-106]]).
|
||||
- Two inverters: when one battery's level is missing, both batteries are held at 0 W, and for about 15 s the last command stays on ([[SAFETY-108]]).
|
||||
- Two inverters: if one battery's level stays missing for 12 h, the other battery's cycle can be marked failed, with a 7-day wait and a notice, though it is healthy. This comes from reading the code; it has not been seen on a site ([[MAINT-17]]).
|
||||
- When the 15-minute demand forecast sensor counts the battery's own charge, the maintenance charge runs at about half the power the peak limit leaves, so it takes about twice as long (seen on a site: about 1.2 kW instead of 2.5 kW; the peak limit was kept). At the start of a month, before a peak above the limit, that is about 2 kWh a night in a rig test: the cycle can reach its 36 h limit after about 4 nights and fail, and since 0.22.0 the other battery gets no grid charge on those nights ([[SAFETY-111]]).
|
||||
- One inverter: after a link drop, the battery's own safety stop to 0 W can be taken as a refusal, and the site stays at 0 W for up to 15 min ([[SAFETY-102]]).
|
||||
- After a Home Assistant restart, control still waits until Home Assistant has finished starting, which can take several minutes, though the readings are already there ([[SAFETY-115]]).
|
||||
- While Home Assistant is not answering, the page can list inverters as refusing commands and sensors as missing, and send you to Developer Tools, though they are fine ([[UX-37]]).
|
||||
- If Home Assistant hangs or stops, the page keeps saying "Waiting for Home Assistant" and never turns into an alarm ([[SAFETY-113]]).
|
||||
- Right after Home Assistant has started, the page can say for about 4 s that an inverter cannot be controlled, and the first command can come late ([[SAFETY-114]]).
|
||||
- After a Home Assistant restart, the controller status sensor can still say "running" while the add-on cannot control. It was seen once, and the cause is not known ([[SAFETY-116]]).
|
||||
- Battery modes on: after a planned top-up from the grid, the Batteries screen can say "Enough sun is forecast" ([[UX-32]]).
|
||||
- Battery modes on: the forecast line "we count on" can show more sun than the plan counts, because the plan takes house use off first ([[UX-33]]).
|
||||
- Battery modes on: before a planned top-up, the Today list shows a smaller "gives" amount than the plan will use; it grows as the charge happens ([[UX-34]]).
|
||||
- Two inverters, battery modes on: while the other battery is in its maintenance charge, a battery's card can say it charges from the grid while it stays at 0 W ([[OPT-18]]).
|
||||
- Two inverters, battery modes on: while a battery refuses to charge in a cheap run, the action log on the page gets about 8 lines an hour for its retries, and the page hint says "waiting for a better price" ([[UX-38]]).
|
||||
- A battery in a safety stop, or one the add-on cannot reach, can still be started for a cycle, and its drain then waits about 12 h and ends in a failed-cycle notice. This comes from reading the code; it has not been seen on a site ([[MAINT-19]]).
|
||||
- On the Settings page, the rows of the solar forecast lists are labelled "Phase 1", "Phase 2" instead of "Sensor 1", "Sensor 2" ([[UX-27]]).
|
||||
- In the solar forecast list, a blank or repeated row makes "source 2 of 2" count differently from the rows on the Settings page ([[UX-28]]).
|
||||
- The solar forecast message says "has no reading" also when the sensor shows a number that is too old or in the wrong unit ([[UX-29]]).
|
||||
- If you use only the forecast lists, two Settings notes sit on the single-sensor field, and one of them tells you to set that field ([[UX-30]]).
|
||||
- After a restart during a price outage, the "No prices" message can say "yet" when prices did come in earlier ([[UX-39]]).
|
||||
- On the new settings page, you cannot see whether a price service token is set. Check the Configuration tab ([[UX-41]]).
|
||||
- On the classic settings page, the first click on Save after editing a field can do nothing. Click again ([[UX-42]]).
|
||||
- A steady overload on a 1 s meter can warn, and send the Home Assistant notification, 2 or 3 times at the start of each 15-minute period instead of once. The peak limit is still kept ([[SAFETY-122]]).
|
||||
- A fixed tariff is priced once per hour, so a price window that starts or ends at :15, :30 or :45 gets the wrong price for part of that hour. Windows that start and end on the hour are right ([[TARIFF-23]]).
|
||||
- Step 6 of the setup wizard stays empty because of an error in the page, in English and in Dutch ([[UX-51]]).
|
||||
- On Dutch pages, refusal texts, the last-event line under the Home buttons, the installer details and the trading status sentences are still English, and a few Dutch texts read badly, such as "1 metingen geweigerd" ([[UX-52]]).
|
||||
- Some price texts say "hour" where the add-on acts on a 15-minute period, such as "cheapest hour" ([[UX-47]]).
|
||||
- After the add-on restarts, the Home price chart shows no price for the earlier part of today, and the setup check can say "12 of 24 hours", though the prices are known ([[UX-48]]).
|
||||
- With battery modes on and only batteries on "Leftover solar", the Home price chart can mark a cheap period where no battery charges ([[UX-49]]).
|
||||
- On a phone, the bars of the Home price chart are too thin to tap one 15-minute period. The arrow keys work ([[UX-50]]).
|
||||
- In the last second of a 15-minute period, being a few watts over the aim can make the peak guard ask a battery for full power for one second. When a charge ends on a period edge, the last-second give can fade out over about 10 s, and a rig test exported up to 7.4 kW for about 8 s ([[SAFETY-124]]).
|
||||
- During the night grid charge, a 15-minute period can end 6 to 14 W over the peak aim, because the battery charges harder than asked. This was seen in simulation; a rig test saw 2 to 8 W ([[OPT-35]]).
|
||||
- The test rig could not bring back the false peak alarm that [[SAFETY-126]] fixes, so that fix is shown in simulation only. Watch the notifications for a few nights ([[TEST-35]]).
|
||||
- The night cheap run is sized for the batteries' full charging power, not for what the peak limit leaves. Under a tight limit the run can end before the batteries reach their level, and Home can show a level they do not reach (79.9 % against a shown 95 % in a rig test) ([[OPT-25]]).
|
||||
- By day, a Leftover solar plan that has only a daily forecast figure counts the sun from now, not from when the figure was read. It counts about 22 % too much for a figure one hour old; the night plan is not affected ([[OPT-30]]).
|
||||
- The night charge can buy too much in a house that uses more at night than by day, such as one with a car charger or heat pump, and on a sunny day, because spare sun in one expensive hour does not count for the later ones ([[OPT-31]]).
|
||||
- A cheap run that has already started can overlap a new give run after a re-plan, so a battery can charge from the grid at the dearest price for part of an hour. This was seen in a test case, not on a site. Also in 0.19.2 ([[OPT-32]]).
|
||||
- If the solar forecast sensors stop updating before 17:00, as in winter or further north, there is no forecast from three hours after their last update until 20:00 ([[OPT-33]]).
|
||||
- With a forecast that gives only a daily total, the sun is spread an hour off on the two clock-change days after the change. The day's total is right ([[OPT-24]]).
|
||||
- The add-on learns the house's use only once a solar forecast is set, so a site that adds a forecast later waits one more day for its first plan ([[OPT-26]]).
|
||||
- Home says "No trading on price yet: no prices have arrived" when every battery is on Solar first, though the prices are shown ([[UX-55]]).
|
||||
- The Home plan header can say "Charges in the cheapest hour, gives power in the dearest" when Home draws no charge, and it says "hour" for 15-minute prices ([[UX-56]]).
|
||||
- While the peak guard holds back charging, Home hides the rest of the cheap run and gives no reason. The charge starts again when the guard lets go ([[UX-57]]).
|
||||
- With battery modes on and selling on, Home can draw a "Sells up to" block when the add-on judges the trade not worth it, and then it will not sell ([[UX-58]]).
|
||||
- Home, the plan and the Forecast tab stop drawing a battery's give at the trading floor, though control goes on giving down to the battery's cut-out ([[UX-59]]).
|
||||
- During a price outage, the Batteries screen says "Prices differ too little" and Home says "The price gap is too small" ([[UX-60]]).
|
||||
- With battery modes on and no meter, or a meter that is a Home Assistant entity, a grid charge is not possible and nothing says so ([[UX-61]]).
|
||||
- On the Batteries screen, a charge the add-on refused in a cheap run reads as "Saves its power for ...", for up to 15 minutes ([[UX-62]]).
|
||||
- A Leftover solar battery with no capacity set never charges from the grid when a solar forecast is set, and nothing warns about it ([[UX-63]]).
|
||||
- The "How the modes work" box on the Batteries screen does not describe Cheap hours only ([[UX-64]]).
|
||||
- With battery modes on, Settings still shows "Trade on the price spread", which the modes ignore. A site with modes on and no price source starts, and the Batteries screen says "No prices, so it follows the house" without pointing to Settings ([[UX-65]]).
|
||||
- With battery modes off and several equal prices in a row, Home and the Forecast tab draw one price quarter, while the add-on trades every quarter of the run ([[UX-67]]).
|
||||
- Late in the day, the Forecast tab's "now" line and last bars sit over the axis labels at the right edge ([[UX-68]]).
|
||||
- The Forecast tab's level curve charges at each battery's full rating. Under a peak limit the levels it draws are too high and a charge block can end early (54.6 % shown against 39.7 % in a rig test) ([[UX-70]]).
|
||||
- The peak forecast check says maintenance charging is not kept under the peak limit when no peak forecast is set, but since 0.19.2 it is ([[UX-73]]).
|
||||
- The peak guard row can show the same figure twice, such as "at this rate 3 500 W, over 3 500 W". Also in 0.19.2 ([[UX-74]]).
|
||||
- If the inverter's setpoint entity appears in Home Assistant after the add-on has started, the page keeps saying "Inverter control: not found in Home Assistant" and the batteries say "An alarm stopped control" until a restart, though control runs ([[UX-75]]).
|
||||
- In the last minute of a 15-minute period, with Home Assistant readings 30 s late, the period can end about 80 W over the peak aim and over the limit: 3 530 W against a 3 450 W aim and a 3 500 W limit in a rig test with a 2 kW load added 45 s before the end. The peak guard sees the load too late to hold it back ([[SAFETY-133]]).
|
||||
- With Home Assistant readings 10 s late, the grid charge in a cheap run can swing by several kW. In a test the add-on asked for an 8.7 kW charge (9.6 kW on 0.20.0) ([[SAFETY-132]]).
|
||||
- A plan rebuilt while the battery levels are missing for a moment can drop a cheap run that has not started yet, so the battery does not charge that day. Seen in a replay of real prices, where it cost about EUR 0.40 of extra grid use; the Leftover solar change in 0.20.1 no longer triggers it in those replays, but the cause stays ([[OPT-37]]).
|
||||
- On a 5 s meter, Home Assistant readings 10 s late are still not caught, and readings 15 s late only after about 4 minutes. Control now follows the meter more gently, so less goes to the grid: in a simulation with a changing load, 340 Wh became 189 Wh at 10 s late and 363 Wh became 296 Wh at 15 s late. In a rig test, 15 s late exported 13 to 19 % more than before ([[SAFETY-136]], [[SAFETY-134]]).
|
||||
- With readings 10 to 15 s late, the hold can end in the middle of the delay and the swing can come back. Seen in rig tests with a 2 s and a 5 s meter ([[SAFETY-134]]).
|
||||
- With readings 10 s late on a 1 s meter, the grid can still move between -422 and +340 W while the batteries are held. With a very long delay (30 to 90 s) the request can swing by about 900 W every few seconds. Seen in review tests ([[SAFETY-130]]).
|
||||
- A battery that answers very slowly (10 s or more) can be taken for late Home Assistant readings and held, and the page then blames Home Assistant. A GoodWe battery settles in about 6 s and this has not been seen on one ([[SAFETY-131]]).
|
||||
- The page row for late readings reads awkwardly in English ("Home Assistant readings show requests about N seconds late, so control holds the batteries"), and the Dutch text misses a word ([[UX-78]]).
|
||||
- When the add-on stops, a write that takes more than 2 s can still land after the 0 W, and the 30 s safety timer on the ESPHome board then sets 0 W. After the Stop button, a cycle that had already decided can send its share (560 to 670 W) just after the 0 W; the next cycle sends 0 W again ([[SAFETY-138]]).
|
||||
- In the last hour of a cheap run, Home can draw a battery's grid charge up to an hour past the time control stops charging it. It only draws too much, never too little ([[UX-79]]).
|
||||
- A tomorrow solar forecast sensor that reports just after midnight with yesterday's value can be used as the new day's forecast for up to 12 hours. This has not been seen on a site ([[OPT-39]]).
|
||||
- During a cheap-hours charge, at some 15-minute boundaries the add-on sends 0 W for one tick ("no trade (headroom)") and then goes on. Seen in a rig test, in 5 of 8 cases; once, with a frozen battery reading, it left a battery at 0 W until 23:45 ([[OPT-40]]).
|
||||
- While one battery's monthly cycle charges, the other battery's card on Home says "Saves its power for higher prices", and the plan still shows its grid charge in the cheap hours, though it will not charge ([[UX-80]]).
|
||||
- After a failed monthly cycle, the plan line shows the day the wait ends, such as 18 November, not when the cycle tries again, such as 19 November at 19:00 ([[MAINT-26]]).
|
||||
- At the start of a cheap window the peak guard can step once although the period is under the aim, and the step can land on a battery in its monthly charge. In a rig test it gave 1.7 to 2.3 kW for 6 s ([[SAFETY-140]]).
|
||||
- A grid charge at full power in the last seconds of a 15-minute period can run into the next period, where the peak guard cuts it back ([[SAFETY-139]]).
|
||||
- In a long real peak, the peak guard can end a 15-minute period up to 10 W over its aim, as 0.22.0 does (up to 31 W there). In a rig test the month's highest peak did not rise ([[SAFETY-141]]).
|
||||
- The peak reserve notification can be created again and again, 24 to 47 times in 2 hours in a rig test, while the guard holds a battery at its reserve. 0.22.0 does the same ([[MAINT-29]]).
|
||||
- When you switch the car charger off, its three sensors stay in Home Assistant with their last values. From reading the code, the PV power sensor does the same when it is switched off ([[TEL-19]]).
|
||||
- In Settings, the choice for no car charger says "None", while its help says "Off" ([[UX-81]]).
|
||||
- DOCS names the car's energy sensor `goodwe_car_today_kwh`, but Home Assistant creates it as `sensor.goodwe_car_energy_today` ([[TEL-20]]).
|
||||
- When the charger refuses a current, the Car card can show two amber rows: "Charger did not take it" and "Charger reading may be stuck" ([[EV-13]]).
|
||||
- In shadow mode, and after a phase change was given up, the Car card's *Why* line says what you set, not what the charger does ([[EV-14]]).
|
||||
- When the add-on changes the car's phases while the batteries are at the peak reserve, "Battery stopped limiting the peak" can show for a moment, with one notification ([[EV-15]]).
|
||||
- With *Batteries help with the peak* on, the Car card's *Why* line can switch between two wordings while the car is over the peak limit ([[EV-16]]).
|
||||
|
||||
### If you are crossing from a version older than 0.10.0
|
||||
|
||||
`## 0.10.0` below can refuse an old config: `slew_w` above its limit, and the
|
||||
withdrawn `price_provider` ids `engie_dynamic`, `totalenergies_dynamic` and
|
||||
`eneco_eddy`. Read it before you update. Run `tools/predeploy_check.py` with the
|
||||
bare options (`jq '.data.options'`) first.
|
||||
|
||||
## 0.23.0
|
||||
|
||||
|
||||
@@ -84,6 +84,46 @@ about 0.8 kW (40 Wh over the 180 s kept) the figure is believed; it cannot hide
|
||||
an overload that matters. (Round 2 had a 15 Wh slack that cancelled the 50 % rule
|
||||
up to 1.8 kW; the 40 Wh floor fixes that.)
|
||||
|
||||
## EV-10, EV-11, EV-12: the rig's three findings (EV-04 test F-1 to F-3)
|
||||
|
||||
- **The car is the cause when the alarm's own test says so, on the same
|
||||
landing** (EV-10). `car_cycle` (`_car_explains_alarm`) runs the alarm's test on
|
||||
the period as it is and on the period without the car's fresh, corroborated
|
||||
average (`car_exclude_alarm`, EV-10b below): the car explains the alarm only if it is true with the
|
||||
car and false without it. A saturated guard, and a floor with other batteries
|
||||
left, use `load_too_high` on the landing (the batteries give only what they
|
||||
still can). A floor that leaves nothing uses SAFETY-126's `misses_aim` (the
|
||||
batteries at 0 W from now on), which is latched for the quarter; the add-on keeps
|
||||
that latch twice, with and without the car, from the same readings. Both reset
|
||||
at a new quarter and when the guard stops wanting power, and they run every
|
||||
cycle, so the cover option does not touch them. This holds with the projection
|
||||
still under the aim (rig: 5888 W against 6000 W). A car of 0 W makes the two the
|
||||
same, so it explains nothing; a stale, stuck or uncorroborated figure is `None`,
|
||||
sets the latch without the car, and the normal alarms stand. There is no minimum
|
||||
car power: the comparison itself is what separates car from house.
|
||||
- **The period without the car is not clipped at 0 W** (EV-10b). The rig showed
|
||||
EV-10 failing: house 3 kW, car 11 kW, batteries 8.1 kW, aim 6 kW. The batteries
|
||||
give more than the house uses, so the house alone is an export; `car_exclude`
|
||||
clipped it at 0 W, `misses_aim` added the batteries' full 8.1 kW back, the
|
||||
"house needs the batteries" latch set early in the quarter, and the floor alarm
|
||||
could never be explained. `car_exclude_alarm` (alarm grading only) builds the
|
||||
house alone as: rest of the period `held - car_w`, keeping its sign, so
|
||||
`misses_aim` adds the batteries back to `held - car_w + batt` = the house; done
|
||||
part `max(0, done - car so far)` in Ws (no export is credited that only the
|
||||
car caused); landing `(done + max(held, 0) * left) / 900`. Without a fresh
|
||||
car reading it is the period as it is. `car_exclude` (the projection the guard
|
||||
sees with the cover off) is unchanged, with its clip.
|
||||
- **Steady row, no hold on the alarm** (EV-11). Cause: after the car's own quarter
|
||||
became the month peak, the aim sat on the grid it made (14.04 kW +-40 W), so
|
||||
the test crossed the aim every few seconds. `car_over` (row, card, notice) now
|
||||
stays on until the test has been false for `OVER_OFF_HOLD_S` = 180 s (longer than
|
||||
the gaps seen on the rig, 150 to 250 s at 50 s sampling, and shorter than a
|
||||
quarter) and a gap does not restart the 10 s
|
||||
on-count. `car_explains`, which the alarms read, has no hold.
|
||||
- **Our own write is ours until its mute ends** (EV-12). The mute of the tracker's
|
||||
own detector opens before the write and runs 15 s from when it returns, because
|
||||
the read-back reaches the cycle while the write still waits for it.
|
||||
|
||||
## The one write shadow mode allows
|
||||
|
||||
When the add-on has paused the car (0 A) for a phase change and has not yet
|
||||
|
||||
@@ -248,9 +248,14 @@ class ManualWriter:
|
||||
"to it until you change it.", cur, known[0])
|
||||
|
||||
async def _write(self, drv, a, was, now, tracker) -> bool:
|
||||
ok = await drv.write_current(a)
|
||||
self._stamp(now)
|
||||
tracker.begin_write() # EV-12: the read-back is ours
|
||||
try:
|
||||
ok = await drv.write_current(a)
|
||||
finally:
|
||||
self._stamp(now)
|
||||
tracker.end_write(self.last_done)
|
||||
tracker.note_write(now, was, a)
|
||||
tracker.end_write(self.last_done)
|
||||
self.log.append(("current", a, now, ok))
|
||||
if ok:
|
||||
self.last_a = a
|
||||
|
||||
@@ -716,6 +716,17 @@ class CarTracker:
|
||||
return None
|
||||
|
||||
# -- EV-04: the stuck-reading rule -------------------------------------------
|
||||
def begin_write(self) -> None:
|
||||
"""EV-12: a write of ours is in flight. Its read-back can reach the
|
||||
tracker before `note_write` runs (the write waits for it), so the mute
|
||||
is open until `end_write`."""
|
||||
self.mute_until = float("inf")
|
||||
|
||||
def end_write(self, now: float) -> None:
|
||||
"""EV-12: the write returned (or failed). The mute runs
|
||||
`OWN_WRITE_MUTE_S` from now, not from before the write."""
|
||||
self.mute_until = now + OWN_WRITE_MUTE_S
|
||||
|
||||
def note_write(self, now: float, was_a, to_a) -> None:
|
||||
"""The add-on wrote the current. Its own change is not "another
|
||||
writer" for `OWN_WRITE_MUTE_S`, and a write that moved the setpoint by
|
||||
|
||||
@@ -20,6 +20,10 @@ CAR_PEAK_KEY = "car_peak_q" # {quarter start iso: the car's average W}
|
||||
CAR_PEAK_MIN_W = 50.0 # a quarter the car hardly touched is not kept
|
||||
CAR_PEAK_KEEP = 3200 # about a month of quarters
|
||||
OVER_HOLD_S = peakguard.ALARM_HOLD_S
|
||||
# EV-11: the card, the row and Why stay on this long after the car stops being
|
||||
# the cause: longer than the gaps seen on the rig (150 to 250 s at 50 s
|
||||
# sampling) and shorter than a quarter, or until the session really ends.
|
||||
OVER_OFF_HOLD_S = 180.0
|
||||
|
||||
|
||||
class CarMixin:
|
||||
@@ -46,6 +50,10 @@ class CarMixin:
|
||||
self.car_explains = False # the car alone explains the excess
|
||||
self.car_over = False # ... held: the card and row say so
|
||||
self._car_over_since = None
|
||||
self._car_over_gone = None
|
||||
self._car_batt_prev = None
|
||||
self._car_need_real = self._car_need_excl = False # EV-10 latches
|
||||
self._car_latch_block = None
|
||||
self._car_over_notified = None # the session a notice was raised for
|
||||
self._car_session = 0
|
||||
self._car_prev_state = None
|
||||
@@ -245,6 +253,28 @@ class CarMixin:
|
||||
proj, projected_w=max(0.0, float(proj.projected_w) - avg),
|
||||
held_w=max(0.0, float(proj.held_w) - float(w)))
|
||||
|
||||
def car_exclude_alarm(self, proj, w):
|
||||
"""EV-10b: the period as it would be without the car, for grading the
|
||||
alarm. The house alone, the batteries giving only what the house
|
||||
would draw from them: the car's share of their power is not charged to
|
||||
the house. The rest of the period keeps its sign (`held - car`, an
|
||||
export while the batteries give more than the house uses), so
|
||||
`misses_aim` adds the batteries back to exactly the house. What is
|
||||
already done is clipped at 0 Ws: no export is credited for power only
|
||||
the car asked for. Unchanged without a fresh car reading."""
|
||||
if proj is None or w is None or proj.block_start is None:
|
||||
return proj
|
||||
avg = self.car_avg_w(proj, w)
|
||||
left = max(0.0, QUARTER_S - float(proj.elapsed_s))
|
||||
held = float(proj.held_w)
|
||||
done_ws = QUARTER_S * float(proj.projected_w) - max(held, 0.0) * left
|
||||
car_ws = avg * QUARTER_S - float(w) * left # the car so far
|
||||
held_x = held - float(w)
|
||||
return dataclasses.replace(
|
||||
proj, held_w=held_x,
|
||||
projected_w=(max(0.0, done_ws - car_ws)
|
||||
+ max(held_x, 0.0) * left) / QUARTER_S)
|
||||
|
||||
def car_cycle(self, real_proj, guard, target_w, now_utc) -> None:
|
||||
"""After the guard has decided: does the car alone explain the excess?
|
||||
`real_proj` is the projection WITH the car, whatever the guard saw."""
|
||||
@@ -253,28 +283,84 @@ class CarMixin:
|
||||
self._car_quarter(real_proj, w, mono)
|
||||
self._car_session_tick(mono)
|
||||
explains = over = False
|
||||
if w is not None and real_proj is not None and target_w is not None \
|
||||
if real_proj is not None and target_w is not None \
|
||||
and real_proj.block_start is not None:
|
||||
# The car explains the excess when the house alone would land the
|
||||
# period under the aim: what the car takes over the whole period
|
||||
# (`car_avg_w`) is at least how far the projection is over it.
|
||||
ex = float(real_proj.projected_w) - float(target_w)
|
||||
beyond = ex > 0.0 and self.car_avg_w(real_proj, w) >= ex
|
||||
# EV-10: every cycle, so the latches do not depend on the option.
|
||||
graded = self._car_explains_alarm(real_proj, guard, target_w, w)
|
||||
if self.car_cover:
|
||||
explains = bool(
|
||||
beyond and guard is not None
|
||||
and (guard.saturated or guard.floor_limited))
|
||||
over = explains
|
||||
else:
|
||||
over = beyond
|
||||
explains = over = graded
|
||||
elif w is not None:
|
||||
ex = float(real_proj.projected_w) - float(target_w)
|
||||
over = ex > 0.0 and self.car_avg_w(real_proj, w) >= ex
|
||||
self.car_explains = explains
|
||||
# EV-11: on once the condition has stood for OVER_HOLD_S, a short gap
|
||||
# in it not starting that count again; off only after it has been gone
|
||||
# for OVER_OFF_HOLD_S. `car_explains` (the alarm decision) has no hold.
|
||||
if over:
|
||||
self._car_over_gone = None
|
||||
if self._car_over_since is None:
|
||||
self._car_over_since = mono
|
||||
held = mono - self._car_over_since >= OVER_HOLD_S
|
||||
if mono - self._car_over_since >= OVER_HOLD_S:
|
||||
self.car_over = True
|
||||
else:
|
||||
self._car_over_since, held = None, False
|
||||
self.car_over = held
|
||||
if self._car_over_gone is None:
|
||||
self._car_over_gone = mono
|
||||
if mono - self._car_over_gone >= OVER_OFF_HOLD_S:
|
||||
self.car_over, self._car_over_since = False, None
|
||||
self._car_over_gone = None
|
||||
|
||||
def _car_explains_alarm(self, real_proj, guard, target_w, w) -> bool:
|
||||
"""EV-10: is the alarm's own test true with the car and false without
|
||||
its fresh, corroborated share (`car_exclude_alarm`), on the same landing? The
|
||||
tests are the alarms': a saturated guard and a floor with other
|
||||
batteries left are graded by `load_too_high` on where the period lands
|
||||
(SAFETY-81 / 87); a floor that leaves nothing is graded by SAFETY-126's
|
||||
`misses_aim` (the batteries at 0 W from now on), latched for the
|
||||
quarter. That latch is kept here twice, on the period as it is
|
||||
(`_car_need_real`) and without the car (`_car_need_excl`), from the
|
||||
same `misses_aim` and the same batteries reading. Both reset at a new
|
||||
quarter and when the guard no longer wants power, whatever the cover
|
||||
option says (this runs every cycle). A car that is 0 W, or untrusted
|
||||
(`w` None sets the second latch), makes the two equal and explains
|
||||
nothing."""
|
||||
batt, prev = self.site_batt_w, self._car_batt_prev
|
||||
self._car_batt_prev = batt
|
||||
wants = bool(guard is not None and guard.engaged
|
||||
and guard.blind is None
|
||||
and (guard.wanted_w or 0.0) > 0.0)
|
||||
if real_proj.block_start != self._car_latch_block:
|
||||
self._car_latch_block = real_proj.block_start
|
||||
self._car_need_real = self._car_need_excl = False
|
||||
if not wants:
|
||||
self._car_need_real = self._car_need_excl = False
|
||||
if batt is not None and prev is not None:
|
||||
batt = min(float(batt), float(prev))
|
||||
excl = self.car_exclude_alarm(real_proj, w)
|
||||
if wants:
|
||||
if batt is None:
|
||||
self._car_need_real = self._car_need_excl = True
|
||||
else:
|
||||
self._car_need_real = self._car_need_real or \
|
||||
peakguard.misses_aim(real_proj, batt_w=batt,
|
||||
target_w=target_w)
|
||||
self._car_need_excl = self._car_need_excl or w is None or \
|
||||
peakguard.misses_aim(excl, batt_w=batt, target_w=target_w)
|
||||
if w is None or batt is None or not wants \
|
||||
or not (guard.saturated or guard.floor_limited):
|
||||
return False
|
||||
if guard.saturated:
|
||||
rating = self.site_rating_w
|
||||
elif (guard.floor_w or 0.0) > 0.0 and guard.able_w is not None:
|
||||
rating = guard.able_w
|
||||
else:
|
||||
return bool(not guard.within_aim and self._car_need_real
|
||||
and not self._car_need_excl)
|
||||
|
||||
def high(p):
|
||||
return peakguard.load_too_high(
|
||||
p, batt_w=batt, ceiling_w=guard.ceiling_w,
|
||||
achievable_w=rating)
|
||||
return bool(high(real_proj) and not high(excl))
|
||||
|
||||
def _car_session_tick(self, mono) -> None:
|
||||
"""A charging session is a plug-in: the state goes from no car to a
|
||||
@@ -283,6 +369,9 @@ class CarMixin:
|
||||
if s in (chargers.NONE_,) and self._car_prev_state not in (
|
||||
None, chargers.NONE_):
|
||||
self._car_over_notified = None
|
||||
# The session is over: that is a real end, with no hold.
|
||||
self.car_over = False
|
||||
self._car_over_since = self._car_over_gone = None
|
||||
if s not in (chargers.NONE_, None) and self._car_prev_state in (
|
||||
chargers.NONE_, None):
|
||||
self._car_session += 1
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
name: GoodWe RS485 Controller
|
||||
version: "0.23.0"
|
||||
version: "0.24.0"
|
||||
slug: goodwe_controller
|
||||
description: >-
|
||||
Drives a GoodWe ES/BP battery inverter over its RS485 EMS port by sending it a
|
||||
|
||||
@@ -0,0 +1,562 @@
|
||||
"""EV-10, EV-11, EV-12: three rig findings of EV-04's test (F-1, F-2, F-3).
|
||||
`python3 -B test_ev10.py`
|
||||
|
||||
1. EV-10: the car alone takes the batteries to the peak reserve while the period
|
||||
is still projected UNDER the aim: no alarm, one grey notice. A stuck car
|
||||
figure with a house overload, and a house-only drain, still alarm. Mutant:
|
||||
an uncorroborated car figure in the "period without the car" test.
|
||||
2. EV-11: the grey row and the Car Why do not flicker while the car keeps the
|
||||
period over the limit; a real end clears them after OVER_OFF_HOLD_S. The
|
||||
alarm decision (`car_explains`) has no hold.
|
||||
3. EV-12: the add-on's own write, and Off within 15 s of it, is never "another
|
||||
writer"; a real outside change afterwards still shows the row.
|
||||
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import dataclasses
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, os.path.join(HERE, "tools"))
|
||||
|
||||
from app import ctl_car, homeview, chargers as CH # noqa: E402
|
||||
from app.main import Controller # noqa: E402
|
||||
from app import freshness # noqa: E402
|
||||
from chargersim import FakeHa, SimCharger # noqa: E402
|
||||
import ev04_peak as P # noqa: E402
|
||||
import safety81_sim as s81 # noqa: E402
|
||||
import opt11_identity as rig # 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()))
|
||||
|
||||
|
||||
LOG = _Log()
|
||||
_lg = logging.getLogger("goodwe")
|
||||
_lg.addHandler(LOG)
|
||||
_lg.setLevel(logging.DEBUG)
|
||||
_lg.propagate = False
|
||||
|
||||
# =========================================================================== #
|
||||
print("1. EV-10: THE CAR ALONE TAKES THE BATTERIES TO THE RESERVE (F-1)")
|
||||
# =========================================================================== #
|
||||
CAP = 4500.0 # the aim is 4450 W (50 W margin)
|
||||
HOUSE = 1100.0
|
||||
|
||||
|
||||
def at_reserve(plant, c):
|
||||
"""The batteries reach the peak reserve late in the period, and the house
|
||||
eases a little: the period is still projected UNDER the aim."""
|
||||
plant.soc = 19.0
|
||||
plant.load = lambda at: 780.0 + plant.ch.power_w
|
||||
|
||||
|
||||
def alarms(r):
|
||||
return P.ids(r, *P.ALARMS)
|
||||
|
||||
|
||||
UNDER = [] # (second, projected W, aim W) while floor-limited
|
||||
|
||||
|
||||
def watch(first, fn):
|
||||
"""Events for seconds 840 to 894: `fn` at `first`, and a note of every
|
||||
cycle in which the guard is floor-limited."""
|
||||
def note(plant, c):
|
||||
g = c.peak_guard
|
||||
if g is not None and g.floor_limited:
|
||||
UNDER.append((plant.t, g.projected_w, g.target_w))
|
||||
ev = {t: note for t in range(first - 10, 895)}
|
||||
ev[first] = lambda plant, c: (fn(plant, c), note(plant, c))
|
||||
return ev
|
||||
|
||||
|
||||
LOG.rec.clear()
|
||||
r10 = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
|
||||
cap=CAP, phases=1, events=watch(850, at_reserve))
|
||||
ERR10 = [m for lv, m in LOG.rec if lv in ("ERROR", "WARNING")]
|
||||
check("PRECONDITION: the guard was floor-limited with the projection UNDER "
|
||||
"the aim (the rig's 5888 W against 6000 W)",
|
||||
any(p < a for _t, p, a in UNDER))
|
||||
check("the car alone: no 'Load too high', no 'Battery stopped limiting the "
|
||||
"peak'", alarms(r10) == [])
|
||||
rows10 = {x["id"]: x for x in r10["c"].checks()}
|
||||
check("...no red row; the grey 'Car over the peak limit' row says it",
|
||||
rows10["peak_guard"]["ok"] is True
|
||||
and not [x for x in r10["c"].checks()
|
||||
if x["ok"] is False and not x["warn"]]
|
||||
and rows10.get("car_over", {}).get("ok") is True)
|
||||
check("...one grey notice for the session", len(P.ids(r10, P.OVER)) == 1)
|
||||
check("...no ERROR (or WARNING) line was logged for it", ERR10 == [])
|
||||
|
||||
|
||||
def house_stuck(plant, c):
|
||||
at_reserve(plant, c)
|
||||
plant.ch.freeze() # the reading stops moving
|
||||
plant.ch.unplug() # the car really goes
|
||||
plant.load = lambda at: 9000.0 + plant.ch.power_w
|
||||
asyncio.get_event_loop().create_task(c.handle_action("car_current",
|
||||
value=10))
|
||||
|
||||
|
||||
r10s = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
|
||||
cap=CAP, phases=1, events=watch(850, house_stuck))
|
||||
check("a stuck car figure and a house overload at the reserve: the normal "
|
||||
"alarm still fires",
|
||||
[n for _t, n in alarms(r10s)]
|
||||
and all(n in P.ALARMS for _t, n in alarms(r10s)))
|
||||
|
||||
|
||||
def house_drain(plant, c):
|
||||
plant.soc = 19.0
|
||||
plant.load = lambda at: 12000.0 + plant.ch.power_w
|
||||
|
||||
|
||||
r10h = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
|
||||
cap=CAP, phases=1, user_a=6, setpoint=6,
|
||||
events=watch(600, house_drain))
|
||||
check("a house-only drain to the reserve with the car charging little: the "
|
||||
"normal alarm still fires",
|
||||
alarms(r10h) != [] and not r10h["c"].car_explains)
|
||||
|
||||
|
||||
|
||||
def plug_late(plant, c):
|
||||
plant.ch.plug_in()
|
||||
|
||||
|
||||
def house_reserve(plant, c):
|
||||
plant.soc = 19.0
|
||||
plant.load = lambda at: 3075.0 + plant.ch.power_w
|
||||
|
||||
|
||||
def swapped_events():
|
||||
ev = watch(850, house_reserve)
|
||||
ev[800] = plug_late
|
||||
return ev
|
||||
|
||||
|
||||
def swapped(mode):
|
||||
return P.drive(s81.constant(6000.0), dur=895, rating=12000.0, soc=60.0,
|
||||
cap=CAP, phases=1, user_a=6, setpoint=6, mode=mode,
|
||||
plug=False, events=swapped_events())
|
||||
|
||||
|
||||
r10x = swapped("manual")
|
||||
r10xo = swapped("off")
|
||||
check("PRECONDITION (review): a 6 kW HOUSE drains the batteries, the car "
|
||||
"plugs in late (a small share); the projection is under the aim at the "
|
||||
"reserve, and Off raises the alarm", alarms(r10xo) != []
|
||||
and any(p < a for _t, p, a in UNDER))
|
||||
check("the house drains the batteries and a small car is plugged in: the "
|
||||
"normal alarm still fires in Manual", alarms(r10x) != [])
|
||||
|
||||
r10off = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
|
||||
cap=CAP, phases=1, mode="off", events=watch(850, at_reserve))
|
||||
check("PRECONDITION: Off, the same case raises the normal alarm (the false "
|
||||
"alarm Manual must not make)", alarms(r10off) != [])
|
||||
|
||||
|
||||
# a direct unit of the rule: the car's average, the period without it
|
||||
class _Car(ctl_car.CarMixin):
|
||||
def __init__(self, cover=True, w=3700.0):
|
||||
self.o = {"ev_batt_cover": cover}
|
||||
self.w = w
|
||||
self._now = 0.0
|
||||
self.site_batt_w, self.site_rating_w = 300.0, 5000.0
|
||||
self.car_init({}, type("S", (), {"data": {}, "set": lambda s, k, v: 0})())
|
||||
|
||||
def car_now(self):
|
||||
return self._now
|
||||
|
||||
def car_alarm_w(self):
|
||||
return self.w
|
||||
|
||||
class car: # noqa: N801
|
||||
@staticmethod
|
||||
def status(*_a):
|
||||
return "charging"
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class _Proj:
|
||||
projected_w: float
|
||||
elapsed_s: float = 850.0
|
||||
held_w: float = 0.0
|
||||
block_start: object = datetime(2026, 11, 16, 20, 0, tzinfo=timezone.utc)
|
||||
|
||||
def __post_init__(self):
|
||||
self.held_w = self.projected_w
|
||||
|
||||
|
||||
class _G:
|
||||
def __init__(self, floor=True, sat=False, within_aim=False):
|
||||
self.floor_limited, self.saturated = floor, sat
|
||||
self.floor_w, self.able_w, self.ceiling_w = 0.0, None, 4500.0
|
||||
self.engaged, self.blind, self.wanted_w = True, None, 300.0
|
||||
self.within_aim = within_aim
|
||||
|
||||
|
||||
def explains(proj_w, car_w, *, floor=True, cover=True, car_so_far_w=None,
|
||||
within_aim=False, earlier=(), block=0, c=None, at=0.0):
|
||||
"""One cycle of `car_cycle` on a stub; `earlier` are projections of
|
||||
cycles before it in the same quarter (they latch SAFETY-126's test)."""
|
||||
c = c or _Car(cover, car_w)
|
||||
c.w = car_w
|
||||
for k, e in enumerate(tuple(earlier) + (proj_w,)):
|
||||
p = _Proj(e)
|
||||
p.block_start = p.block_start + timedelta(minutes=15 * block)
|
||||
c._now = at - len(earlier) + k
|
||||
c._carq = {"key": p.block_start,
|
||||
"ws": ((car_w or 0.0) if car_so_far_w is None else car_so_far_w)
|
||||
* p.elapsed_s, "mono": c._now}
|
||||
c.car_cycle(p, _G(floor, within_aim=within_aim), 4450.0, None)
|
||||
return c.car_explains
|
||||
|
||||
|
||||
check("rule: the alarm's test is true with the car (4468 W, the batteries "
|
||||
"at 0 W land 4485 W) and false without it (768 W): the car explains it, "
|
||||
"with the projection under the aim", explains(4468.0, 3700.0))
|
||||
check("rule: under the aim, the quarter's test latched by the car's share "
|
||||
"(4600 W earlier), the car explains the alarm (the positive under-aim "
|
||||
"case; a single 4300 W cycle has no landing miss to explain, so it "
|
||||
"needs the earlier cycle)", explains(4300.0, 3700.0, earlier=(4600.0,)))
|
||||
check("rule: where the alarm would not fire anyway nothing is explained",
|
||||
not explains(4300.0, 3700.0, within_aim=True))
|
||||
check("rule: without the car it is still over the aim: the car does not "
|
||||
"explain it", not explains(9000.0, 3700.0))
|
||||
check("rule: no car power, no explanation", not explains(4300.0, 0.0))
|
||||
check("rule: ...also when the test was latched earlier in the quarter",
|
||||
not explains(4300.0, 0.0, earlier=(4600.0,))
|
||||
and not explains(9000.0, 0.0))
|
||||
check("rule: an untrusted car figure (None) explains nothing",
|
||||
not explains(4300.0, None, earlier=(4600.0,)))
|
||||
# the latches: per quarter, and independent of the cover option
|
||||
c4 = _Car(True, 3700.0)
|
||||
explains(9000.0, 3700.0, c=c4, block=0) # the house needs it: latched
|
||||
check("latch: in the same quarter the house need stays latched, so the car "
|
||||
"does not explain", not explains(4300.0, 3700.0, c=c4, block=0, at=10.0))
|
||||
check("latch: a new quarter starts clean: the car alone explains it again",
|
||||
explains(4300.0, 3700.0, c=c4, block=1, at=1000.0,
|
||||
earlier=(4600.0,)))
|
||||
c5 = _Car(False, 3700.0) # cover OFF
|
||||
explains(9000.0, 3700.0, c=c5, block=0) # the house needs it
|
||||
c5.o["ev_batt_cover"] = True # ... and the option flips
|
||||
check("latch: the option flipping to ON does not lose a house need seen "
|
||||
"while it was off", not explains(4300.0, 3700.0, c=c5, block=0, at=10.0))
|
||||
c6 = _Car(True, 3700.0)
|
||||
explains(9000.0, 3700.0, c=c6, block=0)
|
||||
c6.o["ev_batt_cover"] = False
|
||||
explains(4300.0, 3700.0, c=c6, block=0, at=10.0)
|
||||
c6.o["ev_batt_cover"] = True
|
||||
check("latch: ... nor does flipping it off and on again",
|
||||
not explains(4300.0, 3700.0, c=c6, block=0, at=20.0))
|
||||
|
||||
check("rule: the guard is not floor-limited or saturated: nothing to explain",
|
||||
not explains(4300.0, 3700.0, floor=False))
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n2. EV-11: THE 'CAR OVER THE PEAK LIMIT' ROW DOES NOT FLICKER (F-2)")
|
||||
# =========================================================================== #
|
||||
# The cause (rig p7off 21:18 to 21:45, plant.csv): after 21:15 the car's own
|
||||
# quarter (14.0 kW) was the month peak, so the aim was that quarter's average
|
||||
# and the grid of the next ones (14.04 kW, +-40 W of noise) sat ON it. The
|
||||
# projection crossed the aim every few seconds, `ex > 0` came and went, and
|
||||
# `car_over` followed it with no hold on the way off.
|
||||
|
||||
|
||||
def over_run(c, secs, proj_of, w_of=lambda t: 11000.0, t0=0.0, target=14000.0,
|
||||
cover=False):
|
||||
"""Run `car_cycle` once a second; returns (car_over, car_explains) per second."""
|
||||
out = []
|
||||
for k in range(secs):
|
||||
t = t0 + k
|
||||
c._now = t
|
||||
c.w = w_of(t)
|
||||
p = _Proj(proj_of(t), elapsed_s=300.0 + (t % 400))
|
||||
c._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s,
|
||||
"mono": t}
|
||||
c.car_cycle(p, _G(True), target, None)
|
||||
out.append((c.car_over, c.car_explains))
|
||||
return out
|
||||
|
||||
|
||||
def noisy(t):
|
||||
"""The projection straddles the aim: +-40 W, a new value every 7 s."""
|
||||
return 14000.0 + (40.0 if int(t // 7) % 2 else -40.0) * (1 + (int(t) % 3))
|
||||
|
||||
|
||||
c11 = _Car(cover=False)
|
||||
o11 = over_run(c11, 1200, noisy)
|
||||
flips = sum(1 for a, b in zip(o11, o11[1:]) if a[0] != b[0])
|
||||
check("while the car keeps the period at the limit the row stays on: one "
|
||||
"switch on in 20 minutes, none off", flips == 1 and len(o11) == 1200 and o11[-1][0] is True)
|
||||
check("it turns on after the existing 10 s hold, not later than the first "
|
||||
"10 s the condition has stood (a gap does not restart the count)",
|
||||
next((i for i, x in enumerate(o11) if x[0]), 10**6) <= 25)
|
||||
|
||||
# the condition on its own, for the PRECONDITION: the same input flips
|
||||
c11o = _Car(cover=False)
|
||||
raw = []
|
||||
for k in range(1200):
|
||||
c11o._now = float(k)
|
||||
p = _Proj(noisy(k), elapsed_s=300.0 + (k % 400))
|
||||
c11o._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s, "mono": k}
|
||||
ex = p.projected_w - 14000.0
|
||||
raw.append(ex > 0.0 and c11o.car_avg_w(p, 11000.0) >= ex)
|
||||
raw_flips = sum(1 for a, b in zip(raw, raw[1:]) if a != b)
|
||||
check("PRECONDITION: the condition itself flips many times in those 20 "
|
||||
"minutes", raw_flips > 20)
|
||||
|
||||
# a real end: the car stops (no trusted power) after 600 s
|
||||
c11e = _Car(cover=False)
|
||||
o11e = over_run(c11e, 1000, lambda t: 14500.0,
|
||||
w_of=lambda t: 11000.0 if t < 600 else None)
|
||||
off_at = next((i for i, x in enumerate(o11e) if i > 600 and not x[0]), -1)
|
||||
check("a real end: the row stays for OVER_OFF_HOLD_S (180 s) and then goes",
|
||||
off_at == 600 + int(ctl_car.OVER_OFF_HOLD_S)
|
||||
and not any(x[0] for x in o11e[off_at:]))
|
||||
o11r = over_run(c11e, 100, lambda t: 14500.0, t0=1000.0)
|
||||
check("it comes back after the usual 10 s if the condition returns after "
|
||||
"it went", len(o11r) == 100 and o11r[9][0] is False and o11r[10][0] is True)
|
||||
|
||||
# the alarm decision has no hold: a real house overload is never delayed
|
||||
c11a = _Car(cover=True)
|
||||
o11a = over_run(c11a, 60, lambda t: 4300.0, target=4450.0)
|
||||
check("decision 1 on: the car explains it at once (no hold)",
|
||||
len(o11a) == 60 and o11a[0][1] is True)
|
||||
c11a.w = None # the figure is not trusted
|
||||
c11a._now = 61.0
|
||||
c11a.car_cycle(_Proj(4300.0), _G(True), 4450.0, None)
|
||||
check("...and the moment the car figure is not trusted it explains nothing, "
|
||||
"so the normal alarms stand at once (the grey row may stay)",
|
||||
c11a.car_explains is False)
|
||||
|
||||
# the whole thing on the real controller: the Why does not flicker either
|
||||
def p7_like(plant, c):
|
||||
plant.load = lambda at: 3000.0 + plant.ch.power_w
|
||||
|
||||
|
||||
r11 = P.drive(s81.constant(HOUSE), dur=700, rating=2000.0, soc=60.0, cap=CAP,
|
||||
phases=3, opts={"ev_batt_cover": False})
|
||||
ov = [s[2] for s in r11["snaps"]]
|
||||
check("real controller, cover off, an 11 kW car: the flag is steady once on",
|
||||
sum(1 for a, b in zip(ov, ov[1:]) if a != b) <= 1 and ov[-1] is True)
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n3. EV-12: OUR OWN WRITE IS NOT ANOTHER WRITER (F-3)")
|
||||
# =========================================================================== #
|
||||
CLOCK = [1000.0]
|
||||
freshness.monotonic = lambda: CLOCK[0]
|
||||
SET = "number.wallbox_power_connector_max_current_socket_1"
|
||||
BASE = {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
|
||||
"soc_entity": "sensor.soc", "batt_entity": "sensor.batt",
|
||||
"meter_source": "off", "max_w": 5000, "gain": 0.6, "slew_w": 500,
|
||||
"deadband_w": 15, "target_grid_w": 0, "step_w": 10, "heartbeat_s": 10,
|
||||
"stale_input_s": 15, "shadow_mode": "off", "peak_cap_w": 3500,
|
||||
"pv_entities": ["sensor.pv"], "ev_charger": "alfen_ha", "ev_max_a": 16,
|
||||
"ev_phases": "auto", "ev_current_entity": SET}
|
||||
|
||||
|
||||
class _Store:
|
||||
def __init__(self):
|
||||
self.data = {}
|
||||
|
||||
def set(self, k, v):
|
||||
self.data[k] = v
|
||||
|
||||
def get(self, k, d=None):
|
||||
return self.data.get(k, d)
|
||||
|
||||
def set_time(self, k, v):
|
||||
self.data[k] = v.isoformat()
|
||||
|
||||
def get_time(self, k):
|
||||
v = self.data.get(k)
|
||||
return None if v is None else datetime.fromisoformat(v)
|
||||
|
||||
|
||||
class _Pub:
|
||||
enabled = False
|
||||
|
||||
def publish(self, v):
|
||||
pass
|
||||
|
||||
def close(self):
|
||||
pass
|
||||
|
||||
|
||||
class Site(FakeHa):
|
||||
def __init__(self, charger):
|
||||
super().__init__(charger, None)
|
||||
|
||||
async def limits(self, _e):
|
||||
return (-5000.0, 5000.0, 1.0)
|
||||
|
||||
def _all(self):
|
||||
out = super()._all()
|
||||
for eid, val, unit in (("sensor.grid", 800.0, "W"),
|
||||
("sensor.soc", 50.0, "%"),
|
||||
("sensor.batt", 0.0, "W"),
|
||||
("sensor.pv", 2000.0, "W")):
|
||||
out[eid] = {"entity_id": eid, "state": str(val),
|
||||
"attributes": {"unit_of_measurement": unit}}
|
||||
return out
|
||||
|
||||
async def number(self, entity_id, invert=False):
|
||||
s = self._all().get(entity_id)
|
||||
try:
|
||||
v = float(s["state"])
|
||||
except (TypeError, ValueError, KeyError):
|
||||
return None
|
||||
return -v if invert else v
|
||||
|
||||
async def set_number(self, entity_id, value):
|
||||
return await super().set_number(entity_id, float(value))
|
||||
|
||||
|
||||
class World:
|
||||
"""A real Controller on the charger model. While a write waits for its
|
||||
read-back, the controller's own reading goes on (as in production, where
|
||||
the cycle runs while the writer task waits): that is how the read-back of
|
||||
our own write reaches the tracker BEFORE the write returns."""
|
||||
|
||||
def __init__(self, setpoint=10):
|
||||
self.sim = SimCharger(setpoint_a=setpoint)
|
||||
self.sim.plug_in()
|
||||
self.sim.lag_s = 2.0 # the rig's read-back lag
|
||||
self.sim.phases_allowed = 1
|
||||
self.t = 1000.0
|
||||
CLOCK[0] = self.t
|
||||
self.c = Controller(dict(BASE), Site(self.sim), _Store(), _Pub(),
|
||||
stop=asyncio.Event())
|
||||
self.c.auto = True
|
||||
self.c.dev_min, self.c.dev_max = -5000.0, 5000.0
|
||||
self.drv = self.c.charger
|
||||
self.drv._sleep = self.sleep
|
||||
self.drv._clock = lambda: CLOCK[0]
|
||||
|
||||
async def sleep(self, s):
|
||||
self.sim.tick(s)
|
||||
self.t += s
|
||||
CLOCK[0] = self.t
|
||||
await self.c.read_inputs(now_mono=self.t) # the cycle reads on
|
||||
|
||||
async def step(self, n=1):
|
||||
for _ in range(n):
|
||||
self.sim.tick(1.0)
|
||||
self.t += 1.0
|
||||
CLOCK[0] = self.t
|
||||
await self.c.read_inputs(now_mono=self.t)
|
||||
await self.c.cycle()
|
||||
await self.c.car_settle()
|
||||
|
||||
def rows(self):
|
||||
return {r["id"]: r for r in self.c.checks()}
|
||||
|
||||
|
||||
async def own_then_off(wait):
|
||||
w = World()
|
||||
await w.step(3)
|
||||
await w.c.handle_action("car_mode", value="manual")
|
||||
await w.c.handle_action("car_current", value=12)
|
||||
await w.step(wait)
|
||||
await w.c.handle_action("car_mode", value="off")
|
||||
await w.step(40)
|
||||
return w
|
||||
|
||||
|
||||
w12 = asyncio.run(own_then_off(2))
|
||||
check("PRECONDITION: the add-on wrote 12 A and the charger took it",
|
||||
w12.sim.readback_a == 12 and len(w12.sim.writes("current")) == 1)
|
||||
check("our own write, then Off 2 s later: no 'Something else changes the "
|
||||
"charger'", "charger_writer" not in w12.rows()
|
||||
and w12.c.car.writer_at_utc is None)
|
||||
w12b = asyncio.run(own_then_off(14))
|
||||
check("...and 14 s later (inside the 15 s)", "charger_writer" not in
|
||||
w12b.rows() and w12b.c.car.writer_at_utc is None)
|
||||
|
||||
|
||||
async def own_then_outside():
|
||||
w = await own_then_off(2)
|
||||
w.sim.set_current(7) # somebody else, afterwards
|
||||
await w.step(3)
|
||||
early = "charger_writer" in w.rows()
|
||||
await w.step(30)
|
||||
return early, "charger_writer" in w.rows()
|
||||
|
||||
|
||||
early12, late12 = asyncio.run(own_then_outside())
|
||||
check("an outside change after that still shows the row (within 30 s)",
|
||||
late12 is True)
|
||||
|
||||
|
||||
async def manual_own():
|
||||
w = World()
|
||||
await w.step(3)
|
||||
await w.c.handle_action("car_mode", value="manual")
|
||||
await w.c.handle_action("car_current", value=12)
|
||||
await w.step(60)
|
||||
await w.c.handle_action("car_current", value=8)
|
||||
await w.step(20)
|
||||
return w
|
||||
|
||||
|
||||
wm = asyncio.run(manual_own())
|
||||
check("Manual: two writes of ours, never 'another writer' in the tracker",
|
||||
wm.c.car.writer_at_utc is None and "charger_other" not in wm.rows())
|
||||
|
||||
|
||||
async def failed_write_then_outside(how):
|
||||
"""A write that RAISES or returns FAILURE must still close the self-mute:
|
||||
it ends 15 s after the write returned, and a later outside change shows
|
||||
the row."""
|
||||
w = World()
|
||||
await w.step(3)
|
||||
await w.c.handle_action("car_mode", value="manual")
|
||||
ret = []
|
||||
|
||||
async def bad(a):
|
||||
await w.sleep(1.0)
|
||||
ret.append(w.t) # when the write came back
|
||||
if how == "raise":
|
||||
raise RuntimeError("the charger link broke")
|
||||
return False
|
||||
w.drv.write_current = bad
|
||||
await w.c.handle_action("car_current", value=12)
|
||||
await w.step(3) # the write is tried
|
||||
closed = (bool(ret) and w.c.car.mute_until <= ret[-1] + 15.0 + 1e-6)
|
||||
await w.c.handle_action("car_mode", value="off")
|
||||
await w.step(20) # past the 15 s mute
|
||||
w.sim.set_current(7) # somebody else
|
||||
await w.step(3)
|
||||
return w, closed
|
||||
|
||||
|
||||
for how in ("raise", "fail"):
|
||||
wf, closed = asyncio.run(failed_write_then_outside(how))
|
||||
check(f"a write that {'raises' if how == 'raise' else 'returns failure'}"
|
||||
": the mute ends within 15 s of the write's return, and a later "
|
||||
"outside change shows the row",
|
||||
closed and "charger_writer" in wf.rows())
|
||||
|
||||
print()
|
||||
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
|
||||
sys.exit(1 if fails else 0)
|
||||
@@ -0,0 +1,176 @@
|
||||
"""EV-10b: the period without the car is not clipped at 0 W (rig F-1 again).
|
||||
`python3 -B test_ev10b.py`
|
||||
|
||||
The rig shape: house 3 kW, car 11 kW, batteries 8.1 kW, aim 6 kW. The batteries
|
||||
give more than the house uses, so the house alone is an export; clipping it at
|
||||
0 W charged the car's battery share to the house, latched "the house needs the
|
||||
batteries" for the quarter, and the floor alarm fired once both batteries
|
||||
reached the reserve. Mutating a module this file grades? Read MUTATION.md first.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import dataclasses
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, os.path.join(HERE, "tools"))
|
||||
|
||||
from app import ctl_car, peakguard, tariff # noqa: E402
|
||||
import ev04_peak as P # noqa: E402
|
||||
import safety81_sim as s81 # noqa: E402
|
||||
|
||||
fails = []
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
CAP = 6050.0 # aim 6000 W
|
||||
OPTS = {"inverters": [
|
||||
{"name": f"inverter-{u}", "setpoint_entity": f"number.sp_{u}",
|
||||
"soc_entity": f"sensor.soc_{u}", "batt_entity": f"sensor.batt_{u}",
|
||||
"max_w": 4050, "bms_soc_floor": 10} for u in "ab"]}
|
||||
|
||||
|
||||
def rig_run(house_w, soc_events, dur=895):
|
||||
"""A whole quarter from its start, N=2 (4.05 kW each = 8.1 kW), the car at
|
||||
11 kW; `soc_events` is {second: {"a": soc, "b": soc}}."""
|
||||
def setter(socs):
|
||||
return lambda plant, c: plant.socs.update(socs)
|
||||
return P.drive(s81.constant(house_w), dur=dur, rating=4050.0,
|
||||
soc={"a": 60.0, "b": 60.0}, cap=CAP, phases=3, n=2,
|
||||
plant_cls=P.CarPlantN, opts=OPTS, dev_w=4050.0,
|
||||
events={t: setter(s) for t, s in soc_events.items()})
|
||||
|
||||
|
||||
def summary(r):
|
||||
rows = r["c"].checks()
|
||||
red = [x["id"] for x in rows if x["ok"] is False and not x["warn"]]
|
||||
return (P.ids(r, *P.ALARMS), red, P.ids(r, P.OVER),
|
||||
max(abs(r["plant"].batt(t)) for t in range(0, 30)) if r else 0)
|
||||
|
||||
|
||||
print("1. THE RIG SHAPE, A WHOLE QUARTER (house 3 kW, car 11 kW, batteries 8.1 kW)")
|
||||
r = rig_run(3000.0, {30: {"a": 19.0, "b": 19.0}})
|
||||
al, red, over, _ = summary(r)
|
||||
peak_batt = max(r["plant"].batt(t) for t in range(5, 30))
|
||||
check("PRECONDITION: the batteries gave more than the house uses (8.1 kW "
|
||||
"against 3 kW) before the reserve", peak_batt > 7500.0)
|
||||
check("both batteries reach the reserve early in the quarter: no 'Battery "
|
||||
"stopped limiting the peak', no 'Load too high'", al == [])
|
||||
check("...no red row, and no goodwe_peak_soc_floor", red == [])
|
||||
check("...one car-over notice", len(over) == 1)
|
||||
check("...the car-over row is on at the end", any(
|
||||
x["id"] == "car_over" and x["ok"] is True for x in r["c"].checks()))
|
||||
|
||||
r2 = rig_run(3000.0, {30: {"a": 19.0}, 200: {"b": 19.0}})
|
||||
al2, red2, over2, _ = summary(r2)
|
||||
check("N=2, one battery reaches the reserve first, the other later: no "
|
||||
"alarm, no red row, one car-over notice",
|
||||
al2 == [] and red2 == [] and len(over2) == 1)
|
||||
|
||||
print("\n2. BATTERIES ABOVE THE HOUSE AND THE HOUSE ALONE OVER THE AIM")
|
||||
r3 = rig_run(7000.0, {30: {"a": 19.0, "b": 19.0}})
|
||||
check("house 7 kW, car 11 kW, aim 6 kW, batteries to the reserve: the alarm "
|
||||
"fires (the house alone misses the aim)", summary(r3)[0] != []
|
||||
and not r3["c"].car_explains)
|
||||
|
||||
|
||||
print("\n3. THE COUNTERFACTUAL ITSELF")
|
||||
BS = datetime(2026, 11, 16, 20, 0, tzinfo=timezone.utc)
|
||||
|
||||
|
||||
class _Car(ctl_car.CarMixin):
|
||||
def __init__(self, cover=True):
|
||||
self.o = {"ev_batt_cover": cover}
|
||||
self._carq = {"key": BS, "ws": 0.0, "mono": 0.0}
|
||||
|
||||
|
||||
def proj(grid, elapsed, held=None):
|
||||
return tariff.Projection(
|
||||
projected_w=grid, elapsed_w=grid, elapsed_s=elapsed,
|
||||
covered_frac=1.0, complete=False, block_start=BS,
|
||||
held_w=grid if held is None else held)
|
||||
|
||||
|
||||
def lands(p, batt, aim=5950.0):
|
||||
return peakguard.misses_aim(p, batt_w=batt, target_w=aim)
|
||||
|
||||
|
||||
c = _Car()
|
||||
for el in (10.0, 30.0, 120.0, 300.0, 600.0):
|
||||
c._carq["ws"] = 11040.0 * el
|
||||
p = proj(3000 + 11040 - 8100, el)
|
||||
x = c.car_exclude_alarm(p, 11040.0)
|
||||
check(f"rig numbers at {el:.0f} s: the house alone does not miss the aim "
|
||||
"(no 0 W clip)", not lands(x, 8100.0))
|
||||
check(f"...and the guard-side `car_exclude` is unchanged (still clipped)",
|
||||
c.car_exclude(p, 11040.0).held_w == 0.0)
|
||||
c._carq["ws"] = 11040.0 * 30
|
||||
x = c.car_exclude_alarm(proj(5940.0, 30.0), 11040.0)
|
||||
check("the rest of the period keeps its sign: held = grid - car = -5100 W",
|
||||
abs(x.held_w - (5940.0 - 11040.0)) < 1e-6)
|
||||
check("a fresh car reading is needed: None gives the period back as it is",
|
||||
c.car_exclude_alarm(proj(5940.0, 30.0), None).held_w == 5940.0)
|
||||
# the house alone over the aim still misses
|
||||
c._carq["ws"] = 11040.0 * 30
|
||||
check("house 7 kW alone (batteries 8.1 kW, car 11 kW): the house misses the aim",
|
||||
lands(c.car_exclude_alarm(proj(7000 + 11040 - 8100, 30.0), 11040.0),
|
||||
8100.0))
|
||||
# review: the done part is clipped at 0 Ws. Rig shape for 400 s (grid 5940 W),
|
||||
# then the batteries at the reserve and the house at 12 kW: the house alone
|
||||
# lands 6667 W. Crediting the car-made export (-5100 W x 400 s) would hide it.
|
||||
c._carq["ws"] = 11040.0 * 400
|
||||
held = 12000.0 + 11040.0
|
||||
check("the car's battery share earlier is not credited against a later house "
|
||||
"overload (done part clipped at 0 Ws)",
|
||||
lands(c.car_exclude_alarm(
|
||||
proj((5940.0 * 400 + held * 500) / 900, 400.0, held), 11040.0), 0.0))
|
||||
# review: the rest of the period takes off the car's power NOW, not its
|
||||
# quarter average. Car 11 kW for 500 s, then 1.4 kW; house 7 kW, no batteries.
|
||||
c._carq["ws"] = 11040.0 * 500 + 1380.0 * 100
|
||||
held = 7000.0 + 1380.0
|
||||
check("a car turned down mid-quarter: the rest takes off its power now, so "
|
||||
"the house alone (7 kW) still misses the aim",
|
||||
lands(c.car_exclude_alarm(
|
||||
proj(((7000 + 11040) * 500 + held * 100 + held * 300) / 900, 600.0,
|
||||
held), 1380.0), 0.0))
|
||||
# with the batteries giving less than the house the two agree where the old
|
||||
# clip did not bite
|
||||
p = proj(3000 + 3700 - 300, 300.0)
|
||||
c._carq["ws"] = 3700.0 * 300.0
|
||||
old, new = c.car_exclude(p, 3700.0), c.car_exclude_alarm(p, 3700.0)
|
||||
check("batteries under the house: the same landing as before (no clip bit)",
|
||||
abs(old.projected_w - new.projected_w) < 1e-6
|
||||
and abs(old.held_w - new.held_w) < 1e-6)
|
||||
|
||||
# cover OFF: the projection the guard sees is `car_exclude`, bit for bit what
|
||||
# b86c015 built (a frozen copy of its formula), over a grid of periods
|
||||
def frozen(c, p, w):
|
||||
avg = c.car_avg_w(p, w)
|
||||
return (max(0.0, float(p.projected_w) - avg),
|
||||
max(0.0, float(p.held_w) - float(w)))
|
||||
|
||||
|
||||
same = True
|
||||
for grid in (-3000.0, 0.0, 800.0, 5900.0, 14000.0):
|
||||
for held in (-4000.0, 0.0, 6000.0, 15000.0):
|
||||
for el in (0.0, 30.0, 450.0, 899.0):
|
||||
for w in (1380.0, 3700.0, 11040.0):
|
||||
c._carq["ws"] = w * el * 0.9
|
||||
p = proj(grid, el, held)
|
||||
x = c.car_exclude(p, w)
|
||||
same = same and (x.projected_w, x.held_w) == frozen(c, p, w)
|
||||
check("cover off: the projection the guard sees (`car_exclude`) is bit for "
|
||||
"bit the old formula over 240 periods", same)
|
||||
check("...and `car_exclude` still hands back the period when the car figure "
|
||||
"is None", c.car_exclude(proj(5000.0, 30.0), None).projected_w == 5000.0)
|
||||
|
||||
print()
|
||||
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
|
||||
sys.exit(1 if fails else 0)
|
||||
@@ -61,33 +61,69 @@ class CarPlant(s81._Plant):
|
||||
return await super().call(domain, service, data)
|
||||
|
||||
|
||||
class CarPlantN(CarPlant):
|
||||
"""EV-10b: N batteries, each its own setpoint, power and SoC (`soc` is a
|
||||
dict {"a": %, "b": %}); `rating` is per battery. The grid sees them all."""
|
||||
|
||||
def __init__(self, house, rating, soc, charger):
|
||||
super().__init__(house, rating, 0.0, charger)
|
||||
self.socs = dict(soc)
|
||||
self.hists = {u: [(-1e9, 0.0)] for u in self.socs}
|
||||
|
||||
def batt_of(self, u, at):
|
||||
w = 0.0
|
||||
for when, v in self.hists[u]:
|
||||
if when <= at:
|
||||
w = v
|
||||
return max(-self.rating, min(self.rating, float(round(w))))
|
||||
|
||||
def batt(self, at):
|
||||
return sum(self.batt_of(u, at) for u in self.socs)
|
||||
|
||||
async def number(self, e, invert=False):
|
||||
for u in self.socs:
|
||||
if e == "sensor.soc_" + u:
|
||||
return self.socs[u]
|
||||
if e == "sensor.batt_" + u:
|
||||
return self.batt_of(u, self.t)
|
||||
return await super().number(e, invert)
|
||||
|
||||
async def set_number(self, e, v):
|
||||
if e.startswith("number.sp_"):
|
||||
self.hists[e[-1]].append((self.t + s81.RESPONSE_S, float(v)))
|
||||
return True
|
||||
return await super().set_number(e, v)
|
||||
|
||||
|
||||
def drive(house, *, dur=300.0, rating=2000.0, soc=60.0, cap=3500.0, margin=50,
|
||||
opts=None, plug=True, setpoint=16, phases=3, mode="manual",
|
||||
user_a=16, events=None, sim=None, store=None):
|
||||
user_a=16, events=None, sim=None, store=None, n=1, plant_cls=None,
|
||||
dev_w=5000.0):
|
||||
"""Run it. Returns a namespace-like dict: plant, controller, charger, the
|
||||
notification ids raised with their second, and the controller's rows."""
|
||||
sim = sim or SimCharger(setpoint_a=setpoint)
|
||||
if plug:
|
||||
sim.plug_in()
|
||||
sim.phases_allowed = phases
|
||||
o = rig._options(1, dict({
|
||||
o = rig._options(n, 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, "max_w": rating,
|
||||
"ev_charger": "alfen_ha", "ev_max_a": 16, "ev_phases": "auto",
|
||||
"ev_current_entity": SET}, **(opts or {})))
|
||||
store = store or rig._Store()
|
||||
store.data[unit_key("inverter-a", packmode.USE_KEY)] = False
|
||||
for u in "ab"[:n]:
|
||||
store.data[unit_key("inverter-" + u, packmode.USE_KEY)] = False
|
||||
store.data[packmode.USE_KEY] = False
|
||||
db = os.path.join(tempfile.mkdtemp(prefix="ev4-"), "tariff.db")
|
||||
out = {}
|
||||
|
||||
async def go():
|
||||
plant = CarPlant(house, rating, soc, sim)
|
||||
plant = (plant_cls or CarPlant)(house, rating, soc, sim)
|
||||
c = Controller(o, plant, store, rig._Pub(), stop=asyncio.Event(),
|
||||
peak_db_path=db)
|
||||
for i in c.inverters:
|
||||
i.dev_min, i.dev_max = -5000.0, 5000.0
|
||||
i.dev_min, i.dev_max = -dev_w, dev_w
|
||||
c.auto = True
|
||||
clock = [0.0]
|
||||
c.car_now = lambda: clock[0]
|
||||
|
||||
Reference in New Issue
Block a user