--- title: "go-e Gemini flex Wallbox" description: "Wallbox go-e Gemini flex w TapHome przez lokalne HTTP API v2: prąd i tryb ładowania, przełączanie faz, energia i dane PV do ładowania nadwyżką." url: "https://taphome.com/pl/compatibility/go-e-wallbox/" language: pl lastmod: 2026-08-25 generator: hugo ai: topics: ["http","wallbox","ev-charging","wifi","pv-surplus","3-phase"] questions: ["Jak zintegrować wallbox go-e Gemini flex z TapHome?","Co kontroluje i monitoruje szablon go-e wallbox w TapHome?","Jak włączyć HTTP API na go-e Charger dla TapHome?","Jak skonfigurować ładowanie nadwyżką FV z go-e wallboxem i TapHome?","Dlaczego prąd ładowania go-e wallboxa obsługuje tylko 6 wartości?","Jak przełączać między ładowaniem 1-fazowym i 3-fazowym na go-e przez TapHome?"] --- # go-e Gemini flex Wallbox Komunikacja: Packet Parser → HTTP - [Oficjalna strona go-e](https://go-e.com) > Adres w sieci > > TapHome łączy się z urządzeniem pod adresem podanym przy imporcie. Nadaj urządzeniu stały adres — rezerwację IP w routerze albo jego nazwę mDNS, jeśli ją obsługuje — inaczej integracja przestanie działać, gdy router zmieni adres. > > [Przygotowanie sieci](https://taphome.com/pl/docs/setup/network-preparation/) ## Poradnik integracji go-e Gemini flex to austriacki wallbox EV dostępny w wariantach 11 kW (16 A) i 22 kW (32 A), a nowszy model Gemini flex 2.0 posiada zintegrowany moduł 4G LTE. TapHome komunikuje się z ładowarką poprzez lokalne HTTP API v2 przez Wi-Fi — połączenie z chmurą nie jest wymagane. API należy jawnie włączyć w aplikacji go-e, zanim TapHome będzie mógł się połączyć. Szablon zapewnia monitorowanie stanu ładowarki, sterowanie prądem, trybem ładowania i wymuszonym stanem, przełączanie faz, odczyty napięcia i prądu na poszczególnych fazach, licznik energii oraz wejścia tylko do zapisu dla zewnętrznych danych mocy FV i sieciowej umożliwiające ładowanie nadwyżką. ## Konfiguracja ### Włączenie HTTP API Lokalne HTTP API v2 jest domyślnie wyłączone. Aby je włączyć: 1. Połącz się z go-e Charger przez aplikację go-e (dostępna na iOS i Android) 2. Przejdź do **Ustawienia > Połączenie > Ustawienia API** 3. Włącz **„Zezwól na dostęp do lokalnego HTTP API vX"** Po włączeniu ładowarka odpowiada na żądania HTTP na porcie 80. Uwierzytelnianie nie jest wymagane — dostęp jest kontrolowany wyłącznie przez ten przełącznik. ### Konfiguracja sieci go-e Gemini flex łączy się przez **Wi-Fi (802.11b/g/n, tylko 2,4 GHz)**. Port Ethernet nie jest dostępny. Podczas importu szablonu TapHome wprowadź adres IP ładowarki. Ładowarka może działać w trybie hotspot (połączenie bezpośrednie) lub dołączyć do istniejącej sieci Wi-Fi. Do integracji z TapHome ładowarka musi znajdować się w tej samej sieci co TapHome CCU. ## Możliwości urządzenia ### Stan ładowarki Urządzenie Stan ładowarki raportuje bieżący stan połączenia i ładowania jako wielowartościowy wskaźnik (tylko do odczytu). Klucz API `car` zwraca jeden z pięciu stanów: **Awaria** (0), **Dostępna** (1), **Ładowanie** (2), **Przygotowanie** (3) lub **Zakończone** (4). Umożliwia to automatyzacjom TapHome reagowanie na to, czy pojazd jest podłączony, aktywnie się ładuje, czy zakończył sesję. ### Sterowanie prądem i trybem ładowania Dwa sterowalne urządzenia zarządzają sposobem działania ładowarki: - **Prąd ładowania** — wybiera żądany prąd ładowania spośród sześciu dyskretnych wartości: 6, 8, 10, 12, 14 i 16 A. Szablon mapuje je na pozycje przełącznika 0–5 za pomocą wzoru `amp/2 - 3` do odczytu i `(position + 3) × 2` do zapisu. Wartości są wysyłane do ładowarki przez `api/set?amp={value}`. - **Tryb ładowania** — wybiera logikę ładowania: **Podstawowy** (domyślne ciągłe ładowanie), **Eco** (optymalizacja cenowa przez taryfę Awattar) lub **Codzienna trasa** (automatyczne zatrzymanie po osiągnięciu celu). API używa wartości 3, 4 i 5; szablon mapuje je na pozycje 0, 1 i 2. > [!NOTE] > Selektor prądu ładowania mapuje tylko sześć wartości (6–16 A w krokach co 2 A). Wariant 22 kW ładowarki Gemini flex obsługuje do 32 A, ale wartości powyżej 16 A nie są objęte tym szablonem. Aby użyć wyższych prądów, klucz API `amp` można ustawić bezpośrednio poza szablonem. ### Wymuszony stan Urządzenie **Wymuszony stan** nadpisuje własną decyzję ładowarki o tym, czy ma ładować. Klucz API `frc` przyjmuje wartości **Neutralny** (0 — decyduje ładowarka), **Zatrzymane** (1 — ładowanie zablokowane) i **Ładuj** (2 — ładowanie wymuszone). Wartość zapisywana jest przez `api/set?frc={value}` i odczytywana z odpowiedzi statusu, dlatego ta wersja szablonu dodaje `frc` do filtra `api/status`. > [!NOTE] > Selektor wymienia również pozycje 3–9 z liczbowymi etykietami zastępczymi odziedziczonymi z szablonu. API go-e nie nadaje im żadnego znaczenia — używaj wyłącznie wartości Neutralny, Zatrzymane i Ładuj. ### Przełączanie faz Urządzenie Przełączanie faz kontroluje liczbę faz używanych przez ładowarkę: **Automatyczne** (0), **1-fazowe** (1) lub **3-fazowe** (2). go-e Charger obsługuje przełączanie faz nawet podczas aktywnej sesji ładowania. W trybie automatycznym ładowarka wybiera optymalną konfigurację faz na podstawie dostępnej mocy. ### Monitorowanie energii Szablon odczytuje napięcie i prąd na poszczególnych fazach z tablicy energetycznej `nrg` ładowarki, która zawiera 16 wartości aktualizowanych w każdym cyklu odpytywania: | Urządzenie | Źródło | Jednostka | |------------|--------|-----------| | L1 Napięcie | `nrg[0]` | V | | L2 Napięcie | `nrg[1]` | V | | L3 Napięcie | `nrg[2]` | V | | L1 Prąd | `nrg[4]` | A | | L2 Prąd | `nrg[5]` | A | | L3 Prąd | `nrg[6]` | A | Urządzenie **Licznik energii ładowarki** raportuje całkowitą dostarczoną energię z klucza `eto` (Wh) oraz chwilowy pobór z `nrg[11]` podzielony przez 1000. Zastępuje wcześniejsze urządzenie Bieżące zużycie. Wszystkie wartości energetyczne są tylko do odczytu. > [!WARNING] > Szablon odczytuje prądy fazowe z `nrg[4]`, `nrg[5]` i `nrg[6]`, a pobór licznika z `nrg[11]`. Dokumentacja API go-e umieszcza prądy fazowe pod indeksami 5, 6 i 7, moc przewodu neutralnego pod indeksem 11, a moc całkowitą pod indeksem 12 — dokładnie tak działała poprzednia wersja szablonu. Przed użyciem do rozliczeń lub automatyzacji sprawdź odczyty na ładowarce. ### Wejścia do ładowania nadwyżką FV Dwa urządzenia tylko do zapisu umożliwiają TapHome przesyłanie zewnętrznych danych energetycznych do ładowarki w celu obliczania ładowania nadwyżką: - **Moc do sieci** — wysyła bieżącą moc eksportu/importu sieciowego (w kW, przeliczoną na W przez pomnożenie przez 1000) przez `api/set?ids={"pGrid":value}` - **Moc FV** — wysyła bieżącą produkcję fotowoltaiczną (w kW, przeliczoną na W przez pomnożenie przez 1000) przez `api/set?ids={"pPv":value}` Te urządzenia **nie** odczytują danych z ładowarki. go-e Charger sam nie mierzy mocy sieciowej ani FV — polega na zewnętrznych źródłach dostarczających te informacje. W typowej konfiguracji TapHome wartości z oddzielnego licznika energii lub falownika solarnego (również zintegrowanego z TapHome) są przekazywane do ładowarki przez te urządzenia tylko do zapisu, umożliwiając tryb ładowania Eco optymalizację samozużycia. > [!TIP] > Aby korzystać z ładowania nadwyżką FV, ustaw Tryb ładowania na **Eco**, a następnie za pomocą automatyzacji TapHome regularnie zapisuj bieżące wartości mocy sieciowej i produkcji FV do urządzeń Moc do sieci i Moc FV. Ładowarka automatycznie dostosuje prąd ładowania na podstawie dostępnej nadwyżki. ### Dodatkowe możliwości API go-e Charger v2 udostępnia dodatkowe dane, które obecnie nie są mapowane w szablonie: moc na fazę (W) i współczynnik mocy, napięcie przewodu neutralnego, moc całkowita (`nrg[12]`), energia sesji (`wh`), kody stanów błędów, limit prądu kabla, czujniki temperatury, częstotliwość sieci, ustawienia limitu energii oraz konfiguracja minimalnego/maksymalnego prądu. Mogą zostać dodane w przyszłej aktualizacji szablonu. ## Rozwiązywanie problemów ### Urządzenie nie odpowiada 1. Sprawdź, czy ładowarka jest połączona z Wi-Fi i ma prawidłowy adres IP — sprawdź w aplikacji go-e w sekcji **Ustawienia > Połączenie** 2. Potwierdź, że HTTP API jest włączone (Ustawienia > Połączenie > Ustawienia API) 3. Otwórz `http://{charger-ip}/api/status` w przeglądarce — jeśli odpowiada JSON-em, API jest osiągalne 4. Sprawdź, czy TapHome CCU i ładowarka są w tej samej sieci / VLAN ### Prąd ładowania się nie zmienia 1. Szablon mapuje tylko sześć wartości (6, 8, 10, 12, 14, 16 A). Jeśli ładowarka pokazuje inną wartość (np. 20 A ustawione przez aplikację), TapHome wyświetli najbliższą zmapowaną pozycję 2. Sprawdź, czy firmware ładowarki to wersja 051.4 lub nowsza — starszy firmware używa innej składni filtra, co może powodować problemy z parsowaniem ### Ładowanie nadwyżką FV nie działa 1. Potwierdź, że Tryb ładowania jest ustawiony na **Eco** — logika nadwyżki aktywuje się tylko w tym trybie 2. Sprawdź, czy wartości Moc do sieci i Moc FV są zapisywane regularnie (co najmniej co 30 sekund) 3. Sprawdź, czy wartości są w kW (szablon automatycznie konwertuje na W) 4. Otwórz `http://{charger-ip}/api/status?filter=pgrid,ppv` aby sprawdzić, czy ładowarka odbiera wartości > [!TIP] > Klucz API `eto` (całkowita energia) jest teraz udostępniony jako urządzenie Licznik energii ładowarki — wartość pobierana w filtrze stanu nie pozostaje już niewykorzystana. ## Dostępne urządzenia 14 Te urządzenia pojawią się w TapHome po imporcie. go-e Wallbox Moduł Zmienne niestandardowe Odczyt (moduł) ```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 ``` Stan ładowarki Przełącznik wielowartościowy Tylko do odczytu Stan połączenia pojazdu i ładowania — Awaria, Dostępna, Ładowanie, Przygotowanie, Zakończone uint8 Wartości / Stany: Failure · Available · Charging · Preparing · Finished Odczyt stanu przełącznika ```taphome RETURN(PARSEjson(responseJson, "car")); ``` Zapis stanu przełącznika ```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 ``` Prąd ładowania Przełącznik wielowartościowy Odczyt i zapis Selektor żądanego prądu ładowania — 6, 8, 10, 12, 14, 16 A w dyskretnych krokach uint8 Jednostka: A numeric Wartości / Stany: 6-Amp · 8-Amp · 10-Amp · 12-Amp · 14-Amp · 16-Amp Odczyt stanu przełącznika ```taphome VAR ampers := PARSEjson(responseJson, "amp"); RETURN(ampers/2-3); ``` Zapis stanu przełącznika ```taphome VAR amps:= (Mu +3)*2; VAR response := SENDHTTPREQUEST("api/set?amp=" + amps); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` Tryb ładowania Przełącznik wielowartościowy Odczyt i zapis Selektor logiki ładowania — Podstawowy (ciągłe), Eco (optymalizacja cenowa / nadwyżka FV), Codzienna trasa (automatyczne zatrzymanie przy celu) uint8 numeric Wartości / Stany: Basic · Eco · Daily trip Odczyt stanu przełącznika ```taphome RETURN(PARSEjson(responseJson, "lmo")-3); ``` Zapis stanu przełącznika ```taphome VAR response := SENDHTTPREQUEST("api/set?lmo=" + (Mu+3)); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` Wymuszony stan Przełącznik wielowartościowy Odczyt i zapis Wymuszenie ładowania — Neutralny pozostawia decyzję ładowarce, Zatrzymane blokuje ładowanie, Ładuj je wymusza uint8 Wartości / Stany: Neutral · Stopped · Charge Odczyt stanu przełącznika ```taphome RETURN(PARSEjson(responseJson, "frc")); ``` Zapis stanu przełącznika ```taphome VAR response := SENDHTTPREQUEST("api/set?frc=" + (Mu)); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` L1 Prąd Zmienna Tylko do odczytu numeric Jednostka: A json\_path Odczyt ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,4))) ``` Zapis ```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 ``` Odczyt (moduł) ```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 Napięcie Zmienna Tylko do odczytu numeric Jednostka: V json\_path Odczyt ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,0))) ``` Zapis ```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 ``` Odczyt (moduł) ```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 Zmienna Tylko do odczytu numeric Jednostka: A json\_path Odczyt ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,5))) ``` Zapis ```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 ``` Odczyt (moduł) ```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 Napięcie Zmienna Tylko do odczytu numeric Jednostka: V json\_path Odczyt ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,1))) ``` Zapis ```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 ``` Odczyt (moduł) ```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 Zmienna Tylko do odczytu numeric Jednostka: A json\_path Odczyt ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,6))) ``` Zapis ```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 ``` Odczyt (moduł) ```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 Napięcie Zmienna Tylko do odczytu numeric Jednostka: V json\_path Odczyt ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,2))) ``` Zapis ```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 ``` Odczyt (moduł) ```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"); ``` Przełączanie faz Przełącznik wielowartościowy Odczyt i zapis Konfiguracja faz — Automatyczne (ładowarka decyduje), 1-fazowe (wymuszone), 3-fazowe (wymuszone). Przełączanie możliwe także podczas aktywnego ładowania. uint8 Wartości / Stany: Automatic · 1-Phase · 3-Phase Odczyt stanu przełącznika ```taphome RETURN(PARSEjson(responseJson, "psm")); ``` Zapis stanu przełącznika ```taphome VAR response := SENDHTTPREQUEST("api/set?psm=" + Mu); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` Moc do sieci Zmienna Odczyt i zapis Tylko do zapisu — wysyła zewnętrzne dane mocy sieciowej (kW) do ładowarki do obliczeń ładowania nadwyżką numeric Jednostka: kW json\_path Zapis ```taphome VAR pgrid := "{\"pGrid\":"+ Round(Va*1000)+"}"; VAR response := SENDHTTPREQUEST("api/set?ids=" + pgrid); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` Odczyt (moduł) ```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"); ``` Moc FV Zmienna Odczyt i zapis Tylko do zapisu — wysyła zewnętrzne dane produkcji FV (kW) do ładowarki do obliczeń ładowania nadwyżką numeric Jednostka: kW json\_path Zapis ```taphome VAR pPv := "{\"pPv\":"+ Round(Va*1000)+"}"; VAR response := SENDHTTPREQUEST("api/set?ids=" + pPv); IF response.IsSuccess = false ADDERROR(response.StatusCode); END ``` Odczyt (moduł) ```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"); ``` Licznik energii ładowarki Licznik energii Tylko do odczytu Licznik energii — całkowita energia dostarczona przez ładowarkę (eto) i chwilowa moc ładowania numeric Jednostka: kWh json\_path Odczyt całkowitego zużycia ```taphome RETURN(PARSEjson(responseJson, "eto")) ``` Odczyt zapotrzebowania ```taphome VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]"); VAR b := SPLIT(a,","); RETURN(TODOUBLE(GETAT(b,11))/1000) ``` **Połączenie:** Packet Parser → HTTP Możliwe ulepszenia (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) ## Parametry importu Te wartości podajesz podczas importu pliku XML. | Pytanie w aplikacji | Domyślnie | |---------------------|---------------| | Adres IP | `192.168.0.1` | ## Źródła - 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 producentów są © ich właścicieli. Udostępniamy je w formie opublikowanej przez producenta, wyłącznie w celach informacyjnych. ## Powiązana dokumentacja - [Integracja Packet Parser](https://taphome.com/pl/compatibility/packet-parser-guide/) - [Packet Parser (HTTP, TCP, UDP, FTP, MQTT)](https://taphome.com/pl/docs/integration/packet-parser/) - [Funkcje Packet parser](https://taphome.com/pl/docs/script/packet-parser/) - [Funkcje parsowania](https://taphome.com/pl/docs/script/parsing-functions/)