--- title: "go-e Gemini flex Wallbox" description: "Integration der go-e Gemini flex EV-Wallbox mit TapHome über HTTP API v2. Steuerung von Ladestrom, Modus und Phasenumschaltung sowie Einspeisung externer." url: "https://taphome.com/de/compatibility/go-e-wallbox/" language: de lastmod: 2026-08-25 generator: hugo ai: topics: ["http","wallbox","ev-charging","wifi","pv-surplus","3-phase"] questions: ["Wie integriert man die go-e Gemini flex Wallbox mit TapHome?","Was steuert und überwacht die go-e-Wallbox-TapHome-Vorlage?","Wie aktiviert man die HTTP-API am go-e Charger für TapHome?","Wie richtet man PV-Überschussladen mit go-e Wallbox und TapHome ein?","Warum unterstützt der Ladestrom der go-e Wallbox nur 6 Werte?","Wie schaltet man zwischen 1-Phasen- und 3-Phasen-Laden bei go-e über TapHome um?"] --- # go-e Gemini flex Wallbox Kommunikation: Packet Parser → HTTP - [Offizielle go-e Website](https://go-e.com) > Netzwerkadresse > > TapHome erreicht dieses Gerät unter der beim Import eingegebenen Adresse. Geben Sie dem Gerät eine feste Adresse — eine IP-Reservierung im Router oder seinen mDNS-Namen, falls es einen unterstützt —, sonst funktioniert die Integration nicht mehr, sobald der Router die Adresse ändert. > > [Netzwerkvorbereitung](https://taphome.com/de/docs/setup/network-preparation/) ## Integrationsanleitung Die go-e Gemini flex ist eine in Österreich hergestellte EV-Wallbox, verfügbar in den Varianten 11 kW (16 A) und 22 kW (32 A), wobei das neuere Modell Gemini flex 2.0 ein integriertes 4G-LTE-Modul bietet. TapHome kommuniziert mit der Ladestation über die lokale HTTP API v2 per Wi-Fi — eine Cloud-Verbindung ist nicht erforderlich. Die API muss in der go-e App explizit aktiviert werden, bevor TapHome eine Verbindung herstellen kann. Die Vorlage bietet Ladestatus-Überwachung, Ladestrom-, Modus- und Zwangszustandssteuerung, Phasenumschaltung, phasenweise Spannungs- und Strommessung, einen Energiezähler sowie schreibgeschützte Eingänge für externe PV- und Netzleistungsdaten zur Ermöglichung des Überschussladens. ## Konfiguration ### Aktivierung der HTTP-API Die lokale HTTP API v2 ist standardmäßig deaktiviert. Zur Aktivierung: 1. Verbinden Sie sich mit dem go-e Charger über die go-e App (verfügbar für iOS und Android) 2. Navigieren Sie zu **Einstellungen > Verbindung > API-Einstellungen** 3. Aktivieren Sie **„Zugriff auf lokale HTTP-API vX erlauben"** Nach der Aktivierung antwortet die Ladestation auf HTTP-Anfragen auf Port 80. Eine Authentifizierung ist nicht erforderlich — der Zugriff wird ausschließlich über diesen Schalter gesteuert. ### Netzwerk-Einrichtung Die go-e Gemini flex verbindet sich über **Wi-Fi (802.11b/g/n, nur 2,4 GHz)**. Ein Ethernet-Anschluss ist nicht vorhanden. Geben Sie beim Import der TapHome-Vorlage die IP-Adresse der Ladestation ein. Die Ladestation kann im Hotspot-Modus (Direktverbindung) oder als Teilnehmer eines bestehenden Wi-Fi-Netzwerks betrieben werden. Für die TapHome-Integration muss sich die Ladestation im selben Netzwerk wie die TapHome CCU befinden. ## Gerätefunktionen ### Ladestatus Das Gerät Ladestatus zeigt den aktuellen Verbindungs- und Ladezustand als Mehrwert-Indikator (nur lesen) an. Der API-Schlüssel `car` gibt einen von fünf Zuständen zurück: **Störung** (0), **Verfügbar** (1), **Laden** (2), **Vorbereitung** (3) oder **Abgeschlossen** (4). Dies ermöglicht TapHome-Automatisierungen, basierend darauf zu reagieren, ob ein Fahrzeug angeschlossen ist, aktiv lädt oder eine Sitzung abgeschlossen hat. ### Ladestrom- und Modussteuerung Zwei steuerbare Geräte verwalten den Betrieb der Ladestation: - **Ladestrom** — wählt den angeforderten Ladestrom aus sechs diskreten Werten: 6, 8, 10, 12, 14 und 16 A. Die Vorlage ordnet diese den Schalterpositionen 0–5 zu, wobei die Formel `amp/2 - 3` zum Lesen und `(position + 3) × 2` zum Schreiben verwendet wird. Werte werden über `api/set?amp={value}` an die Ladestation gesendet. - **Lademodus** — wählt die Ladelogik: **Basis** (Standard-Dauerladen), **Eco** (preisoptimiert über Awattar-Tarif) oder **Tagesfahrt** (automatischer Stopp nach Erreichen des Ziels). Die API verwendet die Werte 3, 4 und 5; die Vorlage ordnet diese den Positionen 0, 1 und 2 zu. > [!NOTE] > Der Ladestrom-Selektor bildet nur sechs Werte ab (6–16 A in 2-A-Schritten). Die 22-kW-Variante der Gemini flex unterstützt bis zu 32 A, aber Werte über 16 A werden von dieser Vorlage nicht abgedeckt. Zur Nutzung höherer Ströme kann der API-Schlüssel `amp` direkt außerhalb der Vorlage gesetzt werden. ### Erzwungener Zustand Das Gerät **Erzwungener Zustand** übersteuert die Entscheidung der Ladestation, ob geladen wird. Der API-Schlüssel `frc` akzeptiert **Neutral** (0 — die Ladestation entscheidet), **Gestoppt** (1 — Laden blockiert) und **Laden** (2 — Laden erzwungen). Der Wert wird über `api/set?frc={value}` geschrieben und aus der Statusantwort zurückgelesen, weshalb diese Vorlagenrevision `frc` in den `api/status`-Filter aufnimmt. > [!NOTE] > Der Selektor listet außerdem die Positionen 3–9 mit numerischen Platzhalter-Bezeichnungen aus der Vorlage. Die go-e API definiert dafür keine Bedeutung — verwenden Sie nur Neutral, Gestoppt und Laden. ### Phasenumschaltung Das Gerät Phasenumschaltung steuert, wie viele Phasen die Ladestation nutzt: **Automatisch** (0), **1-Phasig** (1) oder **3-Phasig** (2). Der go-e Charger unterstützt die Phasenumschaltung auch während einer aktiven Ladesitzung. Im automatischen Modus wählt die Ladestation die optimale Phasenkonfiguration basierend auf der verfügbaren Leistung. ### Energieüberwachung Die Vorlage liest phasenweise Spannung und Strom aus dem `nrg`-Energiearray der Ladestation, das 16 Werte enthält, die in jedem Abfragezyklus aktualisiert werden: | Gerät | Quelle | Einheit | |-------|--------|---------| | L1 Spannung | `nrg[0]` | V | | L2 Spannung | `nrg[1]` | V | | L3 Spannung | `nrg[2]` | V | | L1 Strom | `nrg[4]` | A | | L2 Strom | `nrg[5]` | A | | L3 Strom | `nrg[6]` | A | Das Gerät **Wallbox-Stromzähler** zeigt die gesamte gelieferte Energie aus dem Schlüssel `eto` (Wh) und die momentane Leistungsaufnahme aus `nrg[11]` geteilt durch 1000. Es ersetzt das frühere Gerät Aktuelle Leistungsaufnahme. Alle Energiewerte sind schreibgeschützt. > [!WARNING] > Die Vorlage liest die Phasenströme aus `nrg[4]`, `nrg[5]` und `nrg[6]` und die Zählerleistung aus `nrg[11]`. Die go-e API-Dokumentation führt die Phasenströme an den Indizes 5, 6 und 7, die Neutralleiterleistung an Index 11 und die Gesamtleistung an Index 12 — genau so arbeitete die vorherige Vorlagenrevision. Prüfen Sie die Werte an der Ladestation, bevor Sie sie für Abrechnung oder Automatisierungen verwenden. ### Eingänge für PV-Überschussladen Zwei Nur-Schreiben-Geräte ermöglichen TapHome, externe Energiedaten an die Ladestation für Überschusslade-Berechnungen zu senden: - **Netzeinspeisung** — sendet die aktuelle Netzexport-/-importleistung (in kW, durch Multiplikation mit 1000 in W umgerechnet) über `api/set?ids={"pGrid":value}` - **PV-Leistung** — sendet die aktuelle Photovoltaikproduktion (in kW, durch Multiplikation mit 1000 in W umgerechnet) über `api/set?ids={"pPv":value}` Diese Geräte lesen **keine** Daten von der Ladestation. Der go-e Charger selbst misst weder Netz- noch PV-Leistung — er ist auf externe Quellen angewiesen, die diese Informationen bereitstellen. In einer typischen TapHome-Konfiguration werden Werte von einem separaten Energiezähler oder Solar-Wechselrichter (ebenfalls in TapHome integriert) über diese Nur-Schreiben-Geräte an die Ladestation weitergeleitet, wodurch der Eco-Lademodus zur Optimierung des Eigenverbrauchs aktiviert wird. > [!TIP] > Um PV-Überschussladen zu nutzen, stellen Sie den Lademodus auf **Eco** und verwenden Sie TapHome-Automatisierungen, um regelmäßig aktuelle Netzleistungs- und PV-Produktionswerte in die Geräte Netzeinspeisung und PV-Leistung zu schreiben. Die Ladestation passt ihren Ladestrom automatisch an den verfügbaren Überschuss an. ### Weitere Funktionen Die go-e Charger API v2 stellt zusätzliche Daten bereit, die derzeit nicht in der Vorlage abgebildet sind: phasenweise Leistung (W) und Leistungsfaktor, Neutralleiterspannung, Gesamtleistung (`nrg[12]`), Sitzungsenergie (`wh`), Fehlerzustandscodes, Kabelstromlimit, Temperatursensoren, Netzfrequenz, Energielimit-Einstellungen und Konfiguration des minimalen/maximalen Stroms. Diese können in einer zukünftigen Vorlagenaktualisierung hinzugefügt werden. ## Fehlerbehebung ### Gerät antwortet nicht 1. Überprüfen Sie, ob die Ladestation mit dem Wi-Fi verbunden ist und eine gültige IP-Adresse hat — prüfen Sie in der go-e App unter **Einstellungen > Verbindung** 2. Bestätigen Sie, dass die HTTP-API aktiviert ist (Einstellungen > Verbindung > API-Einstellungen) 3. Öffnen Sie `http://{charger-ip}/api/status` im Browser — wenn JSON zurückgegeben wird, ist die API erreichbar 4. Prüfen Sie, ob TapHome CCU und Ladestation im selben Netzwerk / VLAN sind ### Ladestrom ändert sich nicht 1. Die Vorlage bildet nur sechs Werte ab (6, 8, 10, 12, 14, 16 A). Wenn die Ladestation einen anderen Wert anzeigt (z. B. 20 A über die App eingestellt), zeigt TapHome die nächstgelegene abgebildete Position an 2. Überprüfen Sie, ob die Firmware der Ladestation Version 051.4 oder neuer ist — ältere Firmware verwendet eine andere Filtersyntax, die zu Parsing-Problemen führen kann ### PV-Überschussladen funktioniert nicht 1. Bestätigen Sie, dass der Lademodus auf **Eco** eingestellt ist — die Überschusslogik wird nur in diesem Modus aktiviert 2. Überprüfen Sie, ob die Werte für Netzeinspeisung und PV-Leistung regelmäßig geschrieben werden (mindestens alle 30 Sekunden) 3. Prüfen Sie, ob die Werte in kW angegeben sind (die Vorlage konvertiert automatisch in W) 4. Öffnen Sie `http://{charger-ip}/api/status?filter=pgrid,ppv`, um zu überprüfen, ob die Ladestation die Werte empfängt > [!TIP] > Der API-Schlüssel `eto` (Gesamtenergie) wird jetzt als Gerät Wallbox-Stromzähler bereitgestellt — der im Statusfilter abgerufene Wert bleibt nicht länger ungenutzt. ## Verfügbare Geräte 14 Diese Geräte erscheinen nach dem Import in TapHome. go-e Wallbox Modul Benutzerdefinierte Variablen Lesen (Modul) ```taphome responseJson := "error"; VAR response := SENDHTTPREQUEST("api/status?filter=car,nrg,psm,amp,eto,lmo,frc"); IF response.IsSuccess responseJson := response.Content; ELSE VAR contentJson := response.Content; VAR errCode := response.StatusCode; VAR message := PARSEJSON(contentJson, "message"); #ADDERROR("Failed to read data - (" + errCode + ") " + message); END ``` Ladestatus Mehrwertschalter Nur lesen Fahrzeugverbindungs- und Ladezustand — Störung, Verfügbar, Laden, Vorbereitung, Abgeschlossen uint8 Werte / Zustände: Failure · Available · Charging · Preparing · Finished Schaltzustand lesen ```taphome RETURN(PARSEjson(responseJson, "car")); ``` Schaltzustand schreiben ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/set/value=" + Mu); # IF response.IsSuccess = false # ADDERROR(response.StatusCode); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/setValue", "GET", "value=" + Mu, "header1:value1", "header2:value2", ...);\r # Or VAR request := HTTPREQUEST("/example/setValue"); # request.Method := "PUT"; # VAR response := SENDHTTPREQUEST(request); #r # # Send TCP, UDP data: # VAR data1 := "{\"name\":\"John\", \"age\":" + Mu + "}"; # SENDDATA(data1); # VAR data2 := TOBYTES("{\"name\":\"John\", \"age\":" + Mu + "}", "iso-8859-1"); # SENDDATA(data2); # You can process received TCP or UDP data in the Listener script # # # Upload data to FTP: # FTPUPLOAD("filePath", "somedata=" + Mu, "write"); # use "append" mode to append data to existing file ``` Ladestrom Mehrwertschalter Lesen und Schreiben Ladestromwahl — 6, 8, 10, 12, 14, 16 A in diskreten Stufen uint8 Einheit: A numeric Werte / Zustände: 6-Amp · 8-Amp · 10-Amp · 12-Amp · 14-Amp · 16-Amp Schaltzustand lesen ```taphome VAR ampers := PARSEjson(responseJson, "amp"); RETURN(ampers/2-3); ``` Schaltzustand schreiben ```taphome VAR amps:= (Mu +3)*2; VAR response := SENDHTTPREQUEST("api/set?amp=" + amps); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` Lademodus Mehrwertschalter Lesen und Schreiben Ladelogik-Auswahl — Basis (Dauerladen), Eco (preisoptimiert / PV-Überschuss), Tagesfahrt (automatischer Stopp bei Ziel) uint8 numeric Werte / Zustände: Basic · Eco · Daily trip Schaltzustand lesen ```taphome RETURN(PARSEjson(responseJson, "lmo")-3); ``` Schaltzustand schreiben ```taphome VAR response := SENDHTTPREQUEST("api/set?lmo=" + (Mu+3)); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` Erzwungener Zustand Mehrwertschalter Lesen und Schreiben Lade-Übersteuerung — Neutral überlässt die Entscheidung der Ladestation, Gestoppt blockiert das Laden, Laden erzwingt es uint8 Werte / Zustände: Neutral · Stopped · Charge Schaltzustand lesen ```taphome RETURN(PARSEjson(responseJson, "frc")); ``` Schaltzustand schreiben ```taphome VAR response := SENDHTTPREQUEST("api/set?frc=" + (Mu)); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` L1 Strom Variable Nur lesen numeric Einheit: A json\_path Lesen ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,4))) ``` Schreiben ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/set/value=" + Va); # IF response.IsSuccess = false # ADDERROR(response.StatusCode); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/setValue", "GET", "value=" + Va, "header1:value1", "header2:value2", ...);\r # Or VAR request := HTTPREQUEST("/example/setValue"); # request.Method := "PUT"; # VAR response := SENDHTTPREQUEST(request); #r # # Send TCP, UDP data: # VAR data1 := "{\"name\":\"John\", \"age\":" + Va + "}"; # SENDDATA(data1); # VAR data2 := TOBYTES("{\"name\":\"John\", \"age\":" + Va + "}", "iso-8859-1"); # SENDDATA(data2); # You can process received TCP or UDP data in the Listener script # # # Upload data to FTP: # FTPUPLOAD("filePath", "somedata=" + Va, "write"); # use "append" mode to append data to existing file ``` Lesen (Modul) ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/getValue"); # IF response.IsSuccess # VAR content := response.Content; # VAR responseHeaders := response.Headers; # RETURN(PARSEXML(content, "//element1/value1")); # ELSE # ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); # RETURN(NaN); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...); # OR # VAR request := HTTPREQUEST("/example/getValue", "POST", "some data"); # request.headers := { "header1:value1", "header2:value2", ...}; # request.method := "GET"; # request.data := null; # VAR response := SENDHTTPREQUEST(request); # # # Send TCP, UDP data: # VAR data1 := BYTECOLLECTION("0a bb ea df 01"); # SENDDATA(data1); # VAR data2 := "{\"name\":\"John\", \"age\":32}"; # SENDDATA(data2); # VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1"); # SENDDATA(data3); # Process received TCP or UDP data and set device values in the Listener script # # # Download data from FTP: # FTPDOWNLOAD("filePath"); ``` L1 Spannung Variable Nur lesen numeric Einheit: V json\_path Lesen ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,0))) ``` Schreiben ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/set/value=" + Va); # IF response.IsSuccess = false # ADDERROR(response.StatusCode); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/setValue", "GET", "value=" + Va, "header1:value1", "header2:value2", ...);\r # Or VAR request := HTTPREQUEST("/example/setValue"); # request.Method := "PUT"; # VAR response := SENDHTTPREQUEST(request); #r # # Send TCP, UDP data: # VAR data1 := "{\"name\":\"John\", \"age\":" + Va + "}"; # SENDDATA(data1); # VAR data2 := TOBYTES("{\"name\":\"John\", \"age\":" + Va + "}", "iso-8859-1"); # SENDDATA(data2); # You can process received TCP or UDP data in the Listener script # # # Upload data to FTP: # FTPUPLOAD("filePath", "somedata=" + Va, "write"); # use "append" mode to append data to existing file ``` Lesen (Modul) ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/getValue"); # IF response.IsSuccess # VAR content := response.Content; # VAR responseHeaders := response.Headers; # RETURN(PARSEXML(content, "//element1/value1")); # ELSE # ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); # RETURN(NaN); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...); # OR # VAR request := HTTPREQUEST("/example/getValue", "POST", "some data"); # request.headers := { "header1:value1", "header2:value2", ...}; # request.method := "GET"; # request.data := null; # VAR response := SENDHTTPREQUEST(request); # # # Send TCP, UDP data: # VAR data1 := BYTECOLLECTION("0a bb ea df 01"); # SENDDATA(data1); # VAR data2 := "{\"name\":\"John\", \"age\":32}"; # SENDDATA(data2); # VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1"); # SENDDATA(data3); # Process received TCP or UDP data and set device values in the Listener script # # # Download data from FTP: # FTPDOWNLOAD("filePath"); ``` L2 Strom Variable Nur lesen numeric Einheit: A json\_path Lesen ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,5))) ``` Schreiben ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/set/value=" + Va); # IF response.IsSuccess = false # ADDERROR(response.StatusCode); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/setValue", "GET", "value=" + Va, "header1:value1", "header2:value2", ...);\r # Or VAR request := HTTPREQUEST("/example/setValue"); # request.Method := "PUT"; # VAR response := SENDHTTPREQUEST(request); #r # # Send TCP, UDP data: # VAR data1 := "{\"name\":\"John\", \"age\":" + Va + "}"; # SENDDATA(data1); # VAR data2 := TOBYTES("{\"name\":\"John\", \"age\":" + Va + "}", "iso-8859-1"); # SENDDATA(data2); # You can process received TCP or UDP data in the Listener script # # # Upload data to FTP: # FTPUPLOAD("filePath", "somedata=" + Va, "write"); # use "append" mode to append data to existing file ``` Lesen (Modul) ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/getValue"); # IF response.IsSuccess # VAR content := response.Content; # VAR responseHeaders := response.Headers; # RETURN(PARSEXML(content, "//element1/value1")); # ELSE # ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); # RETURN(NaN); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...); # OR # VAR request := HTTPREQUEST("/example/getValue", "POST", "some data"); # request.headers := { "header1:value1", "header2:value2", ...}; # request.method := "GET"; # request.data := null; # VAR response := SENDHTTPREQUEST(request); # # # Send TCP, UDP data: # VAR data1 := BYTECOLLECTION("0a bb ea df 01"); # SENDDATA(data1); # VAR data2 := "{\"name\":\"John\", \"age\":32}"; # SENDDATA(data2); # VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1"); # SENDDATA(data3); # Process received TCP or UDP data and set device values in the Listener script # # # Download data from FTP: # FTPDOWNLOAD("filePath"); ``` L2 Spannung Variable Nur lesen numeric Einheit: V json\_path Lesen ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,1))) ``` Schreiben ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/set/value=" + Va); # IF response.IsSuccess = false # ADDERROR(response.StatusCode); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/setValue", "GET", "value=" + Va, "header1:value1", "header2:value2", ...);\r # Or VAR request := HTTPREQUEST("/example/setValue"); # request.Method := "PUT"; # VAR response := SENDHTTPREQUEST(request); #r # # Send TCP, UDP data: # VAR data1 := "{\"name\":\"John\", \"age\":" + Va + "}"; # SENDDATA(data1); # VAR data2 := TOBYTES("{\"name\":\"John\", \"age\":" + Va + "}", "iso-8859-1"); # SENDDATA(data2); # You can process received TCP or UDP data in the Listener script # # # Upload data to FTP: # FTPUPLOAD("filePath", "somedata=" + Va, "write"); # use "append" mode to append data to existing file ``` Lesen (Modul) ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/getValue"); # IF response.IsSuccess # VAR content := response.Content; # VAR responseHeaders := response.Headers; # RETURN(PARSEXML(content, "//element1/value1")); # ELSE # ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); # RETURN(NaN); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...); # OR # VAR request := HTTPREQUEST("/example/getValue", "POST", "some data"); # request.headers := { "header1:value1", "header2:value2", ...}; # request.method := "GET"; # request.data := null; # VAR response := SENDHTTPREQUEST(request); # # # Send TCP, UDP data: # VAR data1 := BYTECOLLECTION("0a bb ea df 01"); # SENDDATA(data1); # VAR data2 := "{\"name\":\"John\", \"age\":32}"; # SENDDATA(data2); # VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1"); # SENDDATA(data3); # Process received TCP or UDP data and set device values in the Listener script # # # Download data from FTP: # FTPDOWNLOAD("filePath"); ``` L3 Strom Variable Nur lesen numeric Einheit: A json\_path Lesen ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,6))) ``` Schreiben ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/set/value=" + Va); # IF response.IsSuccess = false # ADDERROR(response.StatusCode); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/setValue", "GET", "value=" + Va, "header1:value1", "header2:value2", ...);\r # Or VAR request := HTTPREQUEST("/example/setValue"); # request.Method := "PUT"; # VAR response := SENDHTTPREQUEST(request); #r # # Send TCP, UDP data: # VAR data1 := "{\"name\":\"John\", \"age\":" + Va + "}"; # SENDDATA(data1); # VAR data2 := TOBYTES("{\"name\":\"John\", \"age\":" + Va + "}", "iso-8859-1"); # SENDDATA(data2); # You can process received TCP or UDP data in the Listener script # # # Upload data to FTP: # FTPUPLOAD("filePath", "somedata=" + Va, "write"); # use "append" mode to append data to existing file ``` Lesen (Modul) ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/getValue"); # IF response.IsSuccess # VAR content := response.Content; # VAR responseHeaders := response.Headers; # RETURN(PARSEXML(content, "//element1/value1")); # ELSE # ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); # RETURN(NaN); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...); # OR # VAR request := HTTPREQUEST("/example/getValue", "POST", "some data"); # request.headers := { "header1:value1", "header2:value2", ...}; # request.method := "GET"; # request.data := null; # VAR response := SENDHTTPREQUEST(request); # # # Send TCP, UDP data: # VAR data1 := BYTECOLLECTION("0a bb ea df 01"); # SENDDATA(data1); # VAR data2 := "{\"name\":\"John\", \"age\":32}"; # SENDDATA(data2); # VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1"); # SENDDATA(data3); # Process received TCP or UDP data and set device values in the Listener script # # # Download data from FTP: # FTPDOWNLOAD("filePath"); ``` L3 Spannung Variable Nur lesen numeric Einheit: V json\_path Lesen ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,2))) ``` Schreiben ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/set/value=" + Va); # IF response.IsSuccess = false # ADDERROR(response.StatusCode); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/setValue", "GET", "value=" + Va, "header1:value1", "header2:value2", ...);\r # Or VAR request := HTTPREQUEST("/example/setValue"); # request.Method := "PUT"; # VAR response := SENDHTTPREQUEST(request); #r # # Send TCP, UDP data: # VAR data1 := "{\"name\":\"John\", \"age\":" + Va + "}"; # SENDDATA(data1); # VAR data2 := TOBYTES("{\"name\":\"John\", \"age\":" + Va + "}", "iso-8859-1"); # SENDDATA(data2); # You can process received TCP or UDP data in the Listener script # # # Upload data to FTP: # FTPUPLOAD("filePath", "somedata=" + Va, "write"); # use "append" mode to append data to existing file ``` Lesen (Modul) ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/getValue"); # IF response.IsSuccess # VAR content := response.Content; # VAR responseHeaders := response.Headers; # RETURN(PARSEXML(content, "//element1/value1")); # ELSE # ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); # RETURN(NaN); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...); # OR # VAR request := HTTPREQUEST("/example/getValue", "POST", "some data"); # request.headers := { "header1:value1", "header2:value2", ...}; # request.method := "GET"; # request.data := null; # VAR response := SENDHTTPREQUEST(request); # # # Send TCP, UDP data: # VAR data1 := BYTECOLLECTION("0a bb ea df 01"); # SENDDATA(data1); # VAR data2 := "{\"name\":\"John\", \"age\":32}"; # SENDDATA(data2); # VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1"); # SENDDATA(data3); # Process received TCP or UDP data and set device values in the Listener script # # # Download data from FTP: # FTPDOWNLOAD("filePath"); ``` Phasenumschaltung Mehrwertschalter Lesen und Schreiben Phasenkonfiguration — Automatisch (Ladestation entscheidet), 1-Phasig (erzwungen), 3-Phasig (erzwungen). Umschaltung auch während aktivem Laden möglich. uint8 Werte / Zustände: Automatic · 1-Phase · 3-Phase Schaltzustand lesen ```taphome RETURN(PARSEjson(responseJson, "psm")); ``` Schaltzustand schreiben ```taphome VAR response := SENDHTTPREQUEST("api/set?psm=" + Mu); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` Netzeinspeisung Variable Lesen und Schreiben Nur Schreiben — sendet externe Netzleistungsdaten (kW) an die Ladestation für Überschusslade-Berechnungen numeric Einheit: kW json\_path Schreiben ```taphome VAR pgrid := "{\"pGrid\":"+ Round(Va*1000)+"}"; VAR response := SENDHTTPREQUEST("api/set?ids=" + pgrid); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` Lesen (Modul) ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/getValue"); # IF response.IsSuccess # VAR content := response.Content; # VAR responseHeaders := response.Headers; # RETURN(PARSEXML(content, "//element1/value1")); # ELSE # ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); # RETURN(NaN); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...); # OR # VAR request := HTTPREQUEST("/example/getValue", "POST", "some data"); # request.headers := { "header1:value1", "header2:value2", ...}; # request.method := "GET"; # request.data := null; # VAR response := SENDHTTPREQUEST(request); # # # Send TCP, UDP data: # VAR data1 := BYTECOLLECTION("0a bb ea df 01"); # SENDDATA(data1); # VAR data2 := "{\"name\":\"John\", \"age\":32}"; # SENDDATA(data2); # VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1"); # SENDDATA(data3); # Process received TCP or UDP data and set device values in the Listener script # # # Download data from FTP: # FTPDOWNLOAD("filePath"); ``` PV-Leistung Variable Lesen und Schreiben Nur Schreiben — sendet externe PV-Produktionsdaten (kW) an die Ladestation für Überschusslade-Berechnungen numeric Einheit: kW json\_path Schreiben ```taphome VAR pPv := "{\"pPv\":"+ Round(Va*1000)+"}"; VAR response := SENDHTTPREQUEST("api/set?ids=" + pPv); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` Lesen (Modul) ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/getValue"); # IF response.IsSuccess # VAR content := response.Content; # VAR responseHeaders := response.Headers; # RETURN(PARSEXML(content, "//element1/value1")); # ELSE # ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); # RETURN(NaN); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...); # OR # VAR request := HTTPREQUEST("/example/getValue", "POST", "some data"); # request.headers := { "header1:value1", "header2:value2", ...}; # request.method := "GET"; # request.data := null; # VAR response := SENDHTTPREQUEST(request); # # # Send TCP, UDP data: # VAR data1 := BYTECOLLECTION("0a bb ea df 01"); # SENDDATA(data1); # VAR data2 := "{\"name\":\"John\", \"age\":32}"; # SENDDATA(data2); # VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1"); # SENDDATA(data3); # Process received TCP or UDP data and set device values in the Listener script # # # Download data from FTP: # FTPDOWNLOAD("filePath"); ``` Wallbox-Stromzähler Stromzähler Nur lesen Energiezähler — von der Ladestation gelieferte Gesamtenergie (eto) und momentane Ladeleistung numeric Einheit: kWh json\_path Gesamtverbrauch lesen ```taphome RETURN(PARSEjson(responseJson, "eto")) ``` Bedarf lesen ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,11))/1000) ``` **Verbindung:** Packet Parser → HTTP Mögliche Verbesserungen (18) - Voltage N — Neutral voltage in V, available in nrg array index 3 - Per-phase Power (L1, L2, L3) — Individual phase power in W — the template reads only element 11 (demand of the Wallbox Electric Meter) - Power Total — Total power in W. The former 'Current consumption' device read this element; the Wallbox Electric Meter that replaced it reads element 11 instead. See inconsistency report - Power Factor (L1, L2, L3) — Power factor per phase, available in nrg array - Session Energy — Energy consumed in current charging session (Wh) - Error State — Error code — None, FiAc, FiDc, Phase, Overvolt, Overamp, etc. Useful for diagnostics. - Allow Charging — Whether the car is presently allowed to charge - Force State — Force charger state: Neutral=0, Off=1, On=2. Read/write. Could override charging logic. - Cable Current Limit — Maximum current the connected cable supports (A) - Temperature Sensors — Controller and charger temperature sensors array - Grid Frequency — Grid frequency in Hz - Firmware Version — Current firmware version string - Serial Number — Device serial number - Uptime — Time since boot in milliseconds - Energy Limit — Charging energy limit in Wh (null=disabled). Read/write. - Ampere Maximum — Maximum ampere limit (R/W) - Minimum Charging Current — Minimum charging current (R/W) - PV Surplus Feature — Enable/disable PV surplus charging (boolean, R/W) ## Importparameter Diese Werte geben Sie beim Import des XML ein. | In der App abgefragt | Standard | |----------------------|---------------| | IP-Adresse | `192.168.0.1` | ## Quellen - go-eCharger API v2 — HTTP API Reference [github.com](https://github.com/goecharger/go-eCharger-API-v2) 2026-03-27 - go-e Charger Gemini flex — Data Sheet V1.4 [go-e.com](https://go-e.com/fileadmin/Support/Anleitungen/Englisch/go-e-gemini-flex-datasheet.pdf) 2026-03-27 [PDF](https://taphome.com/compatibility/devices/go-e-wallbox/manufacturer/go-e-gemini-flex-datasheet.pdf) - ha-goecharger-api2 — Home Assistant Integration [github.com](https://github.com/marq24/ha-goecharger-api2) 2026-03-27 Herstellerdokumente sind © ihrer jeweiligen Eigentümer. Sie werden so bereitgestellt, wie der Hersteller sie veröffentlicht hat, nur zur Information. ## Verwandte Dokumentation - [Packet-Parser-Integration](https://taphome.com/de/compatibility/packet-parser-guide/) - [Packet Parser (HTTP, TCP, UDP, FTP, MQTT)](https://taphome.com/de/docs/integration/packet-parser/) - [Packet-Parser-Funktionen](https://taphome.com/de/docs/script/packet-parser/) - [Parsing-Funktionen](https://taphome.com/de/docs/script/parsing-functions/)