[Feature] Optimize Solar Charging Based on Dynamic Feed-in Tariffs (Opportunity Cost Optimization)

[rrozema]

Area of the proposal

Energy management or control strategy

What problem would this solve?

First of all, thank you for Omnibattery—it's an incredible integration that manages my battery setup wonderfully.

I’d like to propose an enhancement to the predictive charging feature regarding how solar generation is handled under dynamic energy contracts with quarter-hour-based feed-in tariffs.
Currently, predictive charging smartly optimizes grid charging based on electricity prices. However, solar charging is handled passively: when the sun comes up, surplus solar power immediately fills the battery first (self-consumption priority) before any excess is exported to the grid.

On sunny days, my system produces more than double my daily consumption within the first few hours. Currently, the battery fills up rapidly in the morning, and the rest of the day is exported. However, with a dynamic contract, feed-in tariffs fluctuate heavily throughout the day.

The Core Issue: Opportunity Cost of Solar Energy
Solar energy stored in the morning is not "free". If I export that energy instead of storing it in the battery, I receive a high feed-in tariff at that moment. Storing it means forfeiting that revenue. Conversely, later in the day (e.g., during the midday solar peak), feed-in tariffs often drop significantly or even turn negative.
Therefore, it is much more economically advantageous to:
Export solar power during high morning feed-in tariff hours.
Delay battery charging with solar power until later in the day when feed-in prices are lowest (or negative).

Proposed solution

Can predictive charging (or a dedicated strategy) be extended to optimize solar charging based on dynamic feed-in tariffs?
Ideally, the integration could calculate when it's financially better to export solar production (due to high feed-in rates) and intelligently delay charging the battery until the hours with the lowest/negative feed-in prices, rather than just absorbing all solar power immediately by default.
Additional context
This would maximize revenue for users on dynamic contracts who face fluctuating quarter-hour feed-in prices.
It would require the integration to dynamically block/allow solar charging (e.g., setting max charge power to 0W during high feed-in hours, and releasing it when feed-in prices drop).
I'd love to hear your thoughts on whether this fits within the roadmap of Omnibattery!

Example use case

Users that have a dynamic contract and produce -on a summer day- more solar energy than their nightly battery discharge could increase their economic return on their battery usage, just like the current predictive charging feature does in situations where the solar production is less than the nightly battery usage. I.e. this feature could complement predictive charging.

Who would benefit from this?

Users with a specific installation or workflow

Alternatives or workarounds

I could not find a way to do this using the current integration. I've looked at the delayed charging feature, but as far as I can see this just takes a set time, and does not select its time slot to charge based on the feed-in price in any way.

Additional context

I've run a couple of simulated batteries for almost a year before I bought my actual physical battery last month. That simulated battery integration keeps track of both the costs of charging and the profits of discharging the battery. When I ran the simulations the way omnibattery now charges from solar the net profit was positive, but it was only a few cents per day. This made me initially think a battery wasn't really worth the investment. Only after I realised that I could influence the net profit by delaying solar charging until the feed-in price was low I could actually see the daily profit go up significantly. My method of controlling was very crude: by default I would disable charging at all and I would manually specify how many hours I would let the battery charge. My script would automatically select those hours when the prices were lowest and only enable charging during those hours. Completely disabling charging of course ruins the self-sufficiency, but still it resulted in an far better economical result, which ultimately led to me buying my current battery. If we could have a combination where the battery normally makes sure that as little as possible energy needs to be imported and charging is done at the cheapest hours, I think that would be a great feature for everyone who has a dynamic contract plus (during summer) more solar energy than they use on a daily basis.

Confirmations

• I searched existing discussions and did not find the same proposal.
• This is a general feature idea, not a request to support a new battery brand or model.
• I understand that community interest and technical feasibility influence prioritization, and that no delivery date is guaranteed.
• I removed passwords, tokens, API keys, complete serial numbers, IP addresses, and other sensitive information.

[github-actions[bot]]

Thanks for the suggestion! 🙌

Here's how this works:

• Vote by clicking 👍 on the original post — not in the comments
• The more votes an idea gets, the higher it moves in the priority queue
• I review feature ideas periodically and implement the ones that benefit the most users

If your idea is very specific to your setup, it may not make it into the core integration — I'll try to suggest a workaround in that case.

Feel free to discuss details or alternatives below.

[willemjanssens-cell]

Part of the solution has been dealt with through the question in my topic: #70

An addition here might also be to include the total cost for taking from and injecting into the grid based on a formula used for the calculations.

[rrozema]

For as far as I understand all information under your #70, parts of that solution can indeed be re-used/combined.
My intent is however not to do additional exports to free up more space in my battery. I aim to import from and export to the grid as little as possible: energy that was never imported nor exported can not be taxed or charged for under any regime.
At the same time there is a surplus solar energy during summer because I wanted to have some solar production during darker days as well. Given my dynamic contract the value of that surplus depends on when it gets sent into the grid: around noon that value is close to nothing if any (or even negative). In the early morning and in the late afternoon however the value is most of the times higher. Therefore it is better to export the surplus during those times and only charge the battery when there is hardly any compensation.

There is one complication for this strategy: those "cheap hours" are also the best times to run our household appliances like f.e. washing machine, dishwasher and dryer. It is therefore not enough to just look at the solar forecast and subtract the average daily usage to determine how many slots will be needed to charge the battery: household usage is often substantially concentrated into those cheap hours. We may need a way to keep track of "energy reservations" for such usage: f.e. the washing machine will run from 12:15 until 13:30, consuming 0.8kWh. Those are not fixed times and not fixed usages: they may differ per day and the way to determine the usage and length may differ per appliance. I was hoping to create a calendar object that the algorithm can read and into which (external) scripts, integrations and even manually entries can be made to inform the algorithm of when and how much of the surplus energy will not be available to charge the battery.

[mhjansen79]

If this were to be implemented, it would be great if a seperate sensor could be used for the electric rate for exporting to the grid as there are currently electric companies who give you a different export rate, and in the Netherlands next year the energy tax will not be reimbursed for exported electricity (saldering) as is the case currently.

[ffunes]

Hi,

Will look at this for 1.5.0.

Best regards

[rrozema]

I have a small automation that does a rudimentary implementation of the proposed discharge strategy: For as long as charging is disabled on my battery, I compare the export price to the battery price, when export price is > battery price it sets the PD target to the negative value of my solar production. This results in the battery producing exactly the power that my house uses, resulting in all solar power being exported.

I have a 2nd automation that enables my battery's "charge allowed" switch only when the import price is low enough, and just long enough to charge the battery to my maximum SOC (100% for me). That 2nd automation is very rudimentary, it looks at Tibber's prices and selects those slots where the price is below or at a specified percentage between the day's max and min price level, or if insufficient slots were selected adds more slots until a minimum number of hours is selected. This simplified charging method needs to be manually adjusted to match my daily home usage and solar production. This is only to demonstrate the difference for a dynamic contract on how to make a profit based on the price level by charging at the right time and discharging while the sun is already/still up. And doing so without putting an additional strain on the grid: I discharge when other people use the energy (due to the high export price at this time), and I charge off of solar as long as sufficient is available.

The 3rd automation is to keep track of the price of the energy in the battery (/batteries). This uses the fact that the export price is below the import price. This is a little bit more complex as it is a triggered template sensor and it can therefore only be defined in yaml.

Another script I use is that for the current "price for energy used", this is the 4th script below.

--- the scripts ---
1: The automation that sets the PD target:

alias: Set the PD target to push solar out
description: >
  Synchroniseert number.omnibattery_pd_target_grid_power met de inverted solar
  production om de solar power meteen naar het net te sturen.
triggers:
  - alias: When Home Assistant starts
    event: start
    trigger: homeassistant
  - alias: When automations are reloaded
    event_type: automation_reloaded
    trigger: event
  - alias: When one of the inputs changes state
    entity_id:
      - sensor.power_produced
      - sensor.electricity_meter_energy_production_compensation
      - sensor.zendure_solarflow_charging_costs
      - switch.zendure_solarflow_1_battery_allow_charge
    trigger: state
conditions:
  - condition: template
    value_template: |
      {{
        has_value('number.omnibattery_pd_target_grid_power')
        and states('number.omnibattery_pd_target_grid_power')|float != target_value|float
      }}
actions:
  - target:
      entity_id: number.omnibattery_pd_target_grid_power
    data:
      value: '{{ target_value | float }}'
    action: number.set_value
variables:
  target_value: |
    {% if has_value('sensor.power_produced')
      and has_value('sensor.electricity_meter_energy_production_compensation')
      and has_value('sensor.zendure_solarflow_charging_costs')
      and states('sensor.electricity_meter_energy_production_compensation')|float > states('sensor.zendure_solarflow_charging_costs')|float
      and not is_state('switch.zendure_solarflow_1_battery_allow_charge', 'on')
    %}
      {{ min( 0.0, states('sensor.power_produced')|float * -1) }}
    {% else %}
      0.0
    {% endif %}
mode: single

2: The blueprint I wrote for the automation that sets my "charge allowed" switch (the blue print allows to select multiple switches if you have more than one battery):

blueprint:
  name: "Price based switcher"
  description: "Turns one or more switches on and off based on the current price for energy compared to the minimum and maximum price during the day. If the price is under the specified percentage, the switch will be on, when the price goes over it, the switch will be turned off. If a device needs to be on at least some time each day, a minimum amount of hours can be specified that the device must be on, even if the price is higher than the calculated percentage."
  domain: automation
  input:
    tibber_sensor:
      name: "(Tibber) Price Sensor"
      description: "Sensor that holds the prices."
      default: sensor.tibber_prices
      selector:
        entity:
          filter:
            - domain: sensor
    target_switches:
      name: "Switches"
      description: "The switch(es) that must be controlled."
      selector:
        target:
          entity:
            domain:
              - switch
              - light
              - input_boolean
              - fan
              - humidifier
              - siren
              - outlet
    price_percentage:
      name: "Price Range Percentage"
      description: "Percentage of the range from the day's maximum price to the minimum price the switch should be on (0.0 - 1.0)."
      default: 0.95
      selector:
        number:
          min: 0.0
          max: 1.0
          step: 0.01
    guaranteed_hours:
      name: "Guaranteed hours"
      description: "Number of hours the switch must be on at a minimum. The process will select the cheapest hours, even if this means the switch is on while the price is over the percentage."
      default: 1.5
      selector:
        number:
          min: 0
          max: 24
          step: 0.25
          unit_of_measurement: "h"
    invert_logic:
      name: "Invert logic (True = turn switch off when the price is low)."
      description: "Enabled: Switch is off when price is low, Disabled: switch is on when price is low."
      default: false
      selector:
        boolean: {}

variables:
  tibber_entity: !input tibber_sensor
  pct: !input price_percentage
  hours: !input guaranteed_hours
  invert: !input invert_logic
  slots_needed: "{{ (hours * 4) | round(0) | int }}"

  # De basis logica: is het nu een 'goedkoop' moment?
  is_cheap_moment: >
    {% set data = state_attr(tibber_entity, 'prices') %}
    {% if data is not none %}
      {% set start_of_day = today_at("00:00") %}
      {% set end_of_day = start_of_day + timedelta(days=1) %}
      {% set ns = namespace(today_list=[]) %}
      {% for p in data %}
        {% set dt = as_datetime(p.start_time) %}
        {% if dt is not none and dt >= start_of_day and dt < end_of_day %}
          {% set ns.today_list = ns.today_list + [dict(p, dt=dt)] %}
        {% endif %}
      {% endfor %}
      {% if ns.today_list | length > 0 %}
        {% set all_prices = ns.today_list | map(attribute='price') | list %}
        {% set threshold = (all_prices | min) + (pct * ((all_prices | max) - (all_prices | min))) %}
        {% set cheapest_times = (ns.today_list | sort(attribute='price'))[:slots_needed] | map(attribute='start_time') | list %}
        {% set now_dt = now() %}
        {% set current_q = now_dt.replace(minute=(now_dt.minute // 15) * 15, second=0, microsecond=0) %}
        {% set current_entry = ns.today_list | selectattr('dt', 'eq', current_q) | first | default(none) %}
        {% if current_entry is not none %}
          {% set is_guaranteed = current_entry.start_time in cheapest_times %}
          {% set price_is_ok = current_entry.price < threshold %}
          {{ is_guaranteed or price_is_ok }}
        {% else %} true {% endif %}
      {% else %} false {% endif %}
    {% else %} false {% endif %}

  # Bepaal de uiteindelijke actie op basis van de invert-instelling
  final_state: >
    {% set cheap = is_cheap_moment | trim == 'True' %}
    {% if invert %}
      {{ 'off' if cheap else 'on' }}
    {% else %}
      {{ 'on' if cheap else 'off' }}
    {% endif %}

  # Bepaal welke apparaten nu niet overeenkomen met de gewenste stand
  target_entities: !input target_switches
  entities_to_switch: >
    {# Expand haalt alle entiteiten op uit devices, areas of entity_ids in de target #}
    {% set all = expand(target_entities.entity_id or [], target_entities.device_id or [], target_entities.area_id or []) %}
    {# Filter de lijst: behoud alleen diegenen waarvan de state NIET gelijk is aan final_state #}
    {{ all | selectattr('state', '!=', final_state) | map(attribute='entity_id') | list }}

trigger:
  - alias: When the prices change
    platform: state
    entity_id: !input tibber_sensor
  - alias: Every 15 minutes
    platform: time_pattern
    minutes: "/15"
  - alias: When Home Assistant starts
    platform: homeassistant
    event: start
  - alias: When automations are reloaded
    event_type: automation_reloaded
    trigger: event

condition:
  - condition: template
    value_template: "{{ entities_to_switch | count > 0 }}"

action:
  - service: homeassistant.turn_{{ final_state }}
    target:
      entity_id: "{{ entities_to_switch }}"

mode: restart

3: My script for keeping track of the price for the energy in the battery:

template:
  - trigger:
      - trigger: state
        entity_id:
          - sensor.zendure_solarflow_1_stored_energy
        not_to:
          - "unavailable"
          - "unknown"
    sensor:
      - name: "Zendure Solarflow charging costs"
        unique_id: "f997992b-ddf1-44ed-8104-edffa5e68319"
        state: |-
          {%  set efficiency = 0.9025 %}
          {%  set current_price = states('sensor.electricity_meter_current_price_for_energy_used') | float %}
          {%  set costs_old = this.state | float(current_price * (1/efficiency)) %}
          {%  set soc_new = trigger.to_state.state | float %}
          {%  if this.attributes.soc is defined %}
          {%    set soc_old = this.attributes.soc | float(soc_new) %}
          {%  else %}
          {%    set soc_old = float(soc_new) %}
          {%  endif %}
          {%  set soc_delta = (soc_new - soc_old) | round(5) %}
          {% if soc_new <= 0.0 or soc_delta <= 0.0 %}
            {{ costs_old }}
          {% else %}
            {{ (((costs_old * soc_old) + (current_price * (1/efficiency) * soc_delta)) / soc_new) | round(10) }}
          {% endif %}
        state_class: measurement
        unit_of_measurement: "EUR/kWh"
        attributes:
          efficiency: |-
            {{ 0.9025 }}
          soc: |-
            {{ trigger.to_state.state | float }}
          price: |-
            {%  set current_price = states('sensor.electricity_meter_current_price_for_energy_used') | float %}
            {%  if this.attributes.price is defined %}
            {%    set price_old = this.attributes.price | float(current_price) %}
            {%  else %}
            {%    set price_old = float(current_price) %}
            {%  endif %}
            {%  set soc_new = trigger.to_state.state | float %}
            {%  if this.attributes.soc is defined %}
            {%    set soc_old = this.attributes.soc | float(soc_new) %}
            {%  else %}
            {%    set soc_old = soc_new %}
            {%  endif %}
            {%  set soc_delta = (soc_new - soc_old) | round(5) %}
            {% if soc_new <= 0.0 or soc_delta <= 0.0 %}
              {{ price_old }}
            {% else %}
              {{ (((price_old * soc_old) + (current_price * soc_delta)) / soc_new) | round(10) }}
            {% endif %}

4: The template used in my template helper sensor to calculate the price for "energy used" from the export price, import price and battery energy price plus various power sensors to calculate the ration between those source.

{% set import_price_entity = 'sensor.electricity_meter_energy_consumption_price' %}
{% set export_price_entity = 'sensor.electricity_meter_energy_production_compensation' %}
{% set battery_out_price_entity = 'sensor.zendure_solarflow_charging_costs' %}

{% set import_entity = 'sensor.power_imported' %}
{% set export_entity = 'sensor.power_exported' %}
{% set production_entity = 'sensor.power_produced' %}
{% set battery_out_entity = 'sensor.omnibattery_system_discharge_power' %}
{% set battery_in_entity = 'sensor.omnibattery_system_charge_power' %}
{% set target_grid_power_entity = 'number.omnibattery_pd_target_grid_power' %}

{% set unit_map = {'mW': 0.000001, 'W': 0.001, 'kW': 1.0, 'MW': 1000.0} %}
                     
{# grid import #}
{% set import_price = states(import_price_entity) | float(0) %}
{% set import_unit = state_attr(import_entity, 'unit_of_measurement') %}
{% set power_import = (states(import_entity) | float(0)) * (unit_map.get(import_unit, 0)) %}

{# grid export #}
{% set export_price = states(export_price_entity) | float(0) %}
{% set export_unit = state_attr(export_entity, 'unit_of_measurement') %}
{% set power_export = (states(export_entity) | float(0)) * (unit_map.get(export_unit, 0)) %}

{# solar production #}
{% set production_price = states(export_price_entity) | float(0) %}
{% set production_unit = state_attr(production_entity, 'unit_of_measurement') %}
{% set power_production = (states(production_entity) | float(0)) * (unit_map.get(production_unit, 0)) %}

{# battery out #}
{% set battery_out_price = states(battery_out_price_entity) | float(0) %}
{% set battery_out_unit = state_attr(battery_out_entity, 'unit_of_measurement') %}
{% set power_battery_out = (states(battery_out_entity) | float(0)) * (unit_map.get(battery_out_unit, 0)) %}

{# battery in #}
{% set battery_in_unit = state_attr(battery_in_entity, 'unit_of_measurement') %}
{% set power_battery_in = (states(battery_in_entity) | float(0)) * (unit_map.get(battery_in_unit, 0)) %}

{# target grid power #}
{% set target_grid_unit = state_attr(target_grid_power_entity, 'unit_of_measurement') %}
{% set power_grid_target = (states(target_grid_power_entity) | float(0)) * (unit_map.get(target_grid_unit, 0)) %}

{% set total_used = max(0.0, ( power_import + power_production + power_battery_out) - (power_export + power_battery_in)) | round(6) %}

{# Battery is prio 1 #}
{% set battery_used = min(total_used, max(0.0, power_battery_out)) | round(6) %}

{# Solar is prio 2 #}
{% set remaining_after_battery = max(0.0, total_used - battery_used) %}
{% set solar_available = max(0.0, power_production - power_battery_in) %}
{% set solar_used = min(remaining_after_battery, solar_available) | round(6) %}

{# Grid is prio 3 #}
{% set grid_used = max(0.0, total_used - battery_used - solar_used) | round(6) %}

{#
total: {{ total_used }}
grid: {{ grid_used }}
solar: {{ solar_used }}
battery: {{ battery_used }}
#}

{% if total_used > 0.0 %}
  {{ (
    import_price * (grid_used / total_used) +
    production_price * (solar_used / total_used) +
    battery_out_price * (battery_used / total_used))
     | round(4) }}
{% else %}
  0.0
{% endif %}

At 10:40 in the morning I'm still discharging my battery at the rate of my home usage: "Price for energy exported" is higher "Price for energy in the battery" and it's not time to start charging yet:

[rrozema]

b.t.w. automatically when the battery reaches minimal SOC discharging will stop and solar production will take over (at the export cost): the Price for energy used will go up to the price of Price for energy exported.

[rrozema]

Some additional tuning will be needed for when the battery capacity is not sufficient to run the household for the extended time that this strategy needs. Most of the times a peak sits just before our solar start producing again. So with a battery run empty before that peak, we're still paying too much for that energy. We would have been better off if we started running off of the battery a little later or running of the grid from some time when the nightly prices are low.

A possible strategy would be -if expected usage exceeds battery capacity- to add some offset to the price at which we switch to battery power in the script where we set the PD target (and states('sensor.electricity_meter_energy_production_compensation')|float > (states('sensor.zendure_solarflow_charging_costs')|float + offset)). This should result in us running off of solar for a little longer or -when that is not available- grid import even while the price is over that in the battery, but it would still be lower than what we pay for the missing energy whe we use that at the peak. (possibly we need to compare the battery price against the price for energy used instead of the export price like I was doing, but this is just an idea, need to work out what effect that would have first...)

[ffunes]

Hi,

I will implement this feature in Omnibattery 1.5.0.

The initial scope I am considering is price-aware solar-surplus absorption: delay battery charging when exporting solar is more valuable, absorb the surplus during cheaper export periods, re-evaluate the plan during the day, and respect a deadline for reaching the required energy target.

Before implementation, please confirm:

1. Should the first version only delay the absorption of available solar surplus, without deliberately discharging stored battery energy to the grid? The forced-discharge part could remain separate under Force battery discharge during high-price peak spikes #270.
2. Should the target be based on the existing predictive charging balance and SOC floor, or should this feature introduce a separate end-of-day SOC target?
3. If solar surplus is insufficient before the deadline, should Omnibattery automatically use the cheapest remaining grid-charging slots?
4. Should household energy reservations be required for the first version, or should the implementation initially use the existing consumption forecast and excluded-device adjustments?
5. Should “cheap” be determined solely from the export-price curve, or also from the stored-energy cost described in [FEATURE] Stored Energy Cost Sensor (€/kWh) for Dynamic Battery Strategies #269?

Once these points are confirmed, I can keep the 1.5.0 scope precise and avoid mixing this with predictive discharge.

[rrozema]

1 I would like to have delayed charging (I prefer "opportunity cost optimized charging" as it is not necessarily only delayed, it can also be stopped early depending on the prices) as an option separate from forced discharging. They rely on very similar concepts, so I can see you combine them in the code, but they serve very different goals, so I can see people opt in on one feature and not the other. I personally would want to avoid discharging into the grid. My request is aimed at targeting highest possible self sufficiency while maximizing ROI (return on investment).

2 this a difficult one: my request was aimed to discharge over a period between 2 charge opportunities, the period being not exactly a day. Each discharge session stretches between the lows in the day ahead prices: the period can be longer one day than the other, plus it doesn't start or end at calendar day boundaries. So not exactly sure how to answer this one.

3 grid charging can be an option when there is sufficient difference between high and low in the day ahead prices, but there is also a chance that it will be cheaper not to run the battery at all (f.e. due to battery and efficiency losses). By keeping track of the battery price (a.k.a charging costs) we can compare the prices to see if we're selling at a loss or a profit, plus how high a profit or loss. It could therefore be possible to create f.e. a strategy that only discharges the battery when the export price is X over the costs made to charge the battery.

4 the better the forecasts for energy produced and energy used, the more predictable the strategy will be. But with some safeties like already defined for other features (f.e. safety percentage to add) an initial version can certainly be useful.

5 by using the 4 prices I described (import, export, battery and used) we define a mathematically solid model to determine exactly if and even how much a profit or a loss is made. I think we can only make reliable decisions if we have such exact information. So I say we need #269. #269 doesn't have to be part of the omnibattery integration though. It can be a separate integration or blueprint or a trigger template sensor (this is how I implemented it, but I found it is rather hard to distribute it to other people as a trigger template sensor).
I have never created an integration, but I hope to make one one day that implements my proposed 4 energy prices model. You're welcome to use my ideas though if you would want to build it as an integration.

[rrozema]

B.t.w. the 4 energy prices model itself is contract type agnostic, it works just as well for other contract types as for dynamic contracts. The model gives us the ability to calculate exactly what the cost price for energy used in our house is at any time. This means we can also tell exactly what the price is for the energy used to charge our batteries. Using that price we can then calculate the charging costs, resulting in a price for the energy in the battery. And using that price for the energy in the battery we can then always tell whether we're making a profit plus how big a profit.

[syphernl]

@ffunes I had a go at this before seeing your comment: PR #355, against release/v1.4.0. It lands close to your scope, so against your five points:

1. Delay only. A surplus_price_hold charge blocker outside the chosen windows lets the surplus export by itself; nothing is deliberately discharged. Force battery discharge during high-price peak spikes #270 stays separate.
2. Existing balance: remaining consumption + safety margin − energy above the floor, capped by free space. No new end-of-day SOC target.
3. Not yet. The deadline is the end of solar production, and the hold releases once the remaining cheap windows can no longer cover the target. A grid top-up before the evening peak looks like it belongs in _evaluate_evening_recharge rather than a second charging path.
4. Existing forecast, with excluded-device adjustments arriving through the normal decision. No reservations.
5. Export curve only, plus an optional export price sensor (@mhjansen79's ask) that falls back to the import curve when unset. [FEATURE] Stored Energy Cost Sensor (€/kWh) for Dynamic Battery Strategies #269 not used.

Starting point, not a claim on the feature. If you'd rather write it yourself, the PR at least documents the guard matrix against charge delay, cheap grid slots, negative-price charging and smart pre-discharge.

[Roylegr]

Thanks for all the work on this — the approach with #269 and the battery cost model described above looks very promising and seems to cover most of what I was looking for.

There is just one additional use case I would like to clarify, especially for the Netherlands after net metering (saldering) ends.

I am not looking for forced discharge to the grid. I would like the stored-energy cost to also influence normal discharge for self-consumption.

For example:

• Solar energy stored when the feed-in/export value is €0.04/kWh has a very low cost basis.
• Energy deliberately charged from the grid at €0.20/kWh has a much higher cost basis.

If the current import price is €0.15/kWh, I would want Omnibattery to use the solar-charged energy to supply the house, because avoiding €0.15/kWh grid import with energy worth only €0.04/kWh is profitable.

But if the stored energy was charged from the grid at €0.20/kWh, I would want Omnibattery to keep that energy in the battery for a later, more expensive period.

So this is not about deliberately exporting battery energy during price peaks (#270), but about using the stored energy cost from #269 as a dynamic threshold for normal self-consumption discharge.

Would this eventually fall under the planned predictive discharge logic, or would it need a separate feature request?

For Dutch users this will become particularly relevant after saldering ends, because the opportunity cost of storing surplus solar can be much lower than the cost of charging the same battery from the grid.

[rrozema]

That is exactly what i am doing using 2 small automations:
1 - "price based switcher" turns off 'enable charging' except when prices are at their lowest.
2 - "pd target to solar power" keeps omnibattery's PD target in sync with the solar production when charging is not enabled.

These 2 steps have the following effect: i charge my battery at the lowest possible price. Preferably -and in this demo setup only- using solar. A more advanced prediction strategy is needed to automatically determine the exact number of slots of solar charging needed and only if insufficient solar energy can be charged additional grid power should be used to charge, still at the cheapest available slots.
Then when no longer charging and the price for energy in the battery is below the price for exported energy, the pd target will be set to negative solar production. The battery will discharge exactly the energy used by my home. Any solar still left will be pushed into the grid resulting in profit, since we're running our home at the battery price. The script can be kept running all night: as solar will gradually got to 0, also the pd target will go to 0.

blueprint:
  name: "Price based switcher"
  description: "Turns one or more switches on and off based on the current price for energy compared to the minimum and maximum price during the day. If the price is under the specified percentage, the switch will be on, when the price goes over it, the switch will be turned off. If a device needs to be on at least some time each day, a minimum amount of hours can be specified that the device must be on, even if the price is higher than the calculated percentage."
  domain: automation
  input:
    tibber_sensor:
      name: "(Tibber) Price Sensor"
      description: "Sensor that holds the prices."
      default: sensor.tibber_prices
      selector:
        entity:
          filter:
            - domain: sensor
    target_switches:
      name: "Switches"
      description: "The switch(es) that must be controlled."
      selector:
        target:
          entity:
            domain:
              - switch
              - light
              - input_boolean
              - fan
              - humidifier
              - siren
              - outlet
    price_percentage:
      name: "Price Range Percentage"
      description: "Percentage of the range from the day's maximum price to the minimum price the switch should be on (0.0 - 1.0)."
      default: 0.95
      selector:
        number:
          min: 0.0
          max: 1.0
          step: 0.01
    guaranteed_hours:
      name: "Guaranteed hours"
      description: "Number of hours the switch must be on at a minimum. The process will select the cheapest hours, even if this means the switch is on while the price is over the percentage."
      default: 1.5
      selector:
        number:
          min: 0
          max: 24
          step: 0.25
          unit_of_measurement: "h"
    invert_logic:
      name: "Invert logic (True = turn switch off when the price is low)."
      description: "Enabled: Switch is off when price is low, Disabled: switch is on when price is low."
      default: false
      selector:
        boolean: {}

variables:
  tibber_entity: !input tibber_sensor
  pct: !input price_percentage
  hours: !input guaranteed_hours
  invert: !input invert_logic
  slots_needed: "{{ (hours * 4) | round(0) | int }}"

  # De basis logica: is het nu een 'goedkoop' moment?
  is_cheap_moment: >
    {% set data = state_attr(tibber_entity, 'prices') %}
    {% if data is not none %}
      {% set start_of_day = today_at("00:00") %}
      {% set end_of_day = start_of_day + timedelta(days=1) %}
      {% set ns = namespace(today_list=[]) %}
      {% for p in data %}
        {% set dt = as_datetime(p.start_time) %}
        {% if dt is not none and dt >= start_of_day and dt < end_of_day %}
          {% set ns.today_list = ns.today_list + [dict(p, dt=dt)] %}
        {% endif %}
      {% endfor %}
      {% if ns.today_list | length > 0 %}
        {% set all_prices = ns.today_list | map(attribute='price') | list %}
        {% set threshold = (all_prices | min) + (pct * ((all_prices | max) - (all_prices | min))) %}
        {% set cheapest_times = (ns.today_list | sort(attribute='price'))[:slots_needed] | map(attribute='start_time') | list %}
        {% set now_dt = now() %}
        {% set current_q = now_dt.replace(minute=(now_dt.minute // 15) * 15, second=0, microsecond=0) %}
        {% set current_entry = ns.today_list | selectattr('dt', 'eq', current_q) | first | default(none) %}
        {% if current_entry is not none %}
          {% set is_guaranteed = current_entry.start_time in cheapest_times %}
          {% set price_is_ok = current_entry.price < threshold %}
          {{ is_guaranteed or price_is_ok }}
        {% else %} true {% endif %}
      {% else %} false {% endif %}
    {% else %} false {% endif %}

  # Bepaal de uiteindelijke actie op basis van de invert-instelling
  final_state: >
    {% set cheap = is_cheap_moment | trim == 'True' %}
    {% if invert %}
      {{ 'off' if cheap else 'on' }}
    {% else %}
      {{ 'on' if cheap else 'off' }}
    {% endif %}

  # Bepaal welke apparaten nu niet overeenkomen met de gewenste stand
  target_entities: !input target_switches
  entities_to_switch: >
    {# Expand haalt alle entiteiten op uit devices, areas of entity_ids in de target #}
    {% set all = expand(target_entities.entity_id or [], target_entities.device_id or [], target_entities.area_id or []) %}
    {# Filter de lijst: behoud alleen diegenen waarvan de state NIET gelijk is aan final_state #}
    {{ all | selectattr('state', '!=', final_state) | map(attribute='entity_id') | list }}

trigger:
  - alias: When the prices change
    platform: state
    entity_id: !input tibber_sensor
  - alias: Every 15 minutes
    platform: time_pattern
    minutes: "/15"
  - alias: When Home Assistant starts
    platform: homeassistant
    event: start
  - alias: When automations are reloaded
    event_type: automation_reloaded
    trigger: event

condition:
  - condition: template
    value_template: "{{ entities_to_switch | count > 0 }}"

action:
  - service: homeassistant.turn_{{ final_state }}
    target:
      entity_id: "{{ entities_to_switch }}"

  # Voer de actie alleen uit als de lijst niet leeg is
#  - if:
#      - condition: template
#        value_template: "{{ entities_to_switch | length > 0 }}"
#    then:
#      - service: "homeassistant.turn_{{ final_state }}"
#        target:
#          entity_id: "{{ entities_to_switch }}"

mode: restart

alias: 'Battery: Set the PD target to push solar out'
description: >
  Synchroniseert number.omnibattery_pd_target_grid_power met de inverted solar
  production om de solar power meteen naar het net te sturen.
triggers:
  - alias: When Home Assistant starts
    event: start
    trigger: homeassistant
  - alias: When automations are reloaded
    event_type: automation_reloaded
    trigger: event
  - alias: When one of the inputs changes state
    entity_id:
      - sensor.power_produced
      - sensor.electricity_meter_energy_production_compensation
      - sensor.price_for_energy_in_the_battery
      - switch.zendure_solarflow_1_battery_allow_charge
    trigger: state
conditions:
  - condition: template
    value_template: |
      {{
        has_value('number.omnibattery_pd_target_grid_power')
        and states('number.omnibattery_pd_target_grid_power')|float != target_value|float
      }}
actions:
  - target:
      entity_id: number.omnibattery_pd_target_grid_power
    data:
      value: '{{ target_value | float }}'
    action: number.set_value
variables:
  target_value: |
    {% if has_value('sensor.power_produced')
      and has_value('sensor.electricity_meter_energy_production_compensation')
      and has_value('sensor.price_for_energy_in_the_battery')
      and states('sensor.electricity_meter_energy_production_compensation')|float > states('sensor.price_for_energy_in_the_battery')|float
      and not is_state('switch.zendure_solarflow_1_battery_allow_charge', 'on')
    %}
      {{ min( 0.0, states('sensor.power_produced')|float * -1) }}
    {% else %}
      0.0
    {% endif %}
mode: single

[Roylegr]

Thanks, this is exactly the kind of logic I mean.

The important part for my use case is that the stored energy cost can influence whether the battery should be used for self-consumption or preserved for later.

Your workaround shows that this can already be done externally in Home Assistant, but ideally I would like Omnibattery to handle this natively using the stored-energy cost from #269.

That way, after net metering ends, solar-charged energy with a low opportunity cost could be discharged at relatively low import prices, while more expensive grid-charged energy could be kept for later higher-price periods.

[schraller]

Thanks for this suggestion! It would be great, however, if the basic logic of charging from solar during cheapest hours would also work without dynamic feed-in tariffs.
I currently have a fixed feed-in tariff and I am subject to the German rule of not exporting more than 70% of maximum production to the grid. On sunny days I therefore loose some energy during peak hours. I would like to capture that surplus in my battery.

Additionally I would like to be a "good citizen" and charge my battery at time of maximum production to help the grid as much as possible.

Currently I am using Charge Delay with a buffer of several hours. But that is only a rough approximation of what I want.

So for me the goal would be "always charge during time of maximum solar production". This is probably very similar to the proposed "charge when most economical" solution. But I don't think there is a free, public feed-in tariff API available for my region so I would have to use spot-market tariffs as a proxy.

[RobbertvanOeveren]

Adding a concrete Dutch/Nord Pool use case for this, plus some thoughts on the four open questions above.

Problem I ran into

Until separate import/export prices land, Omnibattery's dynamic-pricing engine - specifically the negative-price/opportunistic-charging check, but really any price-vs-threshold comparison - works off the raw wholesale price from price_sensor. In the Netherlands that check has no idea about energy tax (energiebelasting) or the supplier's import markup - together about EUR 0.13/kWh on my contract. Nord Pool NL sat around EUR 0.000-0.005/kWh for part of an afternoon (technically negative at times), while my actual all-in import price stayed a steady ~EUR 0.13/kWh throughout. Omnibattery started an "opportunistic" grid charge in that window - it wasn't actually free or profitable.

I looked at repointing price_sensor at a template sensor with tax added, but the options-flow validation for price_integration_type: nordpool requires the sensor to carry a raw_today attribute (the whole day's curve) - same story for EPEX/ENTSO-E/PVPC/CKW's own required attributes. A plain "current all-in price" sensor can't satisfy any of those, so there's currently no way to get the pricing engine to reason about the after-tax price at all.

On your four questions, from an NL/Nord Pool point of view:

1. Yes - all-in (tax + VAT + supplier fees included), positive EUR/kWh, for both import and export. That's the number that actually matches the bill, and it's what several of us already compute via a template sensor as a workaround.
2. Yes, at least for Nord Pool NL - the official sensor exposes a full day (and next-day-after ~13:00 CET) curve via raw_today/raw_tomorrow attributes. That shape doesn't change whether the values are raw or all-in, so the same "day curve" concept should carry over cleanly.
3. Falling back to current single-price behavior seems safest for backward compatibility - fail-safe would silently disable strategies for anyone who hasn't migrated their config yet.
4. No strong opinion here since I don't have a fixed/dual tariff, but consuming an already-calculated tariff entity seems more robust than Omnibattery reimplementing tariff-period logic per country/contract type.

One concrete ask for whoever implements this: please make sure the negative-price/opportunistic-charging feature (and max_price_threshold / discharge_price_threshold) get switched to compare against the new all-in import price once it exists, not just deficit/arbitrage planning. Right now pricing/engine.py filters slots with a hardcoded slot.price < 0.0 against whatever the single legacy price_sensor reports - that's the specific thing that bit me.

[rrozema]

I have implemented a triggered template sensor off of the nordpool epex integration to calculate Tibber's export price into a sensor that has the exact same format and attributes as the nordpool sensor. I.e. this can be used as the export sensor in Nord pool format by Omnibattery, while still using the original API-based Tibber for the import prices.
Here is the template:

template:
   - trigger:
      - platform: state
        entity_id: sensor.nordpool_kwh_nl_eur_4_10_0
        id: nordpool_updated
      - platform: homeassistant
        event: start
        id: ha_started
      - platform: event
        event_type: event_template_reloaded
        id: ha_started

    sensor:
      - name: "Tibber Export Price (Nord Pool Format)"
        unique_id: tibber_export_price_nordpool_format
        unit_of_measurement: "EUR/kWh"
        device_class: monetary
        state_class: measurement
        icon: mdi:solar-power-variant

        availability: >
          {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
          {{ tr is not none and tr.state not in ['unavailable', 'unknown', 'none'] }}

        state: >
          {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
          {% if tr is none or tr.state in ['unavailable', 'unknown', 'none'] %}
            unknown
          {% else %}
            {% set epex = tr.state | float(0) %}
            {% set yr = tr.last_updated.year if tr.last_updated is defined else now().year %}
            
            {# --- AANPASBARE TARIEVEN --- #}
            {% set eb_inc_vat = 0.11085 %}        {# Energiebelasting incl. BTW #}
            {% set verkoop_inc_vat = 0.01800 %}   {# Tibber verkoopopslag incl. BTW #}
            {% set vat = 1.21 %}                  {# BTW tarief #}
            
            {% if yr <= 2026 %}
              {{ ((epex * vat) + eb_inc_vat - verkoop_inc_vat) | round(4) }}
            {% else %}
              {{ epex | round(4) }}
            {% endif %}
          {% endif %}

        attributes:
          unit: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {{ tr.attributes.get('unit', 'kWh') if tr and tr.attributes is defined else 'kWh' }}
          unit_of_measurement: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {{ tr.attributes.get('unit_of_measurement', 'EUR/kWh') if tr and tr.attributes is defined else 'EUR/kWh' }}
          currency: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {{ tr.attributes.get('currency', 'EUR') if tr and tr.attributes is defined else 'EUR' }}
          country: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {{ tr.attributes.get('country') if tr and tr.attributes is defined else none }}
          region: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {{ tr.attributes.get('region') if tr and tr.attributes is defined else none }}
          tomorrow_valid: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {{ tr.attributes.get('tomorrow_valid', false) if tr and tr.attributes is defined else false }}
          low_price: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {{ tr.attributes.get('low_price', false) if tr and tr.attributes is defined else false }}
          price_percent_to_average: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {{ tr.attributes.get('price_percent_to_average') if tr and tr.attributes is defined else none }}
          off_peak_1: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {{ tr.attributes.get('off_peak_1') if tr and tr.attributes is defined else none }}
          off_peak_2: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {{ tr.attributes.get('off_peak_2') if tr and tr.attributes is defined else none }}
          peak: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {{ tr.attributes.get('peak') if tr and tr.attributes is defined else none }}

          raw_today: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {% set raw = tr.attributes.get('raw_today') if (tr and tr.attributes is defined) else [] %}
            {% if not raw %}[]{% else %}
              {% set yr = tr.last_updated.year if tr.last_updated is defined else now().year %}
              {% set eb_inc_vat = 0.11085 %}
              {% set verkoop_inc_vat = 0.01800 %}
              {% set vat = 1.21 %}
              {% set ns = namespace(items=[]) %}
              {% for item in raw %}
                {% set epex = item.value | float(0) %}
                {% set val = ((epex * vat) + eb_inc_vat - verkoop_inc_vat) | round(4) if yr <= 2026 else epex | round(4) %}
                {% set ns.items = ns.items + [{
                  'start': item.get('start', item.get('time_start')),
                  'end': item.get('end', item.get('time_end')),
                  'value': val
                }] %}
              {% endfor %}
              {{ ns.items }}
            {% endif %}

          raw_tomorrow: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {% set raw = tr.attributes.get('raw_tomorrow') if (tr and tr.attributes is defined) else [] %}
            {% if not raw %}[]{% else %}
              {% set yr = tr.last_updated.year if tr.last_updated is defined else now().year %}
              {% set eb_inc_vat = 0.11085 %}
              {% set verkoop_inc_vat = 0.01800 %}
              {% set vat = 1.21 %}
              {% set ns = namespace(items=[]) %}
              {% for item in raw %}
                {% set epex = item.value | float(0) %}
                {% set val = ((epex * vat) + eb_inc_vat - verkoop_inc_vat) | round(4) if yr <= 2026 else epex | round(4) %}
                {% set ns.items = ns.items + [{
                  'start': item.get('start', item.get('time_start')),
                  'end': item.get('end', item.get('time_end')),
                  'value': val
                }] %}
              {% endfor %}
              {{ ns.items }}
            {% endif %}

          today: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {% set prices = tr.attributes.get('today') if (tr and tr.attributes is defined) else [] %}
            {% if not prices %}[]{% else %}
              {% set yr = tr.last_updated.year if tr.last_updated is defined else now().year %}
              {% set eb_inc_vat = 0.11085 %}
              {% set verkoop_inc_vat = 0.01800 %}
              {% set vat = 1.21 %}
              {% set ns = namespace(items=[]) %}
              {% for p in prices %}
                {% set epex = p | float(0) %}
                {% set val = ((epex * vat) + eb_inc_vat - verkoop_inc_vat) | round(4) if yr <= 2026 else epex | round(4) %}
                {% set ns.items = ns.items + [val] %}
              {% endfor %}
              {{ ns.items }}
            {% endif %}

          tomorrow: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {% set prices = tr.attributes.get('tomorrow') if (tr and tr.attributes is defined) else [] %}
            {% if not prices %}[]{% else %}
              {% set yr = tr.last_updated.year if tr.last_updated is defined else now().year %}
              {% set eb_inc_vat = 0.11085 %}
              {% set verkoop_inc_vat = 0.01800 %}
              {% set vat = 1.21 %}
              {% set ns = namespace(items=[]) %}
              {% for p in prices %}
                {% set epex = p | float(0) %}
                {% set val = ((epex * vat) + eb_inc_vat - verkoop_inc_vat) | round(4) if yr <= 2026 else epex | round(4) %}
                {% set ns.items = ns.items + [val] %}
              {% endfor %}
              {{ ns.items }}
            {% endif %}

          min: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {% set prices = tr.attributes.get('today') if (tr and tr.attributes is defined) else [] %}
            {% if not prices %}0.0{% else %}
              {% set yr = tr.last_updated.year if tr.last_updated is defined else now().year %}
              {% set eb_inc_vat = 0.11085 %}
              {% set verkoop_inc_vat = 0.01800 %}
              {% set vat = 1.21 %}
              {% set min_p = prices | min | float(0) %}
              {{ ((min_p * vat) + eb_inc_vat - verkoop_inc_vat) | round(4) if yr <= 2026 else min_p | round(4) }}
            {% endif %}

          max: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {% set prices = tr.attributes.get('today') if (tr and tr.attributes is defined) else [] %}
            {% if not prices %}0.0{% else %}
              {% set yr = tr.last_updated.year if tr.last_updated is defined else now().year %}
              {% set eb_inc_vat = 0.11085 %}
              {% set verkoop_inc_vat = 0.01800 %}
              {% set vat = 1.21 %}
              {% set max_p = prices | max | float(0) %}
              {{ ((max_p * vat) + eb_inc_vat - verkoop_inc_vat) | round(4) if yr <= 2026 else max_p | round(4) }}
            {% endif %}

          mean: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {% set prices = tr.attributes.get('today') if (tr and tr.attributes is defined) else [] %}
            {% if not prices %}0.0{% else %}
              {% set yr = tr.last_updated.year if tr.last_updated is defined else now().year %}
              {% set eb_inc_vat = 0.11085 %}
              {% set verkoop_inc_vat = 0.01800 %}
              {% set vat = 1.21 %}
              {% set avg_p = (prices | sum / prices | count) | float(0) %}
              {{ ((avg_p * vat) + eb_inc_vat - verkoop_inc_vat) | round(4) if yr <= 2026 else avg_p | round(4) }}
            {% endif %}

          average: >
            {% set tr = trigger.to_state if trigger.id == 'nordpool_updated' else states.sensor.nordpool_kwh_nl_eur_4_10_0 %}
            {% set prices = tr.attributes.get('today') if (tr and tr.attributes is defined) else [] %}
            {% if not prices %}0.0{% else %}
              {% set yr = tr.last_updated.year if tr.last_updated is defined else now().year %}
              {% set eb_inc_vat = 0.11085 %}
              {% set verkoop_inc_vat = 0.01800 %}
              {% set vat = 1.21 %}
              {% set avg_p = (prices | sum / prices | count) | float(0) %}
              {{ ((avg_p * vat) + eb_inc_vat - verkoop_inc_vat) | round(4) if yr <= 2026 else avg_p | round(4) }}
            {% endif %}       

Edit: I accidentally posted the -not correctly working- import price sensor. Now the above is the correct export price sensor. It includes checks so that starting January 1st, 2027 the prices are shown without salderingsregeling and before that with salderingsregeling.

[iceicerickert]

after installing omnibattery and playing with it im very happy except im missing 2 features. This one, #410 and #270.
They all are very popular and I understand why. With those 3 you have a very complete package and I think nothing else for home-assistant comes close to that feature set.
Maybe we can sign off on those 3 so we can start implementing the changes?

[ffunes]

Implemented — available in 1.5.0b3.

How it works:

• The battery no longer swallows solar surplus the moment it appears. It looks at the feed-in price curve for the rest of the day, works out how much it still needs to store to cover the evening, and picks the cheapest feed-in hours to do it. During the expensive hours the surplus goes to the grid instead.
• It only delays absorption — nothing stored is deliberately exported. That stays separate under Force battery discharge during high-price peak spikes #270.
• The plan is rebuilt through the day. If the remaining cheap hours can no longer cover what you need before the sun goes, the hold is released and the battery charges normally. Release is always the safe direction: it will never leave you short to chase a better price.
• Anything that legitimately needs charge — negative prices, the weekly full charge, being at the SOC floor, curtailment, manual mode — releases the hold as well.
• A minimum-saving setting stops it from flipping on and off for a fraction of a cent.

Where to find it: the Surplus Price Hold switch, with Predictive Charging in Dynamic Pricing mode (it needs a forward price curve, so real-time price mode is out). If you have configured a separate feed-in price sensor it uses that; without one it falls back to the import curve, which is the right number under net metering.

What you'll see: a Surplus Price Hold Status sensor with the current plan and the reason, and the battery status showing Surplus Exporting (Cheaper Window Ahead) while it is holding.

Not included: deciding whether to use stored energy based on what it cost to store it — that's #269.

Feedback from a sunny day on a dynamic contract would be very welcome.

[iceicerickert]

this looks awesome, I will migrate from my own custom sensors to the complete solution this week and report back.

[rrozema]

Installed and enabled. Waiting for a sunny day.

[onlineous]

Well done @ffunes !

I might overlook something, but can you explain the

A minimum-saving setting stops it from flipping on and off for a fraction of a cent.

What does this do, what flips on and off?

Lets take the very hypothetical short day of 5 hours day + night after that. All hours have a solar surplus of 2 kWh, your battery is 4 kWh.
Electricity prices
Hour 1: 3 cents
Hour 2: 1 cents
Hour 3: 0 cents
Hour 4: 0 cents
Hour 5: 3 cents

Optimal is when the battery delays charging until hour 3, and then charges for 2 hours until completely full.

What would the minimum saving setting do in this situation?

I can imagine you might not want to discharge your battery for a saving of 1 cent for every kWh, but when you delay charging you don't do that right? You just delay charging, total cycles on the battery stay the same.

But I might have overlooked something totally obvious ;)

[ffunes]

Good catch: "flipping on and off" undersold what it does. Here's what it actually does.

The thing that switches is the hold, meaning "don't charge from surplus right now, export it instead." For each price slot it asks one question: is there a slot later today, with surplus, that's cheaper than this one by at least min_saving? If yes, it holds. If no, the battery charges.

Your example, with the default min_saving = 0.02 (2 c/kWh), ignoring conversion losses:

Hour	Price	Cheapest slot ahead	Check	Result
1	3 c	0 c	0 ≤ 3 − 2 → yes	hold, export
2	1 c	0 c	0 ≤ 1 − 2 → no	charge 2 kWh
3	0 c	–	planned absorption slot	charge 2 kWh, battery full
4	0 c	–	full	export at 0 c
min_saving?* If yes, it holds. If no, the battery charges.

Your example, with the default min_saving = 0.02 (2 c/kWh), ignoring conversion losses:

Hour	Price	Cheapest slot ahead	Check	Result
1	3 c	0 c	0 ≤ 3 − 2 → yes	hold, export
2	1 c	0 c	0 ≤ 1 − 2 → no	charge 2 kWh
3	0 c	–	planned absorption slot	charge 2 kWh, battery full
4	0 c	–	full	export at 0 c

So with the default, it gives up 1 c × 2 kWh = 2 cents compared with your optimum. If you set min_saving to 0.01 or 0, it holds in hour 2 as well and charges inscribe.

You're right that delaying doesn't add cyclereason for the margin. The real reason isforecast risk. A hold is a bet that the surplus will still be there later. If clouds come in hours 3–4, the battery doesn't fill, and you buy that energy back at night at the import price, which is usually many times the 1 c you gained. The margin means the system only makes that bet when the gain is worth it. A small loss is still possible: the hold ends as soon as the remaining planned surplus can't reach the target, but by then the surplus you exported is gone.

If you trust your forecast or your import/export spread is small, lowering it toward 0 is reasonable.

[onlineous]

Thank you for clarifying, the forecast risk makes sense, so I raised the Surplus Hold Minimum Saving a bit from 0.000 to 0.011

I still can't get the delay to work. The entity state from hold_status gives:

enabled: true
min_saving: 0.011
export_price_source: import_fallback
state: released
reason: manual_control
hold: false
plan_status: fail_safe
plan_reason: missing_charge_capacity
target_kwh: 0
remaining_target_kwh: 0
absorbable_remaining_kwh: 0
free_space_kwh: 0
deadline: 2026-09-23T19:32:04.729477
selected_slots:
next_release_at: null
device_class: running
icon: mdi:transmission-tower-export
friendly_name: Omnibattery System Surplus Price Hold Status

What is the charge capacity? I would say, based on the name, that this is the battery capacity, but I do have that number in HA.