Predbat-led EV charger control: shared mixin, and on automatically for GE, Ohme and Zappi (folds #5284 + #5311)

[chalfontchubby]

Posted by Claude on behalf of @chalfontchubby.

Folds the former stack #5284 (shared charger-control mixin) and #5311 (control on automatically, Octopus Intelligent, guest charging) into one PR for a single final review, as Trefor suggested on #5284. It supersedes both, which will be closed once this is open. All their review threads were already answered and resolved; their commit history is kept as it was, so earlier review comments still map to commits.

Rebased onto main (8 Oct). One commit dropped: the gateway commit that moved its car plan parsing onto the shared parser, which main now has from #5120. Ohme's New Year tests from #5120 are ported to the shared control API. A local /code-review high before pushing found two small bugs in the existing code, fixed in the last commit: a dispatch time with no UTC offset raised a TypeError when compared with the clock (now read as UTC), and an is_charger of unknown/unavailable was read as "not the charger" instead of "cannot tell".

Known and not changed here (from the same review): a multi-car setup shares one Octopus-discovery timer, so a second car's discovery timeout can be masked by a first car that is already wired; the Ohme charger is keyed by serial or the literal "ohme", which would orphan held state if the serial arrives late; the guest switch republishes on the next poll rather than immediately.

Part 1: shared mixin (was #5284)

Summary

Predbat-led EV charger control (start/stop the charger from the car charging plan) was implemented three times, once each in gecloud.py (GivEnergy EV charger), myenergi.py (Zappi) and ohme.py, with a fourth window parser in gateway.py. This PR moves the shared loop into one mixin, CarChargerControl (car_charger_control.py), before we turn control on automatically and add more chargers (Hypervolt, Wallbox).

The mixin owns:

• reading each car's plan from binary_sensor.predbat_car_charging_slot[_N]
• on inside a window, off outside one, sending only on a change
• re-applying when the charger has been changed elsewhere (drift)
• releasing on read only mode or when the control switch is turned off, and resuming afterwards
• persisting the control switch across restarts

Each component keeps only what is specific to its charger: which chargers exist and in which order, whether a car is connected, how drift is detected, and the on/off/release commands. Log wording for those commands is unchanged.

One commit per step; each passes the quick suite on its own:

1. Add the mixin, with its own tests
2. GivEnergy EVC onto it
3. Zappi onto it
4. Ohme onto it
5. Gateway: shared window parser only
6. Review fixes: release a charger whose car has gone, and retry refused GivEnergy commands
7. Later review fixes: one charger refusing no longer blocks the others, and a released Zappi forgets its saved mode

Behaviour changes

Intended to be a refactor, with these exceptions:

• New Year fix (Ohme, gateway). Their inline parsers missed this case: read just after midnight on 1 January, a window that started on 31 December parsed as the following December, so a charge running across midnight was paused/stopped. Both now use the shared parse_car_plan_windows(). The gateway copy also moved any window starting more than 23 hours ago a year forward; a finished window now stays finished.
• Chargers with no car to follow. If there are more chargers than num_cars (briefly true while auto-config's num_cars reaches the base), an extra Zappi is now left alone instead of Stopped, matching what GivEnergy EVC already did. A charger Predbat was already holding when its car drops out of num_cars is released back to its own mode rather than left in the state Predbat last set.
• Ohme release retry. A release Ohme refuses is now retried on the next control cycle rather than attempted once, so one failed call can't strand a paused car. Ohme's control tick is now wrapped like myenergi's: a refused command logs a warning instead of failing the whole run, which would otherwise repeat every minute while read only is on.
• GE EVC refused commands retried. async_send_evc_command() reports a refusal by returning None, so a refused start, stop or release used to be recorded as sent and never retried; a refused release could strand a stopped charger. GE charger control now raises EVCCommandFailed on a refusal, so nothing is recorded and the command is tried again next cycle. GE's run loop catches it as a warning, as Ohme's and myenergi's do.
• GE EVC read only fallback. When base.set_read_only is unset, the EVC loop now falls back to the set_read_only arg like the other chargers, not the switch entity. Predbat sets the attribute at startup (predbat.py), so this only affects test doubles. GECloudDirect.read_only_now() is kept for the inverter code that uses it.
• Each charger handled on its own. Releasing and driving used to run as one loop, so the first charger to refuse a command stopped every charger after it, every cycle - with two Zappis held Stopped and read only on, a refusing Zappi 1 left Zappi 2 Stopped for good. Each charger is now handled on its own; the first failure is still raised afterwards for the run loop to log, and only the charger that refused is retried.
• Zappi saved mode. A Zappi released because its car dropped out of num_cars kept its saved mode, so taking it back later restored that stale mode on the next release. The saved mode is now dropped once that Zappi's release goes through.
• Some generic log lines (release, resume, drift) now share one wording.

Gateway control is not moved onto the mixin here: that would add release on read only, which is a behaviour change. It belongs with the follow-up that turns charger control on automatically.

Testing

• New tests/test_car_charger_control.py covers the mixin against a fake component.
• Existing GE, myenergi, Ohme and gateway control tests: internal names updated, assertions unchanged. Exceptions:
  • The gateway year-boundary test pinned the old "older than 23 hours means next year" heuristic. It is replaced by the two real New Year cases on a fixed clock, plus a finished-window case.
  • Ohme's New Year test gains the after-midnight case.
  • Two new myenergi tests cover a failed release being retried with the saved mode intact, and a mode saved ahead of a refused command being forgotten on release. A cold review found both issues; the retry test fails without the fix.
  • A new Ohme test covers a refused release being retried without failing run(), and a new mixin test covers a release that fails part-way through several chargers. Both come from an adversarial review; the Ohme test fails without the fix.
• Review fixes: a mixin test covers a held charger whose car drops out of num_cars being released, and GE control tests 11 and 12 cover a refused stop and a refused release being retried rather than recorded.
• Later review fixes: a mixin test covers a refusing charger not blocking the others (and the existing part-way release test now expects only the refusing charger to be retried), and a myenergi test covers a released Zappi snapshotting its mode afresh when taken back.
• tools/debug-journal.md's myenergi entry is updated for the renamed methods.
• Rebased onto main on 5 Oct. Main's Ohme changes in feat(ohme): take the car plan from Ohme's own schedule when Predbat is not controlling the charger #5401 and fix(ohme): leave the Intelligent car slots to Octopus when the Intelligent device is the car #5405 re-decide control on every poll and hand the charger back when Octopus Intelligent takes over. That hand-back now goes through the mixin (charger_control_state / charger_control_release()), with the same retry until it succeeds, and feat(ohme): take the car plan from Ohme's own schedule when Predbat is not controlling the charger #5401's tests are updated for the new state names.
• Every commit passes pre-commit and the full suite on its own.
• Not changed here, but worth knowing: a hand-back that Ohme refuses in that new fix(ohme): leave the Intelligent car slots to Octopus when the Intelligent device is the car #5405 path raises out of the poll as it did on main, whereas the control tick catches the same refusal as a warning. Making the two match would be a small follow-up.

Part 2: control on automatically (was #5311)

What this does

Stage 2 of Predbat-led EV charger control. It follows the rule agreed on #5284: if Predbat is planning the car and the user has turned on the charger's automatic setup, Predbat can control the charger without being asked separately.

Until now, ge_cloud_evc_control and myenergi_zappi_control were off unless set. They now have three states (ohme_control stays opt-in, see decision 2):

Setting	Unset	false	true
ge_cloud_evc_control	on when ge_cloud_automatic_evc is on	off	on, and warns if a prerequisite is missing
ohme_control	off (unchanged): Ohme's own schedule is the car plan (#5401)	off	on
myenergi_zappi_control	on only if the user wrote myenergi_automatic or myenergi_automatic_zappi in apps.yaml	off	on

It also adds three things, each described below:

• a per-car rule for Octopus Intelligent;
• a guest charging switch;
• a few fixes found while reviewing it.

Behaviour change on upgrade

Users who already have ge_cloud_automatic_evc on now get charger control, and so do Zappi users who wrote myenergi_automatic into apps.yaml. Ohme users see no change. For each of them, Predbat starts and stops the charger unless they set its control setting to false.

Users who already had *_control: true see no change, apart from the new Octopus rule and the guest switch. One part of the Octopus rule does change things for them: where Octopus drives the car itself, Predbat now leaves the charger alone unless switch.predbat_octopus_intelligent_charger_follows_car is on, where before it drove the charger to its plan.

The docs say this in car-charging.md, in the new section "Predbat starting and stopping your charger". This probably wants a line in the release notes.

Decisions, and the options rejected

1. Zappi: on only when the user wrote the automatic setting (fa7c9f6). myenergi_automatic and myenergi_automatic_zappi both default on, so the GE/Ohme rule would switch every Zappi user over on upgrade. A Zappi that Predbat controls is Stopped between windows, so it stops diverting solar in Eco/Eco+. The options considered are in enable_control()'s docstring, for review and to tidy up later:
   • Rejected: on for every Zappi user.
   • Chosen: on only when the user wrote the setting.
   • Rejected: Zappi stays opt-in.
2. Ohme stays opt-in (e631a2c, replacing 7a35d85). Since feat(ohme): take the car plan from Ohme's own schedule when Predbat is not controlling the charger #5401, an Ohme that Predbat does not control already has its own schedule taken as the car plan, so the default user gets a plan that matches what the charger does. Turning control on by default would override that schedule, which the user may have set up deliberately, with max charge, which also overrides the Ohme app's target.
   • Superseded: turning on by default once the car's size and limit are set (7a35d85, before feat(ohme): take the car plan from Ohme's own schedule when Predbat is not controlling the charger #5401 existed).
3. Octopus Intelligent is judged per car (067f637, d3663f6, 3f6422c). You agreed this on refactor(car): share Predbat-led EV charger control across Ohme, Zappi and GivEnergy #5284. Predbat reads is_charger from the car's own dispatch sensor in octopus_intelligent_slot. Both the Octopus and Kraken components publish it, so E.ON/EDF SmartFlex is covered, and a car can't be paired with another car's device. What Predbat does depends on which device Octopus drives:
   • Octopus drives the charger: Predbat leaves the charger alone, whatever switch.predbat_octopus_intelligent_charging says. That switch only changes Predbat's own planning; Octopus keeps switching the charger either way, so driving it would fight Octopus.
   • Octopus drives the car: by default Predbat leaves the charger alone; a charger it was holding is released as usual, since nobody else drives it (5fa79fb, 0ab856d). A new expert-mode switch, switch.predbat_octopus_intelligent_charger_follows_car (default off), has Predbat drive the charger instead: on during dispatches and off otherwise, so the car cannot charge on its own timers. It follows the plan and also the dispatch times on the sensor, judged against the clock, so it picks up a new dispatch without waiting for the 5-minute plan and stops the charger when the dispatch ends. With octopus_intelligent_charging off, Predbat plans the car itself and the charger follows that plan, whatever the new switch says. The Ohme follows the same rules (bbbfb3f), so with the switch on ohme_control: true can run where fix(ohme): leave the Intelligent car slots to Octopus when the Intelligent device is the car #5405 would otherwise stand it down.
   • Can't tell (for example the Octopus Energy HA integration's sensor): Predbat leaves the charger alone unless *_control: true, and logs a warning naming that setting (6cec384). A charger Predbat was holding is handed back as usual, so one it had stopped is not stranded. Released users are unaffected, because before this PR control only ran with true.
   • Still discovering (the Octopus or Kraken component has not wired its devices yet): the charger is left as it is, and still held, until discovery finishes. After 15 minutes it is treated as can't tell, with a warning.
4. Handing a charger to Octopus never starts a charge (d3663f6). A normal release undoes a stop, so that read only mode never leaves a car unable to charge. Octopus deciding when to charge is different, so the hand-over does this instead:
   • GE: sends nothing.
   • Ohme: turns max charge off, then resumes into its smart schedule.
   • Zappi: goes back to its own mode, with Eco+ in place of Fast.
5. Guest charging switch (b6d30e4, 8032b55, ec86180). While Predbat drives a charger it holds it off outside the plan, so a visitor's car can't charge. The switch lets them:
   • The entities: switch.predbat_gecloud_guest_charging, switch.predbat_myenergi_guest_charging and switch.predbat_ohme_guest_charging.
   • What it does: releases the charger, as read only mode does. How the guest charges (boost, solar only) is chosen on the charger itself; Predbat never picks a mode.
   • When it ends: when a car plugged in after the switch went on is unplugged, using the plug state of all three chargers. Unplugging the owner's car to make way for the guest doesn't end it. It also ends after 12 hours.
   • Restarts: it isn't remembered across a restart.

Fixes found in review before opening

• Octopus discovery: with octopus_automatic off, Predbat waited for Octopus discovery that never came, so control never turned on.
• Setting values: a quoted "false" or a 0 read as on, because removing the defaults also skipped get_arg()'s boolean conversion. parse_control_setting() now normalises them.
• Dispatch end: following the dispatch sensor's on/off state ran the charger up to about 3 minutes past the end of a dispatch.
• GE status blip: an offline or unavailable status on a GE charger ended guest charging.

Found by a further /code-review after opening:

• Kraken wasn't waited for (ff0b164): after a restart, a Kraken user's charger could be driven before Kraken had wired its dispatch sensors.
• The same review found two bugs in refactor(car): share Predbat-led EV charger control across Ohme, Zappi and GivEnergy #5284's own code: one charger refusing a command blocked all the others, and a Zappi released because its car had gone kept a stale saved mode. Both are fixed on refactor(car): share Predbat-led EV charger control across Ohme, Zappi and GivEnergy #5284 (d54a3ff), and this PR is rebased onto that.

Rebased onto main (5 Oct)

The stack is rebased onto main, which meanwhile changed the Ohme component in #5401 and #5405. How the two fit:

• fix(ohme): leave the Intelligent car slots to Octopus when the Intelligent device is the car #5405's stand-down release (Ohme hands the charger back when Octopus Intelligent starts scheduling the charge) is on the shared mixin now, with the same retry until the hand-back goes through.
• enable_control() is re-decided whenever the tariff or Intelligent device changes (fix(ohme): leave the Intelligent car slots to Octopus when the Intelligent device is the car #5405), and also when the follows-car or Intelligent charging switch changes while Octopus drives the car.
• feat(ohme): take the car plan from Ohme's own schedule when Predbat is not controlling the charger #5401's charger schedule is unchanged: with ohme_control left off, Ohme's own schedule stays the car plan.
• Octopus driving the car was where fix(ohme): leave the Intelligent car slots to Octopus when the Intelligent device is the car #5405 and this PR disagreed. They now agree by default (the charger is left alone), and the follows-car switch opts every charger, the Ohme included, into driving it to the dispatches.

Found by review after the rebase:

• Can't tell stranded a GE charger: it was let go without being started, as if Octopus were taking over, so a charger Predbat had stopped stayed stopped with nobody in charge (5394c56).
• Discovery waited for good: a Kraken component whose first run never succeeds left every unwired car's charger alone indefinitely. Now bounded at 15 minutes, and a held charger is left as it is while waiting rather than released, so a component restart does not start a charge (5394c56, 6405d2e, c8278fd).
• A false warning on restart: the apps.yaml default's literal re: string, before its regex matches, was read as a dispatch sensor (5394c56).

Not in this PR (known and deferred)

• Empty Zappi or Ohme: Predbat still sends commands to one with no car plugged in. Only GE skips an empty charger today. Using the plug state there is a separate change, because a car plugged into a Zappi left in Fast could charge for up to a minute before the next tick.
• Guest energy: the guest's charging is still counted as the owner's car's.
• GE size and limit: whether GE needs the same size/limit guard as the Ohme.
• Ohme ohme_automatic_octopus_intelligent: has the same quoted-"false" problem, from before this PR.
• No cars: with num_cars at 0 there is no plan to read, so control does nothing that cycle, including releasing a charger it holds. This comes from refactor(car): share Predbat-led EV charger control across Ohme, Zappi and GivEnergy #5284 and is unchanged.
• Hardware: not tested on real chargers. In particular it is unverified that an Ohme resumed into its smart schedule doesn't start charging outside a dispatch.

Testing

• New tests: for each decision above, in test_car_charger_control.py, test_ge_cloud.py, test_ohme.py and test_myenergi.py.
• Checks: every commit passes pre-commit and the full suite on its own.
• Reviews: two rounds before opening and four after the rebase, each a cold subagent review plus a local /code-review high. Their findings are the fixes listed above.

🤖 Generated with Claude Code

[Copilot]

🟡 Changes recommended

Ohme’s live Intelligent handoff uses the unsafe release order, and persistence failures can be silently ignored.

2 open findings

• Handle Storage API save failures during control switch persistence · New
• Use Octopus handoff when switching to Intelligent mode · New

What changed in this PR

Introduces shared Predbat-led EV charger control for GivEnergy, Ohme, and myenergi, including automatic activation, Intelligent dispatch handling, and guest charging.

Changes:

• Adds the shared CarChargerControl mixin.
• Migrates three charger integrations and adds extensive tests.
• Updates configuration and user documentation.

File	Description
apps/​predbat/​car_charger_control.py	Adds shared charger-control logic.
apps/​predbat/​gecloud.py	Migrates GivEnergy charger control.
apps/​predbat/​myenergi.py	Migrates Zappi charger control.
apps/​predbat/​ohme.py	Migrates Ohme control and Intelligent handling.
apps/​predbat/​components.py	Adds tri-state control configuration.
apps/​predbat/​config.py	Adds the follows-car switch.
apps/​predbat/​unit_test.py	Registers shared-control tests.
apps/​predbat/​tests/​test_car_charger_control.py	Tests the shared mixin.
apps/​predbat/​tests/​test_ge_cloud.py	Expands GivEnergy control tests.
apps/​predbat/​tests/​test_myenergi.py	Expands Zappi control tests.
apps/​predbat/​tests/​test_ohme.py	Expands Ohme control tests.
docs/​apps-yaml.md	Documents automatic-control settings.
docs/​car-charging.md	Documents Intelligent and guest charging.
docs/​components.md	Updates component configuration guidance.
tools/​debug-journal.md	Updates myenergi diagnostic notes.

🧠 Review effort: Balanced

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.