How to automate Solarbatteriecharging with these data?

[volkergrabbe]

EOS-connect is using the data from EOS to prdigt Solar Forecast, batterie SOC, Tibber rpices etc.

How this could be used to automate charging the batterie when solar forecasts are bad und the tibber price is cheap?

EOS connect has al the data from tibber etc. Bt the MQTT didn't show this parameters.

So where can i get these Datapoints to automate (with a little help of claude, i am not a programmer) all this?

This is an example from claude:

Optimale Batteriesteuerung basierend auf EOS-Connect Daten

In configuration.yaml oder automations.yaml

Template Sensoren für Entscheidungslogik

template:

• sensor:

  • name: "Battery Optimization Decision"
    state: >
    {% set current_price = states('sensor.eos_tibber_current_price') | float(0) %}
    {% set avg_price_today = states('sensor.eos_tibber_average_price') | float(0) %}
    {% set solar_forecast_next_4h = states('sensor.eos_solar_forecast_next_4h') | float(0) %}
    {% set solar_forecast_today = states('sensor.eos_solar_forecast_today') | float(0) %}
    {% set battery_soc = states('sensor.growatt_battery_soc') | float(0) %}
    {% set current_hour = now().hour %}

    {# Definiere Schwellenwerte #}
    {% set low_price_threshold = avg_price_today * 0.75 %}
    {% set very_low_price_threshold = avg_price_today * 0.6 %}
    {% set high_soc_threshold = 85 %}
    {% set low_soc_threshold = 30 %}

    {# Entscheidungslogik #}
    {% if battery_soc >= high_soc_threshold %}
    idle
    {% elif current_price <= very_low_price_threshold and battery_soc < 90 %}
    force_charge_high
    {% elif current_price <= low_price_threshold and solar_forecast_next_4h < 2 and battery_soc < 80 %}
    force_charge_low
    {% elif solar_forecast_today < 10 and current_price < avg_price_today and battery_soc < 60 and current_hour >= 22 %}
    night_charge
    {% elif battery_soc <= low_soc_threshold and current_price < avg_price_today * 1.2 %}
    emergency_charge
    {% else %}
    auto
    {% endif %}
    attributes:
    current_price: "{{ states('sensor.eos_tibber_current_price') }}"
    avg_price: "{{ states('sensor.eos_tibber_average_price') }}"
    solar_forecast: "{{ states('sensor.eos_solar_forecast_today') }}"
    battery_soc: "{{ states('sensor.growatt_battery_soc') }}"
    reason: >
    {% set current_price = states('sensor.eos_tibber_current_price') | float(0) %}
    {% set avg_price_today = states('sensor.eos_tibber_average_price') | float(0) %}
    {% set solar_forecast_today = states('sensor.eos_solar_forecast_today') | float(0) %}
    {% set battery_soc = states('sensor.growatt_battery_soc') | float(0) %}

    {% if battery_soc >= 85 %}
      Battery nearly full
    {% elif current_price <= avg_price_today * 0.6 %}
      Very cheap electricity ({{ current_price }}ct vs {{ avg_price_today }}ct avg)
    {% elif solar_forecast_today < 10 %}
      Low solar forecast ({{ solar_forecast_today }}kWh)
    {% else %}
      Normal operation
    {% endif %}
    

  • name: "Next Cheap Hours"
    state: >
    {% set prices = states('sensor.eos_tibber_prices_today') %}
    {% if prices != 'unknown' and prices != 'unavailable' %}
    {% set price_list = prices.split(',') | map('float') | list %}
    {% set current_hour = now().hour %}
    {% set avg_price = price_list | average %}
    {% set cheap_threshold = avg_price * 0.8 %}

    {% set cheap_hours = [] %}
    {% for i in range(current_hour, 24) %}
      {% if price_list[i] <= cheap_threshold %}
        {% set cheap_hours = cheap_hours + [i] %}
      {% endif %}
    {% endfor %}
    {{ cheap_hours | join(',') }}
    

    {% else %}
    unknown
    {% endif %}

Automationen

automation:

• alias: "Battery Control - Execute Decision"
  description: "Führt die optimale Batteriesteuerung durch"
  trigger:

  • platform: state
    entity_id: sensor.battery_optimization_decision

  • platform: time_pattern
    minutes: "/15" # Alle 15 Minuten prüfen
    condition:

  • condition: template
    value_template: "{{ states('sensor.battery_optimization_decision') != 'unknown' }}"
    action:

  • choose:

    Force Charge High Power (sehr günstige Preise)

    • conditions:
      • condition: state
        entity_id: sensor.battery_optimization_decision
        state: "force_charge_high"
        sequence:
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter1/charge_mode/set"
        payload: "force_charge"
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter1/charge_power/set"
        payload: "3000" # Maximale Ladeleistung
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter2/charge_mode/set"
        payload: "force_charge"
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter2/charge_power/set"
        payload: "3000"

    Force Charge Low Power (günstige Preise)

    • conditions:
      • condition: state
        entity_id: sensor.battery_optimization_decision
        state: "force_charge_low"
        sequence:
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter1/charge_mode/set"
        payload: "force_charge"
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter1/charge_power/set"
        payload: "2000" # Reduzierte Ladeleistung
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter2/charge_mode/set"
        payload: "force_charge"
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter2/charge_power/set"
        payload: "2000"

    Night Charge (Nachtladung bei schlechter Prognose)

    • conditions:
      • condition: state
        entity_id: sensor.battery_optimization_decision
        state: "night_charge"
        sequence:
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter1/charge_mode/set"
        payload: "force_charge"
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter1/charge_power/set"
        payload: "1500" # Sanfte Nachtladung
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter2/charge_mode/set"
        payload: "force_charge"
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter2/charge_power/set"
        payload: "1500"

    Emergency Charge (Akku sehr leer)

    • conditions:
      • condition: state
        entity_id: sensor.battery_optimization_decision
        state: "emergency_charge"
        sequence:
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter1/charge_mode/set"
        payload: "force_charge"
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter1/charge_power/set"
        payload: "2500"
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter2/charge_mode/set"
        payload: "force_charge"
      • service: mqtt.publish
        data:
        topic: "solar_assistant/growatt_inverter2/charge_power/set"
        payload: "2500"

    Standard Auto Mode (PV-Überschuss)

    default:

    • service: mqtt.publish
      data:
      topic: "solar_assistant/growatt_inverter1/charge_mode/set"
      payload: "auto"
    • service: mqtt.publish
      data:
      topic: "solar_assistant/growatt_inverter2/charge_mode/set"
      payload: "auto"

  Logging der Entscheidung

  • service: logbook.log
    data:
    name: "Battery Optimization"
    message: >
    Decision: {{ states('sensor.battery_optimization_decision') }}
    | Price: {{ states('sensor.eos_tibber_current_price') }}ct
    | SOC: {{ states('sensor.growatt_battery_soc') }}%
    | Reason: {{ state_attr('sensor.battery_optimization_decision', 'reason') }}

• alias: "Battery Control - Morning Reset"
  description: "Setzt am Morgen auf Auto-Modus zurück"
  trigger:

  • platform: time
    at: "06:00:00"
    action:
  • service: mqtt.publish
    data:
    topic: "solar_assistant/growatt_inverter1/charge_mode/set"
    payload: "auto"
  • service: mqtt.publish
    data:
    topic: "solar_assistant/growatt_inverter2/charge_mode/set"
    payload: "auto"

• alias: "Battery Control - Price Alert"
  description: "Benachrichtigung bei extremen Preisschwankungen"
  trigger:

  • platform: numeric_state
    entity_id: sensor.eos_tibber_current_price
    below: 5 # Unter 5ct/kWh
    condition:
  • condition: numeric_state
    entity_id: sensor.growatt_battery_soc
    below: 95
    action:
  • service: notify.mobile_app_your_phone
    data:
    title: "Sehr günstiger Strom!"
    message: >
    Strompreis: {{ states('sensor.eos_tibber_current_price') }}ct/kWh
    Akku: {{ states('sensor.growatt_battery_soc') }}%
    Automatische Ladung aktiviert.

Utility Meter für Kostentracking

utility_meter:
monthly_grid_cost:
source: sensor.total_grid_cost
cycle: monthly
monthly_savings:
source: sensor.optimization_savings
cycle: monthly

[ohAnd]

HI @volkergrabbe ,

I'm a little confused ... That what you are asking for is the main purpose of EOS_connect together with EOS.
And also described in the readme... -> https://github.com/ohAnd/EOS_connect

Key features in short:

Automated energy optimization using real-time and forecast data
Battery and inverter management (charge/discharge, grid/PV modes)
Integration with Home Assistant, OpenHAB, EVCC, and MQTT
Dynamic web dashboard for monitoring and control
Cost optimization using dynamic energy prices (e.g., Tibber, smartenergy.at)
Easy configuration and extensibility

and then -> https://github.com/ohAnd/EOS_connect?tab=readme-ov-file#how-it-works

Base
EOS Connect is a self-running system that periodically collects:

Local energy consumption data.
PV solar forecasts for the next 48 hours.
Upcoming energy prices.
Using this data, a request is sent to EOS, which creates a model predicting the energy needs based on different energy sources and loads (grid, battery, PV).

EOS Connect waits for the response from EOS (e.g., ~2 min 15 sec for a full 48-hour prediction on a Raspberry Pi 5). After receiving the response, it is analyzed to extract the necessary values.

Finally, the system sets up the inverter based on the following states:

MODE_CHARGE_FROM_GRID with a specific target charging power (based on your configuration).
MODE_AVOID_DISCHARGE.
MODE_DISCHARGE_ALLOWED with a specific target maximum discharging power (based on your configuration).
The system repeats this process periodically, e.g., every 3 minutes, as defined in the configuration.

means you can directly connect your inverter:

• with direct interface 'fronius' - (if you have one ;-) )
• or via evcc -> all supported inverters of evcc (here without max charge power control / charging curve)
• or via web api (Extract "Current Controls" values to Homeassistant entities #11)
• or via MQTT
  • EOS Control Demands
    • "control/eos_ac_charge_demand": AC charge demand (W)
    • "control/eos_dc_charge_demand": DC charge demand (W)
    • "control/eos_discharge_allowed": Discharge allowed (bool)

All the mentioned features

• collecting the data for price/ solar/ load/ remaing battery capacity/ ecar charging/ additional load will be done by eos connect
• dependency management (optimization between) for this data will be done by EOS with the result - demand for battery charging (AC/DC) or lock the battery
• this result will be used by eos_connect to control the inverter/ battery with the target setting directly

So, finally, what you're missing? ;-)

[volkergrabbe]

I didn't find the right idea how to control.

I am using a Growatt MOD10KTL-XH with actual an 17.5kwh battery.

I didn't have found the right way to set the config of the Growatt trough the Solarassistent MQTT connection to load when prices are low and the solar forecast is not so good.

Wich parameters I use, and so on.

I didn't own an EV so I didn't have a wallbox ore a need of a evcc instance for that.

Or I didn't understand the documentation......

sorry for that....

Volker

[ohAnd]

Ok, let's try with this steps:

1. at first for this approach your 'Solarassistant" is in parallel to EOS/ EOS connect
   • and if there are currently some control to your inverter/ battery means enabling/ disabling of charging/ discharging
   • this should be disabled to avoid unwanted states
2. have a running instance of EOS without any specific config - the optimization request of EOS connect will be transfer all needed data for optimization - e.g. as an HA addon -> https://github.com/Duetting/ha_eos_addon
3. install EOS connect as an HA addon -> https://github.com/ohAnd/ha_addons
4. configure in the UI the sources for:
   • load (wallbox, additional load etc are optional)
   • eos -> the IP of the running instance - if HA addon installation the IP of Homeassitant
   • price settings
   • battery settings (this section only gathers data - no control here)
   • pv forecast source and details of your PV installation
   • inverter settings - start with default (only showing the result) - in detail below
   • evcc leave at default - then it is disabled
   • mqtt - enabled false - according to your info above
   • refresh_time -> start with 15 min (depeding of your EOS instance - hardware (small old raspberry or big machine))
5. now it should be running

detailing of controlling inverter/ battery:
EOS connect offers 3 different ways:

1. direct connection for FRONIUS inverter and connected batteries
2. via EVCC as a gateway for all supported inverters in evcc
3. via Web API or MQTT

config for variant 1:

type: fronius_gen24
address: 192.168.1.102 # address of the fronius inverter
user: customer
password: *******
max_grid_charge_rate: 10000
max_pv_charge_rate: 10000
max_bat_discharge_rate: 10000

config for variant 2:

type: evcc
address: ""
user: ""
password: ""
max_grid_charge_rate: 10000
max_pv_charge_rate: 10000
max_bat_discharge_rate: 10000

config for variant 3:

type: default
address: ""
user: ""
password: ""
max_grid_charge_rate: 10000
max_pv_charge_rate: 10000
max_bat_discharge_rate: 10000

That means to bring it together with your growatt invterter:
2 possibilities from my point of perspective:

1. the most convenient way

   • install and configure evcc also (only with the base data for growatt connection) - to use it only as a gateway
   • use the 2. configuration above for inverter
   • and configure additonally the evcc section with the right IP in EOS connect

2. use the web api or mqtt control data

   • some skills needed to bring an external command to your inverter
   • use HA or other systems at your side - maybe also solarassistant is capable of that to use the target control of EOS/ EOS connect
   • means: read in here the current demand for inverter - details you can find here -> https://github.com/ohAnd/EOS_connect?tab=readme-ov-file#mqtt---provided-data-and-possible-commands
   • the further detail connection from this target command to the inverter depends on your environment (solarasisstant, ...) and their capabilities to have finally a working control of the inverter - given by eos connect

Summary: EOS connect gathers all the needed data, provide these to EOS, get the optimization result with the target command for the inverter battery - and controls directly the inverter.

e.g. if there is not enough PV forecasted and battery is low and your household load needs more energy and the price is currently low, then it will starts the grid charging for the battery...

hope, that helps for the next steps ...