--- title: "go-e Gemini flex Wallbox" description: "Integrazione della wallbox EV go-e Gemini flex con TapHome tramite HTTP API v2. Controllo della corrente di carica, modalità e commutazione delle fasi,." url: "https://taphome.com/it/compatibility/go-e-wallbox/" language: it lastmod: 2026-08-25 generator: hugo ai: topics: ["http","wallbox","ev-charging","wifi","pv-surplus","3-phase"] questions: ["Come integrare la wallbox go-e Gemini flex con TapHome?","Cosa controlla e monitora il template go-e wallbox di TapHome?","Come abilitare l'API HTTP sul go-e Charger per TapHome?","Come configurare la ricarica con surplus FV con go-e wallbox e TapHome?","Perché la corrente di carica della go-e wallbox supporta solo 6 valori?","Come commutare tra ricarica monofase e trifase su go-e tramite TapHome?"] --- # go-e Gemini flex Wallbox Comunicazione: Packet Parser → HTTP - [Sito ufficiale go-e](https://go-e.com) > Indirizzo di rete > > TapHome raggiunge il dispositivo all'indirizzo inserito durante l'importazione. Assegna al dispositivo un indirizzo fisso — una prenotazione IP nel router, oppure il suo nome mDNS se lo supporta —, altrimenti l'integrazione smette di funzionare quando il router cambia l'indirizzo. > > [Preparazione della rete](https://taphome.com/it/docs/setup/network-preparation/) ## Guida all'integrazione La go-e Gemini flex è una wallbox EV di produzione austriaca disponibile nelle varianti da 11 kW (16 A) e 22 kW (32 A), con il più recente modello Gemini flex 2.0 dotato di modulo 4G LTE integrato. TapHome comunica con il caricatore tramite l'API HTTP v2 locale su Wi-Fi — non è richiesta alcuna connessione cloud. L'API deve essere esplicitamente abilitata nell'app go-e prima che TapHome possa connettersi. Il template fornisce il monitoraggio dello stato del caricatore, il controllo della corrente, della modalità di carica e dello stato forzato, la commutazione delle fasi, le letture di tensione e corrente per fase, un contatore di energia e ingressi in sola scrittura per dati esterni di potenza FV e rete per abilitare la ricarica con surplus. ## Configurazione ### Abilitazione dell'API HTTP L'API HTTP v2 locale è disabilitata per impostazione predefinita. Per abilitarla: 1. Connettersi al go-e Charger tramite l'app go-e (disponibile per iOS e Android) 2. Navigare su **Impostazioni > Connessione > Impostazioni API** 3. Abilitare **"Consenti accesso all'API HTTP locale vX"** Una volta abilitata, il caricatore risponde alle richieste HTTP sulla porta 80. Non è richiesta l'autenticazione — l'accesso è controllato esclusivamente da questo interruttore. ### Configurazione di rete La go-e Gemini flex si connette tramite **Wi-Fi (802.11b/g/n, solo 2,4 GHz)**. Non è presente una porta Ethernet. Durante l'importazione del template TapHome, inserire l'indirizzo IP del caricatore. Il caricatore può operare in modalità hotspot (connessione diretta) o unirsi a una rete Wi-Fi esistente. Per l'integrazione con TapHome, il caricatore deve trovarsi sulla stessa rete della CCU TapHome. ## Funzionalità del dispositivo ### Stato del caricatore Il dispositivo Stato del caricatore riporta lo stato attuale di connessione e carica come indicatore multi-valore in sola lettura. La chiave API `car` restituisce uno dei cinque stati: **Guasto** (0), **Disponibile** (1), **In carica** (2), **Preparazione** (3) o **Completato** (4). Questo consente alle automazioni TapHome di attivarsi in base al fatto che un veicolo sia connesso, in carica attiva o abbia completato una sessione. ### Controllo della corrente e della modalità di carica Due dispositivi controllabili gestiscono il funzionamento del caricatore: - **Corrente di carica** — seleziona la corrente di carica richiesta tra sei valori discreti: 6, 8, 10, 12, 14 e 16 A. Il template mappa questi valori alle posizioni dell'interruttore 0–5 utilizzando la formula `amp/2 - 3` per la lettura e `(position + 3) × 2` per la scrittura. I valori vengono inviati al caricatore tramite `api/set?amp={value}`. - **Modalità di carica** — seleziona la logica di carica: **Base** (carica continua predefinita), **Eco** (ottimizzata sul prezzo tramite tariffa Awattar) o **Viaggio giornaliero** (arresto automatico al raggiungimento dell'obiettivo). L'API utilizza i valori 3, 4 e 5; il template li mappa alle posizioni 0, 1 e 2. > [!NOTE] > Il selettore della corrente di carica mappa solo sei valori (6–16 A con incrementi di 2 A). La variante da 22 kW della Gemini flex supporta fino a 32 A, ma i valori superiori a 16 A non sono coperti da questo template. Per utilizzare correnti più elevate, la chiave API `amp` può essere impostata direttamente al di fuori del template. ### Stato forzato Il dispositivo **Stato forzato** sovrascrive la decisione del caricatore sulla ricarica. La chiave API `frc` accetta **Neutro** (0 — decide il caricatore), **Fermato** (1 — ricarica bloccata) e **Carica** (2 — ricarica forzata). Il valore viene scritto tramite `api/set?frc={value}` e riletto dalla risposta di stato, motivo per cui questa revisione del template aggiunge `frc` al filtro `api/status`. > [!NOTE] > Il selettore elenca anche le posizioni 3–9 con etichette numeriche segnaposto ereditate dal template. L'API go-e non attribuisce loro alcun significato — usare solo Neutro, Fermato e Carica. ### Commutazione delle fasi Il dispositivo Commutazione delle fasi controlla quante fasi utilizza il caricatore: **Automatico** (0), **Monofase** (1) o **Trifase** (2). Il go-e Charger supporta la commutazione delle fasi anche durante una sessione di carica attiva. In modalità automatica, il caricatore seleziona la configurazione ottimale delle fasi in base alla potenza disponibile. ### Monitoraggio energetico Il template legge tensione e corrente per fase dall'array energetico `nrg` del caricatore, che contiene 16 valori aggiornati ad ogni ciclo di polling: | Dispositivo | Sorgente | Unità | |-------------|----------|-------| | L1 Tensione | `nrg[0]` | V | | L2 Tensione | `nrg[1]` | V | | L3 Tensione | `nrg[2]` | V | | L1 Corrente | `nrg[4]` | A | | L2 Corrente | `nrg[5]` | A | | L3 Corrente | `nrg[6]` | A | Il dispositivo **Contatore elettrico della wallbox** riporta l'energia totale erogata dalla chiave `eto` (Wh) e la potenza istantanea da `nrg[11]` diviso 1000. Sostituisce il precedente dispositivo Consumo attuale. Tutti i valori energetici sono in sola lettura. > [!WARNING] > Il template legge le correnti di fase da `nrg[4]`, `nrg[5]` e `nrg[6]` e la potenza del contatore da `nrg[11]`. La documentazione dell'API go-e colloca le correnti di fase agli indici 5, 6 e 7, la potenza del neutro all'indice 11 e la potenza totale all'indice 12 — esattamente come faceva la revisione precedente del template. Verificare le letture sul caricatore prima di usarle per fatturazione o automazioni. ### Ingressi per la ricarica con surplus FV Due dispositivi in sola scrittura consentono a TapHome di inviare dati energetici esterni al caricatore per i calcoli della ricarica con surplus: - **Potenza verso rete** — invia la potenza attuale di esportazione/importazione dalla rete (in kW, convertita in W moltiplicando per 1000) tramite `api/set?ids={"pGrid":value}` - **Potenza FV** — invia la produzione fotovoltaica attuale (in kW, convertita in W moltiplicando per 1000) tramite `api/set?ids={"pPv":value}` Questi dispositivi **non** leggono dati dal caricatore. Il go-e Charger stesso non misura la potenza di rete o FV — si affida a fonti esterne per fornire queste informazioni. In una configurazione TapHome tipica, i valori da un contatore di energia separato o da un inverter solare (anch'esso integrato in TapHome) vengono inoltrati al caricatore tramite questi dispositivi in sola scrittura, abilitando la modalità di carica Eco per ottimizzare l'autoconsumo. > [!TIP] > Per utilizzare la ricarica con surplus FV, impostare la Modalità di carica su **Eco**, quindi utilizzare le automazioni TapHome per scrivere periodicamente i valori attuali di potenza di rete e produzione FV nei dispositivi Potenza verso rete e Potenza FV. Il caricatore regolerà automaticamente la corrente di carica in base al surplus disponibile. ### Funzionalità aggiuntive L'API go-e Charger v2 espone dati aggiuntivi attualmente non mappati nel template: potenza per fase (W) e fattore di potenza, tensione del neutro, potenza totale (`nrg[12]`), energia per sessione (`wh`), codici di stato errore, limite di corrente del cavo, sensori di temperatura, frequenza di rete, impostazioni del limite di energia e configurazione della corrente minima/massima. Questi possono essere aggiunti in un futuro aggiornamento del template. ## Risoluzione dei problemi ### Il dispositivo non risponde 1. Verificare che il caricatore sia connesso al Wi-Fi e abbia un indirizzo IP valido — controllare nell'app go-e in **Impostazioni > Connessione** 2. Confermare che l'API HTTP sia abilitata (Impostazioni > Connessione > Impostazioni API) 3. Aprire `http://{charger-ip}/api/status` in un browser — se risponde con JSON, l'API è raggiungibile 4. Verificare che la CCU TapHome e il caricatore siano sulla stessa rete / VLAN ### La corrente di carica non cambia 1. Il template mappa solo sei valori (6, 8, 10, 12, 14, 16 A). Se il caricatore mostra un valore diverso (es. 20 A impostato tramite l'app), TapHome visualizzerà la posizione mappata più vicina 2. Verificare che il firmware del caricatore sia versione 051.4 o successiva — il firmware precedente utilizza una sintassi di filtro diversa che può causare problemi di parsing ### La ricarica con surplus FV non funziona 1. Confermare che la Modalità di carica sia impostata su **Eco** — la logica del surplus si attiva solo in questa modalità 2. Verificare che i valori di Potenza verso rete e Potenza FV vengano scritti regolarmente (almeno ogni 30 secondi) 3. Controllare che i valori siano in kW (il template converte automaticamente in W) 4. Aprire `http://{charger-ip}/api/status?filter=pgrid,ppv` per verificare che il caricatore stia ricevendo i valori > [!TIP] > La chiave API `eto` (energia totale) è ora esposta come dispositivo Contatore elettrico della wallbox — il valore recuperato nel filtro di stato non resta più inutilizzato. ## Dispositivi disponibili 14 Questi dispositivi compaiono in TapHome dopo l'importazione. go-e Wallbox Modulo Variabili personalizzate Lettura (modulo) ```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 ``` Stato del caricatore Interruttore multivalore Solo lettura Stato connessione veicolo e carica — Guasto, Disponibile, In carica, Preparazione, Completato uint8 Valori / Stati: Failure · Available · Charging · Preparing · Finished Lettura stato interruttore ```taphome RETURN(PARSEjson(responseJson, "car")); ``` Scrittura stato interruttore ```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 ``` Corrente di carica Interruttore multivalore Lettura e scrittura Selettore corrente di carica richiesta — 6, 8, 10, 12, 14, 16 A a passi discreti uint8 Unità: A numeric Valori / Stati: 6-Amp · 8-Amp · 10-Amp · 12-Amp · 14-Amp · 16-Amp Lettura stato interruttore ```taphome VAR ampers := PARSEjson(responseJson, "amp"); RETURN(ampers/2-3); ``` Scrittura stato interruttore ```taphome VAR amps:= (Mu +3)*2; VAR response := SENDHTTPREQUEST("api/set?amp=" + amps); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` Modalità di carica Interruttore multivalore Lettura e scrittura Selettore logica di carica — Base (continua), Eco (prezzo ottimizzato / surplus FV), Viaggio giornaliero (arresto automatico all'obiettivo) uint8 numeric Valori / Stati: Basic · Eco · Daily trip Lettura stato interruttore ```taphome RETURN(PARSEjson(responseJson, "lmo")-3); ``` Scrittura stato interruttore ```taphome VAR response := SENDHTTPREQUEST("api/set?lmo=" + (Mu+3)); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` Stato forzato Interruttore multivalore Lettura e scrittura Forzatura della ricarica — Neutro lascia decidere il caricatore, Fermato blocca la ricarica, Carica la forza uint8 Valori / Stati: Neutral · Stopped · Charge Lettura stato interruttore ```taphome RETURN(PARSEjson(responseJson, "frc")); ``` Scrittura stato interruttore ```taphome VAR response := SENDHTTPREQUEST("api/set?frc=" + (Mu)); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` L1 Corrente Variabile Solo lettura numeric Unità: A json\_path Lettura ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,4))) ``` Scrittura ```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 ``` Lettura (modulo) ```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 Tensione Variabile Solo lettura numeric Unità: V json\_path Lettura ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,0))) ``` Scrittura ```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 ``` Lettura (modulo) ```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 Corrente Variabile Solo lettura numeric Unità: A json\_path Lettura ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,5))) ``` Scrittura ```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 ``` Lettura (modulo) ```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 Tensione Variabile Solo lettura numeric Unità: V json\_path Lettura ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,1))) ``` Scrittura ```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 ``` Lettura (modulo) ```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 Corrente Variabile Solo lettura numeric Unità: A json\_path Lettura ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,6))) ``` Scrittura ```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 ``` Lettura (modulo) ```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 Tensione Variabile Solo lettura numeric Unità: V json\_path Lettura ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,2))) ``` Scrittura ```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 ``` Lettura (modulo) ```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"); ``` Commutazione delle fasi Interruttore multivalore Lettura e scrittura Configurazione fasi — Automatico (il caricatore decide), Monofase (forzato), Trifase (forzato). Commutazione possibile anche durante la carica attiva. uint8 Valori / Stati: Automatic · 1-Phase · 3-Phase Lettura stato interruttore ```taphome RETURN(PARSEjson(responseJson, "psm")); ``` Scrittura stato interruttore ```taphome VAR response := SENDHTTPREQUEST("api/set?psm=" + Mu); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` Potenza verso rete Variabile Lettura e scrittura Sola scrittura — invia dati di potenza di rete esterna (kW) al caricatore per il calcolo della ricarica con surplus numeric Unità: kW json\_path Scrittura ```taphome VAR pgrid := "{\"pGrid\":"+ Round(Va*1000)+"}"; VAR response := SENDHTTPREQUEST("api/set?ids=" + pgrid); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` Lettura (modulo) ```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"); ``` Potenza FV Variabile Lettura e scrittura Sola scrittura — invia dati di produzione FV esterna (kW) al caricatore per il calcolo della ricarica con surplus numeric Unità: kW json\_path Scrittura ```taphome VAR pPv := "{\"pPv\":"+ Round(Va*1000)+"}"; VAR response := SENDHTTPREQUEST("api/set?ids=" + pPv); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` Lettura (modulo) ```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"); ``` Contatore elettrico della wallbox Contatore elettrico Solo lettura Contatore di energia — energia totale erogata dal caricatore (eto) e potenza di carica istantanea numeric Unità: kWh json\_path Lettura consumo totale ```taphome RETURN(PARSEjson(responseJson, "eto")) ``` Lettura domanda ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,11))/1000) ``` **Connessione:** Packet Parser → HTTP Possibili miglioramenti (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) ## Parametri di importazione Inserisci questi valori quando importi l'XML. | Richiesto nell'app | Predefinito | |--------------------|---------------| | Indirizzo IP | `192.168.0.1` | ## Fonti - 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 I documenti del produttore sono © dei rispettivi proprietari. Sono forniti così come pubblicati dal produttore, solo a titolo informativo. ## Documentazione correlata - [Integrazione Packet Parser](https://taphome.com/it/compatibility/packet-parser-guide/) - [Packet Parser (HTTP, TCP, UDP, FTP, MQTT)](https://taphome.com/it/docs/integration/packet-parser/) - [Funzioni Packet parser](https://taphome.com/it/docs/script/packet-parser/) - [Funzioni di parsing](https://taphome.com/it/docs/script/parsing-functions/)