Integration with energy dashboard

[stuertz]

Did someone try to to integrate the solix into the HA energy dashboard. For now it looks like I am missing the correct device types.

[kitokirisaki]

I did, but I needed to create some sensor's by myself.

[Pouda41]

Can you share sensors you have created ?

[thomluther]

In general you need Energie sensors for the energy dashboard. With batteries you need separate energy for charging and discharging to display that correctly.
From the Integration you get positive charging power and negative discharging power.
I recommend to create separate helper templates for charge and discharge power. Set their availability depending on cloud connection status.
Then for each you can create integral helpers to get kWh from W. Those helpers can be added to the energy dashboard.

[thomluther]

One last comment to sensors you use in Energy Dashboard.
I would always recommend to use only template sensors for the Energy Dashboard, never direct device sensors even if they are provided by your device integration.
The reason is that you may have to change your device at a certain point, or the integration changes or other reasons cause a change in the source entity used for the Energy Dashboard.
If you have to replace the entity in the Dashboard, you loose the history data. There are only nasty work arounds modifying the SQLlight DB directly with SQL to maintain the history data for a new entity that was exchanged in the energy Dashboard. You could easily corrupt your whole HA DB with this....
When using a template entity for Energy Dashboard, you never need to change it for the Dashboard configuration. If you need to use new source device sensors, you just need to update your template entity accordingly and keep the history automatically.

[thomluther]

If you have power flow cards in the dashboard, they can typically configured whether using single sensor or separate for the battery power flow. The integration entity should directly be usable for the flow chart.

[thealkly]

produced Energy
I'm not sure if "yield total" would work as an overall solar input for the energy dashboard. I'm using a Tasmota Plug currently between the inverter and main.

Battery:
I didn't find a way of changing the input sensor for battery in the default energy dashboard. It needs a charging and discharging sensor.
Therefore i created some automation to split up charging and discharging.
There is probably an easier solution but just template sensors didn't do the job.

This is a work in progress / test setup, but perhaps it will help.
I'll update it after some more testing.
I'm using the battery energy as a value so i don't need to sum up watt into kwh.

You need to create 4 input helper.

Automation 1 Measure how much the battery changed.

description: Aktualisiert die Batterieenergiedifferenz basierend auf aktuellen Werten
trigger:
  - platform: state
    entity_id: sensor.solarbank_e1600_2_battery_energy
action:
  - service: input_number.set_value
    target:
      entity_id: input_number.battery_energy_difference
    data:
      value: >
        {{ (trigger.to_state.state | float) -
        (states('input_number.last_battery_energy') | float) }}
  - service: input_number.set_value
    target:
      entity_id: input_number.last_battery_energy
    data:
      value: "{{ trigger.to_state.state | float }}"
mode: single

and then separate for charging and discharging

alias: solar ladezustand Update Total Charged Energy
description: Aktualisiert die gesamte geladene Energie, wenn die Batterie geladen wird.
trigger:
  - platform: state
    entity_id: input_number.battery_energy_difference
condition:
  - condition: template
    value_template: "{{ trigger.to_state.state | float > 0 }}"
action:
  - service: input_number.set_value
    target:
      entity_id: input_number.total_charge_test_1
    data:
      value: >-
        {{ (states('input_number.total_charge_test_1') | float) +
        (trigger.to_state.state | float) }}

Discharge:

description: Aktualisiert die gesamte entladene Energie, wenn die Batterie entladen wird.
trigger:
  - platform: state
    entity_id: input_number.battery_energy_difference
condition:
  - condition: template
    value_template: "{{ trigger.to_state.state | float < 0 }}"
action:
  - service: input_number.set_value
    target:
      entity_id: input_number.total_discharge_test_1
    data:
      value: >-
        {{ (states('input_number.total_discharge_test_1') | float) +
        (trigger.to_state.state | float | abs) }}

Template Sensors

Based on Thomas tipp, i converted now the charge and discharge numbers into a template sensor.
Currently only for one solar bank but there would be the place to sum up both.
These two sensor can now be added to the home assistant default energy dashboard.

template:
- sensor:
      - name: "Total Charged Energy Sensor 01"
        unit_of_measurement: 'Wh'
        state_class: 'total_increasing'
        device_class: 'energy'
        state: "{{ states('input_number.total_charge_test_1') | float }}"
        
      - name: "Total Discharged Energy Sensor 01"
        unit_of_measurement: 'Wh'
        state_class: 'total_increasing'
        device_class: 'energy'
        state: "{{ states('input_number.total_discharge_test_1') | float }}"

[thealkly]

after some more days of testing, this does not work reliably. I'll post an update if i find a better solution.

[thomluther]

Following is a subset of my templates to use the battery in power flow charts and energy dashboard.

Sensor for Solar power in Power Flowchart

I had to build this to calculate the Solar power properly independent of an installed solarbank. You have to consider this too, since you may want to uninstall it over winter. When uninstalled, the invert input is your Solarpower, when installed you need to use the solar power entity of the integration, or calculate solar power from DC inverter input and charge power as I did before having the integration solar entity.

- sensor:
    - name: "BKW Batterie Solarleistung"
      unique_id: "BKW-Batterie-Solarleistung"
      unit_of_measurement: "W"
      device_class: "power"
      icon: mdi:home-lightning-bolt
      state: >
        {# first use real value from cloud if connected #}
        {% if is_state('sensor.sb_e1600_cloud_zustand','online') %}
          {{states('sensor.sb_e1600_solarleistung')}}
        {% else %}
          {% set battpower = states('sensor.solarbank_ladeleistung_aktuell')|float(0) %}
          {% set bkwpower = states('sensor.bkw_einspeisung')|float(0) %}
          {% if battpower < 0 %}
            {# battery discharging, set solar output to 0 #}
            {{0}}
          {% else %}
            {{(bkwpower+battpower)|round(0)}}
          {% endif %}
        {% endif %}
      availability: >
        {{ is_state('sensor.sb_e1600_cloud_zustand','online') or has_value('sensor.bkw_einspeisung') }}

Sensor for represent BKW export power without inverter standby power consumption over night

- sensor:
    - name: BKW Einspeisung
      unique_id: "Bkw-Einspeisung"
      icon: mdi:solar-power
      unit_of_measurement: "W"
      device_class: "power"
      # Use Hoymiles power value if available (5 sec interval), otherwise use Fritz Dect 210 value (1 min intervall)
      # Inverter in standby measured by Fritz Dect smart plug < 0.3 W
      # If this value is 0 over night, the energy integral sensor will become unavailable?!, therefore use very small value instead of 0
      state: >
        {% if has_value('sensor.hoymiles_hm_600_power') %}
          {{ states('sensor.hoymiles_hm_600_power')|float|round(3) }}
        {% elif states('sensor.balkonkraftwerk_leistung')|float >= 0.3 %}
          {{ states('sensor.balkonkraftwerk_leistung')|float|round(3) }}
        {% else %}
          {{0.01}}
        {% endif %}
      availability: >
        {{ has_value('sensor.hoymiles_hm_600_power') or has_value('sensor.balkonkraftwerk_leistung') }}

Utility meter for total Solar Energy in Energy dashboard, accumulate export energy to house and battery charge energy if available

Note: This was required before getting the direct solar power from the Anker integration. Now you could create a direct Rieman integral sensor from the solar power sensor. However, you should consider phases where this value is not available, or where you uninstalled the solarbank in winter maybe. Then you need to ensure that the source power template sensor of the kWh integral sensor considers various source sensors that reflect the actual solar power for both cases.
This template gives you an idea, how you can realize your own utility meter with triggered template sensors. They are not that easy, since HA restart caused unwanted resets which I have now eliminated with this template.

- trigger:
    # trigger when BKW energy state changed
    - platform: state
      entity_id: sensor.bkw_einspeiseenergie_kwh
      not_to:
        - "unknown"
        - "unavailable"
    # trigger when Battery charging energy state changed
    - platform: state
      entity_id: sensor.solarbank_aufladeenergie
      not_to:
        - "unknown"
        - "unavailable"
    # initial setting delay until all is loaded
    - platform: homeassistant
      id: start
      event: start
  action:
    - alias: "Wait until all required sensors are reloaded upon HA restart or template reload"
      wait_template: "{{trigger.id != 'start' or (has_value('sensor.solarbank_entladeenergie') and has_value('sensor.solarbank_aufladeenergie') and has_value('sensor.bkw_solarenergie'))}}"
      timeout: "00:00:10"
  sensor:
    - name: "BKW Solarenergie"
      unique_id: "BKW-Solarenergie"
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total_increasing"
      icon: mdi:solar-power
      state: >
        {% set val = states('sensor.bkw_einspeiseenergie_kwh') %}
        {% set last = this.attributes.last_valid_state|default('') %}
        {% set chargeval = states('sensor.solarbank_aufladeenergie') %}
        {% set chargelast = this.attributes.last_valid_charge_state|default('') %}
        {% set mystate = this.state if this.state not in ['unavailable','unknown',None] else 0 %}
        {% set battery = 'sensor.solarbank_status' %}
        {# accumulate BKW energy and (estimated) charge energy only if not discharging #}
        {% if is_number(mystate) and is_number(last) and is_number(val) and states(battery) != 'discharge' %}
          {% if val|float > last|float %}
            {% set mystate = mystate|float + val|float - last|float %}
          {% endif %}
          {# Add (estimated) charge energy #}
          {% if is_number(chargelast) and is_number(chargeval) and chargeval|float > chargelast|float %}
            {% set mystate = mystate|float + chargeval|float - chargelast|float %}
          {% endif %}
        {% endif %}
        {{mystate|round(3)}}
      attributes:
        source: "sensor.bkw_einspeiseenergie_kwh"
        last_valid_state: >
          {% set val = states('sensor.bkw_einspeiseenergie_kwh') %}
          {{val|float(0)|round(3) if is_number(val) else this.attributes.last_valid_state}}
        source_charge: "sensor.solarbank_aufladeenergie"
        last_valid_charge_state: >
          {% set val = states('sensor.solarbank_aufladeenergie') %}
          {{val|float(0)|round(3) if is_number(val) else this.attributes.last_valid_charge_state}}
      availability: "{{has_value('sensor.bkw_einspeiseenergie_kwh')}}"

Battery energy

For the battery energy in the dashboard you need separate total increasing sensors for charge energy and discharge energy. I implemented that already before the integration was available via utility meter templates similar to above. They use the battery energy as source, which I estimated based on other sensors before the integration was available.
Now you can also realize that more easily based on battery power entity of the integration. Just create separate template sensors for charging power (when battery charge entity is > 0 W) and discharging power (when entity is < 0W). An integral helper over each will give you the entities for the energy dashboard.
Here is how I did the same using the battery energy entity as source (instead of power), that may go up and down. The template utility meters just accumulate the energy when increased (for charge) or decreased (for discharge), giving you the same result for the energy dashboard entities. The implementation is just more complex, but that is all I had before the integration and I keep it as fallback when the Api should no longer work,

utility meter for Solarbank battery total charge energy (usable as energy in Power Flowcharts and energy dashboard)

- trigger:
    # trigger when solarbank energy state changed
    - platform: state
      entity_id: sensor.solarbank_akkuenergie
      not_to:
        - "unknown"
        - "unavailable"
    # initial setting delay until all is loaded
    - platform: homeassistant
      id: start
      event: start
  action:
    - alias: "Wait until all required sensors are reloaded upon HA restart"
      wait_template: "{{trigger.id != 'start' or (has_value('sensor.solarbank_aufladeenergie') and has_value('sensor.solarbank_akkuenergie'))}}"
      timeout: "00:00:10"
  sensor:
    - name: "Solarbank Aufladeenergie"
      unique_id: "Solarbank-Aufladeenergie"
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total_increasing"
      icon: mdi:battery-plus
      state: >
        {% set val = states('sensor.solarbank_akkuenergie') %}
        {% set last = this.attributes.last_valid_state|default('') %}
        {% set mystate = this.state if this.state not in ['unavailable','unknown',None] else 0 %}
        {# Source can go up and down, accumulate only increase deltas #}
        {% if is_number(mystate) and is_number(last) and is_number(val) and val|float > last|float %}
          {{(mystate|float + val|float - last|float)|round(3)}}
        {% else %}
          {{mystate}}
        {% endif %}
      attributes:
        source: "sensor.solarbank_akkuenergie"
        last_valid_state: >
          {% set val = states('sensor.solarbank_akkuenergie') %}
          {{val|float(0)|round(3) if is_number(val) else this.attributes.last_valid_state}}
      availability: "{{has_value('sensor.solarbank_akkuenergie')}}"

utility meter for Solarbank battery total discharge energy (usable as energy in Power Flowcharts and energy dashboard)

- trigger:
    # trigger when solarbank energy state changed
    - platform: state
      entity_id: sensor.solarbank_akkuenergie
      not_to:
        - "unknown"
        - "unavailable"
    # initial setting delay until all is loaded
    - platform: homeassistant
      id: start
      event: start
  action:
    - alias: "Wait until all required sensors are reloaded upon HA restart or template reload"
      wait_template: "{{trigger.id != 'start' or (has_value('sensor.solarbank_entladeenergie') and has_value('sensor.solarbank_akkuenergie'))}}"
      timeout: "00:00:10"
  sensor:
    - name: "Solarbank Entladeenergie"
      unique_id: "Solarbank-Entladeenergie"
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total_increasing"
      icon: mdi:battery-minus
      state: >
        {% set val = states('sensor.solarbank_akkuenergie') %}
        {% set last = this.attributes.last_valid_state|default('') %}
        {% set mystate = this.state if this.state not in ['unavailable','unknown',None] else 0 %}
        {# Source can go up and down, accumulate only decrease deltas #}
        {% if is_number(mystate) and is_number(last) and is_number(val) and val|float < last|float %}
          {{(mystate|float + last|float - val|float)|round(3)}}
        {% else %}
          {{mystate}}
        {% endif %}
      attributes:
        source: "sensor.solarbank_akkuenergie"
        last_valid_state: >
          {% set val = states('sensor.solarbank_akkuenergie') %}
          {{val|float(0)|round(3) if is_number(val) else this.attributes.last_valid_state}}
      availability: "{{has_value('sensor.solarbank_akkuenergie')}}"

[RoboMod]

Hi there.

I'm sorry to bother you but I don't get it. How do you create those sensors starting with "trigger"? I tried to use template sensors and copied the code above as template. But that does not work. I just get "Not Available" as result. Do you have an idea what I'm doing waiting wrong?

[thomluther]

These are template sensors that you need to add to your configuration.yaml
The Template helpers do not support yet such advanced template sensors with triggers.
A trigger based template sensor is only updated when triggered, similar to an automation.
Non trigger template sensors are updated when any of the used entities is updating.

I split my config and in configuration.yaml I use:
template: !include templates.yaml

And in templates.yaml I start:
- trigger:
which indicates a definition for a trigger based template.

But my setup is probably more complex than necessary now with the integration values. Before the integration, I used templates to estimate the solarbank values and the rest is based on that.
However, I continue to use my estimation templates and just use the real values if integration entities are available. If the integration breaks, I can then fall back to my origin guessed values.

[thomluther]

And just for reference, here are the 2 power template sensors that you can use instead of the energy utility meter templates:
One is representing only the charge power, the other only the discharge power, but both are positive values.
You can create a Rieman integral helper over each to get your total increasing energy sensors, which you can add to the energy dashboard.

    - name: "Solarbank charge power"
      unique_id: "Solarbank-charge-power"
      unit_of_measurement: "W"
      device_class: "power"
      icon: mdi:home-lightning-bolt
      state: >
        {% set val = states('sensor.solarbank_e1600_charge_power')|float(0) %}
        {{ val if val > 0 else 0 }}
      availability: >
        {{ has_value('sensor.solarbank_e1600_charge_power') }}
    - name: "Solarbank discharge power"
      unique_id: "Solarbank-discharge-power"
      unit_of_measurement: "W"
      device_class: "power"
      icon: mdi:home-lightning-bolt
      state: >
        {% set val = states('sensor.solarbank_e1600_charge_power')|float(0) %}
        {{ val | abs if val < 0 else 0 }}
      availability: >
        {{ has_value('sensor.solarbank_e1600_charge_power') }}

[MarvinW1984]

Hello @thomluther
Thank you for your examples, and especially for your Anker integration!

I tried implementing it myself, but unfortunately, it's not turning out well. I've been working on the display in the Energy Dashboard for 3 days now, and my head is spinning -.-

Could you perhaps help me out a bit?

I have the following sensors through the integration:

• sensor.solarbank_e1600_akkuleistung
• sensor.solarbank_e1600_solarleistung

Then I additionally have the following sensors from my inverter:

• sensor.ecu_current_power
• sensor.ecu_today_energy (So far, I've always used these to display my generated solar energy in the Energy Dashboard.)

Additionally, I have a Shelly 3EM installed to display the consumption from the grid and the feed-in into the grid.

I have built a Riemann helper for the "- sensor.solarbank_e1600_solarleistung". That's displaying some really strange values. (Solar output is at 375 watts but it shows 11.46 kWh). It should actually display 0.37 kWh, correct?

Then I also have the issue of the battery charge in my Energy Dashboard showing 80 kWh and the discharge showing 560 kWh. Everything seems quite chaotic. See Picture:

This is how my Energy Dashboard configuration looks like:

And here is my configuration.yaml where I integrated your code:

template:

- sensor:
    - name: "Shelly3EM Total Energy"
      unique_id: shelly3em_energy_total
      device_class: energy
      state_class: total
      unit_of_measurement: "kWh"
      state: >
         {{ 
         states('sensor.shelly_em3_channel_a_power')| float(0) + 
         states('sensor.shelly_em3_channel_b_power')| float(0) +
         states('sensor.shelly_em3_channel_c_power')| float(0) 
         }}
        
- sensor:
    - name: "BKW Batterie Solarleistung"
      unique_id: "BKW-Batterie-Solarleistung"
      unit_of_measurement: "W"
      device_class: "power"
      icon: mdi:home-lightning-bolt
      state: >
        {# first use real value from cloud if connected #}
        {% if is_state('sensor.solarbank_e1600_cloud_zustand','online') %}
          {{states('sensor.solarbank_e1600_solarleistung')}}
        {% else %}
          {% set battpower = states('sensor.solarbank_e1600_akkuleistung')|float(0) %}
          {% set bkwpower = states('sensor.bkw_einspeisung')|float(0) %}
          {% if battpower < 0 %}
            {# battery discharging, set solar output to 0 #}
            {{0}}
          {% else %}
            {{(bkwpower+battpower)|round(0)}}
          {% endif %}
        {% endif %}
      availability: >
        {{ is_state('sensor.solarbank_e1600_cloud_zustand','online') or has_value('sensor.bkw_einspeisung') }}

- sensor:
    - name: BKW Einspeisung
      unique_id: "Bkw-Einspeisung"
      icon: mdi:solar-power
      unit_of_measurement: "W"
      device_class: "power"
      # Use Hoymiles power value if available (5 sec interval), otherwise use Fritz Dect 210 value (1 min intervall)
      # Inverter in standby measured by Fritz Dect smart plug < 0.3 W
      # If this value is 0 over night, the energy integral sensor will become unavailable?!, therefore use very small value instead of 0
      state: >
        {% if has_value('sensor.ecu_current_power') %}
          {{ states('sensor.ecu_current_power')|float|round(3) }}
        {% elif states('sensor.solarbank_e1600_solarleistung')|float >= 0.3 %}
          {{ states('sensor.solarbank_e1600_solarleistung')|float|round(3) }}
        {% else %}
          {{0.01}}
        {% endif %}
      availability: >
        {{ has_value('sensor.ecu_current_power') or has_value('sensor.solarbank_e1600_solarleistung') }}

- trigger:
    # trigger when solarbank energy state changed
    - platform: state
      entity_id: sensor.solarbank_e1600_akkuenergie
      not_to:
        - "unknown"
        - "unavailable"
    # initial setting delay until all is loaded
    - platform: homeassistant
      id: start
      event: start
  action:
    - alias: "Wait until all required sensors are reloaded upon HA restart"
      wait_template: "{{trigger.id != 'start' or (has_value('sensor.solarbank_aufladeenergie') and has_value('sensor.solarbank_e1600_akkuenergie'))}}"
      timeout: "00:00:10"
  sensor:
    - name: "Solarbank Aufladeenergie"
      unique_id: "Solarbank-Aufladeenergie"
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total_increasing"
      icon: mdi:battery-plus
      state: >
        {% set val = states('sensor.solarbank_e1600_akkuenergie') %}
        {% set last = this.attributes.last_valid_state|default('') %}
        {% set mystate = this.state if this.state not in ['unavailable','unknown',None] else 0 %}
        {# Source can go up and down, accumulate only increase deltas #}
        {% if is_number(mystate) and is_number(last) and is_number(val) and val|float > last|float %}
          {{(mystate|float + val|float - last|float)|round(3)}}
        {% else %}
          {{mystate}}
        {% endif %}
      attributes:
        source: "sensor.solarbank_e1600_akkuenergie"
        last_valid_state: >
          {% set val = states('sensor.solarbank_e1600_akkuenergie') %}
          {{val|float(0)|round(3) if is_number(val) else this.attributes.last_valid_state}}
      availability: "{{has_value('sensor.solarbank_e1600_akkuenergie')}}"

- trigger:
    # trigger when solarbank energy state changed
    - platform: state
      entity_id: sensor.solarbank_e1600_akkuenergie
      not_to:
        - "unknown"
        - "unavailable"
    # initial setting delay until all is loaded
    - platform: homeassistant
      id: start
      event: start
  action:
    - alias: "Wait until all required sensors are reloaded upon HA restart or template reload"
      wait_template: "{{trigger.id != 'start' or (has_value('sensor.solarbank_entladeenergie') and has_value('sensor.solarbank_e1600_akkuenergie'))}}"
      timeout: "00:00:10"
  sensor:
    - name: "Solarbank Entladeenergie"
      unique_id: "Solarbank-Entladeenergie"
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total_increasing"
      icon: mdi:battery-minus
      state: >
        {% set val = states('sensor.solarbank_e1600_akkuenergie') %}
        {% set last = this.attributes.last_valid_state|default('') %}
        {% set mystate = this.state if this.state not in ['unavailable','unknown',None] else 0 %}
        {# Source can go up and down, accumulate only decrease deltas #}
        {% if is_number(mystate) and is_number(last) and is_number(val) and val|float < last|float %}
          {{(mystate|float + last|float - val|float)|round(3)}}
        {% else %}
          {{mystate}}
        {% endif %}
      attributes:
        source: "sensor.solarbank_e1600_akkuenergie"
        last_valid_state: >
          {% set val = states('sensor.solarbank_e1600_akkuenergie') %}
          {{val|float(0)|round(3) if is_number(val) else this.attributes.last_valid_state}}
      availability: "{{has_value('sensor.solarbank_e1600_akkuenergie')}}"


sensor:
  - platform: template
    sensors:

      # Template sensor for values of power import (active_power > 0)
      power_import:
        friendly_name: "Power Import"
        unit_of_measurement: 'W'
        value_template: >-
          {% if (states('sensor.shelly_em3_channel_a_power')|float + states('sensor.shelly_em3_channel_b_power')|float + states('sensor.shelly_em3_channel_c_power')|float) > 0 %}
            {{ states('sensor.shelly_em3_channel_a_power')|float + states('sensor.shelly_em3_channel_b_power')|float + states('sensor.shelly_em3_channel_c_power')|float }}
          {% else %}
            {{ 0 }}
          {% endif %}
        availability_template: "{{
            [ states('sensor.shelly_em3_channel_a_power'),
              states('sensor.shelly_em3_channel_b_power'),
              states('sensor.shelly_em3_channel_c_power')
            ] | map('is_number') | min
          }}"

      # Template sensor for values of power export (active_power < 0)
      power_export:
        friendly_name: "Power Export"
        unit_of_measurement: 'W'
        value_template: >-
          {% if (states('sensor.shelly_em3_channel_a_power')|float + states('sensor.shelly_em3_channel_b_power')|float + states('sensor.shelly_em3_channel_c_power')|float) < 0 %}
            {{ (states('sensor.shelly_em3_channel_a_power')|float + states('sensor.shelly_em3_channel_b_power')|float + states('sensor.shelly_em3_channel_c_power')|float) * -1 }}
          {% else %}
            {{ 0 }}
          {% endif %}
        availability_template: "{{
            [ states('sensor.shelly_em3_channel_a_power'),
              states('sensor.shelly_em3_channel_b_power'),
              states('sensor.shelly_em3_channel_c_power')
            ] | map('is_number') | min
          }}"

      # Template sensor for values of power consumption
      power_consumption:
        friendly_name: "Power Consumption"
        unit_of_measurement: 'W'
        value_template: >-
          {% if (states('sensor.power_export')|float(0)) > 0 and (states('sensor.power_solargen')|float(0) - states('sensor.power_export')|float(0)) < 0 %}
          {% elif (states('sensor.power_export')|float(0)) > 0 and (states('sensor.power_solargen')|float(0) - states('sensor.power_export')|float(0)) > 0 %}
            {{ (states('sensor.power_solargen')|float(0)) - states('sensor.power_export')|float(0) }}    
          {% else %}
            {{ states('sensor.power_import')|float(0) + states('sensor.power_solargen')|float(0) }}
          {% endif %}






  # Sensor for Riemann sum of energy import (W -> Wh)
  - platform: integration
    source: sensor.power_import
    name: energy_import_sum
    unit_prefix: k
    round: 2
    method: left

  # Sensor for Riemann sum of energy export (W -> Wh)
  - platform: integration
    source: sensor.power_export
    name: energy_export_sum
    unit_prefix: k
    round: 2
    method: left

  # Sensor for Riemann sum of energy consumption (W -> Wh)
  - platform: integration
    source: sensor.power_consumption
    name: energy_consumption_sum
    unit_prefix: k
    round: 2
    method: left
    
  # Sensor for Riemann sum of energy consumption (W -> Wh)
  - platform: integration
    source: sensor.solarbank_e1600_solarleistung
    name: energy_bkw_batterie_solarleistung
    unit_prefix: k
    round: 2
    method: left
    


utility_meter:
  energy_import_daily:
    source: sensor.energy_import_sum
    name: Energy Import Daily
    cycle: daily
  energy_import_monthly:
    source: sensor.energy_import_sum
    name: Energy Import Monthly
    cycle: monthly
  energy_export_daily:
    source: sensor.energy_export_sum
    name: Energy Export Daily
    cycle: daily
  energy_export_monthly:
    source: sensor.energy_export_sum
    name: Energy Export Monthly
    cycle: monthly
  energy_consumption_daily:
    source: sensor.energy_consumption_sum
    name: Energy Consumption Daily
    cycle: daily
  energy_consumption_monthly:
    source: sensor.energy_consumption_sum
    name: Energy Consumption Monthly
    cycle: monthly

Thanks for your help!

[thomluther]

I would always use template sensors for energy dashboard, this allows replacing the source/device sensor easily when necessary without loosing energy dashboard history.
I would also prefer to use summary/total energy sensors for the dashboard, It records and displays the deltas between measurements. So when you have a sensor that resets frequently, this can mess up your stats...

"I have built a Riemann helper for the "- sensor.solarbank_e1600_solarleistung". That's displaying some really strange values. (Solar output is at 375 watts but it shows 11.46 kWh). It should actually display 0.37 kWh, correct?"
=> No, Watt is power and kWh is energy (power over time), completely different things. Energy sums up power over time, always increasing like your grid meter

"Then I also have the issue of the battery charge in my Energy Dashboard showing 80 kWh and the discharge showing 560 kWh. Everything seems quite chaotic. See Picture:"
=> The Energy Flow displays the energy for the selected time frame (not the real time power flow). You need to use the power flow plus card from HACS if you want to see power flow.
The values again are energy, a sum of all deltas recorded for the selected time range. If you see strange values, you may have to correct your statistics

[MarvinW1984]

Hey, thanks, I've solved it by now.

[MarvinW1984]

My solution for the Energy Dashboard

Many who struggle with *.YAML, just like I did, seem to have difficulties setting up the sensors for the Energy Dashboard. After numerous tests, reconfigurations, and headaches, I've finally managed to find a working solution. (Perhaps not the most elegant programming solution, but it has been working very reliably for a week now.) The whole setup is in combination with a Shelly 3EM that measures consumption and grid feed-in. Perhaps it might help someone else. I need to apologize for my poor English!

Important! After changing the configuration, please restart HomeAssistant. It may take several hours for the Energy Dashboard to display the values. It's best to let it run for a day and see.

configuration.yaml

# Loads default set of integrations. Do not remove.
default_config:

# Load frontend themes from the themes folder
frontend:
  themes: !include_dir_merge_named themes

automation: !include automations.yaml
script: !include scripts.yaml
scene: !include scenes.yaml
homekit:
  - filter:
      include_domains:
        - alarm_control_panel
        - light
        - media_player
        - camera
template:

- sensor:
    - name: "Shelly3EM Total Energy"
      unique_id: shelly3em_energy_total
      device_class: energy
      state_class: total
      unit_of_measurement: "kWh"
      state: >
         {{ 
         states('sensor.shelly_em3_channel_a_power')| float(0) + 
         states('sensor.shelly_em3_channel_b_power')| float(0) +
         states('sensor.shelly_em3_channel_c_power')| float(0) 
         }}

- sensor:
    - name: "Solarleistung"
      unique_id: solarleistung
      device_class: energy
      state_class: total
      unit_of_measurement: "W"
      state: >
         {{ 
         states('sensor.solarbank_e1600_solarleistung')| float(0) 
         }}
         
sensor:
  - platform: template
    sensors:

# Template sensor fuer values of power import (active_power > 0)
      power_import:
        friendly_name: "Power Import"
        unit_of_measurement: 'W'
        value_template: >-
          {% if (states('sensor.shelly_em3_channel_a_power')|float + states('sensor.shelly_em3_channel_b_power')|float + states('sensor.shelly_em3_channel_c_power')|float) > 0 %}
            {{ states('sensor.shelly_em3_channel_a_power')|float + states('sensor.shelly_em3_channel_b_power')|float + states('sensor.shelly_em3_channel_c_power')|float }}
          {% else %}
            {{ 0 }}
          {% endif %}
        availability_template: "{{
            [ states('sensor.shelly_em3_channel_a_power'),
              states('sensor.shelly_em3_channel_b_power'),
              states('sensor.shelly_em3_channel_c_power')
            ] | map('is_number') | min
          }}"

# Template sensor fuer values of power export (active_power < 0)
      power_export:
        friendly_name: "Power Export"
        unit_of_measurement: 'W'
        value_template: >-
          {% if (states('sensor.shelly_em3_channel_a_power')|float + states('sensor.shelly_em3_channel_b_power')|float + states('sensor.shelly_em3_channel_c_power')|float) < 0 %}
            {{ (states('sensor.shelly_em3_channel_a_power')|float + states('sensor.shelly_em3_channel_b_power')|float + states('sensor.shelly_em3_channel_c_power')|float) * -1 }}
          {% else %}
            {{ 0 }}
          {% endif %}
        availability_template: "{{
            [ states('sensor.shelly_em3_channel_a_power'),
              states('sensor.shelly_em3_channel_b_power'),
              states('sensor.shelly_em3_channel_c_power')
            ] | map('is_number') | min
          }}"

# Template sensor fuer values of power consumption
      power_consumption:
        friendly_name: "Power Consumption"
        unit_of_measurement: 'W'
        value_template: >-
          {% if (states('sensor.power_export')|float(0)) > 0 and (states('sensor.power_solargen')|float(0) - states('sensor.power_export')|float(0)) < 0 %}
          {% elif (states('sensor.power_export')|float(0)) > 0 and (states('sensor.power_solargen')|float(0) - states('sensor.power_export')|float(0)) > 0 %}
            {{ (states('sensor.power_solargen')|float(0)) - states('sensor.power_export')|float(0) }}    
          {% else %}
            {{ states('sensor.power_import')|float(0) + states('sensor.power_solargen')|float(0) }}
          {% endif %}

# Template sensor fuer Battery Power import (active_power > 0)
      battery_import:
        friendly_name: "Battery Import"
        unit_of_measurement: 'W'
        value_template: >-
          {% if (states('sensor.solarbank_e1600_akkuleistung')|float) > 0 %}
            {{ states('sensor.solarbank_e1600_akkuleistung')|float }}
          {% else %}
            {{ 0 }}
          {% endif %}
        availability_template: "{{
            [ states('sensor.solarbank_e1600_akkuleistung')
            ] | map('is_number') | min
          }}"

# Template sensor fuer Battery Power export (active_power < 0)
      battery_export:
        friendly_name: "Battery Export"
        unit_of_measurement: 'W'
        value_template: >-
          {% if (states('sensor.solarbank_e1600_akkuleistung')|float) < 0 %}
            {{ (states('sensor.solarbank_e1600_akkuleistung')|float) * -1 }}
          {% else %}
            {{ 0 }}
          {% endif %}
        availability_template: "{{
            [ states('sensor.solarbank_e1600_akkuleistung')
            ] | map('is_number') | min
          }}"

# Sensoren fuer Riemann sum of energy import (W -> Wh)

  - platform: integration
    source: sensor.power_import
    name: energy_import_sum
    unit_prefix: k
    round: 2
    method: left

  - platform: integration
    source: sensor.power_export
    name: energy_export_sum
    unit_prefix: k
    round: 2
    method: left

  - platform: integration
    source: sensor.power_consumption
    name: energy_consumption_sum
    unit_prefix: k
    round: 2
    method: left

  - platform: integration
    source: sensor.battery_import
    name: energy_battery_import_sum
    unit_prefix: k
    round: 2
    method: left
    
  - platform: integration
    source: sensor.battery_export
    name: energy_battery_export_sum
    unit_prefix: k
    round: 2
    method: left
    
  - platform: integration
    source: sensor.solarleistung
    name: solarleistung_kwh_sum
    unit_prefix: k
    round: 2
    method: left


utility_meter:
  energy_import_daily:
    source: sensor.energy_import_sum
    name: Energy Import Daily
    cycle: daily
  energy_import_monthly:
    source: sensor.energy_import_sum
    name: Energy Import Monthly
    cycle: monthly
  energy_export_daily:
    source: sensor.energy_export_sum
    name: Energy Export Daily
    cycle: daily
  energy_export_monthly:
    source: sensor.energy_export_sum
    name: Energy Export Monthly
    cycle: monthly
  energy_consumption_daily:
    source: sensor.energy_consumption_sum
    name: Energy Consumption Daily
    cycle: daily
  energy_battery_import_daily:
    source: sensor.energy_battery_import_sum
    name: Energy Battery Import Daily
    cycle: daily
  energy_battery_import_monthly:
    source: sensor.energy_battery_import_sum
    name: Energy Battery Import Monthly
    cycle: monthly
  energy_battery_export_daily:
    source: sensor.energy_battery_export_sum
    name: Energy Battery Export Daily
    cycle: daily
  energy_battery_export_monthly:
    source: sensor.energy_battery_export_sum
    name: Energy Battery Export Monthly
    cycle: monthly
  energy_solarleistung_daily:
    source: sensor.solarleistung_kwh_sum
    name: Energy Solarleistung Daily
    cycle: daily

Assignment of the sensors in the Energy Dashboard.

So this is how the whole thing should look.

[thomluther]

Hi @MarvinW1984
Glad to read that you got it to work for you.
Looking over your yaml code, I see some parts that you can optionally improve. I also recommend, especially for HA newcomers, to use the UI Helpers when creating those sensors or entities. It's much more user friendly for the configuration than raw yaml code, and you can even create template sensors as helpers meanwhile. With the UI all required fields will be prompted during creation, optional fields such as icons can be changed after helper creation. That would have probably made your life easier. I say so, because I never setup an integral sensor or standard utility meter in yaml due to time overhead looking the documentation for required parameters. Another advantage of the UI helpers is that creation and change is effective immediately, no reload of yaml configs is required. When you need template helpers, verify the template first in the developer tools. There you can also modify and test the input variables/sensors/values for your template code to make it more robust against unexpected conditions. Because you always have to consider how the template evaluates, if the used sensors are unavailable for instance....

Some hints on your yaml code:

1. You define a template sensor for the shelly total energy but sum up power and never use it in the other templates?
2. This is probably because the Shelly total template is wrong. When you sum power entities, you cannot make it an energy entity with a kWh unit instead of Watt. I'd suggest to correct it and add an availability to it. Then you just have a single total grid meter power entity in Watt that you can use in all other template sensors, much more simplification for your code...
   Here is the corrected version, but I recommend using the UI to select proper state and device class for a Power entity

template:
  - sensor:
    - name: "Grid Total Power"
      unique_id: grid_total_power
      device_class: power
      state_class: measurement
      unit_of_measurement: "W"
      state: >
         {{ 
         states('sensor.shelly_em3_channel_a_power')| float(0) + 
         states('sensor.shelly_em3_channel_b_power')| float(0) +
         states('sensor.shelly_em3_channel_c_power')| float(0) 
         }}
      availability: >
         {{ 
         has_value('sensor.shelly_em3_channel_a_power') and 
         has_value('sensor.shelly_em3_channel_b_power') and
         has_value('sensor.shelly_em3_channel_c_power')
         }}

3. Your charge and discharge power template sensor code can then be simplified very much. Again, I recommend to use to UI to verify the templates upfront and then configure the UI helper template sensors with it. You even have direct control how the template evaluates actually when creating the UI template helper...

template:
  - sensor:
    - name: "Power Export"
      unit_of_measurement: 'W'
      device_class: power
      state_class: measurement
      state: >-
          {% if (states('sensor.grid_total_power')|float(0)) < 0 %}
            {{ (states('sensor.grid_total_power')|float(0)) * -1 }}
          {% else %}
            {{ 0 }}
          {% endif %}
      availability: "{{has_value('sensor.grid_total_power')}}"

Simple if-then-else parts can also be reduced to one liners, for example

      state: >-
          {% set grid = states('sensor.grid_total_power')|float(0) %}
          {{ grid * -1 if grid < 0 else 0 }}

4. You create templates of type sensors, and sensors of the template platform. These are 'different types' of sensors in HA. Sensors of the template platform is the old way to create 'template sensors', HA recommends to use only the Template sensors, nowadays from the UI for simple templates:
   https://www.home-assistant.io/integrations/template/

I hope this helps

[MarvinW1984]

Hello @thomluther

that helps me a lot. I am a beginner and also a father of a little daughter! Therefore, unfortunately, I have not so much time to delve into the topic and understand it properly.

For example, I didn't know about the UI helper. :D

Thank you very much for the hint, I will implement your suggestions in the next few days.

Have a nice weekend.

[nicolinuxfr]

Thanks to the codes here, I managed to add my own templates to monitor the energy produced and distributed through my SolarBank 2 system.

It seems to work fine, but I miss one data, which is not available through this integration I think : the Smart Meter data, which is the only way as far as I can tell to know if some energy is sent back to the grid.

Is there a way to calculate the value otherwise ? Comparing with the app, I don't have the 729 W value on the bottom right on this screenshot and without it, I can't deduce the 70 W sent to the grid.

Am I missing something here ?

[xsasx]

I dont have an answer for you but could you show your sensor config ? Cause with my config Anker app show today 1.5kwh solar production and in energy monitor in HA i have only 0.3 kwh :D

[thomluther]

Important: The Solarbank 2 is not supported yet by the Api or HA integration.

It changed the way how data is transferred to the cloud. Only when the main account is open in mobile App, data is sent frequently. Otherwise the interval seems to be 5 min at least. The cloud is then aging the data after a minute or so and just returns 0W for all values, therefore you get wrong energy values with any Rieman Integral sensors.
See api issue in the library

[andsk8]

Hey @nicolinuxfr did you install version 2.0.1? If so, do you have that integrated with the Energy Integration? If so again, can you share the code? I have a Solarbank 2 Pro and the smart meter, a similar setup as you I think. Thanks

[nicolinuxfr]

Hello

Yes, I have !

I'm using several custom entities, but I'm not sure if they are still necessary using the 2.0 version. For instance, the solar energy production is an integral based on the solar power of the Solarbank 2 device. This is my configuration :

For the energy that go back to the grid, I'm directly using the daily export entity from the system device.

For the battery, I created several entities to follow what power goes in and out but I think you have entities for that now, and then integral based on this in order to add those to the energy dashboard. Same config as above.

Let me know if you want more explanations on something in particular. It works great in the end :

[thomluther]

You may also have a look to the summary that I just posted.
You should always work with local integral sensors to have flexibility and avoid recording of wrong energy spikes that may be provided by the integration/cloud.

[longliveenduro]

@thomluther I tried to understand the above as I think it relates to my problem.

For the energy dashboard (Solar production) I now use solar total yield, which seems to work nicely and produce a good daily solar production graph.

For the battery charge/discharge in the energy dashboard I used daily discharge / charge sensors of the solarbanks, but this gives an ugly/wrong spike at midnight.

Is there a solution to emulate a battery discharge/charge (all time) total that I can then simply use for the battery charge/discharge portions used in the energy dashboard?

[longliveenduro]

Had some help by Claude 3.5, will try it out ion the next hours:

template:
  - sensor:
      - name: "SB Haus naeher am, Cumulative Battery Charge"
        unique_id: sb_haus_naher_am_e1600_cumulative_battery_charge
        unit_of_measurement: "kWh"
        state_class: total_increasing
        device_class: energy
        state: >
          {% set cumulative = states('sensor.sb_haus_naher_am_e1600_cumulative_battery_charge') | float(0) %}
          {% set daily = states('sensor.sb_haus_naher_am_e1600_daily_charge') | float %}
          {% if daily != None %}
            {{ cumulative + daily }}
          {% else %}
            {{ cumulative }}
          {% endif %}
        attributes:
          last_reset: "1970-01-01T00:00:00+00:00"
          daily_value: "{{ states('sensor.sb_haus_naher_am_e1600_daily_charge') }}"
          daily_state: "{{ states('sensor.sb_haus_naher_am_e1600_daily_charge') }}"

      - name: "SB Haus naeher am, Cumulative Battery Discharge"
        unique_id: sb_haus_naher_am_e1600_cumulative_battery_discharge
        unit_of_measurement: "kWh"
        state_class: total_increasing
        device_class: energy
        state: >
          {% set cumulative = states('sensor.sb_haus_naher_am_e1600_cumulative_battery_discharge') | float(0) %}
          {% set daily = states('sensor.sb_haus_naher_am_e1600_daily_discharge') | float %}
          {% if daily != None %}
            {{ cumulative + daily }}
          {% else %}
            {{ cumulative }}
          {% endif %}
        attributes:
          last_reset: "1970-01-01T00:00:00+00:00"
          daily_value: "{{ states('sensor.sb_haus_naher_am_e1600_daily_discharge') }}"
          daily_state: "{{ states('sensor.sb_haus_naher_am_e1600_daily_discharge') }}"

  - trigger:
      - platform: time
        at: "00:00:10"
    sensor:
      - name: "SB Haus naeher am, Daily Battery Charge Snapshot"
        unique_id: sb_haus_naher_am_e1600_daily_charge_snapshot
        state: "{{ states('sensor.sb_haus_naher_am_e1600_daily_charge') }}"

      - name: SB Haus naeher am, "Daily Battery Discharge Snapshot"
        unique_id: sb_haus_naher_am_e1600_daily_discharge_snapshot
        state: "{{ states('sensor.sb_haus_naher_am_e1600_daily_discharge') }}"
        
        

[thomluther]

I would not accumulate any daily energy sensors. Risk is too high that triggers are wrong, accumulated too often or wrongly.
Also the examples use 0 as default float which is OK, but when the state is unavailable at HA startup/restart, it will render 0 and reset the template value....I'm not surprised if you all have issues with the dashboard history when trying to use sensors that reset frequently or templates that are based on those...

It's better to use W => Rieman Integral => kWh always increasing => Energy Dashboard
For Batteries: Separate W for charge and discharge first if you have a single positive/negative Watt sensor.

[thomluther]

Any total increasing sensor is good for the dashboard, do not used sensors that reset frequently.
Also do not use direct entity from devices or integrations in the dashboard. When you need to replace the device or intergration, you will loose all history tracking in the dashboard!
Easiest way:

• Use a Power entity that you want to track. If it is positive and negative like for batteries, you need to use template sensors which separate the positive or negative values in dedicated entities for Charging and discharging power.
• Create Rieman Integration sensors using the dedicated power entities as source to get an always increasing Energy senor. This you can use in the Energy dashboard
• When the power source entity must be changed, you only need to change your templates or the Rieman integral sensor to use the new power entity. The dashboard and history will remain unaffected.

[longliveenduro]

Hi @thomluther , i did set up charging and discharging template sensors. And did set integration sensors for summing up.

I see the sum sensors in the Overview but the have "Unknown".
Do you have any idea what I am doing wrong?

I have 3 solarbanks in 3 systems. Charging and Discharging sensors display values.

# Template sensors to separate charging and discharging power for each Solarbank
template:
  - sensor:
      # 4 kleinere Panels
      - name: "4 kleinere Panels Charging Power"
        unique_id: sb_4_kleinere_panels_charging_power
        unit_of_measurement: "W"
        device_class: power
        state: >
          {% set power = states('sensor.sb_4_kleinere_panels_battery_power') | float(0) %}
          {% if power > 0 %}
            {{ power }}
          {% else %}
            0
          {% endif %}

      - name: "4 kleinere Panels Discharging Power"
        unique_id: sb_4_kleinere_panels_discharging_power
        unit_of_measurement: "W"
        device_class: power
        state: >
          {% set power = states('sensor.sb_4_kleinere_panels_battery_power') | float(0) %}
          {% if power < 0 %}
            {{ power | abs }}
          {% else %}
            0
          {% endif %}
          
  - sensor:
      # SB naeher am Haus
      - name: "SB Haus naeher am Charging Power"
        unique_id: sb_haus_charging_power
        unit_of_measurement: "W"
        device_class: power
        state: >
          {% set power = states('sensor.sb_haus_naher_am_e1600_battery_power') | float(0) %}
          {% if power > 0 %}
            {{ power }}
          {% else %}
            0
          {% endif %}

      - name: "SB Haus naeher am Discharging Power"
        unique_id: sb_haus_discharging_power
        unit_of_measurement: "W"
        device_class: power
        state: >
          {% set power = states('sensor.sb_haus_naher_am_e1600_battery_power') | float(0) %}
          {% if power < 0 %}
            {{ power | abs }}
          {% else %}
            0
          {% endif %}
          
  - sensor:
      # SB naeher an Schlund
      - name: "SB Schlund naeher an Charging Power"
        unique_id: sb_schlund_charging_power
        unit_of_measurement: "W"
        device_class: power
        state: >
          {% set power = states('sensor.sb_schlund_naher_an_e1600_battery_power') | float(0) %}
          {% if power > 0 %}
            {{ power }}
          {% else %}
            0
          {% endif %}

      - name: "SB Schlund naeher an Discharging Power"
        unique_id: sb_schlund_discharging_power
        unit_of_measurement: "W"
        device_class: power
        state: >
          {% set power = states('sensor.sb_schlund_naher_an_e1600_battery_power') | float(0) %}
          {% if power < 0 %}
            {{ power | abs }}
          {% else %}
            0
          {% endif %}
          
sensor:
  - platform: integration
    source: sensor.sb_haus_charging_power
    name: "SB Haus Sum Charge"
    unique_id: sb_haus_charge_sum
    unit_prefix: k
    round: 2
    method: left
    
  - platform: integration
    source: sensor.sb_haus_discharging_power
    name: "SB Haus Sum Discharge"
    unique_id: sb_haus_discharge_sum
    unit_prefix: k
    round: 2
    method: left
    
  - platform: integration
    source: sensor.sb_schlund_charging_power
    name: "SB Schlund Sum Charge"
    unique_id: sb_schlund_charge_sum
    unit_prefix: k
    round: 2
    method: left
    
  - platform: integration
    source: sensor.sb_schlund_discharging_power
    name: "SB Schlund Sum Discharge"
    unique_id: sb_schlund_discharge_sum
    unit_prefix: k
    round: 2
    method: left
    
  - platform: integration
    source: sensor.sb_4_kleinere_panels_charging_power
    name: "SB 4 kleinere Panels Sum Charge"
    unique_id: sb_4_kleinere_panels_charge_sum
    unit_prefix: k
    round: 2
    method: left
    
  - platform: integration
    source: sensor.sb_4_kleinere_panels_discharging_power
    name: "SB 4 kleinere Panels Sum Discharge"
    unique_id: sb_4_kleinere_panels_discharge_sum
    unit_prefix: k
    round: 2
    method: left

[thomluther]

The integral sensor need at least an hour to show the first value.
If that does not work, maybe the sensor code has a typo. I never setup integral sensors via YAML, always used the UI helper for it since its much easier.

[thomluther]

Integration of solarbank into energy dashboard

Here I want to summarize some of the previous discussions and give a general guideline how energy dashboard integration can be accomplished for your solarbank. As mentioned on various places, I do NOT recommend using integration or and device entities directly in the energy dashboard for various reasons:

• Integrations may break, have breaking changes or you need to switch to a different integration for your device, which will always require to change the entity in the dashboard directly and therefore causes issues maintaining the energy history in HA
• Devices may break or maybe will be exchanged with different devices, which again requires to change the entity in the dashboard directly and you need to deal with associated history data problems accordingly
• Energy entities from devices or integration may provide wrong 0 values or have spikes from time to time, which will screw up your HA energy statistics massively and you would need to process statistic corrections afterwards. When using power sensors instead and doing the energy integration locally over time, you can pretty much avoid recording of incorrect energy spikes.
• Certain device entities may be used just temporarily over the year, and therefore may screw up your energy stats if used directly. For example I can use the Solarbank PV energy only when the Solarbank is really installed. But I uninstall it over winter since it does not give me any benefit outsite at cold temperatures. During those months I must track the PV energy entities of the inverter, which however I cannot use when the Solarbank is installed, because then the inverter entities just provide the output power of the Solarbank but not the real PV energy...

Following is the recommended high level approach to integrate devices such as the Solarbank into the Energy dashboard:

1. Create a power template sensor for the source that you want to add to the dashboard. If you have a reliable entity from the device/integration that you can use all year you may skip the template sensor for this. The power sensor should NOT become negative, since that would reduce the accumulated Energy!
2. When you have batteries, you need separate positive power (template) sensors for charging power and discharging power
3. Create a Riemann Integral helper over the power sensors to get their energy (Power over time). They are automatically classified as total_increasing sensor due to their accumulation characteristics. Therefore it is important that the source sensor does not provide negative values to avoid warnings for decreasing energy values of a total_increasing entity. The integral over power is typically 1 hour with the kilo unit prefix to get kWh for energy.

Each of those template helpers can be created in the UI nowadays. There is no need to use templates in the configuration.yaml, which may be complex and error prone for beginners.

Battery entities for the energy dashboard

Battery integration requires separate energy sensors of total_increasing class for both, battery charging energy and battery discharge energy. The Anker HA integration does only provide daily energy sensors for the solarbank, and since version 2.0.1 they are also classified correctly as total_increasing. While they should be directly usable in the energy dashboard, I recommend to create separate power template sensors for charging power and discharging power absolute values, and then create Riemann integral sensors over the power sensors to accumulate their energy over time. The reasons for this approach are described above.

Battery power template sensors for solarbank

When creating those template sensors via UI, you just need to copy the state template and adjust the remaining fields in the UI as desired. The availability template can just be used when defining the sensor in a configuration yaml file. Make sure to adjust the battery power sensor entity_id to your setup. If you have a dual Solarbank system, it is sufficient to use the system device SB battery power entity in the template, since this accumulates already the battery power for both solarbanks. Only if you want to track energy separately for each solarbank in the dashboard, or if you use an asymmetrical charging/discharging pattern for your two solarbanks, you better create separate templates for each solarbank to track their energy balance separately.

template:
  - sensor:

    - name: "Solarbank charge power"
      unique_id: "solarbank-charge-power"
      unit_of_measurement: "W"
      device_class: "power"
      icon: mdi:home-lightning-bolt
      state: >
        {% set val = states('sensor.solarbank_e1600_battery_power')|float(0) %}
        {{ val if val > 0 else 0 }}
      availability: >
        {{ has_value('sensor.solarbank_e1600_battery_power') }}

    - name: "Solarbank discharge power"
      unique_id: "solarbank-discharge-power"
      unit_of_measurement: "W"
      device_class: "power"
      icon: mdi:home-lightning-bolt
      state: >
        {% set val = states('sensor.solarbank_e1600_battery_power')|float(0) %}
        {{ val | abs if val < 0 else 0 }}
      availability: >
        {{ has_value('sensor.solarbank_e1600_battery_power') }}

Battery energy template sensors for solarbank

Following is the code for the Riemann integral sensors that you need to create from your power template sensors above. I recommend to create them with the UI, using the parameters as shown in the code. The default trapezoidal method follows the Trapezoidal rule. This method is the most accurate of the currently implemented methods for source sensors that permanently change in short regular intervals, since it better fits the curve of the intrinsic source. However, for power sensors that may stay at a constant value for longer periods, the left integration method is typically most accurate and recommended for battery energy. This is because of the way how updates are provided to HA for less frequently updating sensors at different time intervals and only when values really change. Also if the source sensor value remains constant at 0, the sensor is not considered as updated. So it is no update either for the integral sensor method and the trapezoidal rule may cause an initial average offset value for the whole 0 W period.

sensor:
  - platform: integration
    source: sensor.solarbank_charge_power
    name: "Solarbank charge kWh"
    unique_id: solarbank_charge_kwh
    unit_prefix: k
    unit_time: h
    round: 3
    method: left
    
  - platform: integration
    source: sensor.solarbank_discharge_power
    name: "Solarbank discharge kWh"
    unique_id: solarbank_discharge_kwh
    unit_prefix: k
    unit_time: h
    round: 3
    method: left

PV Energy entity for the energy dashboard

If you use the solarbank all over the year, you can use the existing solarbank photovoltaic power entity of the integration as source for your Riemann integral helper. I use the solarbank not over the complete year, therefore I use a template sensor to reflect the correct PV power depending on whether the solarbank is installed or not. When uninstalled, I use the inverter AC power entities to reflect generated PV power instead. When using this to accumulate energy statistics, it would be most accurate to consider only the AC power that really contributes to your house energy balance. However, with the solarbank DC PV power, only a subset might be converted to AC and go to the house at a given point in time, so it is difficult to consider it accurately in a correct energy balance. The following template simply ignores DC to AC conversion loss and uses the full DC PV power as reported by the solarbank, but in winter it uses the AC PV power as reported by the inverter since the inverter PV conversion loss does not contribute to the house energy balance tracked in the dashboard.
The decision criteria for an installed solarbank is simply the device tracker of my Fritz Box integration, abbreviated from the Wifi precense of the solarbank. Wifi presence is typically only lost when:

• Solarbank is switched off completely
• Local Wifi is down

template:
  - sensor:
    - name: "PV generated power"
      unique_id: "photovoltaik power"
      unit_of_measurement: "W"
      device_class: "power"
      icon: mdi:home-lightning-bolt
      state: >
        {% if is_state('device_tracker.anker_solarbank','home') %}
          {% set val = states('sensor.sb_e1600_solar_power')|float(0)|round %}
          {{val if val >= 0 else 0}}
        {% elif has_value('sensor.hoymiles_hm_600_power') %}
          {% set val = states('sensor.hoymiles_hm_600_power')|float(0)|round %}
          {{val if val >= 0 else 0}}
        {% else %}
          {{0}}
        {% endif %}
      availability: >
        {{ has_value('device_tracker.anker_solarbank') or has_value('sensor.hoymiles_hm_600_power')}}

Energy dashboard example with included solarbank

Once you have integrated all correctly, your home energy balance may look like this for a day. The pink battery charge energy is balanced as negative energy while the cyan battery discharge energy is positive energy in the balance. The orange PV consumed energy in the balance is the difference of the orange PV produced energy, pink battery charge energy and purple grid export energy. The cyan battery discharge energy will be added to the blue grid import energy and is being considered as energy that goes into the house.

[Siddi2872]

Hello Tom,

first of all thx for your great work.
I have created the template sensors and the Riemann integral helfers for charge and discharge the Battery, but it didn‘t work. The template sensors are always in the state unknown because i get the following message. How can i fix it?

[thomluther]

The availability setting is nothing you can use in the UI templates, that can be defined only in YAML
You cannot either specify the states keyword.
ONLY the JINJA template of the state: key must be specified in the UI

[thomluther]

Actually I'm still evaluating if the trapezoidal integration method is really the most accurate integration method for the charge and discharge energy. This method is accurate if there is a continous and short update of the value. However, the source power sensors update frequently only for certain periods, and then they stay 0 for long time. I had occurances, where the energy jumped up significantly once power sensor got >0 values again. This could be from trapezoidal rule. Look at following example when discharging starts there is an initial step which cannot be accurate.

The Left integration method may be more accurate, or the max interval time for the integral sensor should be specified, e.g. to 2 minutes.
Fortunately the integration method can meanwhile be changed afterwards in the entity details via the UI, this was not easily doable before.

[D4ddy-LiLd4rk]

Greetings. First off all many thanks for this guide and your Integration in general! I used this guide to create my templates and integral sensors. But it feels a bit odd after setting up the energy resources. Maybe I made a mistake? My Smart Meter is currently not installed and therefore I don't have any data of actual grid imports. All I have are two Smart Plugs (TV, PC). So for the sake of seeing something I added those two as grid consumers. On the other hand I put the solarbank output as providers to the grid. Is that correct or is that taken into account with the whole battery templates (discharge). Thanks in advance!

[thomluther]

Hi @D4ddy-LiLd4rk, if you have no energy entities representing your grid import and export, you should not put something into the energy dashboard config that does not make sense for the grid energy...
Energy from your BKW goes first into your house, not to the grid. It depends on your house consumption what will go into the grid...
The consumptions of your devices need to be configured under individual devices ONLY.

If you have no smart meter entity representing grid energies, you can build template sensors representing that until you got better sensors.
But if you only have few consumer values, it will be difficult to sum them up and add little bit constant base consumption for your grid import....It will always be inaccurate, but should be better than just the 2 device energies...
The grid export is nothing you can calculate in a template in a meaningful way, since that depends on what how much PV you push to the house and how much of that is consumed.,,,Without knowing accurate home consumptions, you cannot guess whether you export or import from grid...

[andsk8]

I have taken your last post, and modified the sensors and templates for the Solarbank 2 Pro model with the Smart Meter. It works but I'm not completely sure if what I did is the right way of doing it. I post my code in case there are any modifications that need to be done, or in case this is the right setup so that anyone can copy and benefit from it.

template:
  - sensor:
      - name: "Solarbank charge power"
        unique_id: "solarbank-charge-power"
        unit_of_measurement: "W"
        device_class: "power"
        icon: mdi:home-lightning-bolt
        state: >
          {% set val = states('sensor.solarbank_2_e1600_pro_battery_power')|float(0) %}
          {{ val if val > 0 else 0 }}
        availability: >
          {{ has_value('sensor.solarbank_2_e1600_pro_battery_power') }}

      - name: "Solarbank discharge power"
        unique_id: "solarbank-discharge-power"
        unit_of_measurement: "W"
        device_class: "power"
        icon: mdi:home-lightning-bolt
        state: >
          {% set val = states('sensor.solarbank_2_e1600_pro_battery_power')|float(0) %}
          {{ val | abs if val < 0 else 0 }}
        availability: >
          {{ has_value('sensor.solarbank_2_e1600_pro_battery_power') }}

      - name: "Solarbank solar power"
        unique_id: "solarbank-solar-power"
        unit_of_measurement: "W"
        device_class: "power"
        icon: mdi:home-lightning-bolt
        state: >
          {% set val = states('sensor.solarbank_2_e1600_pro_solar_power')|float(0) %}
          {{ val if val > 0 else 0 }}
        availability: >
          {{ has_value('sensor.solarbank_2_e1600_pro_solar_power') }}

      - name: "Grid export power"
        unique_id: "grid-export-power"
        unit_of_measurement: "W"
        device_class: "power"
        icon: mdi:transmission-tower
        state: >
          {% set val = states('sensor.smart_meter_grid_export')|float(0) %}
          {{ val if val > 0 else 0 }}
        availability: >
          {{ has_value('sensor.smart_meter_grid_export') }}

      - name: "Grid import power"
        unique_id: "grid-import-power"
        unit_of_measurement: "W"
        device_class: "power"
        icon: mdi:transmission-tower
        state: >
          {% set val = states('sensor.smart_meter_grid_import')|float(0) %}
          {{ val if val > 0 else 0 }}
        availability: >
          {{ has_value('sensor.smart_meter_grid_import') }}

sensor:
  - platform: integration
    source: sensor.solarbank_charge_power
    name: "Solarbank charge kWh"
    unique_id: solarbank_charge_kwh
    unit_prefix: k
    unit_time: h
    round: 3
    method: trapezoidal

  - platform: integration
    source: sensor.solarbank_discharge_power
    name: "Solarbank discharge kWh"
    unique_id: solarbank_discharge_kwh
    unit_prefix: k
    unit_time: h
    round: 3
    method: trapezoidal

  - platform: integration
    source: sensor.solarbank_solar_power
    name: "Solarbank solar kWh"
    unique_id: solarbank_solar_kwh
    unit_prefix: k
    unit_time: h
    round: 3
    method: trapezoidal

  - platform: integration
    source: sensor.grid_export_power
    name: "Grid export kWh"
    unique_id: grid_export_kwh
    unit_prefix: k
    unit_time: h
    round: 3
    method: trapezoidal

  - platform: integration
    source: sensor.grid_import_power
    name: "Grid import kWh"
    unique_id: grid_import_kwh
    unit_prefix: k
    unit_time: h
    round: 3
    method: trapezoidal

I added the config at 9:00 am, so there are no metrics before that.

[Deaderz90]

Hello @thomluther thank you alot for your great tool and work. I´m new in HA and struggle with the Dashboard. I use Anker Pro2 Solarbank with 4x Panels and the Smart Meter without a athoer Grid Meter.... so i copy your Template above and try to get it work in my Dashboard but i get same Errors :( I use German Letters and replaced your Sensor Intetys but looks so

`template:

• sensor:

  • name: "Solarbank charge power"
    unique_id: "solarbank-charge-power"
    unit_of_measurement: "W"
    device_class: "power"
    icon: mdi:home-lightning-bolt
    state: >
    {% set val = states('sensor.solarbank_2_e1600_pro_akkuenergie')|float(0) %}
    {{ val if val > 0 else 0 }}
    availability: >
    {{ has_value('sensor.solarbank_2_e1600_pro_akkuenergie') }}

  • name: "Solarbank discharge power"
    unique_id: "solarbank-discharge-power"
    unit_of_measurement: "W"
    device_class: "power"
    icon: mdi:home-lightning-bolt
    state: >
    {% set val = states('sensor.solarbank_2_e1600_pro_akkuenergie')|float(0) %}
    {{ val | abs if val < 0 else 0 }}
    availability: >
    {{ has_value('sensor.solarbank_2_e1600_pro_akkuenergie') }}

  • name: "Solarbank solar power"
    unique_id: "solarbank-solar-power"
    unit_of_measurement: "W"
    device_class: "power"
    icon: mdi:home-lightning-bolt
    state: >
    {% set val = states('sensor.solarbank_2_e1600_pro_solarleistung')|float(0) %}
    {{ val if val > 0 else 0 }}
    availability: >
    {{ has_value('sensor.solarbank_2_e1600_pro_solarleistung') }}

  • name: "Grid export power"
    unique_id: "grid-export-power"
    unit_of_measurement: "W"
    device_class: "power"
    icon: mdi:transmission-tower
    state: >
    {% set val = states('sensor.smart_meter_netzeinspeisung')|float(0) %}
    {{ val if val > 0 else 0 }}
    availability: >
    {{ has_value('sensor.smart_meter_netzeinspeisung') }}

  • name: "Grid import power"
    unique_id: "grid-import-power"
    unit_of_measurement: "W"
    device_class: "power"
    icon: mdi:transmission-tower
    state: >
    {% set val = states('sensor.smart_meter_netzbezug')|float(0) %}
    {{ val if val > 0 else 0 }}
    availability: >
    {{ has_value('sensor.smart_meter_netzbezug') }}

sensor:

• platform: integration
  source: sensor.solarbank_charge_power
  name: "Solarbank charge kWh"
  unique_id: solarbank_charge_kwh
  unit_prefix: k
  unit_time: h
  round: 3
  method: trapezoidal

• platform: integration
  source: sensor.solarbank_discharge_power
  name: "Solarbank discharge kWh"
  unique_id: solarbank_discharge_kwh
  unit_prefix: k
  unit_time: h
  round: 3
  method: trapezoidal

• platform: integration
  source: sensor.solarbank_solar_power
  name: "Solarbank solar kWh"
  unique_id: solarbank_solar_kwh
  unit_prefix: k
  unit_time: h
  round: 3
  method: trapezoidal

• platform: integration
  source: sensor.grid_export_power
  name: "Grid export kWh"
  unique_id: grid_export_kwh
  unit_prefix: k
  unit_time: h
  round: 3
  method: trapezoidal

• platform: integration
  source: sensor.grid_import_power
  name: "Grid import kWh"
  unique_id: grid_import_kwh
  unit_prefix: k
  unit_time: h
  round: 3
  method: trapezoidal
  
  
  `

[Deaderz90]

Found it its was a wrong Variable

[Deaderz90]

Hello i have a Strange Value on Grid power Export KWH, I Export a little aroung 225W in 6 Minutes but get in the helper 1,4KWH Export as Value :O any Idea?

- platform: integration source: sensor.grid_export_power name: "Grid export kWh" unique_id: grid_export_kwh unit_prefix: k unit_time: h round: 3 method: trapezoidal

[thomluther]

This might be related to trapezoidal rule. Change all your Riemann integral templates to LEFT method, since that is more accurate when the sensors have longer periods of constant 0 values, see here
I changed that in my templates as well.

[Deaderz90]

Okay thank you for your anwser i change my Helpers all in LEFT Methode and will see whats happen

[mike4001]

Is there really no way to split the Battery Wh sensor of the integration into charge and discharge?

The measurements in Wh are all right there ...

Anker only provies a new data point for Battery power every 5 minutes which we integrate with this workaround.

This just cannot be correct IMHO

[thomluther]

Here is one of my custom template sensors that use a similar approach. You will have to modify that accordingly to get the last delta from the last_period attribute upon daily value resets, just to make sure the last daily delta is not skipped.

# Solarbank battery total charge energy
- trigger:
    # trigger when solarbank energy state changed
    - trigger: state
      entity_id: sensor.solarbank_ladeenergie
      not_to:
        - "unknown"
        - "unavailable"
    # initial setting delay until all is loaded
    - trigger: homeassistant
      id: start
      event: start
  action:
    - alias: "Wait until all required sensors are reloaded upon HA restart"
      wait_template: "{{trigger.id != 'start' or (has_value('sensor.solarbank_aufladeenergie') and has_value('sensor.solarbank_ladeenergie'))}}"
      timeout: "00:00:30"
  sensor:
    - name: "Solarbank Aufladeenergie"
      unique_id: "Solarbank-Aufladeenergie"
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total_increasing"
      icon: mdi:battery-plus
      state: >
        {% set val = states('sensor.solarbank_ladeenergie') %}
        {% set last = this.attributes.last_valid_state|default('') %}
        {% set mystate = this.state if this.state not in ['unavailable','unknown',None] else 0 %}
        {# Source can go up and down, accumulate only increase deltas #}
        {% if is_number(mystate) and is_number(last) and is_number(val) and val|float > last|float %}
          {{(mystate|float + val|float - last|float)|round(3)}}
        {% else %}
          {{mystate}}
        {% endif %}
      attributes:
        source: "sensor.solarbank_ladeenergie"
        last_valid_state: >
          {% set val = states('sensor.solarbank_ladeenergie') %}
          {{val|float(0)|round(3) if is_number(val) else this.attributes.last_valid_state}}
      availability: "{{has_value('sensor.solarbank_ladeenergie')}}"

[thomluther]

One important note for state and attribute field templates:
The state as well as the attributes can access only the current value of the sensor's state object. None of them can access the evaluated template value of another field from the current update. So if you have dependent calculations or logic,, the logic has to be repeated for each of the field templates that depend on current values.

[mike4001]

Thanks, I think I understand using the battery indicator this way, though the code is a little bit "high" for me ... but I will figure it out eventually :-)

And yes I understand that this is also not completely correct.

But the point why I was writing this is just that I believe I made the implementation correctly according to your guide. I startet with 10% battery in the morning and ended with 10% battery.

But the Rieman Integrators calculated a battery charge of 0,93 kWh and a battery discharge of 2,30 kWh ....

... which is probably caused by the Rieman Integrators get a new value every 5 minutes but these can always be little power spikes and the integrator assumes this power is delivered for 5 minutes straight.

[mike4001]

OK, maybe the trapezoid integration was the issue.

Basically jumps from 700 watt to 0 for a long time will get integrated if I understand it correctly. And I had 3 of those today :-)

[thomluther]

Yes, I noticed the same issue on my other riemann sensors. If your source is constant for longer periods, the trapezoidal rule will give wrong values because it averages the next change over the complete constant duration!
The LEFT rule should be accurate, since it sums the new value until it received another new value.

[mike4001]

I had another idea. Just sharing.

I am measuring the power the Anker Solix 2 puts into my home via a shelly 1PM. So there I get accurate readings every second.

We know the Solar Power of the Anker Solix 2. Though they only update every 5 mintues, these values will not change that often compared to the battery Watt in Smartmeter mode.

So if we subtract one from the other we basically get what gets charged into the battery or discharged from the battery as a far more accurate reading.

There are just the edge cases if the battery is full and is not charging anymore and so on.

[thomluther]

Sure, such a template may be more reliable for the battery power. The Solar PV is more steady in 5 min intervals, just at very cloudy mix days you may get more inaccuracy in the battery power template that will be used for the energy calculation.
That template should also consider the solarbank states. Or better, use different templates for charge and discharge power which both consider the solarbank state as well. You will need to find a good way whether the battery at daytime is charging or discharging, depending on the measured shelly power and the home demand. So to make this more accurate, you need another home demand sensor that updates frequently to know whether the demand is higher or lower than PV. Depending on that the battery may be discharging or charging....So not that simple without having frequent home demand values.