---
title: "go-e Gemini flex Wallbox"
description: "Integrarea stației de încărcare EV go-e Gemini flex cu TapHome prin HTTP API v2. Controlul curentului, modului și fazelor, plus date externe PV/rețea."
url: "https://taphome.com/ro/compatibility/go-e-wallbox/"
language: ro
lastmod: 2026-08-25
generator: hugo
ai:
  topics: ["http","wallbox","ev-charging","wifi","pv-surplus","3-phase"]
  questions: ["Cum integrez stația de încărcare go-e Gemini flex cu TapHome?","Ce controlează și ce monitorizează șablonul TapHome pentru stația de încărcare go-e?","Cum activez HTTP API pe go-e Charger pentru TapHome?","Cum configurez încărcarea din surplusul PV cu stația de încărcare go-e și TapHome?","De ce Curentul de încărcare al stației go-e acceptă doar 6 valori?","Cum comut între încărcarea monofazată și trifazată la go-e prin TapHome?"]
---

# go-e Gemini flex Wallbox

Comunicație: Packet Parser → HTTP

- [Site-ul oficial go-e](https://go-e.com)

> Adresa în rețea
> 
> TapHome comunică cu dispozitivul la adresa introdusă la import. Atribuiți dispozitivului o adresă fixă — o rezervare IP în router sau numele său mDNS, dacă îl acceptă —, altfel integrarea nu mai funcționează când routerul schimbă adresa.
> 
> [Pregătirea rețelei](https://taphome.com/ro/docs/setup/network-preparation/)

## Ghid de integrare

go-e Gemini flex este o stație de încărcare EV fabricată în Austria, disponibilă în variantele de 11 kW (16 A) și 22 kW (32 A); modelul mai nou Gemini flex 2.0 are 4G LTE integrat. TapHome comunică cu stația de încărcare prin API-ul său HTTP local v2 pe Wi-Fi — nu este necesară conexiunea la cloud. Înainte ca TapHome să se poată conecta, API-ul trebuie activat explicit în aplicația go-e.

Șablonul oferă monitorizarea stării stației de încărcare, controlul curentului de încărcare, al modului și al forțării stării, comutarea fazelor, citirea tensiunii și a curentului pe fiecare fază, un contor electric și intrări doar pentru scriere pentru datele externe despre puterea PV și a rețelei, care permit încărcarea din surplus.

## Configurare

### Activarea HTTP API

API-ul HTTP local v2 este dezactivat implicit. Pentru a-l activa:

1. Conectați-vă la go-e Charger prin aplicația go-e (disponibilă pentru iOS și Android)
2. Mergeți la **Settings > Connection > API Settings**
3. Activați **„Allow access to local HTTP API vX”**

După activare, stația de încărcare răspunde la cererile HTTP pe portul 80. Nu este necesară autentificarea — accesul este controlat exclusiv de acest comutator.

### Configurarea rețelei

go-e Gemini flex se conectează prin **Wi-Fi (802.11b/g/n, doar 2,4 GHz)**. Nu dispune de port Ethernet. La importul șablonului în TapHome introduceți adresa IP a stației de încărcare.

Stația de încărcare poate funcționa în modul hotspot (conexiune directă) sau se poate conecta la o rețea Wi-Fi existentă. Pentru integrarea cu TapHome, stația de încărcare trebuie să fie în aceeași rețea ca unitatea de control TapHome.

## Funcțiile dispozitivului

### Starea stației de încărcare

Dispozitivul Stare stație de încărcare raportează starea actuală a conectării și a încărcării ca indicator multivaloare doar pentru citire. Cheia API `car` returnează una din cele cinci stări: **Defecțiune** (0), **Disponibilă** (1), **Încărcare** (2), **Pregătire** (3) sau **Finalizată** (4). Astfel, automatizările TapHome se pot declanșa în funcție de faptul că un vehicul este conectat, se încarcă activ sau și-a încheiat sesiunea.

### Controlul curentului de încărcare și al modului

Două dispozitive controlabile gestionează modul de funcționare al stației de încărcare:

- **Curent de încărcare** — selectează curentul de încărcare solicitat dintre șase valori discrete: 6, 8, 10, 12, 14 și 16 A. Șablonul le mapează pe pozițiile comutatorului 0–5 cu formula `amp/2 - 3` la citire și `(position + 3) × 2` la scriere. Valorile se trimit stației de încărcare prin `api/set?amp={value}`.

- **Mod de încărcare** — selectează logica de încărcare: **De bază** (încărcare continuă implicită), **Eco** (optimizat după preț prin tariful Awattar) sau **Călătorie zilnică** (oprire automată după atingerea țintei). API-ul folosește valorile 3, 4 și, respectiv, 5; șablonul le mapează pe pozițiile 0, 1 și 2.

> [!NOTE]
> Selectorul Curent de încărcare mapează doar șase valori (6–16 A în pași de 2 A). Varianta de 22 kW a Gemini flex acceptă până la 32 A, dar valorile peste 16 A nu sunt acoperite de acest șablon. Pentru curenți mai mari, cheia API `amp` poate fi setată direct, în afara șablonului.

### Forțarea stării

Dispozitivul **Forțare stare** are prioritate față de decizia proprie a stației de încărcare de a încărca sau nu. Cheia API `frc` acceptă **Neutru** (0 — decide stația de încărcare), **Oprită** (1 — încărcarea blocată) și **Încărcare** (2 — încărcarea pornită forțat). Valoarea se scrie prin `api/set?frc={value}` și se recitește din răspunsul de stare; de aceea această revizie a șablonului adaugă `frc` în filtrul `api/status`.

> [!NOTE]
> Selectorul afișează și pozițiile 3–9 cu etichete numerice substituente, moștenite din șablon. API-ul go-e nu le atribuie niciun sens — folosiți doar Neutru, Oprită și Încărcare.

### Comutarea fazelor

Dispozitivul Comutare faze controlează câte faze folosește stația de încărcare: **Automat** (0), **Monofazat** (1) sau **Trifazat** (2). go-e Charger permite comutarea fazelor chiar și în timpul unei sesiuni de încărcare active. În modul Automat, stația de încărcare alege configurația optimă a fazelor în funcție de puterea disponibilă.

### Monitorizarea energiei

Șablonul citește tensiunea și curentul pe fiecare fază din matricea de energie `nrg` a stației de încărcare, care conține 16 valori actualizate la fiecare ciclu de interogare:

| Dispozitiv | Sursă | Unitate |
|--------|--------|------|
| Tensiune L1 | `nrg[0]` | V |
| Tensiune L2 | `nrg[1]` | V |
| Tensiune L3 | `nrg[2]` | V |
| Curent L1 | `nrg[4]` | A |
| Curent L2 | `nrg[5]` | A |
| Curent L3 | `nrg[6]` | A |

Dispozitivul **Contor electric stație de încărcare** raportează energia totală livrată din cheia `eto` (Wh) și puterea instantanee din `nrg[11]`, împărțită la 1000. Acesta înlocuiește fostul dispozitiv Current Consumption. Toate valorile de energie sunt doar pentru citire.

> [!WARNING]
> Șablonul citește curenții pe faze din `nrg[4]`, `nrg[5]` și `nrg[6]`, iar puterea raportată de contor din `nrg[11]`. Documentația API go-e plasează curenții pe faze la indicii 5, 6 și 7, puterea pe neutru la indicele 11 și puterea totală la indicele 12 — exact aceștia erau folosiți în revizia anterioară a șablonului. Înainte de a vă baza pe aceste valori pentru facturare sau automatizări, verificați-le comparativ cu stația de încărcare.

### Intrări pentru încărcarea din surplusul PV

Două dispozitive doar pentru scriere permit TapHome să transmită stației de încărcare date externe despre energie pentru calculul încărcării din surplus:

- **Putere spre rețea** — trimite puterea actuală exportată în rețea / importată din rețea (în kW, convertită în W prin înmulțire cu 1000) prin `api/set?ids={"pGrid":value}`
- **Putere PV** — trimite producția fotovoltaică actuală (în kW, convertită în W prin înmulțire cu 1000) prin `api/set?ids={"pPv":value}`

Aceste dispozitive **nu** citesc date de la stația de încărcare. go-e Charger nu măsoară singur puterea rețelei sau puterea PV — se bazează pe surse externe care îi furnizează aceste informații. Într-o configurație TapHome tipică, valorile de la un contor electric separat sau de la un invertor solar (integrate și ele în TapHome) sunt transmise stației de încărcare prin aceste dispozitive doar pentru scriere, ceea ce permite modului de încărcare Eco să optimizeze autoconsumul.

> [!TIP]
> Pentru încărcarea din surplusul PV setați Mod de încărcare la **Eco**, apoi folosiți automatizările TapHome pentru a scrie periodic valorile actuale ale puterii rețelei și ale producției PV în dispozitivele Putere spre rețea și Putere PV. Stația de încărcare își va ajusta automat curentul de încărcare în funcție de surplusul disponibil.

### Funcții suplimentare

API-ul go-e Charger v2 pune la dispoziție și date care nu sunt mapate în prezent în șablon: puterea (W) și factorul de putere pe fiecare fază, tensiunea pe neutru, puterea totală (`nrg[12]`), energia pe sesiune (`wh`), codurile stărilor de eroare, limita de curent a cablului, senzorii de temperatură, frecvența rețelei, setările limitei de energie și configurarea curentului minim/maxim. Acestea pot fi adăugate într-o actualizare viitoare a șablonului.

## Rezolvarea problemelor

### Dispozitivul nu răspunde

1. Verificați dacă stația de încărcare este conectată la Wi-Fi și are o adresă IP validă — verificați în aplicația go-e la **Settings > Connection**
2. Confirmați că HTTP API este activat (Settings > Connection > API Settings)
3. Deschideți `http://{charger-ip}/api/status` într-un browser — dacă răspunde cu JSON, API-ul este accesibil
4. Verificați dacă unitatea de control TapHome și stația de încărcare sunt în aceeași rețea / VLAN

### Curentul de încărcare nu se schimbă

1. Șablonul mapează doar șase valori (6, 8, 10, 12, 14, 16 A). Dacă stația de încărcare afișează o altă valoare (de ex. 20 A setați din aplicație), TapHome va afișa cea mai apropiată poziție mapată
2. Verificați dacă firmware-ul stației de încărcare este 051.4 sau mai nou — firmware-ul mai vechi folosește o altă sintaxă a filtrului, care poate cauza probleme la parsare

### Încărcarea din surplusul PV nu funcționează

1. Confirmați că Mod de încărcare este setat la **Eco** — logica de surplus se activează doar în acest mod
2. Verificați dacă valorile Putere spre rețea și Putere PV se scriu regulat (cel puțin la fiecare 30 de secunde)
3. Verificați dacă valorile sunt în kW (șablonul le convertește automat în W)
4. Deschideți `http://{charger-ip}/api/status?filter=pgrid,ppv` pentru a verifica dacă stația de încărcare primește valorile

> [!TIP]
> Cheia API `eto` (energia totală) este acum disponibilă ca dispozitivul Contor electric stație de încărcare — valoarea obținută în filtrul de stare nu mai rămâne nefolosită.

## Dispozitive disponibile 14

Aceste dispozitive apar în TapHome după import.

go-e Wallbox Modul

Variabile personalizate

Citire (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
```

Stare stație de încărcare Comutator cu mai multe valori Doar citire

Starea conectării mașinii și a încărcării — Defecțiune, Disponibilă, Încărcare, Pregătire, Finalizată

uint8

Valori / Stări: Failure · Available · Charging · Preparing · Finished

Citirea stării comutatorului

```taphome
RETURN(PARSEjson(responseJson, "car"));
```

Scrierea stării comutatorului

```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
```

Curent de încărcare Comutator cu mai multe valori Citire și scriere

Selector al curentului de încărcare solicitat — 6, 8, 10, 12, 14, 16 A în trepte discrete

uint8 Unitate: A numeric

Valori / Stări: 6-Amp · 8-Amp · 10-Amp · 12-Amp · 14-Amp · 16-Amp

Citirea stării comutatorului

```taphome
VAR ampers := PARSEjson(responseJson, "amp");
RETURN(ampers/2-3);
```

Scrierea stării comutatorului

```taphome
VAR amps:= (Mu +3)*2;
VAR response := SENDHTTPREQUEST("api/set?amp=" + amps);
IF response.IsSuccess = false
ADDERROR(response.StatusCode);
END
```

Mod de încărcare Comutator cu mai multe valori Citire și scriere

Selector al logicii de încărcare — De bază (continuu), Eco (optimizat după preț / surplus PV), Călătorie zilnică (oprire automată la atingerea țintei)

uint8 numeric

Valori / Stări: Basic · Eco · Daily trip

Citirea stării comutatorului

```taphome
RETURN(PARSEjson(responseJson, "lmo")-3);
```

Scrierea stării comutatorului

```taphome
VAR response := SENDHTTPREQUEST("api/set?lmo=" + (Mu+3));
IF response.IsSuccess = false
ADDERROR(response.StatusCode);
END
```

Forțare stare Comutator cu mai multe valori Citire și scriere

Comandă prioritară de încărcare — Neutru lasă decizia stației de încărcare, Oprită blochează încărcarea, Încărcare o pornește forțat

uint8

Valori / Stări: Neutral · Stopped · Charge

Citirea stării comutatorului

```taphome
RETURN(PARSEjson(responseJson, "frc"));
```

Scrierea stării comutatorului

```taphome
VAR response := SENDHTTPREQUEST("api/set?frc=" + (Mu));
IF response.IsSuccess = false
ADDERROR(response.StatusCode);
END
```

Curent L1 Variabilă Doar citire

numeric Unitate: A json\_path

Citire

```taphome
VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]");
VAR b := SPLIT(a,",");
RETURN(TODOUBLE(GETAT(b,4)))
```

Scriere

```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
```

Citire (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");
```

Tensiune L1 Variabilă Doar citire

numeric Unitate: V json\_path

Citire

```taphome
VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]");
VAR b := SPLIT(a,",");
RETURN(TODOUBLE(GETAT(b,0)))
```

Scriere

```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
```

Citire (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");
```

Curent L2 Variabilă Doar citire

numeric Unitate: A json\_path

Citire

```taphome
VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]");
VAR b := SPLIT(a,",");
RETURN(TODOUBLE(GETAT(b,5)))
```

Scriere

```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
```

Citire (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");
```

Tensiune L2 Variabilă Doar citire

numeric Unitate: V json\_path

Citire

```taphome
VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]");
VAR b := SPLIT(a,",");
RETURN(TODOUBLE(GETAT(b,1)))
```

Scriere

```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
```

Citire (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");
```

Curent L3 Variabilă Doar citire

numeric Unitate: A json\_path

Citire

```taphome
VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]");
VAR b := SPLIT(a,",");
RETURN(TODOUBLE(GETAT(b,6)))
```

Scriere

```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
```

Citire (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");
```

Tensiune L3 Variabilă Doar citire

numeric Unitate: V json\_path

Citire

```taphome
VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]");
VAR b := SPLIT(a,",");
RETURN(TODOUBLE(GETAT(b,2)))
```

Scriere

```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
```

Citire (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");
```

Comutare faze Comutator cu mai multe valori Citire și scriere

Configurația fazelor — Automat (decide stația de încărcare), Monofazat (forțat), Trifazat (forțat). Comutarea este posibilă și în timpul încărcării active.

uint8

Valori / Stări: Automatic · 1-Phase · 3-Phase

Citirea stării comutatorului

```taphome
RETURN(PARSEjson(responseJson, "psm"));
```

Scrierea stării comutatorului

```taphome
VAR response := SENDHTTPREQUEST("api/set?psm=" + Mu);
IF response.IsSuccess = false
ADDERROR(response.StatusCode);
END
```

Putere spre rețea Variabilă Citire și scriere

Doar scriere — trimite stației de încărcare date externe despre puterea rețelei (kW) pentru calculul încărcării din surplus

numeric Unitate: kW json\_path

Scriere

```taphome
VAR pgrid := "{\"pGrid\":"+ Round(Va*1000)+"}";

VAR response := SENDHTTPREQUEST("api/set?ids=" + pgrid);

IF response.IsSuccess = false
ADDERROR(response.StatusCode);
END
```

Citire (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");
```

Putere PV Variabilă Citire și scriere

Doar scriere — trimite stației de încărcare date externe despre producția PV (kW) pentru calculul încărcării din surplus

numeric Unitate: kW json\_path

Scriere

```taphome
VAR pPv := "{\"pPv\":"+ Round(Va*1000)+"}";

VAR response := SENDHTTPREQUEST("api/set?ids=" + pPv);

IF response.IsSuccess = false
ADDERROR(response.StatusCode);
END
```

Citire (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");
```

Contor electric stație de încărcare Contor electric Doar citire

Contor electric — energia totală livrată de stația de încărcare (eto) și puterea de încărcare instantanee

numeric Unitate: kWh json\_path

Citirea consumului total

```taphome
RETURN(PARSEjson(responseJson, "eto"))
```

Citirea cererii

```taphome
VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]");
VAR b := SPLIT(a,",");
RETURN(TODOUBLE(GETAT(b,11))/1000)
```

**Conexiune:** Packet Parser → HTTP

Îmbunătățiri posibile (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 de import

Introduceți aceste valori când importați XML-ul.

| Solicitat în aplicație | Implicit      |
|------------------------|---------------|
| Adresă IP              | `192.168.0.1` |

## Surse

- 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

Documentele producătorilor sunt © ale proprietarilor respectivi. Sunt furnizate așa cum au fost publicate de producător, doar ca referință.

## Documentație asociată

- [Packet Parser Integration](https://taphome.com/ro/compatibility/packet-parser-guide/)
- [Packet Parser (HTTP, TCP, UDP, FTP, MQTT)](https://taphome.com/ro/docs/integration/packet-parser/)
- [Funcții Packet parser](https://taphome.com/ro/docs/script/packet-parser/)
- [Funcții de parsare](https://taphome.com/ro/docs/script/parsing-functions/)

