Was bedeuten die Werte vom Shelly Pro 3EM

[Die wilde Inge]

Grüße,

Ich habe mal eine Verständnisproblem mit den Werten welche mir mein Shelly Pro 3EM liefert.

Ich verstehe nicht genau was die Werte bedeuten, vielleicht kann es mir ja jemand erklären.

Der 3EM hängt direkt vor dem Zähler. Ich habe zusätzlich ein Messgerät am Balkonkraftwerk.
Ich speichere alle Total-Werte 1x töglich in einer DB um mit den Werten rechnen zu können.

Also, folgende Zahlen kriege ich:

Mein BKW hat gestern 4,36kWh erzeugt,

der Shelly meldet für den gleichen Zeiraum für den Wert

total_act_ret: 2,320 kWh (Differenz aus Vorgestern 23Uhr minus gestern 23Uhr)
= "Gesamte zurückgegebene Wirkenergie auf allen Phasen"

sowie

total_act: 4,275kWh (Differenz aus Vorgestern 23Uhr minus gestern 23Uhr)
= "Gesamtwirkenergie auf allen Phasen"


Ich wäre jetzt im ersten Augenblick davon ausgegangen, dass Total_Act_Ret wiederspiegelt wie viel eingespeist wurde, ist das korrekt?
Ich habe also 4,36kWh erzeugt und davon 2,320 eingepeist, weil kein Abnehmer da war.

Was ist dann aber total_act ? Der Wert an Energie der zusätzlich aus dem Netz gezogen wurde oder der Gesamtverbrauch des Hauses inkl. das was der BKW beigesteuert hat?

Also

Gesamtverbrauch = total_act + (BWK - totcal_act_ret)

oder

Gesamtverbrauch = total_act


Wer jetzt denkt: Geht doch zum Zähler und notier dir die Werte: Ja, aber nein Das Display von meinem Holley Zähler ist kaputt und der Zähler wird sonstwann ausgetauscht. Ich will nicht Wochen warten bis ich es empirisch nachprüfen kann.

Kann mir jemand erklären was ich hier sehe, bitte?

VG

 

[kartoffelpü]

Aufgrund der Shelly-API hört sich total_act nach Gesamtverbrauch in dem Zeitraum an.

 

[DoNG]

Dein Shelly saldiert nicht. Das heißt die total_act[_ret] gibt jeweils an, wie viel in Summe über die Phasen gelaufen ist, rechnet aber nicht über alle Phasen gegen.

Beispiel:

Phasen A,B,C
BKW hängt auf Phase A und erzeugt 800W

Verbrauch der Phasen:
A: 200W
B: 50W
C: 550W

Der Shelly zeigt folgende Werte an:
A: -600W
B: 50W
C: 550W

Angenommen die Werte an den Phasen bleiben für eine Stunde konstant, dann kommt bei total_act 600Wh dazu (1 Stunde * (Phase B + Phase C)) und bei total_act_ret 600Wh (1 Stunde * Phase A).

Dein Stromzähler saldiert jedoch alle drei Phasen (A + B + C) und meldet daher auch einen Bezug von 0Wh für diese Stunde. D.h. korrekterweise würden total_act und total_act_ret nicht steigen, weil du weder Strom bezogen, noch eingespeist hast.

Du kannst aber in der Shelly-Appp seit dem letzten Update auf "Saldiert" umstellen, siehe Anhang, einmal normal, einmal saldiert (zumindest für die Anzeige in der App).

 

[Die wilde Inge]

Der Shelly zeigt folgende Werte an:
A: -600W
B: 50W
C: 550W

Angenommen die Werte an den Phasen bleiben für eine Stunde konstant, dann kommt bei total_act 600Wh dazu (1 Stunde * (Phase B + Phase C))

Ich will schwer hoffen, dass zumindest der Teil nicht stimmt. Wenn er nicht alle 3 Phasen addiert, also bei total_act auch auf 0W für die eine Stunde kommt, dann wäre das ja ziemlich beknackt :-D

abr gut, der Gesamtverbrauch würde sich dann ja auch ergeben, wenn ich von dem total_Act das _ret abziehe. Nur habe ich dann geblich weniger als 2kWh verbraucht und das kann nicht stimmen, zu wenig. Allerdings könnte das der Wert sein, der aus dem Netz nachgezogen wurde, + Differenz aus Erzeugung und Einspeisung.

Wenn nur der Zähler was einzigen würde, wie nervig
Naja, im Zweifel speichere ich die Werte erstmal in die DB und mache damit eben später weiter, wenn der Zähler wieder was anzeigt.

VG

 

[Foehammer]

Ich will schwer hoffen, dass zumindest der Teil nicht stimmt. Wenn er nicht alle 3 Phasen addiert, also bei total_act auch auf 0W für die eine Stunde kommt, dann wäre das ja ziemlich beknackt :-D

Ich bin einigermassen sicher, dass es genau so funktioniert - der Stromzähler vom EW machts auch nicht anders.

 

[DoNG]

Nein, der Shelly saldiert die Phasen nicht. Sieht man ja auch gut bei meinen zwei Bildern (einmal Standard und einmal das neue "Net-Metering").

Die Stromzähler vom Netzbetreiber (zB Smart Meter) sind saldierend.

Du kannst vielleicht auch bei deinem Netzbetreiber die Werte abfragen, wenn du einen Smart Meter verbaut hast, dann geht das (allerdings meist nicht in Echtzeit).

 

[Masamune2]

wenn ich von dem total_Act das _ret abziehe.

Das gibt Murks.
Das eine ist dein Bezug, das andere deine Einspeisung. Es kann ja durchaus sein das du Mittags Einspeisung hast weil das Balkonkraftwerk mehr erzeugt als du im Haus brauchst und Abends dann Bezug weil du im Haus mehr brauchst als das Balkonkraftwerk dann noch erzeugen kann.
Das muss getrennt gezählt werden da es auch vom Energieversorger bzw. Netzbetreiber unterschiedlich vergütet bzw. in Rechnung gestellt wird.

 

[Die wilde Inge]

@Masamune2 stimmt schon, aber die Werte vom Shelly sind ja auch nicht die, die am Ende beim Zähler auftauchen. Diesen Werten muss ich mich also rechnerisch nähern.

4,275kWh wäre auf jeden Fall ein realistischer Tageswert. Nun ja, ich werde mich wohl gedulden müssen bis ich die Werte mit denen des zählers vergleichen kann. Einen Smart Meter habe ich nicht, nur einen Zweirichtungszähler.

Wenn ich dran denke, werde ich demnächst noch mal Rückmeldung geben, wie viel Bezug ich am Ende wirklich hatte, von einer Nacht bis zur nächsten.

VG

 

[DoNG]

Wie gesagt, der Shelly saldiert nicht. Du kannst nicht einfach Bezug - Einspeisung rechnen. Auch nicht Bezug + BKW - Einspeisung.

Was du machen kannst, um näherungsweise an den Verbrauch zu kommen, falls du die Werte vom BKW abfragen kannst, wieder unter der Annahme das BKW hängt an Phase A und du kannst die Werte kontinuierlich/bei Änderung abfragen:

// Werte in Watt
val Number phaseA = em_phase_a
val Number balkonPV = balkon_pv
val Number phaseANorm = phaseA + balkonPV
val Number phaseB = em_phase_b
val Number phaseC = em_phase_c

// Gesamtverbrauch berechnen
val Number overall = phaseANorm + phaseB + phaseC

// import aus Grid berechnen
var Number gridImport = overall - balkonPV
if (gridImport < 0) {
    gridImport = 0
}

// export in Grid berechnen
var Number gridExport = phaseA + phaseB + phaseC
if (gridExport < 0) {
    gridExport = gridExport * -1
}
else {
    gridExport =  0
}

Damit hättest du den aktuellen Verbrauch, den Bezug aus dem Netz und die Einspeisung in das Netz.

Im Anhang nochmal die Daten von meinem Netzbetreiber für die letzten drei Tage und zum Vergleich die Daten aus der Shelly App. Da sieht man, dass der Shelly genau so arbeitet, wie von mir beschrieben.

 

[Die wilde Inge]

@DoNG Danke, aber dann muss ich mir etwas anderes einfallen lassen. Ich müsste die Werte dann viel zu häufig abfragen um da auf einen grünen Zweig zu kommen. Aktuell mache ich es alle 2min. Das reicht für ein Liniendiegramm aus und die Gesamterzeugung rechnet das Messgerät ohnehin einzeln zusammen.
Würde ich den Verbrauch selber errechnen wollen müsste ich die Werte ja deutlich häufiger abfragen.

 

[Ibims12]

Guten Abend,

Ich habe mich jetzt extra registriert, um dir die passende Lösung mitzuteilen. Ich habe selbst vor einiger Zeit danach gesucht. Es gibt es Script, dass alle 500ms beide Werte (Bezug und Einspeisung) miteinander verrechnet und daraus den Gesamtwert bildet.
Das Script nutze ich seit ca. April, bislang gibt es keine Abweichung zu meinem tatsächlichen Zähler.

In der Shelly App auf Script (die beiden geschwungenen Klammern) und dann auf Neues Script erstellen.

Dort das folgende einfügen und speichern:

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);




_________
Über diesen Link sieht man dann sowohl den Verbrauch und die Einspeisung, die auch am Zähler abzulesen sind:

http://ip vom Shelly/script/1/energy_counter

 

[Die wilde Inge]

@Ibims12 Wow, danke für deine Mühe. Werde ich mir gleich nachher mal genauer angucken.

 

[Ibims12]

Der Code ist nicht von mir, sondern von einem Projekt auf Github.
Leider habe ich den Namen des Projektes vergessen, aber unter Shelly Pro saldierend sollte man es finden.

Funktioniert bei mir wie gesagt einwandfrei

 

[crowbar44]

Danke, funktioniert das Script.
Kann ich irgendwo den reellen Zählerstand eingeben und er wird dazugerechnet?

 

[Die wilde Inge]

@crowbar44 Na klar, hier wird doch auch schon an anderer Stelle addiert:

energyReturned: (energyReturnedKWh+(energyReturnedWs / 3600000)).toFixed(5) + " KWh"

Müsstest du gucken welcher von beiden Werten welcher ist und dann einfach den Zählerstand addieren, würde ich sagen. Musst aber auf die Einheit achten. Hier werden WattSekunden genommen, deswegen /360.0000

 

[crowbar44]

@Die wilde Inge Danke. Ich habe ChatGPT befragt…es ist etwas anders:

let energyReturnedKWh = 0.0;
let energyConsumedKWh = 0.0;

Gleich am Anfang kommen die Werte rein.

Es muss allerdings vorher mit einem anderen Script der Wert aus dem Speicher gelöscht werden:

function ResetKVS() {
Shelly.call("KVS.Delete", { "key": "EnergyConsumedKWh" });
Shelly.call("KVS.Delete", { "key": "EnergyReturnedKWh" });
}

// Diese Funktion vor dem Laden der gespeicherten Werte aufrufen
ResetKVS();

Wichtig: das andere Script währenddessen pausieren. Das löschen Script dann nur kurz ausführen und wieder stoppen.

Zusätzlich habe ich mir noch das Skript noch mehr erweitern lassen: so dass ein täglicher Bericht 23:59uhr hinzugefügt wird.
Mal schauen ob das klappt.