{"id":13062,"date":"2026-09-18T12:46:00","date_gmt":"2026-09-18T10:46:00","guid":{"rendered":"https:\/\/www.lukaswojcik.com\/blog\/?p=13062"},"modified":"2026-08-31T15:15:51","modified_gmt":"2026-08-31T13:15:51","slug":"tutorial-sunspec-register-eines-pv-wechselrichters-uber-modbus-tcp-auslesen","status":"publish","type":"post","link":"https:\/\/www.lukaswojcik.com\/blog\/de\/smart-home-de\/tutorials-de-smart-home-de\/tutorial-sunspec-register-eines-pv-wechselrichters-uber-modbus-tcp-auslesen\/","title":{"rendered":"Tutorial: SunSpec-Register eines PV-Wechselrichters \u00fcber Modbus TCP auslesen"},"content":{"rendered":"

Eine Registernummer aus einem Forenbeitrag funktioniert. Sie funktioniert bis zur n\u00e4chsten Firmware, bis zum n\u00e4chsten Modell desselben Wechselrichters, bis ein zweites Ger\u00e4t hinzukommt, das denselben Wert woanders ablegt. Dann stimmt die Nummer nicht mehr, und nichts sagt es: Modbus liefert, was an dieser Adresse steht, und eine plausible Zahl ist von einer richtigen nicht zu unterscheiden.<\/p>\n

Aus diesem Grund gibt es SunSpec. Es ist ein Verzeichnis, das \u00fcber den Registerraum gelegt ist, und es zu lesen kostet vier Schritte, die auf jedem Wechselrichter mit dieser Unterst\u00fctzung gleich funktionieren.<\/p>\n

\n\"Eine
Die Kette beschreibt sich selbst: Jedes Modell nennt seine eigene L\u00e4nge, die Adresse des n\u00e4chsten ergibt sich also aus dem laufenden. Nur der Anfang muss gefunden werden.<\/figcaption><\/figure>\n

Warum eine Registernummer allein nicht gen\u00fcgt<\/h2>\n

Modbus kennt keine Namen, keine Einheiten und keine Typen. Ein Lesevorgang liefert sechzehn Bit, und jede Deutung dieser Bits geschieht beim Lesenden. Ein Register mit dem Inhalt 1234 kann 1234 Watt bedeuten, 123,4 Volt oder 12,34 Ampere – und das Protokoll sagt dazu nichts.<\/p>\n

SunSpec erg\u00e4nzt drei Dinge, und alle drei stehen im Registerraum selbst: eine Marke, die sagt, dass das Verzeichnis vorhanden ist, eine Kette von Bl\u00f6cken, die sagt, welche Messwerte es gibt und wo, und je Gruppe von Werten ein Skalierungsfaktor, der sagt, wo das Komma steht.<\/p>\n

Die praktische Folge ist, dass ein einmal geschriebener Leser auch beim n\u00e4chsten Ger\u00e4t funktioniert. Das wiegt mehr, als es klingt, denn die Alternative – eine Adresstabelle je Hersteller und Firmwarestand – ist genau das, was stillschweigend veraltet.<\/p>\n

Die Basisadresse und die Marke finden<\/h2>\n

Das Verzeichnis beginnt an einer von drei Adressen, und die ersten beiden Register sagen, ob es dort beginnt. Sie enthalten die vier Zeichen SunS<\/code>, als 32-Bit-Wert also 0x53756E53.<\/p>\n

from pymodbus.client import ModbusTcpClient\n\nc = ModbusTcpClient(\"192.168.1.50\", port=502)\nc.connect()\n\nfor basis in (40000, 0, 50000):\n    r = c.read_holding_registers(basis, count=2, slave=1)\n    if not r.isError() and r.registers == [0x5375, 0x6E53]:\n        print(\"SunSpec ab\", basis)\n        break<\/code><\/pre>\n
In diesem kurzen St\u00fcck Code stecken zwei Stolpersteine. Der erste ist die Verschiebung um eins, \u00fcber die jeder einmal f\u00e4llt: Die Dokumentation z\u00e4hlt Register ab eins, das Protokoll adressiert sie ab null. Eine im Handbuch als 40001 gedruckte Adresse ist auf der Leitung der Offset 40000, und ein Lesevorgang bei 40001 liefert die zweite H\u00e4lfte der Marke und keine \u00dcbereinstimmung.<\/p>\n
Der zweite ist die Ger\u00e4teadresse. Ein Wechselrichter mit eingebautem Z\u00e4hler antwortet als zwei Ger\u00e4te auf derselben Verbindung, jedes mit eigener Kennung und eigenem SunSpec-Verzeichnis. Die Leistung des Z\u00e4hlers unter der Kennung des Wechselrichters zu lesen liefert einen Wert, der kein Fehler und nicht die Wahrheit ist. Welche Kennungen in Gebrauch sind, zeigt die Modbus-Seite der Weboberfl\u00e4che des Ger\u00e4ts – und dort wird Modbus TCP \u00fcberhaupt erst eingeschaltet, denn bei den meisten Wechselrichtern ist es ab Werk aus.<\/p>\n
Die Modellkette ablaufen<\/h2>\n
Nach der Marke folgt eine Reihe von Bl\u00f6cken, und jeder Block beginnt mit zwei Registern: seiner Modellnummer und seiner L\u00e4nge. Die L\u00e4nge zur laufenden Position addiert ergibt den Anfang des n\u00e4chsten Blocks, und eine Modellnummer von 65535 beendet die Kette.<\/p>\n
pos = basis + 2\nwhile True:\n    kopf = c.read_holding_registers(pos, count=2, slave=1).registers\n    modell, laenge = kopf[0], kopf[1]\n    if modell == 0xFFFF:\n        break\n    print(f\"Modell {modell:5d}  Laenge {laenge:3d}  Daten ab {pos + 2}\")\n    pos += 2 + laenge<\/code><\/pre>\n
Ein \u00fcblicher Wechselrichter antwortet mit drei oder vier Modellen, und die Nummern sagen, was jedes davon ist.<\/p>\n\n\n\n\n\n\n\n\n\n
Modell<\/th>\nInhalt<\/th>\n<\/tr>\n<\/thead>\n
1<\/td>\nGemeinsames: Hersteller, Modellbezeichnung, Seriennummer, Firmwarestand<\/td>\n<\/tr>\n
101, 102, 103<\/td>\nWechselrichter ein-, zwei-, dreiphasig – ganze Zahlen mit Skalierungsfaktoren<\/td>\n<\/tr>\n
111, 112, 113<\/td>\nDieselben Messwerte als Gleitkommazahlen, ohne Skalierungsfaktoren<\/td>\n<\/tr>\n
160<\/td>\nDie einzelnen Strings, ein wiederholter Block je MPP-Regler<\/td>\n<\/tr>\n
201 bis 204<\/td>\nZ\u00e4hler, ein Modell je Anschlussart<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Ob ein Ger\u00e4t 103 oder 113 anbietet, ist meist eine Einstellung und keine Eigenschaft. Viele Wechselrichter haben einen Schalter zwischen ganzen Zahlen mit Skalierungsfaktoren und Gleitkomma, und er bestimmt, welche der beiden Modellfamilien in der Kette erscheint. Ein Leser, der das eine erwartet und das andere vorfindet, meldet \u00fcberhaupt keine Messwerte – ein verwirrendes Anzeichen f\u00fcr eine Einstellung, an deren \u00c4nderung sich niemand erinnert.<\/p>\n
Skalierungsfaktoren, Datentypen und die Ersatzwerte<\/h2>\n
Innerhalb eines Modellblocks steht die Position eines Werts in der Spezifikation und wird ab dem Anfang der Daten gez\u00e4hlt. Der Strom der Phase A sitzt auf Offset 2, der dazugeh\u00f6rige Skalierungsfaktor auf Offset 5.<\/p>\n
Modell 103, Daten ab 40071\n\n  Offset 1   A      uint16   Gesamtstrom\n  Offset 2   AphA   uint16   Phase A\n  Offset 3   AphB   uint16   Phase B\n  Offset 4   AphC   uint16   Phase C\n  Offset 5   A_SF   int16    Skalierungsfaktor fuer alle vier\n\n  40072 = 1234        Rohwert\n  40075 = 0xFFFE      Zweierkomplement, also \u22122\n\n  1234 \u00d7 10\u207b\u00b2 = 12,34 A<\/code><\/pre>\n
Der Skalierungsfaktor ist ein vorzeichenbehafteter Zehnerexponent und gilt f\u00fcr eine ganze Gruppe von Werten, nicht f\u00fcr einen. Deshalb erscheint er einmal f\u00fcr vier Str\u00f6me, und deshalb liefert ein ohne ihn gelesener Strom eine hundertfach zu grosse Zahl – die in einer Hausanlage immer noch nach einem plausiblen Messwert aussieht.<\/p>\n
Drei weitere Eigenschaften der Kodierung z\u00e4hlen in der Praxis. Werte \u00fcber zwei Register stehen mit dem h\u00f6herwertigen Wort zuerst, was der Modbus-Konvention entspricht und was fast jede Bibliothek von allein richtig macht. Textfelder haben eine feste L\u00e4nge und werden mit Nullbytes aufgef\u00fcllt statt von ihnen beendet. Und ein Wert, den das Ger\u00e4t nicht f\u00fchrt, ist nicht null, sondern ein Ersatzwert: 0x8000 bei int16, 0xFFFF bei uint16, 0x80000000 bei int32. Ein Leser, der diese als Zahlen behandelt, meldet 65535 Volt – und eine Regel, die sie verwirft, ist drei Zeilen lang.<\/p>\n
LEER = {\"int16\": 0x8000, \"uint16\": 0xFFFF,\n        \"int32\": 0x80000000, \"uint32\": 0xFFFFFFFF}\n\ndef wert(roh, typ, sf):\n    if roh == LEER.get(typ):\n        return None\n    return roh * (10 ** sf)<\/code><\/pre>\n
Einen Wert von Anfang bis Ende lesen<\/h2>\n
Die Teile zusammen ergeben einen Leser, der das Modell findet, statt seine Adresse anzunehmen.<\/p>\n
def modell_finden(c, basis, gesucht, slave=1):\n    pos = basis + 2\n    while True:\n        m, laenge = c.read_holding_registers(pos, count=2, slave=slave).registers\n        if m == 0xFFFF:\n            return None\n        if m == gesucht:\n            return pos + 2, laenge\n        pos += 2 + laenge\n\ndef vorzeichen(r):\n    return r - 0x10000 if r > 0x7FFF else r\n\nstart, _ = modell_finden(c, 40000, 103)\nblock    = c.read_holding_registers(start, count=6, slave=1).registers\n\nstrom = block[1]                 # AphA, Offset 2 ab eins gezaehlt\nsf    = vorzeichen(block[4])     # A_SF, Offset 5\nprint(f\"{strom * 10 ** sf:.2f} A\")<\/code><\/pre>\n
Es lohnt sich, den ganzen Block in einer Anfrage zu lesen statt jeden Wert einzeln. Ein Modbus-Lesevorgang kostet unabh\u00e4ngig von der L\u00e4nge einige Millisekunden Umlaufzeit – sechs Register in einem Aufruf kosten also so viel wie ein Register in einem Aufruf. Wichtiger noch: Alle sechs Werte stammen dann aus demselben Augenblick. Sechs getrennte Lesevorg\u00e4nge f\u00fcr Strom, Spannung und Leistung liefern drei Gr\u00f6ssen, die nicht zusammenpassen, und eine darauf gebaute Plausibilit\u00e4tspr\u00fcfung schl\u00e4gt grundlos an.<\/p>\n
Eine Anmerkung zur Abfrageh\u00e4ufigkeit: Ein Wechselrichter ist keine Datenbank. Eine Anfrage alle f\u00fcnf Sekunden ist unproblematisch, einmal je Sekunde ist bei manchen Ger\u00e4ten die Grenze, und schneller erzeugt Zeit\u00fcberschreitungen, die wie Netzfehler aussehen. Die Messwerte selbst aktualisieren sich ohnehin selten schneller als sek\u00fcndlich.<\/p>\n
Das Ganze in Home Assistant bringen<\/h2>\n
Sind die Adressen bekannt, funktioniert dasselbe Lesen auch beschreibend. Die Modbus-Anbindung von Home Assistant k\u00fcmmert sich um Datentyp und Vorzeichen; nur der Skalierungsfaktor muss als Zahl eingetragen werden, denn die Anbindung liest ihn nicht aus dem Ger\u00e4t.<\/p>\n
modbus:\n  - name: wechselrichter\n    type: tcp\n    host: 192.168.1.50\n    port: 502\n    sensors:\n      - name: \"Strom Phase A\"\n        slave: 1\n        address: 40072\n        data_type: uint16\n        scale: 0.01\n        precision: 2\n        unit_of_measurement: \"A\"\n        device_class: current\n        state_class: measurement\n        scan_interval: 10\n      - name: \"Wirkleistung\"\n        slave: 1\n        address: 40084\n        data_type: int16\n        scale: 1\n        precision: 0\n        unit_of_measurement: \"W\"\n        device_class: power\n        state_class: measurement\n        scan_interval: 10<\/code><\/pre>\n
Der fest eingetragene scale<\/code> ist der Kompromiss dieses Weges, und es lohnt sich festzuhalten, woher er kommt. Der Skalierungsfaktor wurde einmal mit dem Skript von oben gelesen; er steht im Ger\u00e4t und \u00e4ndert sich praktisch nie, garantiert ist das aber nicht. Nach einer Firmware-Aktualisierung dauert ein Vergleich zwischen angezeigtem Wert und dem Display des Wechselrichters zehn Sekunden und f\u00e4ngt einen Faktor hundert sofort ab.<\/p>\n
Ein letztes Feld entscheidet, ob der Wert in der Energiestatistik landet statt nur auf einer Karte. Ein Leistungswert in Watt ist device_class: power<\/code> mit state_class: measurement<\/code>; ein Z\u00e4hlerstand in Kilowattstunden ist device_class: energy<\/code> mit state_class: total_increasing<\/code>. Beides ist nicht austauschbar, und nur das Zweite l\u00e4sst sich als Energiequelle ausw\u00e4hlen.<\/p>\n
\n
Quellen<\/h2>\n