Solakon ONE support

[phoerious]

I'm trying to integrate my Solakon ONE with Predbat. I think I got halfway there, but it's not yet working.

First of all, the Solakon ONE comes with a remote control HA integration, which I have installed (that works I've used it for other things before). Here are the entities it exposes:

It does not support any kind of scheduled charge or discharge cycles. You have to enable remote control mode to force charge or force discharge, and then set number.solakon_one_remote_control_power or number.solakon_one_maximum_discharge_current.

I got predbat to detect my current consumption and make a plan. However, I could not get it to set any actual helper values and it also keeps throwing warnings about certain entities either not being available or being unable to change their values. I've created dummy entities for some of them already.

Here's my current config:

Details

pred_bat:
  module: predbat
  class: PredBat

  # Sets the prefix for all created entities in HA - only change if you want to run more than once instance
  prefix: predbat

  # XXX: This is a configuration template, delete this line once you edit your configuration
  #template: true
  # Timezone to work in
  timezone: Europe/Berlin

  # Currency, symbol for main currency and second symbol for 1/100s e.g. $ c, £ p or € c
  currency_symbols:
  - '€'
  - 'ct'

  # Number of threads to use in plan calculation
  # Can be auto for automatic, 0 for off or values 1-N for a fixed number
  threads: auto

  # If you are using Predbat outside of HA then set the HA URL and Key (long lived access token here)
  #ha_url: 'http://homeassistant.local:8123'
  #ha_key: !secret ha_key

  # Set to auto-match with a GivEnergy serial number, but you can override the serial or the sensor names
  # if it doesn't work or if you have more than one inverter you will need to list both
  #geserial: 're:sensor.givtcp_(.+)_soc_kwh'
  #geserial2: 're:sensor.givtcp2_(.+)_soc_kwh'

  # Sets the maximum period of zero load before the gap is filled, default 30 minutes
  # To disable set it to 1440
  load_filter_threshold: 30

  #
  # Energy today (not power) sensors, more than one can be specified and they will be summed up automatically
  #
  # For two inverters the load today would normally be the master load sensor only (to cover the entire house)
  # If you have three phase and one inverter per phase then you would need three load sensors
  #
  # For pv_today if you have multiple solar inverter inputs then you should include one entry for each inverter
  #
  load_today:
  - sensor.predbat_load_energy_today
  import_today:
  - sensor.tibber_pulse_MYHOME_accumulated_consumption
  export_today:
  - sensor.tibber_pulse_MYHOME_accumulated_production
  pv_today:
  - sensor.solakon_one_daily_energy

  # Load forecast can be used to add to the historical load data (heat-pump)
  # To link to Predheat
  # Data must be in the format of 'last_updated' timestamp and 'energy' for incrementing kWh
  #load_forecast:
  #  - predheat.heat_energy$external
  #
  # If you enable ge_cloud_data then the load/import and export data will be fetches from the GE cloud instead of from GivTCP sensors
  # this is usually less efficient and of course prone to internet downtime, but could be useful if you lost your GivTCP data
  # Set the serial to the inverter serial to pull the data from and the key to your API key
  # When this is set load_today, import_today and export_today are not used
  #
  #ge_cloud_data: False
  #ge_cloud_serial: '{geserial}'
  #ge_cloud_key: !secret ge_cloud_key

  # Fox direct cloud interface
  #fox_key: !secret fox_key
  #fox_automatic: True

  #
  # Controls/status - must by 1 per inverter
  #
  num_inverters: 1

  #
  # Run balance inverters every N seconds (0=disabled) - only for multi-inverter
  balance_inverters_seconds: 60
  #
  # When set use the REST API rather than HA entity for control, should be more reliable/faster to control
  # Set one per inverter
  # If using Docker then change homeassistant.local to the Docker IP address
  #givtcp_rest:
  #- 'http://homeassistant.local:6345'
  #- 'http://homeassistant.local:6346'

  # When enabled automatic restart will restart the app if communication fails
  # Example below is auto-restart for GivTCP app itself
  #auto_restart:
  #  - shell: 'rm -rf /homeassistant/GivTCP/*.pkl'
  #  - service: hassio/addon_restart
  #    addon: 533ea71a_givtcp
  #
  #  Example on how to restart the inverter via GivTCP
  #  - service: button.press
  #    entity_id: button.givtcp_{geserial}_reboot_invertor

  # If not using REST then instead set the Control here (one for each inverter)
  # You should keep this section even when using REST as a fallback if it fails and for charge curve calculations
  inverter_type: Solakon ONE
  inverter:
    name: Solakon ONE
    has_rest_api: false
    has_mqtt_api: false
    has_service_api: false
    current_dp: 1
    charge_discharge_with_rate: false
    has_charge_enable_time: false
    has_discharge_enable_time: false
    has_target_soc: false
    target_soc_used_for_discharge: false
    has_timed_pause: false
    time_button_press: false
    support_charge_freeze: false
    support_discharge_freeze: false
    has_ge_inverter_mode: false
    has_fox_inverter_mode: false
    has_idle_time: false
    has_time_window: false
    soc_units: "%"
    has_reserve_soc: true

  charge_control_immediate: true
  output_charge_control: current
  timed_charge_current:
  - input_number.predbat_timed_charge_current
  timed_discharge_current:
  - input_number.predbat_timed_discharge_current
  reserve:
  - number.solakon_one_minimum_state_of_charge
  
  # Dummy entities to silence warnings
  charge_start_time:
  - input_datetime.predbat_dummy_charge_start
  charge_end_time:
  - input_datetime.predbat_dummy_charge_end
  discharge_start_time:
  - input_datetime.predbat_dummy_discharge_start
  discharge_end_time:
  - input_datetime.predbat_dummy_discharge_end
  charge_rate:
  - input_number.predbat_dummy_charge_rate
  discharge_rate:
  - input_number.predbat_dummy_discharge_rate

  pv_power:
  - sensor.solakon_one_pv_power
  load_power:
  - sensor.predbat_load_power
  grid_power:
  - sensor.tibber_bridge_0100100700ff
  battery_power:
  - sensor.solakon_one_battery_power_2
  soc_percent:
  - sensor.solakon_one_battery_state_of_charge
  soc_max:
  - sensor.solakon_one_battery_capacity
  battery_voltage:
  - sensor.solakon_one_battery_voltage
  battery_temperature:
  - sensor.solakon_one_battery_max_temperature

  # Inverter max AC limit (one per inverter). E.g for a 3.6kw inverter set to 3600
  # If you have a second inverter for PV only please add the two values together
  inverter_limit:
  - 1200

  # Export limit is a software limit set on your inverter that prevents exporting above a given level
  # When enabled Predbat will model this limit
  export_limit:
  - 800
  inverter_limit_discharge:
  - 800

  # Some inverters don't turn off when the rate is set to 0, still charge or discharge at around 200w
  # The value can be set here in watts to model this (doesn't change operation)
  #inverter_battery_rate_min:
  #  - 200

  # Workaround to limit the maximum reserve setting, some inverters won't allow 100% to be set
  # Comment out if your inverter allows 100%
  #inverter_reserve_max: 100

  # Some batteries tail off their charge rate at high soc%
  # enter the charging curve here as a % of the max charge rate for each soc percentage.
  # the default is 1.0 (full power)
  # The example below is from GE 9.5kwh battery with latest firmware and gen1 inverter
  #
  # Predbat can compute this curve automatically if you have enough data, restart the app and look in the logfile for the data
  # once set here Predbat will no longer re-compute the curve.
  # Can also be set to 'auto' to just use the calculation curve, not recommended if you are using low power charging mode.
  #battery_charge_power_curve:
  #  91 : 0.91
  #  92 : 0.81
  #  93 : 0.71
  #  94 : 0.62
  #  95 : 0.52
  #  96 : 0.43
  #  97 : 0.33
  #  98 : 0.24
  #  99 : 0.24
  #  100 : 0.24
  #battery_discharge_power_curve:
  #  4 : 1.0

  # Inverter clock skew in minutes, e.g. 1 means it's 1 minute fast and -1 is 1 minute slow
  # Separate start and end options are applied to the start and end time windows, mostly as you want to start late (not early) and finish early (not late)
  # Separate discharge skew for discharge windows only
  inverter_clock_skew_start: 0
  inverter_clock_skew_end: 0
  inverter_clock_skew_discharge_start: 0
  inverter_clock_skew_discharge_end: 0

  # Clock skew adjusts the Appdaemon time
  # This is the time that Predbat takes actions like starting discharge/charging
  # Only use this for workarounds if your inverter time is correct but Predbat is somehow wrong (AppDaemon issue)
  # 1 means add 1 minute to AppDaemon time, -1 takes it away
  clock_skew: 0

  # Solcast cloud interface, set this or the local interface below
  #solcast_host: 'https://api.solcast.com.au/'
  #solcast_api_key: !secret solcast_api_key
  #solcast_poll_hours: 8

  # Forecast Solar interface, set this or the local interface below
  forecast_solar:
  - latitude: 0.0
    longitude: 0.0
    kwp: 0.2
    azimuth: 240
    declination: 42
  #  api_key: !secret forecast_solar_api_key
  #  azimuth_zero_south: false  # Set to true if azimuth is already in Forecast.solar/Open-Meteo convention (0=South) rather than Predbat convention (0=North)

  # Set these to match solcast sensor names if not using the cloud interface
  # The regular expression (re:) makes the solcast bit optional
  # If these don't match find your own names in Home Assistant
  #pv_forecast_today: "sensor.energy_production_today"
  #pv_forecast_tomorrow: "sensor.energy_production_tomorrow"
  #pv_forecast_d3: re:(sensor.(solcast_|)(pv_forecast_|)forecast_(day_3|d3))
  #pv_forecast_d4: re:(sensor.(solcast_|)(pv_forecast_|)forecast_(day_4|d4))

  # Ohme EV charger cloud direct integration
  #ohme_login: !secret ohme_login
  #ohme_password: !secret ohme_password
  #ohme_automatic_octopus_intelligent: True

  # car_charging_energy defines an incrementing sensor which measures the charge added to your car
  # is used for car_charging_hold feature to filter out car charging from the previous load data
  # Automatically set to detect Wallbox and Zappi, if it doesn't match manually enter your sensor name
  # Also adjust car_charging_energy_scale if it's not in kwH to fix the units
  #car_charging_energy: 're:(sensor.myenergi_zappi_[0-9a-z]+_charge_added_session|sensor.wallbox_portal_added_energy)'

  # Defines the number of cars modelled by the system, set to 0 for no car
  num_cars: 0

  # Energy rates
  # Please set one of these three, if multiple are set then Octopus is used first, second rates_import/rates_export and latest basic metric
  plan_interval_minutes: 15

  # Set import and export entity to point to the Octopus Energy plugin import and export sensors
  # automatically matches your meter number assuming you have only one (no need to edit the below)
  # Will be ignored if you don't have the sensor but will error if you do have one and it's incorrect
  # Note: To get detailed energy rates you need to go in and manually enable the following events in HA
  #       event.octopus_energy_electricity_xxxxxxxx_previous_day_rates
  #       event.octopus_energy_electricity_xxxxxxxx_current_day_rates
  #       event.octopus_energy_electricity_xxxxxxxx_next_day_rates
  # and if you have export enable:
  #       event.octopus_energy_electricity_xxxxxxxx_export_previous_day_rates
  #       event.octopus_energy_electricity_xxxxxxxx_export_current_day_rates
  #       event.octopus_energy_electricity_xxxxxxxx_export_next_day_rates
  # Predbat will automatically find the event. entities from the link below to the sensors
  metric_octopus_import: sensor.tibber_predbat_import_rates
  #metric_octopus_import: 're:(sensor.(octopus_energy_|)electricity_[0-9a-z]+_[0-9a-z]+_current_rate)'
  #metric_octopus_export: 're:(sensor.(octopus_energy_|)electricity_[0-9a-z]+_[0-9a-z]+_export_current_rate)'

  # Standing charge in pounds, can be set to a sensor or manually entered (e.g. 0.50 is 50p)
  # The default below will pick up the standing charge from the Octopus Plugin
  # The standing charge only impacts the cost graphs and doesn't change the way Predbat plans
  # If you don't want to show the standing charge then just delete this line or set to zero
  metric_standing_charge: 0
  #metric_standing_charge: 're:(sensor.(octopus_energy_|)electricity_[0-9a-z]+_[0-9a-z]+_current_standing_charge)'

  # Energy data service (https://github.com/MTrab/energidataservice)
  #metric_energidataservice_import: 'sensor.energi_data_service_import'
  #metric_energidataservice_export: 'sensor.energi_data_service_export'

  rates_export:
  - rate: 0

  # Days previous is the number of days back to find historical load data
  # Recommended is 7 to capture day of the week but 1 can also be used
  # if you have more history you could use 7 and 14 (in a list) but the standard data in HA only lasts 10 days
  days_previous:
  - 1
  - 2
  - 7

  days_previous_weight:
  - 1

  # Number of hours forward to forecast, best left as-is unless you have specific reason
  forecast_hours: 48
  battery_scaling:
  - 1.0

  # Can be used to scale import and export data, used for workarounds
  import_export_scaling: 1.0

This kind of worked, but since I changed the inverter_type, it seems to be stuck in "Calculating progress" and the status dashboard is no longer green:

The currency is also back to pounds.

In configuration.yaml, I created the following helpers:

Details

utility_meter:
  solakon_one_battery_discharge_energy_today:
    source: sensor.solakon_one_grid_export_energy
    cycle: daily

  solakon_one_battery_charge_energy_today:
    source: sensor.solakon_one_grid_import_energy
    cycle: daily

input_number:
  predbat_timed_charge_current:
    name: Predbat Timed Charge Current
    min: 0
    max: 40
    step: 1
    unit_of_measurement: "A"
    mode: box

  predbat_timed_discharge_current:
    name: Predbat Timed Discharge Current
    min: 0
    max: 40
    step: 1
    unit_of_measurement: "A"
    mode: box
    
  predbat_dummy_charge_rate:
    name: Predbat Dummy Charge Rate
    min: 0
    max: 1200
    step: 1
    unit_of_measurement: "W"
    mode: box

  predbat_dummy_discharge_rate:
    name: Predbat Dummy Discharge Rate
    min: 0
    max: 800
    step: 1
    unit_of_measurement: "W"
    mode: box
    
input_datetime:
  predbat_dummy_charge_start:
    name: Predbat Dummy Charge Start
    has_date: false
    has_time: true

  predbat_dummy_charge_end:
    name: Predbat Dummy Charge End
    has_date: false
    has_time: true

  predbat_dummy_discharge_start:
    name: Predbat Dummy Discharge Start
    has_date: false
    has_time: true

  predbat_dummy_discharge_end:
    name: Predbat Dummy Discharge End
    has_date: false
    has_time: true

template:
  - sensor:
      - name: "Predbat Load Energy Today"
        unique_id: predbat_load_energy_today
        unit_of_measurement: "kWh"
        device_class: energy
        state_class: total
        state: >
          {% set grid_import = states('sensor.tibber_pulse_MYHOME_accumulated_consumption') | float(0) %}
          {% set grid_export = states('sensor.tibber_pulse_MYHOME_accumulated_production') | float(0) %}
          {% set pv = states('sensor.solakon_one_daily_energy') | float(0) %}
          {% set battery_discharge = states('sensor.solakon_one_battery_discharge_energy_today') | float(0) %}
          {% set battery_charge = states('sensor.solakon_one_battery_charge_energy_today') | float(0) %}
          {{ [grid_import + pv + battery_discharge - battery_charge - grid_export, 0] | max | round(3) }}
  - sensor:
      - name: "Predbat Load Power"
        unique_id: predbat_load_power
        unit_of_measurement: "W"
        device_class: power
        state_class: measurement
        state: >
          {% set grid = states('sensor.tibber_bridge_0100100700ff') | float(0) %}
          {% set pv = states('sensor.solakon_one_pv_power') | float(0) %}
          {% set batt = states('sensor.solakon_one_battery_power_2') | float(0) %}
          {{ [grid + pv + batt, 0] | max | round(0) }}

  - trigger:
      - platform: homeassistant
        event: start
      - platform: state
        entity_id: sensor.MYHOME_current_electricity_price
    action:
      - action: tibber_prices.get_chartdata
        data:
          day:
            - today
            - tomorrow
          output_format: array_of_objects
          resolution: interval
          price_source: total
          subunit_currency: false
        response_variable: tibber_chartdata
    sensor:
      - name: "Tibber Predbat Import Rates"
        unique_id: tibber_predbat_import_rates
        unit_of_measurement: "ct/kWh"
        state_class: measurement
        state: >
          {{ states('sensor.MYHOME_current_electricity_price') | float(0) }}
        attributes:
          raw_today: >
            {% set rows = tibber_chartdata.data | default([]) %}
            {% set ns = namespace(out=[]) %}
            {% for r in rows %}
              {% set start = as_datetime(r.start_time) %}
              {% if start.date() == now().date() %}
                {% set ns.out = ns.out + [{
                  'start': start.isoformat(),
                  'end': (start + timedelta(minutes=15)).isoformat(),
                  'value': r.price_per_kwh | float
                }] %}
              {% endif %}
            {% endfor %}
            {{ ns.out | to_json }}
          raw_tomorrow: >
            {% set rows = tibber_chartdata.data | default([]) %}
            {% set ns = namespace(out=[]) %}
            {% for r in rows %}
              {% set start = as_datetime(r.start_time) %}
              {% if start.date() == (now() + timedelta(days=1)).date() %}
                {% set ns.out = ns.out + [{
                  'start': start.isoformat(),
                  'end': (start + timedelta(minutes=15)).isoformat(),
                  'value': r.price_per_kwh | float
                }] %}
              {% endif %}
            {% endfor %}
            {{ ns.out | to_json }}

The most important helpers are the load energy, which accumulates grid import/export, battery discharge, and PV production, and the Tibber price helper that creates an Octopus-compatible price dict. The rest is mostly dummy helpers.

I want to set input_number.predbat_timed_charge_current and input_number.predbat_timed_discharge_current
should be set according to the created plan, so that I can then later use them in an automation that sets the actual Solakon entities. I also need to make this work together with a zero-export automation I have, so predbat should probably not try to write to the Solakon directly, which would create conflicts.

Any help would be greatly appreciated.

[phoerious]

With

  inverter_type: Solakon ONE
  inverter:
    name: Solakon ONE
    has_rest_api: false
    has_mqtt_api: false
    has_service_api: false
    current_dp: 1
    charge_discharge_with_rate: false
    has_charge_enable_time: false
    has_discharge_enable_time: false
    has_target_soc: false
    target_soc_used_for_discharge: false
    has_timed_pause: false
    time_button_press: false
    support_charge_freeze: false
    support_discharge_freeze: false
    has_ge_inverter_mode: false
    has_fox_inverter_mode: false
    has_idle_time: false
    has_time_window: false
    soc_units: "%"
    has_reserve_soc: true

The app gets stuck, the dashboard is red, and I get these red entries, even though I've set all those things to disabled:

When I remove inverter_type and inverter from my config, it uses the standard GE entities and at least the dashboard is green again.

[phoerious]

I found a solution. The Solakon ONE seems to be a FoxESS under the hood, but the HA integration is a bit different.

The Solakon integration does not have any knowledge about grid usage, so it cannot do zero export controlling. You have to use an external system for that, such as this blueprint or better even: this integration. Both also support AC charging, but you should not use it. Predbat will take care of that.

You should also set input_number.predbat_set_reserve_min in the Predbat settings to at least 10%, not 4%. input_number.predbat_manual_soc_value should be at most 99%, otherwise you'll be zig-zagging between 99% and 100% a lot.

input_number.predbat_battery_loss and input_number.predbat_battery_loss_discharge should probably be set to 6-9% each and input_number.predbat_inverter_loss to 0, since we cannot model it separately.

Minimal Predbat Config

Use the default config or the FoxESS template, but adjust a few parameters. Replace UPPERCASE stuff with your own sensors. Adjust the solakon_one_* entity names if needed.

pred_bat:
  module: predbat
  class: PredBat

  # XXX: This is a configuration template, delete this line once you edit your configuration
  #template: true

  # Other standard stuff here

  load_today:
  - sensor.predbat_load_energy_today
  import_today:
  - sensor.YOUR_DAILY_GRID_IMPORT_SENSOR
  export_today:
  - sensor.YOUR_DAILY_GRID_EXPORT_SENSOR
  pv_today:
  - sensor.solakon_one_effective_pv_energy_today

  pv_power:
  - sensor.solakon_one_effective_pv_power
  load_power:
  - sensor.predbat_load_power
  grid_power:
  - sensor.YOUR_GRID_LOAD_SENSOR
  battery_power:
  - sensor.solakon_one_battery_power
  soc_percent:
  - sensor.solakon_one_battery_state_of_charge
  soc_max:
  - sensor.solakon_one_battery_capacity
  battery_voltage:
  - sensor.solakon_one_battery_voltage
  battery_temperature:
  - sensor.solakon_one_battery_max_temperature

  # Solakon ONE is a FoxESS inverter internally.
  num_inverters: 1
  inverter_type: FoxESS
  charge_control_immediate: true
  output_charge_control: power
  charge_rate:
  - input_number.predbat_remote_control_charge_power
  discharge_rate:
  - input_number.predbat_remote_control_discharge_power
  reserve:
  - number.solakon_one_minimum_state_of_charge_on_grid

  charge_start_service:
    service: select.select_option
    entity_id: select.solakon_one_remote_control_mode
    option: "3"

  charge_stop_service:
    service: select.select_option
    entity_id: select.solakon_one_remote_control_mode
    option: "0"

  discharge_start_service:
    service: select.select_option
    entity_id: select.solakon_one_remote_control_mode
    option: "1"

  discharge_stop_service:
    service: select.select_option
    entity_id: select.solakon_one_remote_control_mode
    option: "0"

  charge_freeze_service:
    service: select.select_option
    entity_id: select.solakon_one_remote_control_mode
    option: "0"

  discharge_freeze_service:
    service: select.select_option
    entity_id: select.solakon_one_remote_control_mode
    option: "0"

  # Forecast Solar interface. Configure as needed.
  forecast_solar:
  - latitude: 0.00
    longitude: 0.00
    kwp: 1
    azimuth: 240
    declination: 42

  # Either your Octopus price sensor or a reformatted Tibber sensor (see below)
  metric_octopus_import: sensor.tibber_predbat_import_rates
  
  # Inverter charge limit is 1200W, discharge is limited to 800W.
  inverter_limit:
  - 1200
  inverter_limit_charge:
  - 1200
  inverter_limit_discharge:
  - 800

  # Zero export (don't ever feed into the grid).
  export_limit:
  - 0

  rates_export:
  - rate: 0

  # Other stuff

Additional Sensors and Inputs

Apart from that, you need the following extra sensors and inputs:

input_number:
  predbat_remote_control_charge_power:
    name: "Predbat Remote Control Charge Power"
    icon: mdi:flash
    min: 0
    max: 1200
    step: 1
    unit_of_measurement: W
    mode: box
    
  predbat_remote_control_discharge_power:
    name: "Predbat Remote Control Discharge Power"
    icon: mdi:flash
    min: 0
    max: 800
    step: 1
    unit_of_measurement: W
    mode: box

utility_meter:
  solakon_one_battery_discharge_energy_today:
    name: "Solakon ONE Battery Discharge Energy Today"
    unique_id: solakon_one_battery_discharge_energy_today
    source: sensor.solakon_one_grid_export_energy
    cycle: daily

  solakon_one_battery_charge_energy_today:
    name: "Solakon ONE Battery Charge Energy Today"
    unique_id: solakon_one_battery_discharge_energy_today
    source: sensor.solakon_one_grid_import_energy
    cycle: daily
    
  solakon_one_effective_pv_energy_today:
    name: "Solakon ONE Effective PV Energy Today"
    unique_id: solakon_one_effective_pv_energy_today
    source: sensor.solakon_one_effective_pv_power
    cycle: daily

sensor:
  - platform: integration
    name: "Solakon ONE Effective PV Energy"
    unique_id: solakon_one_effective_pv_energy
    source: sensor.solakon_one_effective_pv_power
    unit_prefix: k
    unit_time: h
    method: left
    round: 3

template:
  - sensor:
      # sensor.solakon_one_pv_power seems to have an almost constant 15W offset and about a 25W dead band.
      - name: "Solakon ONE Effective PV Power"
        unique_id: solakon_one_effective_pv_power
        unit_of_measurement: "W"
        device_class: power
        state_class: measurement
        state: >
          {% set pv_power = states('sensor.solakon_one_pv_power') | float(0) %}
          {% if pv_power > 25 %}{{ max(0, pv_power - 15) }}{% else %}0{% endif %}

  - sensor:
      - name: "Predbat Load Power"
        unique_id: predbat_load_power
        unit_of_measurement: "W"
        device_class: power
        state_class: measurement
        state: >
          {% set grid = states('sensor.YOUR_GRID_LOAD_SENSOR') | float(0) %}
          {% set pv = states('sensor.solakon_one_effective_pv_power') | float(0) %}
          {% set batt = states('sensor.solakon_one_battery_power') | float(0) %}
          {{ max(grid + pv + batt, 0) | round(1) }}

  - sensor:
      - name: "Predbat Load Energy Today"
        unique_id: predbat_load_energy_today
        unit_of_measurement: "kWh"
        device_class: energy
        state_class: total
        state: >
          {% set grid_import = states('sensor.YOUR_DAILY_GRID_IMPORT_SENSOR') | float(0) %}
          {% set grid_export = states('sensor.YOUR_DAILY_GRID_EXPORT_SENSOR') | float(0) %}
          {% set pv = states('sensor.solakon_one_effective_pv_energy_today') | float(0) %}
          {% set battery_discharge = states('sensor.solakon_one_battery_discharge_energy_today') | float(0) %}
          {% set battery_charge = states('sensor.solakon_one_battery_charge_energy_today') | float(0) %}
          {{ max(grid_import + pv + battery_discharge - battery_charge - grid_export, 0) | round(3) }}

As well as this automation to forward charge/discharge power. Without it, Predbat will always try to write both 1200W and 800W to the same sensor, and it will interfere with the zero export integration:

automation:
  - alias: Solakon Predbat Remote Control Power Sync
    id: solakon_predbat_remote_control_power_sync
    mode: restart
    triggers:
      - trigger: state
        entity_id:
          - input_number.predbat_remote_control_charge_power
          - input_number.predbat_remote_control_discharge_power
          - predbat.status
    conditions:
      - condition: state
        entity_id: input_boolean.solakon_predbat_remote_control_active
        state: "on"
    actions:
      - choose:
          - conditions:
              - condition: state
                entity_id: predbat.status
                state: "Charging"
            sequence:
              - action: number.set_value
                target:
                  entity_id: number.solakon_one_remote_control_power
                data:
                  value: "{{ states('input_number.predbat_remote_control_charge_power') | float(0) }}"
          - conditions:
              - condition: state
                entity_id: predbat.status
                state: "Discharging"
            sequence:
              - action: number.set_value
                target:
                  entity_id: number.solakon_one_remote_control_power
                data:
                  value: "{{ states('input_number.predbat_remote_control_discharge_power') | float(0) }}"

If you use Tibber instead of Octopus, I recommend this integration. Then you only need to convert the price information to the format expected by Predbat:

template:
  - trigger:
      - platform: homeassistant
        event: start
      - platform: state
        entity_id: sensor.TIBBER_CURRENT_PRICE_SENSOR
    action:
      - action: tibber_prices.get_chartdata
        data:
          day:
            - today
            - tomorrow
          output_format: array_of_objects
          resolution: interval
          price_source: total
          subunit_currency: false
        response_variable: tibber_chartdata
    sensor:
      - name: "Tibber Predbat Import Rates"
        unique_id: tibber_predbat_import_rates
        unit_of_measurement: "EUR/kWh"
        state_class: measurement
        state: >
          {{ states('sensor.TIBBER_CURRENT_PRICE_SENSOR') | float(0) }}
        attributes:
          raw_today: >
            {% set rows = tibber_chartdata.data | default([]) %}
            {% set ns = namespace(out=[]) %}
            {% for r in rows %}
              {% set start = as_datetime(r.start_time) %}
              {% if start.date() == now().date() %}
                {% set ns.out = ns.out + [{
                  'start': start.isoformat(),
                  'end': (start + timedelta(minutes=15)).isoformat(),
                  'value': r.price_per_kwh | float
                }] %}
              {% endif %}
            {% endfor %}
            {{ ns.out | to_json }}
          raw_tomorrow: >
            {% set rows = tibber_chartdata.data | default([]) %}
            {% set ns = namespace(out=[]) %}
            {% for r in rows %}
              {% set start = as_datetime(r.start_time) %}
              {% if start.date() == (now() + timedelta(days=1)).date() %}
                {% set ns.out = ns.out + [{
                  'start': start.isoformat(),
                  'end': (start + timedelta(minutes=15)).isoformat(),
                  'value': r.price_per_kwh | float
                }] %}
              {% endif %}
            {% endfor %}
            {{ ns.out | to_json }}

Zero-Export Integration

The config above will charge your battery when Predbat sees the need, but it will only disable the Solakon remote control otherwise. To actually discharge the battery, use the zero-export integration mentioned above and then use the following scripts in place of the explicit service calls from above to toggle switch.solakon_zero_export_regelung_aktiv on or off (or enable/disable the automation if you use the blueprint):

solakon_predbat_remote_control_enable:
  alias: Solakon Predbat Remote Control Enable
  mode: restart
  sequence:
    - service: input_boolean.turn_on
      target:
        entity_id: input_boolean.solakon_predbat_remote_control_active

    - service: number.set_value
      target:
        entity_id: number.solakon_one_force_mode_duration
      data:
        value: 60

    - service: number.set_value
      target:
        entity_id: number.solakon_one_remote_control_timeout
      data:
        value: 3600

solakon_predbat_remote_control_disable:
  alias: Solakon Predbat Remote Control Disable
  mode: restart
  sequence:
    - service: input_boolean.turn_off
      target:
        entity_id: input_boolean.solakon_predbat_remote_control_active

    - service: number.set_value
      target:
        entity_id: number.solakon_one_force_mode_duration
      data:
        value: 0

    - service: number.set_value
      target:
        entity_id: number.solakon_one_remote_control_timeout
      data:
        value: 0

solakon_predbat_charge_start:
  alias: Solakon Predbat Charge Start
  mode: restart
  sequence:
    - service: script.solakon_predbat_remote_control_enable

    # Enable Inverter import (PV priority).
    - service: select.select_option
      target:
        entity_id: select.solakon_one_remote_control_mode
      data:
        option: "3"

solakon_predbat_charge_stop:
  alias: Solakon Predbat Charge Stop
  mode: restart
  sequence:
    - service: script.solakon_predbat_remote_control_disable

solakon_predbat_discharge_start:
  alias: Solakon Predbat Discharge Start
  mode: restart
  sequence:
    - service: script.solakon_predbat_remote_control_enable
        
    # Enable Inverter export (PV priority).
    - service: select.select_option
      target:
        entity_id: select.solakon_one_remote_control_mode
      data:
        option: "1"
    - service: number.set_value
      target:
        entity_id: number.solakon_one_maximum_discharge_current
      data:
        value: 40

solakon_predbat_discharge_stop:
  alias: Solakon Predbat Discharge Stop
  mode: restart
  sequence:
    - service: script.solakon_predbat_remote_control_disable

solakon_predbat_hold_start:
  alias: Solakon Predbat Hold Start
  mode: restart
  sequence:
    - service: script.solakon_predbat_remote_control_enable

    # Hold charge / disable active remote power.
    - service: select.select_option
      target:
        entity_id: select.solakon_one_remote_control_mode
      data:
        option: "0"

    # Prevent battery discharge.
    - service: number.set_value
      target:
        entity_id: number.solakon_one_remote_control_power
      data:
        value: 0
    - service: number.set_value
      target:
        entity_id: number.solakon_one_maximum_discharge_current
      data:
        value: 0

solakon_predbat_hold_stop:
  alias: Solakon Predbat Hold Stop
  mode: restart
  sequence:
    # Re-enable battery discharge.
    - service: number.set_value
      target:
        entity_id: number.solakon_one_maximum_discharge_current
      data:
        value: 40

    - service: script.solakon_predbat_remote_control_disable

With the following periodic automation:

input_boolean:
  solakon_predbat_remote_control_active:
    name: Solakon Predbat Remote Control Active
    icon: mdi:remote

automation:
  - id: solakon_predbat_remote_control_refresh
    alias: Solakon Predbat Remote Control Refresh
    mode: restart
    triggers:
      - trigger: state
        entity_id: input_boolean.solakon_predbat_remote_control_active
        id: remote_control_changed
      - trigger: time_pattern
        seconds: "/15"
        id: refresh
    actions:
      - choose:
          # Predbat remote control is active:
          # Disable zero-export and refresh Solakon timeout/duration.
          - conditions:
              - condition: state
                entity_id: input_boolean.solakon_predbat_remote_control_active
                state: "on"
            sequence:
              - action: switch.turn_off
                target:
                  entity_id: switch.solakon_zero_export_regelung_aktiv
              - action: script.solakon_predbat_remote_control_enable
    
          # Predbat remote control switched off:
          # Reset remote control exactly once and concede control to zero export.
          - conditions:
              - condition: trigger
                id: remote_control_changed
              - condition: template
                value_template: >
                  {{ trigger.from_state is not none
                     and trigger.to_state is not none
                     and trigger.from_state.state == 'on'
                     and trigger.to_state.state == 'off' }}
            sequence:
              - action: script.solakon_predbat_remote_control_disable
              - action: switch.turn_on
                target:
                  entity_id: switch.solakon_zero_export_regelung_aktiv

And then in the Predbat config:

  charge_start_service:
    service: script.solakon_predbat_charge_start
  charge_stop_service:
    service: script.solakon_predbat_charge_stop
  discharge_start_service:
    service: script.solakon_predbat_discharge_start
  discharge_stop_service:
    service: script.solakon_predbat_discharge_stop
  charge_freeze_service:
    service: script.solakon_predbat_hold_start
  discharge_freeze_service:
    service: script.solakon_predbat_hold_start

Make sure you don't have Tariff charging enabled in the zero-export integration. I would also lower the Zone 1 SoC threshold, since Predbat decides when the battery should be preserved or not.