Shelly Pro 3em und richtig saldieren bzw. richtige Werte in HA

Gemessen wird schon korrekt, nur wirds falsch zusammengezählt.
Dabei spielt es keine Rollte, ob ich ein Template baue und alle Phasen zusammenzähle, oder den internen Shelly Zähler nehme.
Der einzige Weg wäre die Leistung zu nehmen und die zwischen positiven und negativen Werten zu unterscheiden, danach einen Helper mit einem Integralsensor (linke Riemansche Summe) für die Positiven Werte und einen für die Negativen Werte anlegen.
Damit kommst du annähernd an die korrekten Werte.

Anbei noch ein Screenshot von EHZ und Shelly Pro 3EM mit dem integrierten Zähler. Der Zeitraum ist ein Tag.

Rechnet man Gewinne und Verluste des jeweiligen Zählers zusammen, kommt in etwa der gleiche Wert dabei raus (23,9 zu 23,6 kWh)
Für die Kosten zu ermitteln, ist die Saldierung vom Shelly Pro jedenfalls unbrauchbar.

Danke für die Erklärung.

Ich habe noch einen analogen Zähler, dieser hat letzten Monat einen Unterschied von 0,4 KWh zum Ergebnis des Shelly (Berechnung über .yaml) gezeigt.
Aber ich finde deinen Ansatz sehr interessant und werde es überprüfen, sobald mein digitaler Zähler installiert ist.

Der einzige Weg wäre die Leistung zu nehmen und die zwischen positiven und negativen Werten zu unterscheiden, danach einen Helper mit einem Integralsensor (linke Riemansche Summe) für die Positiven Werte und einen für die Negativen Werte anlegen.

So habe ich es in den Beitrag von August beschrieben und so läuft es bei mir.

In der .yaml wird a+b+c zusammen gezählt, ist es dann ein positiver Wert (Sensor = Leistung aus dem Netz), oder negativer Wert (Sensor = Leistung ins Netz).
Diese beiden Sensoren werden mit Integralsensor (linke Riemansche Summe) in KWh umgerechnet und im Energy Dashboard verwendet.

Ich stelle mal meine Templates (Templatesensor über Ui) für den 3EM zu Verfügung.
Bei dem Pro reicht dann nur der Power Total Sensor.

Den jeweiligen (Template) Powersensor kann man dann in einem Integral Sensor hinterlegen.

(Template Powersensor Bezug)


{% if states('sensor.shellyem3_channel_a_power')|is_number and
      states('sensor.shellyem3_channel_b_power')|is_number and
	  states('sensor.shellyem3_channel_c_power')|is_number and 
	  states('sensor.shellyem3_channel_a_power')|float + states('sensor.shellyem3_channel_b_power')|float + states('sensor.shellyem3_channel_c_power')|float > 0
%}
  {{ (states('sensor.shellyem3_channel_a_power')|float(0) +
             states('sensor.shellyem3_channel_b_power')|float(0) +
             states('sensor.shellyem3_channel_c_power')|float(0)) }}
{% else %}       
0
{% endif %}

(Template Powersensor Lieferung)


{% if states('sensor.shellyem3_channel_a_power')|is_number and
      states('sensor.shellyem3_channel_b_power')|is_number and
	  states('sensor.shellyem3_channel_c_power')|is_number and 
	  states('sensor.shellyem3_channel_a_power')|float + states('sensor.shellyem3_channel_b_power')|float + states('sensor.shellyem3_channel_c_power')|float < 0
%}
  {{ (states('sensor.shellyem3_channel_a_power')|float(0) +
             states('sensor.shellyem3_channel_b_power')|float(0) +
             states('sensor.shellyem3_channel_c_power')|float(0)) *-1 }}
{% else %}       
0
{% endif %}

Das ganze Problem wurde hier schon häufiger diskutiert, unter anderem in diesem Thread → Shellypro3em + Balkonkraftwerk ins Energiedashboard

Dort werden neben der Erläuterung auch diverse Lösungen aufgezeigt, wobei nach eigener Erfahrung das Template von BobG ein wenig genauer rechnet (warum auch immer).

Ja ich wollte nur klarstellen, dass dieser Thread irreführend ist.
Da man via Google immer auf diesen Thread stößt, könnten andere User auch in diese Falle tappen.

@rubinho wenn ich das bei meinem 3EM Pro aber richtig sehe, dann ist der “total active power” sensor schon richtig beim zusammenzählen.

Das ist der Echtzeit Summen wert aller drei Phasen.
Diesen müsste man dann nur mehr in “negativ” oder “positiv” filtern und daraus import bzw Export ableiten.

Sollte genauer und schneller als das manuelle zählen der drei Phasen sein weil es ja direkt der Shelly macht?

@zakazak
Wenn du keine Einspeisung hast, zählt er auch korrekt.
Wenn du aber eine Einspeisung hast und deine 3 Phasen nicht absolut syncron sind, zählt er nicht mehr korrekt. Wenn nur eine Phase einspeist und der rest noch Bezug hat, fängt er schon an den Einspeisezähler hochzutzählen, auch wenn die Summe aller Zähler (Bezug und Einspeisung) noch nicht negativ ist. Und das ist Abrechnungstech. falsch! Das ist in gewisserweise zwar mathematisch trotzdem richtig, aber der EHZ des Netzbetreibers zählt halt saldierend. Es kommen letztdenlich unterschiedliche Werte dabei raus. Das ist definitiv fakt. Also nix theoretisches, sondern auch in der Praxis getestet.

2 „Gefällt mir“

Danke - das erklärt vermutlich warum die Werte von smartlese meines Netzbetreibers (Tageswerte) anders als die in HA sind.

Kannst du mir vl dein ganzes yaml Script zur verfügung stellen? Also inkl dem template, sensor, utility_meters und allem drum und dran? Ich sehe schon den Wald vor lauter Sensoren .ehh…bäumen nicht mehr. Würde dann alles aus meinen .yaml Dateien löschen und nur deines verwenden.

Was meinst du auch mit “bei dem Pro reicht der Power Total Sensor”? Ich dachte genau der zählt falsch?

Danke dir!

Sorry, ich habe momentan etwas Stress auf der Arbeit.
Ein Yaml kann ich dir leider nicht (mehr) zu Verfügung stellen, da ich mit meinen beiden 3EMpro´s auf ein internal script umgestiegen bin.

Hast du einen EM oder EM Pro?
Bei einem EM Pro kannst du ein Script direkt im Shelly einbinden, was im Prinzip das Gleiche wie HA macht, nur lokal halt. Das hat den Vorteil, dass die Werte auch dann korrekt gezählt werden, wenn die Verbindung zu HA mal nicht da ist. Zb. bei einem Neustart von HA. Darüber hinaus ist die berechnung etwas genauer, da kein Zeitversatz besteht.

Da das ganze über MQTT übermittelt wird, benötigst du dann noch zwei MQTT Sensoren in HA…

    - name: shellypro3em-steuve-diff_total_energy-consumed
      unique_id:shellypro3em-abcdedf-c
      state_topic: "shellypro3em-abcdedf/energy_counter/consumed"
      unit_of_measurement: "kWh"
      state_class: total_increasing
      device_class: energy
    - name: shellypro3em-steuve-diff_total_energy-returned
      unique_id: shellypro3em-abcdedf-r
      state_topic: "shellypro3em-abcdedf/energy_counter/returned"
      unit_of_measurement: "kWh"
      state_class: total_increasing
      device_class: energy

Anbei das Shelly 3EM Pro Script

let energyReturnedWs = 0.0;
let energyConsumedWs = 0.0;

let energyReturnedKWh = 0.0;
let energyConsumedKWh = 0.0;

let log = 0;

// set this to false to stop publishing on MQTT
let MQTTpublish = true;

// set this to false if you DONT want to update the name
// (the updated name is necessary to read the data with the iobroker shelly plugin)
let updateName = false;

// query the MQTT prefix on startup
let SHELLY_ID = undefined;
Shelly.call("Mqtt.GetConfig", "", function (res, err_code, err_msg, ud) {
  SHELLY_ID = res["topic_prefix"];
});

function SetKVS(key, value)
{
 Shelly.call(
   "KVS.Set", {
     "key": key,
     "value": value,
   },
   function(result) {
     if (log > 0)
       print("KVS Saved, rev:", result.rev);
   }
 );
}
 
function SaveCounters()
{
  SetKVS("EnergyConsumedKWh", energyConsumedKWh );
  SetKVS("EnergyReturnedKWh", energyReturnedKWh );
}
     
Shelly.call(
   "KVS.Get", {
     "key": "EnergyReturnedKWh",
   },
  function callback(result, error_code, error_message, userdata) {
     if (error_code === 0) 
     {
       energyReturnedKWh = Number(result.value);
       print("Loaded returned energy: ", energyReturnedKWh, " KWh");
     }       
   }
 );
 
 Shelly.call(
   "KVS.Get", {
     "key": "EnergyConsumedKWh",
   },
  function callback(result, error_code, error_message, userdata) {
     if (error_code === 0) 
     {
       energyConsumedKWh = Number(result.value);
       print("Loaded consumed energy: ", energyConsumedKWh, " KWh");
     }       
   }
 );

let counter3600 = 0;
let counter20 = 18;

let lastPublishedMQTTConsumed = "";
let lastPublishedMQTTReturned = "";

function timerHandler(user_data)
{
  let em = Shelly.getComponentStatus("em", 0);
  if (typeof em.total_act_power !== 'undefined') {
    let power = em.total_act_power;
    
    if (power >= 0)
    {
        energyConsumedWs = energyConsumedWs + power * 0.5;
    }
    else
    {
        energyReturnedWs = energyReturnedWs - power * 0.5;
    }
    
    // once a full Wh is accumulated, move it to the KWh counter
    let fullWh = Math.floor((energyConsumedWs / 3600));
    if (fullWh > 0)
    {
      energyConsumedKWh += fullWh / 1000;
      energyConsumedWs -= fullWh * 3600;
      if (log > 0)
        print("Changed consumed KWh: ",energyConsumedKWh);
    }
    
    fullWh = Math.floor((energyReturnedWs / 3600));
    if (fullWh > 0)
    {
      energyReturnedKWh += fullWh / 1000;
      energyReturnedWs -= fullWh * 3600;
      if (log > 0)
        print("Changed returned KWh: ",energyReturnedKWh);
    }
    
    if (log > 0)
      print(power , "W");
      
    counter3600 = counter3600 + 1;
    if (counter3600 > 3600)      
    {
      counter3600 = 0;     
      SaveCounters();
    }
    
    counter20 = counter20 + 1;
    if ( counter20 > 20)
    {
      counter20 = 0;  
      if (updateName)
      {
        Shelly.call(
          "Sys.SetConfig", {
             config: {device:{name:energyConsumedKWh.toFixed(3)+" KWh ; "+(energyReturnedKWh+energyReturnedWs / 3600000).toFixed(5)+" KWh"}},
          },
          function(result, error_code, error_message, userdata) {
             //print("error ", error_code, " : ", error_message);
             //print("result", JSON.stringify(result));
          }
        );
      }
             
      if (typeof SHELLY_ID !== "undefined" && MQTTpublish === true) 
      {         
        let value = energyConsumedKWh.toFixed(3);
        if (value !== lastPublishedMQTTConsumed)
        {
          MQTT.publish(
            SHELLY_ID + "/energy_counter/consumed",
            value,
            0,
            false
          );
          lastPublishedMQTTConsumed = value;
        }
        
        let value = energyReturnedKWh.toFixed(3);
        if (value !== lastPublishedMQTTReturned)
        {
          MQTT.publish(
            SHELLY_ID + "/energy_counter/returned",
            value,
            0,
            false
          );
          lastPublishedMQTTReturned = value;
        }           
      }
    }
  };
}

Timer.set(500, true, timerHandler, null);

function httpServerHandler(request, response) {
    response.code = 200;

    // create JSON object 
    const energyData = {
        energyConsumed: energyConsumedKWh.toFixed(3) + " KWh",
        energyReturned: (energyReturnedKWh+(energyReturnedWs / 3600000)).toFixed(5) + " KWh"
    };

    // convert JSON object to string and send it as reply
    response.body = JSON.stringify(energyData);
    response.send();
    return;
}
HTTPServer.registerEndpoint("energy_counter", httpServerHandler);

Quelle:GitHub - sicanins/shelly-pro3EM-energycounter

1 „Gefällt mir“

@rubinho Vielen Dank! Ich werde das mal auf meinem 3EM Pro installieren und parallel zu folgendem HA script laufen lassen:

# Shelly 3EM templates for 3-phase Net Import, Export and Consumption(if you have solar generation details)
# This uses the shelly instantaneous power sensors to achieve the best possible accuracy. 
# Shelly Sensors are  sensor.shellypro3em_abcdef_phase_a_active_power, sensor.shellypro3em_abcdef_phase_b_active_power, sensor.shellypro3em_abcdef_phase_c_active_power for the three phases
# Solar generation in W is used to calculate consumption via sensor.power_solargen
# V1.0 Initial release by Uksa007
# V1.1 add float(0) to Consumption template to stop log warnings.
# V1.2 add Friendly names to Utility Meter sensors
# V1.3 remove negative spikes from power consumption due to different update timing of solar sensor
# V1.4 change round: 2 for small value users.
# M1.0 Set round to 4, integrate PV-Summation_Delivered to be used with sensor.power_solargen, add float for each phase (otherwise error)

sensor:
  - platform: template
    sensors:
    
    # Template sensor for Ikea Inspelning to work with sensor.power_solargen
      pv_power_watts:
        friendly_name: "PV Power (W)"
        unit_of_measurement: "W"
        value_template: "{{ (states('sensor.pv_instantaneous_power') | float(0)) * 1000 }}"

      # 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.shellypro3em_abcdef_phase_a_active_power')|float + states('sensor.shellypro3em_abcdef_phase_b_active_power')|float + states('sensor.shellypro3em_abcdef_phase_c_active_power')|float) > 0 %}
            {{ states('sensor.shellypro3em_abcdef_phase_a_active_power')|float + states('sensor.shellypro3em_abcdef_phase_b_active_power')|float + states('sensor.shellypro3em_abcdef_phase_c_active_power')|float }}
          {% else %}
            {{ 0 }}
          {% endif %}
        availability_template: "{{
            [ states('sensor.shellypro3em_abcdef_phase_a_active_power')|float,
              states('sensor.shellypro3em_abcdef_phase_b_active_power')|float,
              states('sensor.shellypro3em_abcdef_phase_c_active_power')|float
            ] | 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.shellypro3em_abcdef_phase_a_active_power')|float + states('sensor.shellypro3em_abcdef_phase_b_active_power')|float + states('sensor.shellypro3em_abcdef_phase_c_active_power')|float) < 0 %}
            {{ (states('sensor.shellypro3em_abcdef_phase_a_active_power')|float + states('sensor.shellypro3em_abcdef_phase_b_active_power')|float + states('sensor.shellypro3em_abcdef_phase_c_active_power')|float) * -1 }}
          {% else %}
            {{ 0 }}
          {% endif %}
        availability_template: "{{
            [ states('sensor.shellypro3em_abcdef_phase_a_active_power')|float,
              states('sensor.shellypro3em_abcdef_phase_b_active_power')|float,
              states('sensor.shellypro3em_abcdef_phase_c_active_power')|float
            ] | 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: 4
    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: 4
    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: 4
    method: left
   
  # Sensor to make Ikea Inspelning work with sensor.power_solargen 
  - platform: derivative
    source: sensor.pv_smartdose_summation_delivered
    name: pv_instantaneous_power
    #name: "PV Instantaneous Power"
    unit_time: h
    round: 4

Dieses script habe ich in einem forum gefunden und noch etwas angepasst. Es war über die letzten 2 tage schon mal recht genau.
Damit kann ich die beiden scripte vergleichen.

Das script am EM Pro laufen zu lassen ist jedenfalls charmant!

Hast du bisher getestet bzw einen Unterschied bemerkt ob der ECO Modus an ist oder nicht?

Danke!

Update:
Ich kann den Shelly leider nicht mit HA verbindne via MQTT.
MQTT Broker ist installiert.
Die MQTT Integration erscheint und z.B. mein Hoymiles Addon kann darüber auch kommunizieren.
Beim Shelly habe ich ingestellt:

  • no TLS
  • MQTT prefix shellypro3em_abcdfdfg
  • Enable MQTT Control
  • Enable RPC over MQTT
  • RPC Status notification
  • Generic status update
  • Server: IP von Homeassistant mit port 1883
  • Client id: shellypro3em-abcdfdf
  • Username / Passwort

Ich habe eine Saldierungslösung erzeugt welche auch bei Netzwerk-, HA reboot etc. weiterläuft und auch schon die Werte in der Shelly Integration korrekt an HA meldet. (Nur 2 Helfer notwenig, keinerlei yaml etc.)
Siehe: Link zur Doku

5 „Gefällt mir“

Hallo, im Home Assistant stehen leider bei mir die richtigen Sensoren für den Shelly 3EM Pro für Netzbezug und Netzeinspeisung nicht zur Verfügung. Leider waren mir die Anleitungen hier bisher zu schwer zu verstehen.

Hat jemand vielleicht eine Anleitung, wo alles detaillierter steht. Was man genau wo eintragen muss. Den Editor habe ich zumindest schon installiert.

Vielen Dank

Hallo, wenn du mit den oben von mir beschrieben nicht zurecht kommst, kann ich dir nur das Video aus meinem Post oben empfehlen, da wir alles sehr gut beschrieben uns erklärt.

https://community.simon42.com/t/shelly-pro-3em-und-richtig-saldieren-bzw-richtige-werte-in-ha/24672/12?u=hette78

Hallo HighFive, dein Link zu der Anleitung funktioniert nicht mehr. Könntest du diesen erneut teilen oder mir sonst anderweitig das PDF zukommen lassen? Danke!

Hallo,

Der Link ist korrekt und funktioniert bei mir wie erwartet. Sag mir welche Fehlermeldung du erhältst.

Grüße HighFive

Hallo HighFive,sorry, war mein Fehler, ich hatte an meinem Firmenrechner wohl eingeschränkte Rechte, nun hat es funktioniert. Danke!

Hallo zusammen,

ich muss mich auch mal einhaken, da ich nach langem Herumprobieren mit HA und Shelly 3EM Pro nicht weitergekommen bin bzw. ich ein Verständnisproblem habe. Ich habe seit einigen Monaten ein Balkonkraftwerk, allerdings ohne Speicher. Ich habe mir hinter den Zähler ein Shelly 3EM Pro geklemmt, der den gesamten Stromfluss im Haus misst. Ich möchte jetzt für die Entscheidung ob Speicher ja oder nein wissen, wie viel von dem produzierten Strom ich eigentlich “verschenke”. In der Energieanzeige der Shelly App sieht man ja den “gesamten Echtzeitverbrauch” und ob man gerade bezieht oder einspeist. Meine Frage: kann ich irgendwo in der App sehen, wie viel Überschuss ich an einem Tag hatte? Es gibt ja die Diagramme wo ich Auswertungen für die letzten 24 Stunden, einen bestimmten Tag usw. auswerten kann. Dort gibt es auch immer den Wert “insgesamt zurückgegeben”. Die Werte die dort auftauchen erscheinen mir aber doch recht hoch. Wenn ich mir zum Beispiel mal den September ansehe, habe ich 112 kW produziert und 103 kW zurückgegeben?

Praxisbeispiel: mal angenommen ich habe einen konstanten Verbrauch von 200 Wh. Mein Balkonkraftwerk produziert vier Stunden lang genau 200 Wh und zwei weitere Stunden 600 Wh. Dann habe ich in meiner Welt einen Überschuss von 2 x 400 Wh die ich “verschenkt” habe. Genau diesen Wert will ich ausgewertet haben. Entspricht das also dem Wert “insgesamt zurückgegeben”?

Vielen Dank für eure Hilfe :slight_smile:

Beste Grüße

Marcel

Hallo, bin bzgl. Shelly 3 ProEm etwas verwirrt. Mein Shelly zeugt mit nur 6 Entitäten. HA ist komplett neu aufgesetzt und die Shelly Integration ist aktiv. Hast du eine Idee wie ich die fehlenden Entitäten bekomme?

Schau mal ob Du dein Shelly auf 3 Phasen einstellst. Könnte daran liegen.
Einloggen auf dem Pro, dort unter Settings ( Zahnrad ) dann bei Device settings → Device profile