---
title: "go-e Gemini flex Wallbox"
description: "go-e Gemini flex EV wallbox integráció a TapHome rendszerrel HTTP API v2-n keresztül."
url: "https://taphome.com/hu/compatibility/go-e-wallbox/"
language: hu
lastmod: 2026-08-25
generator: hugo
ai:
  topics: ["http","wallbox","ev-charging","wifi","pv-surplus","3-phase"]
  questions: ["Hogyan integrálható a go-e Gemini flex wallbox a TapHome rendszerrel?","Mit vezérel és monitoroz a go-e wallbox TapHome sablon?","Hogyan engedélyezhető a HTTP API a go-e Chargeren a TapHome számára?","Hogyan állítható be a FV felesleg töltés go-e wallboxszal és TapHome-mal?","Miért támogat a go-e wallbox töltőárama csak 6 értéket?","Hogyan váltható 1 fázisú és 3 fázisú töltés között a go-e-n a TapHome-on keresztül?"]
---

# go-e Gemini flex Wallbox

Kommunikáció: Packet Parser → HTTP

- [go-e hivatalos weboldal](https://go-e.com)

> Hálózati cím
> 
> A TapHome az importáláskor megadott címen éri el az eszközt. Adjon az eszköznek állandó címet — IP-foglalást a routerben, vagy az mDNS-nevét, ha támogatja —, különben az integráció leáll, amikor a router megváltoztatja a címet.
> 
> [A hálózat előkészítése](https://taphome.com/hu/docs/setup/network-preparation/)

## Integrációs útmutató

A go-e Gemini flex egy osztrák gyártású EV wallbox, amely 11 kW (16 A) és 22 kW (32 A) változatban érhető el, az újabb Gemini flex 2.0 modell integrált 4G LTE modullal rendelkezik. A TapHome a helyi HTTP API v2-n keresztül kommunikál a töltővel Wi-Fi-n — felhőkapcsolat nem szükséges. Az API-t a go-e alkalmazásban kifejezetten engedélyezni kell, mielőtt a TapHome csatlakozhatna.

A sablon biztosítja a töltő állapotának monitorozását, a töltőáram, az üzemmód és a kényszerített állapot vezérlését, a fázisváltást, fázisonkénti feszültség- és árammérést, energiamérőt, valamint írásvédett bemeneteket külső FV- és hálózati teljesítményadatokhoz a felesleges energiával történő töltés lehetővé tételéhez.

## Konfiguráció

### A HTTP API engedélyezése

A helyi HTTP API v2 alapértelmezés szerint le van tiltva. Az engedélyezéséhez:

1. Csatlakozzon a go-e Chargerhez a go-e alkalmazáson keresztül (iOS és Android rendszerre elérhető)
2. Navigáljon a **Beállítások > Kapcsolat > API beállítások** menüpontra
3. Engedélyezze a **„Helyi HTTP API vX elérésének engedélyezése"** opciót

Az engedélyezés után a töltő a 80-as porton válaszol HTTP kérésekre. Hitelesítés nem szükséges — a hozzáférést kizárólag ez a kapcsoló szabályozza.

### Hálózati beállítás

A go-e Gemini flex **Wi-Fi-n (802.11b/g/n, csak 2,4 GHz)** keresztül csatlakozik. Ethernet port nem áll rendelkezésre. A TapHome sablon importálásakor adja meg a töltő IP-címét.

A töltő hotspot módban (közvetlen kapcsolat) vagy meglévő Wi-Fi hálózathoz csatlakozva is működhet. A TapHome integrációhoz a töltőnek ugyanazon a hálózaton kell lennie, mint a TapHome CCU-nak.

## Eszközök képességei

### Töltő állapota

A Töltő állapota eszköz az aktuális csatlakozási és töltési állapotot jeleníti meg többértékű indikátorként (csak olvasható). A `car` API kulcs öt állapot egyikét adja vissza: **Hiba** (0), **Elérhető** (1), **Töltés** (2), **Előkészítés** (3) vagy **Befejezve** (4). Ez lehetővé teszi a TapHome automatizációk számára, hogy reagáljanak arra, hogy a jármű csatlakoztatva van-e, aktívan tölt-e, vagy befejezte-e a munkamenetet.

### Töltőáram és üzemmód vezérlése

Két vezérelhető eszköz irányítja a töltő működését:

- **Töltőáram** — a kért töltőáramot hat diszkrét értékből választja ki: 6, 8, 10, 12, 14 és 16 A. A sablon ezeket a 0–5 kapcsolóállásokra képezi le az `amp/2 - 3` képlettel olvasáshoz és a `(position + 3) × 2` képlettel íráshoz. Az értékek az `api/set?amp={value}` végponton keresztül kerülnek a töltőhöz.

- **Töltési üzemmód** — a töltési logikát választja ki: **Alap** (alapértelmezett folyamatos töltés), **Eco** (Awattar tarifa alapján ároptimalizált) vagy **Napi út** (automatikus leállás a cél elérésekor). Az API a 3, 4 és 5 értékeket használja; a sablon ezeket a 0, 1 és 2 pozíciókra képezi le.

> [!NOTE]
> A töltőáram-választó csak hat értéket képez le (6–16 A, 2 A-es lépésekben). A Gemini flex 22 kW-os változata akár 32 A-t is támogat, de a 16 A feletti értékeket ez a sablon nem fedi le. Magasabb áramok használatához az `amp` API kulcs közvetlenül, a sablonon kívül állítható be.

### Kényszerített állapot

A **Kényszerített állapot** eszköz felülbírálja a töltő saját döntését arról, hogy tölt-e. Az `frc` API kulcs a **Semleges** (0 — a töltő dönt), **Leállítva** (1 — a töltés tiltva) és **Töltés** (2 — a töltés kikényszerítve) értékeket fogadja el. Az értéket az `api/set?frc={value}` végpont írja, és az állapotválaszból olvasható vissza, ezért ez a sablonváltozat felveszi az `frc` kulcsot az `api/status` szűrőjébe.

> [!NOTE]
> A választó a sablonból örökölt 3–9 pozíciókat is felsorolja számozott helyőrző címkékkel. A go-e API ezekhez nem rendel jelentést — csak a Semleges, Leállítva és Töltés értékeket használja.

### Fázisváltás

A Fázisváltás eszköz azt szabályozza, hány fázist használ a töltő: **Automatikus** (0), **1 fázisú** (1) vagy **3 fázisú** (2). A go-e Charger támogatja a fázisváltást aktív töltési munkamenet közben is. Automatikus módban a töltő az elérhető teljesítmény alapján választja ki az optimális fáziskonfigurációt.

### Energiamonitorozás

A sablon a töltő `nrg` energiatömbjéből olvassa a fázisonkénti feszültséget és áramot, amely 16 értéket tartalmaz, amelyek minden lekérdezési ciklusban frissülnek:

| Eszköz | Forrás | Egység |
|--------|--------|--------|
| L1 feszültség | `nrg[0]` | V |
| L2 feszültség | `nrg[1]` | V |
| L3 feszültség | `nrg[2]` | V |
| L1 áram | `nrg[4]` | A |
| L2 áram | `nrg[5]` | A |
| L3 áram | `nrg[6]` | A |

A **Fali töltő villamos mérő** eszköz az `eto` kulcsból származó teljes leadott energiát (Wh) és az `nrg[11]` 1000-rel osztott pillanatnyi teljesítményfelvételét jeleníti meg. Az korábbi Aktuális fogyasztás eszközt váltja fel. Minden energiaérték csak olvasható.

> [!WARNING]
> A sablon a fázisáramokat az `nrg[4]`, `nrg[5]` és `nrg[6]` elemekből, a mérő teljesítményfelvételét pedig az `nrg[11]` elemből olvassa. A go-e API dokumentációja a fázisáramokat az 5., 6. és 7., a nullavezető teljesítményét a 11., a teljes teljesítményt pedig a 12. indexre teszi — pontosan így működött az előző sablonváltozat. Számlázás vagy automatizáció előtt ellenőrizze az értékeket a töltőn.

### FV felesleg töltés bemenetek

Két csak írható eszköz lehetővé teszi a TapHome számára, hogy külső energiaadatokat továbbítson a töltőnek a felesleges energiával történő töltés számításaihoz:

- **Hálózati teljesítmény** — az aktuális hálózati export/import teljesítményt küldi (kW-ban, W-ra konvertálva 1000-rel való szorzással) az `api/set?ids={"pGrid":value}` végponton keresztül
- **FV teljesítmény** — az aktuális fotovoltaikus termelést küldi (kW-ban, W-ra konvertálva 1000-rel való szorzással) az `api/set?ids={"pPv":value}` végponton keresztül

Ezek az eszközök **nem** olvasnak adatot a töltőből. A go-e Charger önmagában nem méri a hálózati vagy FV teljesítményt — külső forrásokra támaszkodik ezen információk biztosításához. Egy tipikus TapHome konfigurációban egy különálló energiamérő vagy napelemes inverter (szintén TapHome-ba integrált) értékeit továbbítják a töltőhöz ezeken a csak írható eszközökön keresztül, lehetővé téve az Eco töltési mód számára az önfogyasztás optimalizálását.

> [!TIP]
> A FV felesleg töltés használatához állítsa a Töltési üzemmódot **Eco**-ra, majd TapHome automatizációkkal rendszeresen írja az aktuális hálózati teljesítmény és FV termelés értékeit a Hálózati teljesítmény és FV teljesítmény eszközökbe. A töltő automatikusan igazítja a töltőáramot a rendelkezésre álló felesleg alapján.

### További képességek

A go-e Charger API v2 további adatokat is biztosít, amelyek jelenleg nincsenek leképezve a sablonban: fázisonkénti teljesítmény (W) és teljesítménytényező, nullavezeték feszültsége, teljes teljesítmény (`nrg[12]`), munkamenet energia (`wh`), hibaállapot-kódok, kábel áramkorlátja, hőmérséklet-érzékelők, hálózati frekvencia, energiakorlát-beállítások és minimális/maximális áramerősség konfigurálása. Ezek egy jövőbeli sablonfrissítésben adhatók hozzá.

## Hibaelhárítás

### Az eszköz nem válaszol

1. Ellenőrizze, hogy a töltő csatlakozik-e a Wi-Fi-hez és van-e érvényes IP-címe — ellenőrizze a go-e alkalmazásban a **Beállítások > Kapcsolat** alatt
2. Győződjön meg arról, hogy a HTTP API engedélyezve van (Beállítások > Kapcsolat > API beállítások)
3. Nyissa meg a `http://{charger-ip}/api/status` címet egy böngészőben — ha JSON-nal válaszol, az API elérhető
4. Ellenőrizze, hogy a TapHome CCU és a töltő ugyanazon a hálózaton / VLAN-on van-e

### A töltőáram nem változik

1. A sablon csak hat értéket képez le (6, 8, 10, 12, 14, 16 A). Ha a töltő más értéket mutat (pl. 20 A, amelyet az alkalmazáson keresztül állítottak be), a TapHome a legközelebbi leképezett pozíciót jeleníti meg
2. Ellenőrizze, hogy a töltő firmware-e 051.4-es vagy újabb verziójú — a régebbi firmware eltérő szűrőszintaxist használ, ami értelmezési problémákat okozhat

### A FV felesleg töltés nem működik

1. Győződjön meg arról, hogy a Töltési üzemmód **Eco**-ra van állítva — a felesleg logika csak ebben az üzemmódban aktiválódik
2. Ellenőrizze, hogy a Hálózati teljesítmény és FV teljesítmény értékei rendszeresen íródnak (legalább 30 másodpercenként)
3. Ellenőrizze, hogy az értékek kW-ban vannak megadva (a sablon automatikusan W-ra konvertálja)
4. Nyissa meg a `http://{charger-ip}/api/status?filter=pgrid,ppv` címet annak ellenőrzéséhez, hogy a töltő fogadja-e az értékeket

> [!TIP]
> Az `eto` (összes energia) API kulcs mostantól a Fali töltő villamos mérő eszközként érhető el — az állapotszűrőben lekérdezett érték már nem marad kihasználatlanul.

## Elérhető eszközök 14

Ezek az eszközök az importálás után jelennek meg a TapHome-ban.

go-e Wallbox Modul

Egyéni változók

Olvasás (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
```

Töltő állapota Többértékű kapcsoló Csak olvasható

Járműcsatlakozás és töltési állapot — Hiba, Elérhető, Töltés, Előkészítés, Befejezve

uint8

Értékek / Állapotok: Failure · Available · Charging · Preparing · Finished

Kapcsoló állapot olvasása

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

Kapcsoló állapot írása

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

Töltőáram Többértékű kapcsoló Olvasás és írás

Kért töltőáram választó — 6, 8, 10, 12, 14, 16 A diszkrét lépésekben

uint8 Egység: A numeric

Értékek / Állapotok: 6-Amp · 8-Amp · 10-Amp · 12-Amp · 14-Amp · 16-Amp

Kapcsoló állapot olvasása

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

Kapcsoló állapot írása

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

Töltési üzemmód Többértékű kapcsoló Olvasás és írás

Töltési logika választó — Alap (folyamatos), Eco (ároptimalizált / FV felesleg), Napi út (automatikus leállás célnál)

uint8 numeric

Értékek / Állapotok: Basic · Eco · Daily trip

Kapcsoló állapot olvasása

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

Kapcsoló állapot írása

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

Kényszerített állapot Többértékű kapcsoló Olvasás és írás

Töltés felülbírálása — a Semleges a töltőre bízza a döntést, a Leállítva tiltja a töltést, a Töltés kikényszeríti

uint8

Értékek / Állapotok: Neutral · Stopped · Charge

Kapcsoló állapot olvasása

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

Kapcsoló állapot írása

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

L1 áram Változó Csak olvasható

numeric Egység: A json\_path

Olvasás

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

Írás

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

Olvasás (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 feszültség Változó Csak olvasható

numeric Egység: V json\_path

Olvasás

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

Írás

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

Olvasás (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 áram Változó Csak olvasható

numeric Egység: A json\_path

Olvasás

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

Írás

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

Olvasás (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 feszültség Változó Csak olvasható

numeric Egység: V json\_path

Olvasás

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

Írás

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

Olvasás (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 áram Változó Csak olvasható

numeric Egység: A json\_path

Olvasás

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

Írás

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

Olvasás (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 feszültség Változó Csak olvasható

numeric Egység: V json\_path

Olvasás

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

Írás

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

Olvasás (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");
```

Fázisváltás Többértékű kapcsoló Olvasás és írás

Fáziskonfiguráció — Automatikus (töltő dönt), 1 fázisú (kényszerített), 3 fázisú (kényszerített). Váltás aktív töltés közben is lehetséges.

uint8

Értékek / Állapotok: Automatic · 1-Phase · 3-Phase

Kapcsoló állapot olvasása

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

Kapcsoló állapot írása

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

Hálózati teljesítmény Változó Olvasás és írás

Csak írható — külső hálózati teljesítményadatokat (kW) küld a töltőnek a felesleges energiával történő töltés számításaihoz

numeric Egység: kW json\_path

Írás

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

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

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

Olvasás (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");
```

FV teljesítmény Változó Olvasás és írás

Csak írható — külső FV termelési adatokat (kW) küld a töltőnek a felesleges energiával történő töltés számításaihoz

numeric Egység: kW json\_path

Írás

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

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

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

Olvasás (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");
```

Fali töltő villamos mérő Villanyóra Csak olvasható

Energiamérő — a töltő által leadott összes energia (eto) és a pillanatnyi töltési teljesítmény

numeric Egység: kWh json\_path

Összes fogyasztás olvasása

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

Igény olvasása

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

**Kapcsolat:** Packet Parser → HTTP

Lehetséges fejlesztések (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)

## Importálási paraméterek

Ezeket az értékeket az XML importálásakor adja meg.

| Az alkalmazás kéri | Alapérték     |
|--------------------|---------------|
| IP-cím             | `192.168.0.1` |

## Források

- 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

A gyártói dokumentumok © a mindenkori tulajdonosaikat illetik. A gyártó által közzétett formában, kizárólag tájékoztatásul tesszük elérhetővé őket.

## Kapcsolódó dokumentáció

- [Packet Parser integráció](https://taphome.com/hu/compatibility/packet-parser-guide/)
- [Packet Parser (HTTP, TCP, UDP, FTP, MQTT)](https://taphome.com/hu/docs/integration/packet-parser/)
- [Packet parser függvények](https://taphome.com/hu/docs/script/packet-parser/)
- [Elemző függvények](https://taphome.com/hu/docs/script/parsing-functions/)