Met dit Home Assistant-pakket bepaal je met één keuzelijst wie je thuisbatterij stuurt: Zonneplan (powerplay), de omvormer zelf (huisondersteuning of zelfverbruik) of de planning van DAO (Day Ahead Optimizer). Een pyscript voert dat elke minuut uit.
Het script gebruikt drie knoppen: de batterijbesturingsmodus van de Zonneplan ONE-integratie, de RC-force-registers van de Solis-omvormer via Modbus en een slimme schakelaar op de voeding van de Zonneplan-dongel. Staat de dongel aan, dan regelt Zonneplan; staat hij uit, dan stuurt Home Assistant zelf.
Wat het pakket doet:
- Negen standen: uit, auto, powerplay, huisondersteuning, zelfverbruik, dao, dao_tennet, force_charge en force_discharge
- DAO volgen: laden, ontladen of 0 op de meter, inclusief de stoptijd voor een deel-kwartier
- Bijladen in de goedkoopste kwartieren van de dag als er te weinig zon verwacht wordt
- Optioneel: TenneT-override naar powerplay bij een onbalansprijs onder nul of boven je drempel
- Optioneel: fasebewaking als de auto buiten DAO om laadt (samen met het laadpaal-pakket)
- Een leesbare statusregel voor je dashboard
Onderaan dit artikel kun je de complete, kant-en-klare YAML downloaden, met een uitgebreide PDF-handleiding. Getest met Home Assistant 2026.10.
Het pakket bestaat uit: een pyscript voor de beslissing, een package met helpers en sensoren, en een package voor de koppeling met DAO.
⚙️ Wat heb je nodig?
Hardware:
- Een Zonneplan Nexus-thuisbatterij met Solis-hybride omvormer
- Een Modbus-verbinding met de Solis, bijvoorbeeld een RS485-naar-ethernet- of wifi-adapter op de COM-poort van de omvormer
- Een slimme schakelaar (bijvoorbeeld een Shelly) op de voeding van de Zonneplan-dongel
- Optioneel: een P1-meter met vermogen per fase, voor de fasebewaking
- Een dynamisch energiecontract bij Zonneplan
In Home Assistant:
- Pyscript via HACS
- De integratie Solis Modbus uit HACS (SoC, laad- en ontlaadvermogen, RC force)
- De integratie Zonneplan ONE (batterijbesturingsmodus en kwartierprijzen)
- Optioneel: DAO (Day Ahead Optimizer), een zonneverwachting (Forecast.Solar of Solcast) en een TenneT-onbalansprijs-sensor
- Ondersteuning voor packages in
configuration.yaml
Zelf aan te maken helpers:
input_select.tb_mode— de stand van de thuisbatterijinput_number.tb_soc_min / tb_soc_optimal_lower / tb_soc_max— SoC-grenzen, dezelfde als in DAOinput_number.tb_batt_kwh— capaciteit van je batterijinput_number.tb_max_charge_power_w / tb_max_discharge_power_w— maximaal laad- en ontlaadvermogeninput_number.tb_powerplay_minimaal_min— minimale tijd in powerplay, tegen heen-en-weer schakeleninput_number.tb_energie_productie_minimaal_kwh— vanaf hoeveel verwachte zon het bijladen minder wordtinput_number.tb_tennet_offset / tb_tennet_avg_weight— TenneT-drempel en weging (optioneel)
🧩 De 5 onderdelen
Pyscript: Instellingen bovenaan
Wat doet dit: koppelt het script aan jouw entiteiten.
Hoe maak je dit:
ENT = {
"mode_select": "input_select.tb_mode",
"battery_control_mode": "select.thuisbatterij_battery_control_mode", # Zonneplan ONE
"soc": "sensor.solis_battery_soc", # Solis Modbus
"rc_force_select": "select.solis_rc_force_charge_discharge",
"dongel_switch": "switch.zonneplan_dongel",
"tennet_balance": None, # optioneel
"dao_feedin": "input_number.dao_tb_power_feedin",
# ...
}
Bovenaan in ENT staan alle entiteiten. Optionele onderdelen zet je uit met None: zonder TenneT-sensor is er geen TenneT-override, zonder DAO werken de DAO-standen niet, zonder P1-fasen geen fasebewaking. Ook de waarden van de RC-force-keuzelijst en de hoofdzekering (FASE_ZEKERING_A) staan bovenaan.
Pyscript: Wie stuurt: dongel aan of uit
Wat doet dit: kiest of Zonneplan of Home Assistant de batterij stuurt.
Hoe maak je dit:
# Dongel: uit = zelf sturen, aan = Zonneplan regelt
self_steer = (want_fc or want_fd) or (
(mode in SELF_STEER_MODES) and not dao_balance_now and not tennet_override)
desired_dongel_on = not self_steer
Moet de batterij geforceerd laden of ontladen, of staat de stand op dao, dao_tennet of force, dan gaat de dongel uit en zet het script de RC-registers van de Solis. Wil DAO 0 op de meter, of is er een TenneT-override, dan gaat de dongel aan en regelt Zonneplan. Bij de overgang naar dongel aan zet het script de RC-registers eenmalig terug op None en 0 W. Geforceerde setpoints worden elke 4 minuten opnieuw gestuurd.
Pyscript: Bijladen in goedkope kwartieren
Wat doet dit: laadt de batterij in de stand zelfverbruik bij in de goedkoopste kwartieren van de dag.
Hoe maak je dit:
need_kwh = (soc_max - soc) / 100 * batt_kwh - verwachte_zon
need_quarters = ceil(need_kwh * 4000 / max_ch_w)
laden = rang_huidig_kwartier < need_quarters
Het script rekent uit hoeveel kWh er nodig is tot de maximale SoC, trekt daar de verwachte zon van af (als die boven je drempel ligt) en rekent dat om naar kwartieren op maximaal laadvermogen. Is het huidige kwartier een van die goedkoopste kwartieren van vandaag, dan laadt de batterij maximaal. De kwartierprijzen leest het script zelf uit de Zonneplan-integratie.
Package: Helpers en sensoren
Wat doet dit: maakt de keuzelijst met standen, de SoC-grenzen en de vermogens, plus een sensor voor het netto batterijvermogen en een statussensor.
Hoe maak je dit:
input_select:
tb_mode:
name: Thuisbatterij stand
options:
- uit
- auto
- powerplay
- dao
sensor.thuisbatterij_netto_vermogen is laadvermogen min ontlaadvermogen (+ = laden). Het laadpaal-pakket gebruikt dezelfde sensor. sensor.thuisbatterij_status toont de reden van de laatste beslissing, met de leesbare statusregel in het attribuut tekst.
Package: Koppeling met DAO
Wat doet dit: de helpers die DAO vult: vermogen, modus, 0 op de meter en stoptijd.
Hoe maak je dit:
input_number:
dao_tb_power_feedin:
name: DAO thuisbatterij vermogen
min: -10000
max: 10000
DAO schrijft na elke berekening het gewenste vermogen in dao_tb_power_feedin (+ = laden, – = ontladen), zet dao_tb_operating_mode op Aan of Uit en zet dao_tb_balance_switch aan als de batterij 0 op de meter moet houden. Plant DAO minder dan een kwartier, dan staat de stoptijd in dao_tb_stop_inverter.
📝 Gebruikte templates
- Netto vermogen — laadvermogen min ontlaadvermogen van de Solis, + = laden.
- Rang van het kwartier — het aantal kwartieren van vandaag dat goedkoper is dan het huidige; 0 is het goedkoopste.
- Statusregel — een zin per situatie, bijvoorbeeld “DAO-plan: batterij laadt (3.0 kW)”.
❓ Veelgestelde vragen
Werkt dit ook met andere thuisbatterijen? Het script is gemaakt voor een Zonneplan Nexus met Solis-omvormer: het gebruikt de besturingsmodus van Zonneplan ONE, de RC-force-registers van Solis en de Zonneplan-dongel. Voor een andere batterij moet je die drie delen aanpassen.
Waarom een schakelaar op de dongel? Zolang de dongel aan staat, stuurt Zonneplan de batterij en overschrijft het je eigen instellingen. Met de dongel uit kan Home Assistant de omvormer zelf sturen; met de dongel aan regelt Zonneplan weer, bijvoorbeeld voor 0 op de meter.
Heb ik DAO nodig? Nee. Zonder DAO gebruik je de standen uit, powerplay, zelfverbruik, huisondersteuning en force. Met DAO komen de standen dao, dao_tennet en auto erbij.
Wat doet de TenneT-override? Is de onbalansprijs nul of negatief, of hoger dan je drempel, dan schakelt de batterij in zelfverbruik, dao_tennet en auto naar powerplay, zodat Zonneplan op de onbalansmarkt kan handelen. In de stand dao gebeurt dat nooit.
Laad je ook een elektrische auto? Lees Laadpaal slim laden op zon en DAO. Meer over DAO zelf: Day Ahead Optimizer (DAO) met Home Assistant.
Hieronder kun je bovenstaande automatiseringen downloaden incl. de genoemde helpers en templates, de volledige YAML en een uitgebreide PDF-handleiding.
De genoemde helpers kun je zelf aanmaken in Home Assistant onder apparaten en diensten -> helpers -> Helper toevoegen.
Let op gebruik is op eigen risico!!
Home Assistant: control your home battery yourself with DAO (Zonneplan Nexus, Solis)
With this Home Assistant package you choose with one dropdown who controls your home battery: Zonneplan (powerplay), the inverter itself (home support or self consumption) or the DAO schedule (Day Ahead Optimizer). A pyscript carries this out every minute.
The script uses three levers: the battery control mode of the Zonneplan ONE integration, the RC force registers of the Solis inverter via Modbus and a smart switch on the power supply of the Zonneplan dongle. With the dongle on, Zonneplan controls; with the dongle off, Home Assistant controls.
What the package does:
- Nine modes: uit, auto, powerplay, huisondersteuning, zelfverbruik, dao, dao_tennet, force_charge and force_discharge
- Follow DAO: charge, discharge or zero on the meter, including the stop time for a partial quarter
- Top up in the cheapest quarter hours of the day when too little sun is expected
- Optional: TenneT override to powerplay when the imbalance price is below zero or above your threshold
- Optional: phase protection when the car charges outside DAO (together with the EV charging package)
- A readable status line for your dashboard
At the bottom of this article you can download the complete, ready-to-use YAML with an extensive PDF guide. Tested with Home Assistant 2026.10.
The package consists of: a pyscript for the decision, a package with helpers and sensors, and a package for the DAO link.
⚙️ What do you need?
Hardware:
- A Zonneplan Nexus home battery with a Solis hybrid inverter
- A Modbus connection to the Solis, for example an RS485-to-ethernet or wifi adapter on the inverter’s COM port
- A smart switch (for example a Shelly) on the power supply of the Zonneplan dongle
- Optional: a P1 meter with power per phase, for phase protection
- A dynamic energy contract with Zonneplan
In Home Assistant:
- Pyscript via HACS
- The Solis Modbus integration from HACS (SoC, charge and discharge power, RC force)
- The Zonneplan ONE integration (battery control mode and quarter-hourly prices)
- Optional: DAO (Day Ahead Optimizer), a solar forecast (Forecast.Solar or Solcast) and a TenneT imbalance price sensor
- Support for packages in
configuration.yaml
Helpers to create yourself:
input_select.tb_mode— the home battery modeinput_number.tb_soc_min / tb_soc_optimal_lower / tb_soc_max— SoC limits, the same as in DAOinput_number.tb_batt_kwh— capacity of your batteryinput_number.tb_max_charge_power_w / tb_max_discharge_power_w— maximum charge and discharge powerinput_number.tb_powerplay_minimaal_min— minimum time in powerplay, against switching back and forthinput_number.tb_energie_productie_minimaal_kwh— from how much expected sun topping up is reducedinput_number.tb_tennet_offset / tb_tennet_avg_weight— TenneT threshold and weight (optional)
🧩 The 5 parts
Pyscript: Settings at the top
What it does: links the script to your entities.
How to build it:
ENT = {
"mode_select": "input_select.tb_mode",
"battery_control_mode": "select.thuisbatterij_battery_control_mode", # Zonneplan ONE
"soc": "sensor.solis_battery_soc", # Solis Modbus
"rc_force_select": "select.solis_rc_force_charge_discharge",
"dongel_switch": "switch.zonneplan_dongel",
"tennet_balance": None, # optioneel
"dao_feedin": "input_number.dao_tb_power_feedin",
# ...
}
At the top, ENT lists all entities. Switch optional parts off with None: without a TenneT sensor there is no TenneT override, without DAO the DAO modes don’t work, without P1 phases no phase protection. The values of the RC force select and the main fuse (FASE_ZEKERING_A) are also at the top.
Pyscript: Who controls: dongle on or off
What it does: chooses whether Zonneplan or Home Assistant controls the battery.
How to build it:
# Dongel: uit = zelf sturen, aan = Zonneplan regelt
self_steer = (want_fc or want_fd) or (
(mode in SELF_STEER_MODES) and not dao_balance_now and not tennet_override)
desired_dongel_on = not self_steer
If the battery has to force charge or discharge, or the mode is dao, dao_tennet or force, the dongle goes off and the script sets the Solis RC registers. If DAO wants zero on the meter, or there is a TenneT override, the dongle goes on and Zonneplan controls. When switching to dongle on, the script resets the RC registers once to None and 0 W. Forced setpoints are resent every 4 minutes.
Pyscript: Topping up in cheap quarter hours
What it does: tops up the battery in the cheapest quarter hours of the day in the zelfverbruik mode.
How to build it:
need_kwh = (soc_max - soc) / 100 * batt_kwh - verwachte_zon
need_quarters = ceil(need_kwh * 4000 / max_ch_w)
laden = rang_huidig_kwartier < need_quarters
The script calculates how many kWh are needed to reach the maximum SoC, subtracts the expected sun (if above your threshold) and converts that to quarter hours at maximum charge power. If the current quarter is one of today’s cheapest, the battery charges at maximum power. The script reads the quarter-hourly prices itself from the Zonneplan integration.
Package: Helpers and sensors
What it does: creates the mode dropdown, SoC limits and power settings, plus a sensor for net battery power and a status sensor.
How to build it:
input_select:
tb_mode:
name: Thuisbatterij stand
options:
- uit
- auto
- powerplay
- dao
sensor.thuisbatterij_netto_vermogen is charge power minus discharge power (+ = charging). The EV charging package uses the same sensor. sensor.thuisbatterij_status shows the reason for the last decision, with the readable status line in the tekst attribute. The status texts are Dutch.
Package: DAO link
What it does: the helpers DAO fills in: power, mode, zero on the meter and stop time.
How to build it:
input_number:
dao_tb_power_feedin:
name: DAO thuisbatterij vermogen
min: -10000
max: 10000
After every calculation DAO writes the desired power to dao_tb_power_feedin (+ = charge, – = discharge), sets dao_tb_operating_mode to Aan or Uit and switches dao_tb_balance_switch on when the battery should keep zero on the meter. If DAO plans less than a quarter hour, the stop time is in dao_tb_stop_inverter.
📝 Templates used
- Net power — Solis charge power minus discharge power, + = charging.
- Rank of the quarter — the number of today’s quarters cheaper than the current one; 0 is the cheapest.
- Status line — one sentence per situation, for example “DAO-plan: batterij laadt (3.0 kW)”.
❓ Frequently asked questions
Does this work with other home batteries? The script is made for a Zonneplan Nexus with a Solis inverter: it uses the Zonneplan ONE control mode, the Solis RC force registers and the Zonneplan dongle. For another battery you need to adapt those three parts.
Why a switch on the dongle? As long as the dongle is on, Zonneplan controls the battery and overrides your own settings. With the dongle off Home Assistant can control the inverter itself; with the dongle on Zonneplan takes over again, for example for zero on the meter.
Do I need DAO? No. Without DAO you use the modes uit, powerplay, zelfverbruik, huisondersteuning and force. With DAO the modes dao, dao_tennet and auto are added.
What does the TenneT override do? If the imbalance price is zero or negative, or higher than your threshold, the battery switches to powerplay in zelfverbruik, dao_tennet and auto, so Zonneplan can trade on the imbalance market. In the dao mode this never happens.
Charging an electric car too? Read Smart EV charging on solar and DAO. More about DAO itself: Day Ahead Optimizer (DAO) with Home Assistant.
Below you can download the automations above including the helpers and templates mentioned, the complete YAML and an extensive PDF guide.
You can create the helpers yourself in Home Assistant under Devices & services -> Helpers -> Create helper.
Use at your own risk!!


Geef een reactie