Die Energiewende ist in vollem Gange, und immer mehr Hausbesitzer setzen auf die Kraft der Sonne, um ihren eigenen Strom zu erzeugen. Eine Photovoltaik-Anlage auf dem Dach ist eine Investition in die Zukunft – ökologisch und ökonomisch sinnvoll. Doch die bloße Installation ist oft nur der erste Schritt. Das wahre Potenzial Ihrer Anlage entfaltet sich erst, wenn Sie die Kontrolle über Ihre Energiedaten übernehmen. Deye-Wechselrichter, bekannt für ihre Zuverlässigkeit und Effizienz, bieten eine oft übersehene Möglichkeit, genau das zu tun: den direkten Zugriff auf Ihre Leistungsdaten über den TCP-Port 8899. In diesem umfassenden Artikel tauchen wir tief in die Materie ein und zeigen Ihnen Schritt für Schritt, wie Sie die Kontrolle zurückgewinnen.
Warum der direkte Datenzugriff so wichtig ist
Viele Hersteller von Solar-Wechselrichtern bieten Cloud-basierte Überwachungssysteme an. Diese sind bequem, aber oft auch mit Einschränkungen verbunden: Abhängigkeit von einer Internetverbindung, potenzielle Verzögerungen bei der Datenanzeige, eingeschränkte Anpassungsmöglichkeiten und manchmal auch Bedenken hinsichtlich des Datenschutzes. Für engagierte Anlagenbetreiber, die ihre Erträge maximieren, ihre Verbräuche optimieren oder ihre Anlage nahtlos in ein Smart Home System integrieren möchten, ist ein lokaler Zugriff auf die Daten unerlässlich. Er ermöglicht:
- Echtzeit-Monitoring: Sekundengenaue Einsicht in Produktion, Verbrauch und Batteriespeicher.
- Unabhängigkeit von Hersteller-Clouds: Keine Abhängigkeit von externen Servern oder Internetverfügbarkeit.
- Datenschutz: Ihre sensiblen Energiedaten bleiben in Ihrem Netzwerk.
- Individuelle Analyse: Erstellung eigener Dashboards, Langzeitanalysen und Vergleichsstudien.
- Integration in Smart Home: Nutzung der Daten zur Automatisierung von Verbrauchern (z.B. Waschmaschine starten bei Solarüberschuss).
- Schnelle Fehlererkennung: Abweichungen im Leistungsverlauf sofort identifizieren.
Deye-Wechselrichter und das Geheimnis des TCP-Ports 8899
Deye, ein führender Hersteller von Hybrid-Wechselrichtern, bietet eine Reihe von Geräten an, die für ihre Robustheit und Vielseitigkeit geschätzt werden. Viele Deye-Wechselrichter, insbesondere die Hybrid-Modelle, verfügen über eine integrierte Kommunikationsschnittstelle, die über das lokale Netzwerk erreichbar ist. Während die offizielle Deye-App oder das Webportal des Herstellers auf Cloud-Dienste setzen, steckt in vielen dieser Geräte eine direktere Schnittstelle, die über den TCP-Port 8899 angesprochen werden kann. Dies ist der „Hintereingang” zu Ihren Energiedaten.
Doch was genau verbirgt sich hinter diesem Port? Es ist kein Standard-Modbus-TCP im herkömmlichen Sinne. Vielmehr handelt es sich um ein proprietäres Deye-Protokoll, das oft Modbus-RTU-Anfragen und -Antworten innerhalb eines benutzerdefinierten TCP/IP-Rahmens tunnelt. Der Wechselrichter agiert hier quasi als ein Gateway, das lokale Modbus-Register über das Netzwerk zugänglich macht. Dieses Wissen ist der Schlüssel zum Entschlüsseln Ihrer Daten.
Vorbereitung ist alles: Was Sie benötigen
Bevor wir uns in die technischen Details stürzen, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen:
- Netzwerkzugang für den Wechselrichter: Ihr Deye-Inverter muss mit Ihrem lokalen Netzwerk verbunden sein. Dies geschieht in der Regel über WLAN oder ein Ethernet-Kabel. Stellen Sie sicher, dass der Wechselrichter eine gültige IP-Adresse von Ihrem Router erhalten hat.
- IP-Adresse des Wechselrichters: Sie müssen die spezifische IP-Adresse Ihres Deye-Inverters in Ihrem lokalen Netzwerk kennen. Diese finden Sie normalerweise in der Client-Liste Ihres Routers (z.B. FritzBox, Telekom Speedport, etc.). Suchen Sie nach einem Gerät, dessen Name „Deye” oder „Solar” enthält, oder dessen MAC-Adresse zu Deye passt. Eine statische IP-Adresse für den Wechselrichter ist empfehlenswert, um Probleme bei Adressänderungen zu vermeiden.
- Gerät für den Zugriff: Ein Computer (PC, Mac, Raspberry Pi) oder ein anderes Netzwerkgerät, das sich im selben lokalen Netzwerk befindet wie Ihr Wechselrichter.
- Grundlagenwissen Netzwerke: Ein Verständnis für IP-Adressen, Ports und grundlegende Netzwerkdiagnose ist hilfreich, aber nicht zwingend notwendig.
- Software/Skripte: Für das Auslesen der Daten benötigen Sie entweder eine fertige Softwarelösung oder ein kleines Skript, meist in Python geschrieben.
Schritt-für-Schritt-Anleitung: Energiedaten auslesen
Schritt 1: Netzwerk-Konnektivität und IP-Adresse prüfen
Vergewissern Sie sich, dass Ihr Wechselrichter online ist und eine IP-Adresse hat. Öffnen Sie die Benutzeroberfläche Ihres Routers und suchen Sie die Liste der verbundenen Geräte. Notieren Sie die IP-Adresse Ihres Deye-Inverters.
Ein einfacher Test, ob der TCP-Port 8899 offen ist, kann mit dem Kommandozeilen-Tool `netcat` (oder `nc`) erfolgen. Öffnen Sie ein Terminal oder die Kommandozehle (Windows: `cmd`, Linux/macOS: `Terminal`) und geben Sie ein:
nc -zv <IP-Adresse_Ihres_Deye-Inverters> 8899Wenn die Ausgabe „succeeded!” oder „Connection to … port 8899 [tcp/radan-http] succeeded!” lautet, ist der Port erreichbar. Andernfalls müssen Sie die Netzwerkeinstellungen Ihres Wechselrichters oder Ihrer Firewall überprüfen.
Schritt 2: Das Deye-Protokoll verstehen (kurz)
Wie bereits erwähnt, ist das Deye-Protokoll über Port 8899 eine Art „Wrapper” für Modbus RTU. Das bedeutet, Sie senden eine TCP-Nachricht an den Port, die eine Modbus-RTU-Anfrage enthält. Der Wechselrichter antwortet dann mit einer TCP-Nachricht, die die Modbus-RTU-Antwort enthält. Die genaue Struktur der Anfragen und welche Modbus-Register welche Daten enthalten, ist entscheidend. Glücklicherweise gibt es eine aktive Community, die dies bereits entschlüsselt hat.
Ein typisches Modbus-RTU-Request-Frame sieht so aus:
[Slave-ID (1 Byte)] [Funktionscode (1 Byte)] [Startadresse (2 Bytes)] [Anzahl Register (2 Bytes)] [CRC (2 Bytes)]
Dieses Frame wird dann in das Deye-spezifische TCP-Paket eingebettet, das oft einen 10-Byte-Header enthält (z.B. `A5`, Länge, `10`, `45`, `00`, `00`, `00`, `00`, `00`, `00`).
Schritt 3: Daten mit einem Python-Skript auslesen
Python ist aufgrund seiner Einfachheit und der Verfügbarkeit von Bibliotheken eine ausgezeichnete Wahl für diese Aufgabe. Es gibt mehrere Projekte auf GitHub, die Bibliotheken oder Skripte für den Deye-Inverter-Zugriff anbieten. Ein bekanntes Beispiel ist `deye-inverter-mqtt`, das die Daten ausliest und als MQTT-Nachrichten bereitstellt, was ideal für die Home Assistant Integration ist.
Ein vereinfachtes Beispiel für das Auslesen der aktuellen Leistung (AC-Leistung) könnte so aussehen. Beachten Sie, dass die genauen Registeradressen je nach Deye-Modell variieren können und oft in Community-Wikis oder den jeweiligen Projekt-Repositories dokumentiert sind.
import socket
import struct
import time
# Konfiguration
INVERTER_IP = "IHRE_DEYE_IP_ADRESSE" # Ersetzen Sie dies durch die IP Ihres Deye
INVERTER_PORT = 8899
SLAVE_ID = 1 # Meistens 1
REGISTER_ADDRESS = 0x0052 # Beispiel: Register für AC-Leistung (kann variieren!)
NUM_REGISTERS = 2 # AC-Leistung ist oft ein 32-Bit Wert (2 Modbus-Register)
def create_deye_modbus_request(slave_id, function_code, start_address, num_registers):
# Modbus RTU Anfrage erstellen (ohne CRC, da dies vom Modbus-Bibliothek gehandhabt wird, falls verwendet)
# Hier simulieren wir die direkte Erstellung für den Wrapper.
# Für eine Modbus-RTU-Read-Holding-Registers-Anfrage (Funktion 0x03)
modbus_rtu_frame = struct.pack('>BBHH', slave_id, function_code, start_address, num_registers)
# Deye Wrapper Header (oft statisch, die Länge muss angepasst werden)
# Header: A5 10 45 00 00 00 00 00 00
# Die tatsächliche Länge des nachfolgenden Modbus-RTU-Pakets + 1 (für SlaveID in Deye Header)
payload_len = len(modbus_rtu_frame) + 1 # +1 weil SlaveID nochmal im Deye Header ist.
total_len = payload_len + 7 # +7 für den Rest des Deye-Headers
# Deye spezifischer Header
# Byte 0: Start Byte (A5)
# Byte 1: Länge (Gesamtlänge des Pakets minus A5 - 1)
# Byte 2-9: Festwerte für Deye-Protokoll (oft 10 45 00 00 00 00 00 00)
deye_header = struct.pack('>BBBBBBBBBB', 0xA5, total_len, 0x10, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
# Das eigentliche Request-Paket zusammensetzen
# Deye Header + SlaveID + Modbus RTU Frame
# ACHTUNG: Die SlaveID wird oft auch nochmal im Deye-Header oder direkt nach dem Deye-Header erwartet.
# Dies ist eine vereinfachte Darstellung. Realistische Implementierungen nutzen oft ein Python-Modbus-Lib
# und schicken dessen PDU durch den Deye-Wrapper.
# Für Deye's 8899 ist der Aufbau oft:
# Magic Header (10 Bytes: A5 80 10 45 00 00 00 00 00 00)
# Payload Length (2 Bytes)
# Modbus RTU Payload (Slave ID + Function Code + Data + CRC)
# Dies ist eine gängigere (aber immer noch vereinfachte) Struktur, die in vielen Community-Projekten verwendet wird:
# Magic header (A5 80 10 45 00 00 00 00 00 00)
# Length (des Modbus RTU frames)
# Modbus RTU frame itself (incl. CRC)
# Tatsächliche Implementierungen sind komplexer. Daher ist es ratsam, bestehende Bibliotheken zu nutzen!
# Für dieses Beispiel zeigen wir, wie man eine Verbindung herstellt und Daten empfängt,
# die dann noch als Modbus-RTU-Antwort interpretiert werden müssen.
# Hier ein stark vereinfachtes Beispiel für eine Deye-Anfrage, wie sie in Community-Projekten üblich ist.
# Es wird davon ausgegangen, dass die Modbus-RTU-Anfrage (inkl. CRC) vorab generiert wird.
# Dieses Beispiel ist nur zur Veranschaulichung der Socket-Kommunikation.
# Eine echte Implementierung würde die Modbus-RTU-Pakete korrekt erstellen (z.B. mit PyModbus).
# Beispiel einer Deye-Anfrage (Modbus FC 0x03, Register 0x52, 2 Register für Inverter Power)
# Diese Bytesequenz ist typisch für eine Anfrage an einen Deye-Inverter.
# Sie beinhaltet den Deye Header und die Modbus RTU Anfrage mit CRC.
request_bytes = bytes([
0xA5, 0x10, 0x10, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, # Deye Header
0x01, # Slave ID
0x03, # Function Code: Read Holding Registers
0x00, 0x52, # Start Address (0x52 = 82)
0x00, 0x02, # Number of registers (2)
0xCD, 0xFA # CRC (Beispielwert, muss korrekt berechnet werden)
])
return request_bytes
try:
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.settimeout(5) # Timeout für die Verbindung
s.connect((INVERTER_IP, INVERTER_PORT))
print(f"Verbunden mit Deye Inverter {INVERTER_IP}:{INVERTER_PORT}")
request = create_deye_modbus_request(SLAVE_ID, 0x03, REGISTER_ADDRESS, NUM_REGISTERS)
s.sendall(request)
print("Anfrage gesendet. Warte auf Antwort...")
response = s.recv(1024) # Empfange bis zu 1024 Bytes
if response:
print(f"Empfangene Rohdaten ({len(response)} Bytes): {response.hex()}")
# Hier beginnt die eigentliche Interpretation der Modbus-Antwort.
# Deye-Antworten sind oft auch in einem Deye-Wrapper.
# Typischerweise ist die Modbus RTU Antwort ab Byte 10 oder 11 enthalten,
# nach dem Deye-Header und ggf. einer weiteren Längenangabe.
# Annahme: Nach dem 10-Byte Deye-Header kommt die Modbus-RTU-Antwort (inkl. SlaveID, FC, Byte Count, Data, CRC)
# Dies ist stark vereinfacht und dient nur als Beispiel.
# Eine korrekte Interpretation würde die Deye-Wrapper-Längenfelder auswerten.
# Ein gängiger Ansatz ist, die letzten Bytes zu extrahieren, die die Modbus-RTU-Antwort darstellen.
# Beispiel: Deye Header (10 Bytes) + Modbus RTU Response (mind. 5 Bytes + Daten + CRC)
# Wenn die Modbus-RTU-Antwort z.B. 7 Bytes Daten enthält (2x 32-Bit Werte), dann 1 SlaveID + 1 FC + 1 ByteCount + 7 Data + 2 CRC = 12 Bytes
# Für 2 Register (32-bit Wert) => 4 Bytes Daten.
# Modbus RTU Antwort: SlaveID(1) + FC(1) + ByteCount(1) + Data(4) + CRC(2) = 9 Bytes
# Wenn response[10:] die Modbus RTU Antwort ist:
modbus_response = response[10:] # Annahme: Modbus RTU Antwort beginnt nach 10 Byte Deye-Header
if len(modbus_response) >= 9: # Mindestens 9 Bytes für 2 Register Modbus-Antwort
# Wir erwarten SlaveID, FunctionCode, ByteCount, Daten (4 Bytes), CRC (2 Bytes)
slave_id_resp = modbus_response[0]
function_code_resp = modbus_response[1]
byte_count = modbus_response[2]
# Prüfen, ob der Funktionscode und die Slave-ID übereinstimmen
if slave_id_resp == SLAVE_ID and function_code_resp == 0x03 and byte_count == 4:
# Daten extrahieren (4 Bytes für 2 Register / 32-Bit Wert)
data_bytes = modbus_response[3:7]
# Umwandlung der 4 Bytes in einen Integer (Big-Endian, unsigned int)
ac_power = struct.unpack('>I', data_bytes)[0]
print(f"Aktuelle AC-Leistung des Inverters: {ac_power} W")
else:
print("Modbus-Antwortstruktur unerwartet oder Fehler.")
else:
print("Antwort zu kurz, um als Modbus-RTU-Antwort interpretiert zu werden.")
else:
print("Keine Daten vom Inverter empfangen.")
except socket.timeout:
print("Verbindungstimeout: Inverter nicht erreichbar oder antwortet nicht.")
except ConnectionRefusedError:
print("Verbindung verweigert: Der Inverter hat die Verbindung abgelehnt. Prüfen Sie IP und Port.")
except Exception as e:
print(f"Ein Fehler ist aufgetreten: {e}")
Wichtiger Hinweis: Das obige Python-Skript ist eine stark vereinfachte Darstellung und dient primär der Veranschaulichung der Socket-Kommunikation. Die tatsächliche Implementierung des Deye-Protokolls mit Modbus-RTU-Kapselung ist komplexer. Es wird dringend empfohlen, bestehende Open-Source-Bibliotheken und Community-Projekte (z.B. auf GitHub nach „Deye Modbus” oder „Deye inverter MQTT” suchen) zu verwenden, da diese die Protokolldetails bereits korrekt implementiert haben. Sie müssen sich dann nur noch um die korrekten Modbus-Registeradressen für Ihr spezifisches Deye-Modell kümmern.
Schritt 4: Register-Adressen finden und Daten interpretieren
Die größte Herausforderung ist oft, die richtigen Modbus-Registeradressen für die gewünschten Datenpunkte zu finden. Die Deye-Dokumentation ist hierbei nicht immer sehr offen. Glücklicherweise hat die Community fantastische Arbeit geleistet, diese Informationen zusammenzutragen. Suchen Sie nach „Deye Modbus Register List” oder „Deye inverter register map” in Foren oder GitHub-Wikis. Häufige Datenpunkte sind:
- 0x0052 (82 dezimal): AC-Leistung aktuell (W)
- 0x002B (43 dezimal): Tagesertrag (Wh)
- 0x0033 (51 dezimal): Gesamt AC-Ertrag (Wh)
- 0x0066 (102 dezimal): Batterieladezustand (%)
- 0x0067 (103 dezimal): Batteriestrom (A)
- 0x0068 (104 dezimal): Batteriespannung (V)
Beachten Sie, dass viele Werte als 16-Bit- oder 32-Bit-Integer übermittelt werden und oft noch mit einem Skalierungsfaktor multipliziert oder durch 10 oder 100 geteilt werden müssen, um den realen Wert zu erhalten (z.B. Spannung in V, Strom in A, Leistung in W). Die Dokumentation der Community-Projekte gibt hier meist genaue Auskunft.
Integration in Home Assistant und andere Smart Home Systeme
Der wahre Mehrwert des lokalen Datenzugriffs zeigt sich in der Integration in Ihre Smart Home Umgebung. Systeme wie Home Assistant sind ideal dafür geeignet. Es gibt spezielle Integrationen (oft über HACS – Home Assistant Community Store), die das Auslesen des Deye-Inverters über TCP-Port 8899 stark vereinfachen. Einmal eingerichtet, stehen Ihnen die Daten als Sensoren in Home Assistant zur Verfügung, die Sie dann für folgende Zwecke nutzen können:
- Visualisierung: Erstellen Sie elegante Dashboards, die Ihre aktuelle Erzeugung, Ihren Verbrauch, den Batteriestand und den Hausverbrauch übersichtlich darstellen.
- Automatisierung: Schalten Sie Geräte (z.B. Wallbox, Heizstab, Spülmaschine) automatisch ein, wenn ein Überschuss an Solarstrom vorhanden ist. Laden Sie Ihr E-Auto nur mit Solarstrom.
- Langzeitarchivierung und Analyse: Home Assistant speichert die Daten und ermöglicht detaillierte Auswertungen über Tage, Wochen, Monate oder Jahre hinweg.
- Benachrichtigungen: Erhalten Sie Alarme, wenn der Batteriestand kritisch ist oder die Produktion unter den Erwartungen liegt.
Die Home Assistant Integration für Deye-Wechselrichter ist in der Regel als Modbus-TCP-Integration konfiguriert, die dann die Deye-spezifischen Register abfragt. Suchen Sie nach „Deye Modbus Home Assistant” in der Dokumentation oder in den Foren von Home Assistant, um die aktuellsten Anleitungen und Integrationen zu finden.
Wichtige Überlegungen und Troubleshooting
- Sicherheit: Obwohl lokaler Zugriff sicherer ist als die Abhängigkeit von Cloud-Diensten, sollten Sie dennoch sicherstellen, dass Ihr Heimnetzwerk gut geschützt ist. Öffnen Sie TCP-Port 8899 NICHT zum Internet hin!
- Firmware-Updates: Deye-Firmware-Updates können das Protokoll oder die Registerbelegung ändern. Seien Sie vorsichtig bei Updates, wenn Sie auf lokalen Zugriff angewiesen sind. Überprüfen Sie immer die Kompatibilität mit Ihren Skripten/Integrationen.
- Inverter-Modelle: Nicht alle Deye-Inverter verhalten sich exakt gleich. Die Modbus-Register können variieren. Stellen Sie sicher, dass Sie die Registerliste für Ihr spezifisches Modell verwenden.
- Netzwerkprobleme: Firewall-Einstellungen auf Ihrem Router oder dem Gerät, das die Daten ausliest, können den Zugriff blockieren. Stellen Sie sicher, dass keine Blockaden vorliegen.
- Dateninterpretation: Falsche Skalierungsfaktoren oder Datenformate (z.B. Big-Endian vs. Little-Endian) sind häufige Fehlerquellen. Vergleichen Sie Ihre ausgelesenen Werte mit denen der Deye-App oder des Displays am Wechselrichter.
- Keine Garantie: Dieser lokale Zugriff wird von Deye offiziell nicht unterstützt oder dokumentiert. Änderungen sind jederzeit möglich. Gehen Sie auf eigenes Risiko vor.
Fazit
Der Zugriff auf die Energiedaten Ihres Deye Solar-Inverters über den TCP-Port 8899 ist ein mächtiges Werkzeug für jeden, der seine Photovoltaik-Anlage optimal nutzen und steuern möchte. Er befreit Sie von der Abhängigkeit proprietärer Cloud-Lösungen und eröffnet Ihnen eine Welt voller Möglichkeiten – von präzisem Echtzeit-Monitoring bis hin zur intelligenten Automatisierung Ihres Smart Homes. Es erfordert zwar ein wenig Einarbeitung und technisches Verständnis, aber die Belohnung ist eine nie dagewesene Kontrolle und Transparenz über Ihre Energieproduktion und -nutzung. Nutzen Sie die Ressourcen der engagierten Community und tauchen Sie ein in die spannende Welt der lokalen Energiedaten!