SMA Home-Manager Multicast-Messages Auswertung

[Bot N. (botnec)]

Hallo,

ich konnte mit Hilfe hier aus dem Forum mittels ESP01S Multicast-
messages vom SMA Homemanager2 und Energymeter empfangen. Meine
Beispiele liefert alles was in der Message steckt. Ich brauche aber
nur paar bestimmte Werte daraus und bin jetzt dabei die Ausgaben
zu durchforsten und nur das was für mich interessant ist auszuwählen.

Dabei bin ich auf folgende Dinge gestoßen dir mir im Moment nicht
ergründlich sind.

- Ich bekomme einen Timestampwert. Welche Zeit ist das ? Epochtime wäre
zu weit in der Zukunft.

- Es gibt da eine OBIS Wert 0:73.4.0 , der ist in der SMA Doku zum
Protokoll aber nicht aufgeführt.

- dann gibt es am Ende noch paar Bytes die auch nicht dokumentiert sind.

Hier ein Beispiel:

0 4 2 A0 0 0 0 1 defaultGroup=1
2 4C 0 10 60 69 1 74
protocolID=24681, susyID=372, serial=3011230234, timestamp=2572600805
0:1.4.0=49
0:1.8.0=506032560.00
.....
.....
0:71.4.0=910
0:72.4.0=224305
0:73.4.0=758
144:0.0.0=Strange measurement skipped
2:13.6.82=Strange measurement skipped

Hat da vielleicht jemand weitere Kenntnisse dazu oder Hinweise
auf Dokumentation dazu und kann mir helfen?

Das SMA Dokument zum Protokoll habe ich.

Danke für sachdienliche Hinweise.

[Εrnst B. (ernst)]

Wie schon geschrieben: Bei mir läuft das über node-red, das Parsen des 
UDP-Packets hab ich in Javascript.
Für deinen ESP-Beispielcode hab ich das KI-Gestützt in Arduino-C++ 
übersetzt. Ob da die Byteorder passt, ob irgendwelche integer-promotions 
den int64 kaputt machen, usw. bitte selber prüfen. Als MSP430-Entwickler 
sollten dir die C-Fallstricke an der Stelle ja bekannt sein.

Für die Datenübertragung ESP->MSP430 ist das als Dezimalzahl eh 
"suboptimal", der liest das einfacher als HEX oder Binär...
d.H. das ganze rumgerechne ist eher für den Menschen der an der 
Seriellen mitliest.

Ansonsten, das ist meine Feld-Config:

const WsToWh=1.0/3600.0;

const felder={
    "0:1.8.0": { name: "Summe_Bezug", factor: WsToWh, db: true },
    "0:1.4.0": { name: "Wirkleistung_Summe_Plus", factor: 0.1 },

    "0:2.8.0": { name: "Summe_Einspeisung", factor: WsToWh, db:true },
    "0:2.4.0": { name: "Wirkleistung_Summe_Minus", factor: 0.1 },

    "0:3.8.0": { name: "Blindleistung_Summe_Saldo_Plus", factor: WsToWh },
    "0:3.4.0": { name: "Blindleistung_Summe_Plus", factor: 0.1 },

    "0:4.8.0": { name: "Blindleistung_Summe_Saldo_Minus", factor: WsToWh },
    "0:4.4.0": { name: "Blindleistung_Summe_Minus", factor: 0.1 },

    "0:9.8.0": { name: "Scheinleistung_Summe_Saldo_Plus", factor: WsToWh },
    "0:9.4.0": { name: "Scheinleistung_Summe_Plus", factor: 0.1 },

    "0:10.8.0": { name: "Scheinleistung_Summe_Saldo_Minus", factor: WsToWh },
    "0:10.4.0": { name: "Scheinleistung_Summe_Minus", factor: 0.1 },

    "0:13.4.0": { name: "Leistungsfaktor", factor: 0.001 },

    // dieser Block wiederholt sich für jede Phase:
    "0:21.8.0": { name: "Summe_L1_Bezug", factor: WsToWh },
    "0:21.4.0": { name: "Wirkleistung_L1_Plus", factor: 0.1 },
    "0:22.8.0": { name: "Summe_L1_Einspeisung", factor: WsToWh },
    "0:22.4.0": { name: "Wirkleistung_L1_Minus", factor: 0.1 },
    "0:23.4.0": { name: "Blindleistung_L1_Plus", factor: 0.1 },
    "0:24.4.0": { name: "Blindleistung_L1_Minus", factor: 0.1 },
    "0:23.8.0": { name: "Blindleistung_L1_Saldo_Plus", factor: WsToWh },
    "0:24.8.0": { name: "Blindleistung_L1_Saldo_Minus", factor: WsToWh },
    "0:29.4.0": { name: "Scheinleistung_L1_Plus", factor: 0.1 },
    "0:30.4.0": { name: "Scheinleistung_L1_Minus", factor: 0.1 },
    "0:29.8.0": { name: "Scheinleistung_L1_Saldo_Plus", factor: WsToWh },
    "0:30.8.0": { name: "Scheinleistung_L1_Saldo_Minus", factor: WsToWh },
    "0:31.4.0": { name: "Strom_L1", factor: 0.001, db: true },
    "0:32.4.0": { name: "Spannung_L1", factor: 0.1, db: true },
    "0:33.4.0": { name: "Leistungsfaktor_L1", factor: 0.001 },

    "0:41.8.0": { name: "Summe_L2_Bezug", factor: WsToWh },
    "0:41.4.0": { name: "Wirkleistung_L2_Plus", factor: 0.1 },
    "0:42.8.0": { name: "Summe_L2_Einspeisung", factor: WsToWh },
    "0:42.4.0": { name: "Wirkleistung_L2_Minus", factor: 0.1},
    "0:43.4.0": { name: "Blindleistung_L2_Plus", factor: 0.1 },
    "0:44.4.0": { name: "Blindleistung_L2_Minus", factor: 0.1 },
    "0:43.8.0": { name: "Blindleistung_L2_Saldo_Plus", factor: WsToWh },
    "0:44.8.0": { name: "Blindleistung_L2_Saldo_Minus", factor: WsToWh },
    "0:49.4.0": { name: "Scheinleistung_L2_Plus", factor: 0.1 },
    "0:50.4.0": { name: "Scheinleistung_L2_Minus", factor: 0.1 },
    "0:49.8.0": { name: "Scheinleistung_L2_Saldo_Plus", factor: WsToWh },
    "0:50.8.0": { name: "Scheinleistung_L2_Saldo_Minus", factor: WsToWh },
    "0:51.4.0": { name: "Strom_L2", factor: 0.001, db: true },
    "0:52.4.0": { name: "Spannung_L2", factor: 0.1, db: true },
    "0:53.4.0": { name: "Leistungsfaktor_L2", factor: 0.001 },

    "0:61.8.0": { name: "Summe_L3_Bezug", factor: WsToWh },
    "0:61.4.0": { name: "Wirkleistung_L3_Plus", factor: 0.1 },
    "0:62.8.0": { name: "Summe_L3_Einspeisung", factor: WsToWh },
    "0:62.4.0": { name: "Wirkleistung_L3_Minus", factor: 0.1 },
    "0:63.4.0": { name: "Blindleistung_L3_Plus", factor: 0.1 },
    "0:64.4.0": { name: "Blindleistung_L3_Minus", factor: 0.1 },
    "0:63.8.0": { name: "Blindleistung_L3_Saldo_Plus", factor: WsToWh },
    "0:64.8.0": { name: "Blindleistung_L3_Saldo_Minus", factor: WsToWh },
    "0:69.4.0": { name: "Scheinleistung_L3_Plus", factor: 0.1 },
    "0:70.4.0": { name: "Scheinleistung_L3_Minus", factor: 0.1 },
    "0:69.8.0": { name: "Scheinleistung_L3_Saldo_Plus", factor: WsToWh },
    "0:70.8.0": { name: "Scheinleistung_L3_Saldo_Minus", factor: WsToWh },
    "0:71.4.0": { name: "Strom_L3", factor: 0.001, db: true },
    "0:72.4.0": { name: "Spannung_L3", factor: 0.1, db: true },
    "0:73.4.0": { name: "Leistungsfaktor_L3", factor: 0.001 }

jeweils mit Namen und Umrechnungsfaktor (Zählerwerte sind in 
Wattsekunden, Spannungen in 0.1V usw), das "db"-Flag markiert die Werte 
die ich zur Auswertung in der Datenbank speichere.

Der Datenblock für jede Phase ist immer gleich, nur um 20 verschoben, 
startet bei 21, 41, 61. So kommst du auch ohne explizite Dokumentation 
auf den 0:73.4.0 er Wert.

Was das 144er Feld bedeutet, weiß ich auch nicht.

und "2:13.6.82" macht wenig Sinn. Könnte sein, dass da der Parser-Code 
irgendwie aus dem Tritt gekommen ist, und die Feldgrenzen nicht mehr 
richtig erwischt. Evtl. wegen falscher Länge des 144er Feldes davor? 
Wenn die Werte danach nicht interessieren, könntest du die Bearbeitung 
auch gleich an der Stelle abbrechen.

Und der Timestamp sagt bei mir auch nix aus, kommt auch über Minuten 
immer derselbe Wert.

[Bot N. (botnec)]

Danke Ernst für die erneute Hilfe!

Ohne deine Unterstützung und Vorbereitung wäre ich nicht soweit 
gekommen.
Da ich jetzt sowohl die serielle Schnittstelle in beiden Richtungen und
einen TCP Server betreiben und auch noch die Multicast Messages
mitlesen kann, gebe ich meine AT-FW Version auf. Der MSP430 bleibt
natürlich. Diese eigene ESP01S FW-Version erleichtert das Ganze 
ungemein.

Mit der Darstellung der Multicast Messages oben komme ich weiter, danke
für die ausführliche Beschreibung.

Zu 144:0.0.0 habe ich was in der Doku EMETER-Protokoll-TI-de-10.pdf
gefunden. Wird als Softwareversion mit 4 Byte angegeben.

Der Timestampwert zählt bei mir schon hoch, deshalb dachte ich zuerst
an Epochtime, aber da wäre heute der 12. April 2053. Wäre schön gewesen
wenn man daraus noch die Uhrzeit ermitteln könnte.

Habe jetzt wieder neues "Futter" .

Danke nochmals für die äußerst hilfreich Unterstützung!

[Εrnst B. (ernst)]

Bot N. schrieb:
> Zu 144:0.0.0 habe ich was in der Doku EMETER-Protokoll-TI-de-10.pdf
> gefunden. Wird als Softwareversion mit 4 Byte angegeben.

Beitrag "Re: ESP01S: TCP Server und UDP Multicast"

Dann also ein

} if (index==144) {
  // Optional: Versionsnummer auslesen... aber interessiert die?
  offset += 4;

vor dem

} else {
// Strange

ergänzen...
dann sollte auch das "2:13.6.82" - Feld weg sein.

[Bot N. (botnec)]

Danke,

nein , Versionsnummer und vieles andere interessiert nicht. Mir ging es
nur ums Verständnis der Daten.

Grüße und schönes WE

[Holger (mindmaster)]

Hi,

habe dank der 2 Beiträge hier, es geschaft meinen Home Manger 2.0 
auzulesen.
Habe noch einen Punkt:
Mein Timestamp ist negativ und zählt somit runter Richtung 0.
-1482800258#Leistung=699.40
-1482799263#Leistung=715.50
-1482798268#Leistung=722.80
-1482797263#Leistung=710.50

@Bot N.: Könntest du mir deinen ESP Code zukommen lassen zum Vergleich?!

#include <ESP8266WiFi.h>
#include <ESP8266WiFiSTA.h>
#include <WiFiUdp.h>
#define LED D4 
const char* ssid = "********";
const char* password = "********";
unsigned int multicastPort = 9522;  // local port to listen on
IPAddress multicastIP(239, 12, 255, 254);
WiFiUDP Udp;
static void initWiFi() {
    WiFi.mode(WIFI_STA);
    WiFi.begin(ssid, password);
    Serial.print("Connecting to WiFi ..");
    while (WiFi.status() != WL_CONNECTED) {
        Serial.print('.');
        delay(500);
    }
    Serial.println(WiFi.localIP());
}
static void Soutput(int kanal, int index, int art, int tarif, String Bezeichnung, double value, int timestamp){
  Serial.print (timestamp);
  Serial.print ('#');
  //Serial.print(kanal);
  //Serial.print(':');
  //Serial.print(index);
  //Serial.print('.');
  //Serial.print(art);
  //Serial.print('.');
  //Serial.print(tarif);
  //Serial.print('#');
  Serial.print(Bezeichnung);
  Serial.print('=');
  Serial.println(value);
}
void setup() {
  pinMode(LED, OUTPUT);    // Setzen des PINs als Ausgang
  Serial.begin(57600);
  Serial.println("Connecting...");
  initWiFi();
  Udp.begin(multicastPort);
#ifdef ESP8266
  Udp.beginMulticast(WiFi.localIP(), multicastIP, multicastPort);
#else
  Udp.beginMulticast(multicastIP, multicastPort);
#endif
}
void loop() {
    digitalWrite(LED, !(digitalRead(LED))); // LED umschalten
    uint8_t buffer[1024];
    int packetSize = Udp.parsePacket();
    String Bezeichnung;
    double Pbezug = 0;
    double Peinspeisung = 0;
    double Leistung = 0;
    uint32_t timestampalt = 0;
    bool output = false;
    if (packetSize) {
        int rSize = Udp.read(buffer, 1024);
        if (buffer[0] != 'S' || buffer[1] != 'M' || buffer[2] != 'A') {
            Serial.println("Not an SMA packet?");
            return;
        }
        uint16_t grouplen;
        uint16_t grouptag;
        uint8_t* offset = buffer + 4;
        do {
            grouplen = (offset[0] << 8) + offset[1];
            grouptag = (offset[2] << 8) + offset[3];
            offset += 4;
            if (grouplen == 0xffff) return;
            if (grouptag == 0x02A0 && grouplen == 4) {
                offset += 4;
            } else if (grouptag == 0x0010) {
                uint8_t* endOfGroup = offset + grouplen;
                uint16_t protocolID = (offset[0] << 8) + offset[1];
                offset += 2;
                uint16_t susyID = (offset[0] << 8) + offset[1];
                offset += 2;
                uint32_t serial = (offset[0] << 24) + (offset[1] << 16) + (offset[2] << 8) + offset[3];
                offset += 4;
                uint32_t timestamp = (offset[0] << 24) + (offset[1] << 16) + (offset[2] << 8) + offset[3];
                offset += 4;
                while (offset < endOfGroup) {
                    uint8_t kanal = offset[0];
                    uint8_t index = offset[1];
                    uint8_t art = offset[2];
                    uint8_t tarif = offset[3];
                    offset += 4;
                    if (art == 8) {
                        uint64_t data = ((uint64_t)offset[0] << 56) +
                                      ((uint64_t)offset[1] << 48) +
                                      ((uint64_t)offset[2] << 40) +
                                      ((uint64_t)offset[3] << 32) +
                                      ((uint64_t)offset[4] << 24) +
                                      ((uint64_t)offset[5] << 16) +
                                      ((uint64_t)offset[6] << 8) +
                                      offset[7];
                        offset += 8;
                    } else if (art == 4) {
                      uint32_t data = (offset[0] << 24) +
                      (offset[1] << 16) +
                      (offset[2] << 8) +
                      offset[3];
                      offset += 4;
                      switch (index) {
                      case 1:
                        Pbezug = data * 0.1;
                        break;
                      case 2:
                        Peinspeisung = data * 0.1;
                        output = true;
                        break;
                      default:
                        Bezeichnung = "Data         : ";
                        break; // Wird nicht benötigt, wenn Statement(s) vorhanden sind
                      }
                        if (output == true){
                        Leistung = Peinspeisung - Pbezug;
                        Soutput(kanal, index, art, tarif, "Leistung", Leistung, timestamp);
                        output = false;
                      }
                    } else if (kanal==144) {
                      // Optional: Versionsnummer auslesen... aber interessiert die?
                      offset += 4;
                    } else {
                        offset += art;
                        Serial.println("Strange measurement skipped");
                    }
                }
            } else if (grouptag == 0) {
                // end marker
                offset += grouplen;
            } else {
                Serial.print("unhandled group ");
                Serial.print(grouptag);
                Serial.print(" with len=");
                Serial.println(grouplen);
                offset += grouplen;
            }
        } while (grouplen > 0 && offset + 4 < buffer + rSize);
    }
}

[Bot N. (botnec)]

Ich benutze hier den originalen Teil des Sourcecodes von
Ernst B. hier im Forum.

Beitrag "ESP01S: TCP Server und UDP Multicast"

Habe da nichts geändert. Meine Timestamp zählt aufwärts, ist aber
leider keine Uhrzeit. Ich ignoriere diesen Wert.

Hoffe das hilft weiter.