---
title: "go-e Gemini flex Wallbox"
description: "Integrácia go-e Gemini flex EV wallboxu s TapHome cez HTTP API v2. Ovládanie nabíjacieho prúdu, režimu a prepínania fáz, zasielanie externých FV/sieťových."
url: "https://taphome.com/sk/compatibility/go-e-wallbox/"
language: sk
lastmod: 2026-08-25
generator: hugo
ai:
  topics: ["http","wallbox","ev-charging","wifi","pv-surplus","3-phase"]
  questions: ["Ako integrovať go-e Gemini flex wallbox s TapHome?","Čo ovláda a monitoruje šablóna go-e wallbox v TapHome?","Ako povoliť HTTP API na go-e Charger pre TapHome?","Ako nastaviť prebytkovú FV nabíjanie s go-e wallboxom a TapHome?","Prečo nabíjací prúd go-e wallboxu podporuje len 6 hodnôt?","Ako prepínať medzi 1-fázovým a 3-fázovým nabíjaním na go-e cez TapHome?"]
---

# go-e Gemini flex Wallbox

Komunikácia: Packet Parser → HTTP

- [Oficiálna stránka go-e](https://go-e.com)

> Adresa v sieti
> 
> TapHome komunikuje so zariadením na adrese zadanej pri importe. Dajte zariadeniu stálu adresu — rezerváciu IP v routeri, alebo jeho mDNS meno, ak ho podporuje —, inak integrácia prestane fungovať, keď router adresu zmení.
> 
> [Príprava siete](https://taphome.com/sk/docs/setup/network-preparation/)

## Návod na integráciu

go-e Gemini flex je rakúsky EV wallbox dostupný vo variantoch 11 kW (16 A) a 22 kW (32 A), pričom novší model Gemini flex 2.0 obsahuje integrovaný 4G LTE modul. TapHome komunikuje s nabíjačkou cez lokálne HTTP API v2 po Wi-Fi — nie je potrebné cloudové pripojenie. API je potrebné explicitne povoliť v aplikácii go-e pred pripojením TapHome.

Šablóna poskytuje monitorovanie stavu nabíjačky, ovládanie nabíjacieho prúdu, režimu a vynúteného stavu, prepínanie fáz, meranie napätia a prúdu na jednotlivých fázach, elektromer a zapisovacie vstupy pre externé FV a sieťové dáta umožňujúce prebytkovú nabíjanie.

## Konfigurácia

### Povolenie HTTP API

Lokálne HTTP API v2 je predvolene vypnuté. Na jeho povolenie:

1. Pripojte sa k go-e Charger cez aplikáciu go-e (dostupná pre iOS a Android)
2. Prejdite do **Nastavenia > Pripojenie > Nastavenia API**
3. Povoľte **„Povoliť prístup k lokálnemu HTTP API vX"**

Po povolení nabíjačka odpovedá na HTTP požiadavky na porte 80. Autentifikácia nie je vyžadovaná — prístup sa riadi výlučne týmto prepínačom.

### Nastavenie siete

go-e Gemini flex sa pripája cez **Wi-Fi (802.11b/g/n, len 2,4 GHz)**. Ethernetový port nie je k dispozícii. Pri importe šablóny TapHome zadajte IP adresu nabíjačky.

Nabíjačka môže pracovať v režime hotspot (priame pripojenie) alebo sa pripojiť k existujúcej Wi-Fi sieti. Pre integráciu s TapHome musí byť nabíjačka v rovnakej sieti ako TapHome CCU.

## Možnosti zariadenia

### Stav nabíjačky

Zariadenie Stav nabíjačky zobrazuje aktuálny stav pripojenia a nabíjania ako viachodnotový indikátor (len na čítanie). API kľúč `car` vracia jeden z piatich stavov: **Porucha** (0), **Dostupná** (1), **Nabíjanie** (2), **Príprava** (3) alebo **Dokončené** (4). To umožňuje automatizáciám TapHome reagovať na to, či je vozidlo pripojené, aktívne sa nabíja alebo dokončilo reláciu.

### Ovládanie nabíjacieho prúdu a režimu

Dve ovládateľné zariadenia riadia spôsob fungovania nabíjačky:

- **Nabíjací prúd** — vyberá požadovaný nabíjací prúd zo šiestich diskrétnych hodnôt: 6, 8, 10, 12, 14 a 16 A. Šablóna mapuje tieto hodnoty na pozície prepínača 0–5 pomocou vzorca `amp/2 - 3` pre čítanie a `(position + 3) × 2` pre zápis. Hodnoty sa odosielajú na nabíjačku cez `api/set?amp={value}`.

- **Režim nabíjania** — vyberá logiku nabíjania: **Základný** (predvolené nepretržité nabíjanie), **Eco** (cenovo optimalizované cez tarif Awattar) alebo **Denná cesta** (automatické zastavenie po dosiahnutí cieľa). API používa hodnoty 3, 4 a 5; šablóna ich mapuje na pozície 0, 1 a 2.

> [!NOTE]
> Selektor nabíjacieho prúdu mapuje len šesť hodnôt (6–16 A v krokoch po 2 A). Variant 22 kW nabíjačky Gemini flex podporuje až 32 A, no hodnoty nad 16 A nie sú pokryté touto šablónou. Pre použitie vyšších prúdov je možné nastaviť API kľúč `amp` priamo mimo šablónu.

### Vynútený stav

Zariadenie **Vynútený stav** prebíja vlastné rozhodnutie nabíjačky o tom, či má nabíjať. API kľúč `frc` prijíma hodnoty **Neutrál** (0 — rozhoduje nabíjačka), **Zastavené** (1 — nabíjanie je zablokované) a **Nabíjať** (2 — nabíjanie je vynútené). Hodnota sa zapisuje cez `api/set?frc={value}` a číta sa späť zo stavovej odpovede, preto táto revízia šablóny pridáva `frc` do filtra `api/status`.

> [!NOTE]
> Selektor uvádza aj pozície 3–9 s číselnými zástupnými názvami zdedenými zo šablóny. API go-e im nedáva žiadny význam — používajte len Neutrál, Zastavené a Nabíjať.

### Prepínanie fáz

Zariadenie Prepínanie fáz riadi počet fáz používaných nabíjačkou: **Automaticky** (0), **1-fázový** (1) alebo **3-fázový** (2). go-e Charger podporuje prepínanie fáz aj počas aktívnej nabíjacej relácie. V automatickom režime nabíjačka zvolí optimálnu konfiguráciu fáz podľa dostupného výkonu.

### Meranie energie

Šablóna číta napätie a prúd na jednotlivých fázach z poľa `nrg` nabíjačky, ktoré obsahuje 16 hodnôt aktualizovaných v každom cykle dotazovania:

| Zariadenie | Zdroj | Jednotka |
|------------|-------|----------|
| L1 Napätie | `nrg[0]` | V |
| L2 Napätie | `nrg[1]` | V |
| L3 Napätie | `nrg[2]` | V |
| L1 Prúd | `nrg[4]` | A |
| L2 Prúd | `nrg[5]` | A |
| L3 Prúd | `nrg[6]` | A |

Zariadenie **Elektromer nabíjačky** zobrazuje celkovú dodanú energiu z kľúča `eto` (Wh) a okamžitý odber z `nrg[11]` delený 1000. Nahrádza pôvodné zariadenie Aktuálna spotreba. Všetky energetické hodnoty sú len na čítanie.

> [!WARNING]
> Šablóna číta fázové prúdy z `nrg[4]`, `nrg[5]` a `nrg[6]` a odber elektromera z `nrg[11]`. Dokumentácia API go-e umiestňuje fázové prúdy na indexy 5, 6 a 7, výkon neutrálneho vodiča na index 11 a celkový výkon na index 12 — presne tak to robila predchádzajúca revízia šablóny. Pred použitím na fakturáciu alebo automatizácie si hodnoty overte priamo na nabíjačke.

### Vstupy pre prebytkovú FV nabíjanie

Dve zariadenia (len na zápis) umožňujú TapHome zasielať externé energetické dáta do nabíjačky pre výpočty prebytkovej nabíjania:

- **Výkon do siete** — odosiela aktuálny výkon exportu/importu do siete (v kW, konvertovaný na W násobením 1000) cez `api/set?ids={"pGrid":value}`
- **FV výkon** — odosiela aktuálnu fotovoltaickú produkciu (v kW, konvertovanú na W násobením 1000) cez `api/set?ids={"pPv":value}`

Tieto zariadenia **ne**čítajú dáta z nabíjačky. go-e Charger sám nemeria výkon siete ani FV — spolieha sa na externé zdroje, ktoré mu tieto informácie poskytujú. V typickej konfigurácii TapHome sa hodnoty zo samostatného elektromeru alebo solárneho striedača (tiež integrovaného v TapHome) preposielajú na nabíjačku cez tieto zapisovacie zariadenia, čím sa aktivuje režim Eco na optimalizáciu vlastnej spotreby.

> [!TIP]
> Pre použitie prebytkovej FV nabíjania nastavte režim nabíjania na **Eco** a potom pomocou automatizácií TapHome pravidelne zapisujte aktuálne hodnoty výkonu siete a FV produkcie do zariadení Výkon do siete a FV výkon. Nabíjačka automaticky prispôsobí nabíjací prúd podľa dostupného prebytku.

### Ďalšie možnosti

API go-e Charger v2 sprístupňuje ďalšie dáta, ktoré momentálne nie sú mapované v šablóne: výkon na fázu (W) a účinník, napätie neutrálneho vodiča, celkový výkon (`nrg[12]`), energiu za reláciu (`wh`), kódy chybových stavov, prúdový limit kábla, teplotné senzory, frekvenciu siete, nastavenia energetického limitu a konfiguráciu minimálneho/maximálneho prúdu. Tieto je možné pridať v budúcej aktualizácii šablóny.

## Riešenie problémov

### Zariadenie neodpovedá

1. Overte, že nabíjačka je pripojená k Wi-Fi a má platnú IP adresu — skontrolujte v aplikácii go-e v časti **Nastavenia > Pripojenie**
2. Potvrďte, že HTTP API je povolené (Nastavenia > Pripojenie > Nastavenia API)
3. Otvorte `http://{charger-ip}/api/status` v prehliadači — ak odpovie JSON, API je dostupné
4. Skontrolujte, že TapHome CCU a nabíjačka sú v rovnakej sieti / VLAN

### Nabíjací prúd sa nemení

1. Šablóna mapuje len šesť hodnôt (6, 8, 10, 12, 14, 16 A). Ak nabíjačka zobrazuje inú hodnotu (napr. 20 A nastavenú cez aplikáciu), TapHome zobrazí najbližšiu mapovanú pozíciu
2. Overte, že firmware nabíjačky je verzia 051.4 alebo novšia — starší firmware používa odlišnú syntax filtra, čo môže spôsobiť problémy s parsovaním

### Prebytková FV nabíjanie nefunguje

1. Potvrďte, že režim nabíjania je nastavený na **Eco** — logika prebytku sa aktivuje len v tomto režime
2. Overte, že hodnoty Výkon do siete a FV výkon sa zapisujú pravidelne (aspoň každých 30 sekúnd)
3. Skontrolujte, že hodnoty sú v kW (šablóna ich automaticky konvertuje na W)
4. Otvorte `http://{charger-ip}/api/status?filter=pgrid,ppv` na overenie, že nabíjačka prijíma hodnoty

> [!TIP]
> API kľúč `eto` (celková energia) je teraz sprístupnený ako zariadenie Elektromer nabíjačky — hodnota načítaná vo filtri stavu už neostáva nevyužitá.

## Dostupné zariadenia 14

Tieto zariadenia sa po importe zobrazia v TapHome.

go-e Wallbox Modul

Vlastné premenné

Čítanie (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
```

Stav nabíjačky Viacstavový prepínač Len na čítanie

Stav pripojenia vozidla a nabíjania — Porucha, Dostupná, Nabíjanie, Príprava, Dokončené

uint8

Hodnoty / Stavy: Failure · Available · Charging · Preparing · Finished

Čítanie stavu prepínača

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

Zápis stavu prepínača

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

Nabíjací prúd Viacstavový prepínač Čítanie aj zápis

Selektor požadovaného nabíjacieho prúdu — 6, 8, 10, 12, 14, 16 A v diskrétnych krokoch

uint8 Jednotka: A numeric

Hodnoty / Stavy: 6-Amp · 8-Amp · 10-Amp · 12-Amp · 14-Amp · 16-Amp

Čítanie stavu prepínača

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

Zápis stavu prepínača

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

Režim nabíjania Viacstavový prepínač Čítanie aj zápis

Selektor logiky nabíjania — Základný (nepretržité), Eco (cenovo optimalizované / FV prebytok), Denná cesta (automatické zastavenie pri dosiahnutí cieľa)

uint8 numeric

Hodnoty / Stavy: Basic · Eco · Daily trip

Čítanie stavu prepínača

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

Zápis stavu prepínača

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

Vynútený stav Viacstavový prepínač Čítanie aj zápis

Vynútenie nabíjania — Neutrál necháva rozhodnutie na nabíjačke, Zastavené nabíjanie blokuje, Nabíjať ho vynúti

uint8

Hodnoty / Stavy: Neutral · Stopped · Charge

Čítanie stavu prepínača

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

Zápis stavu prepínača

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

L1 Prúd Premenná Len na čítanie

numeric Jednotka: A json\_path

Čítanie

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

Zápis

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

Čítanie (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 Napätie Premenná Len na čítanie

numeric Jednotka: V json\_path

Čítanie

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

Zápis

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

Čítanie (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 Prúd Premenná Len na čítanie

numeric Jednotka: A json\_path

Čítanie

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

Zápis

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

Čítanie (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 Napätie Premenná Len na čítanie

numeric Jednotka: V json\_path

Čítanie

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

Zápis

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

Čítanie (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 Prúd Premenná Len na čítanie

numeric Jednotka: A json\_path

Čítanie

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

Zápis

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

Čítanie (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 Napätie Premenná Len na čítanie

numeric Jednotka: V json\_path

Čítanie

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

Zápis

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

Čítanie (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");
```

Prepínanie fáz Viacstavový prepínač Čítanie aj zápis

Konfigurácia fáz — Automaticky (rozhoduje nabíjačka), 1-fázový (vynútený), 3-fázový (vynútený). Prepínanie je možné aj počas aktívneho nabíjania.

uint8

Hodnoty / Stavy: Automatic · 1-Phase · 3-Phase

Čítanie stavu prepínača

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

Zápis stavu prepínača

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

Výkon do siete Premenná Čítanie aj zápis

Len na zápis — odosiela externé dáta o výkone siete (kW) na nabíjačku pre výpočty prebytkovej nabíjania

numeric Jednotka: kW json\_path

Zápis

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

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

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

Čítanie (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 výkon Premenná Čítanie aj zápis

Len na zápis — odosiela externé dáta o FV produkcii (kW) na nabíjačku pre výpočty prebytkovej nabíjania

numeric Jednotka: kW json\_path

Zápis

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

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

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

Čítanie (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");
```

Elektromer nabíjačky Elektromer Len na čítanie

Merač energie — celková energia dodaná nabíjačkou (eto) a okamžitý nabíjací výkon

numeric Jednotka: kWh json\_path

Čítanie celkovej spotreby

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

Čítanie odberu

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

**Pripojenie:** Packet Parser → HTTP

Možné vylepšenia (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)

## Parametre importu

Tieto hodnoty zadáte pri importe XML.

| Pýta sa v aplikácii | Predvolené    |
|---------------------|---------------|
| IP adresa           | `192.168.0.1` |

## Zdroje

- 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

Dokumenty výrobcov sú © ich príslušných vlastníkov. Poskytujeme ich tak, ako ich zverejnil výrobca, len na informačné účely.

## Súvisiaca dokumentácia

- [Integrácia Packet Parser](https://taphome.com/sk/compatibility/packet-parser-guide/)
- [Packet Parser (HTTP, TCP, UDP, FTP, MQTT)](https://taphome.com/sk/docs/integration/packet-parser/)
- [Funkcie Packet parsera](https://taphome.com/sk/docs/script/packet-parser/)
- [Parsovacie funkcie](https://taphome.com/sk/docs/script/parsing-functions/)