--- title: "Shelly i3" description: "Shelly i3 ohne Relais lokal per HTTP: drei Taster- oder Schaltereingänge mit Einzel-, Doppel-, Dreifach- und Langklick als Ereignisse in TapHome." url: "https://taphome.com/de/compatibility/shelly-i3/" language: de lastmod: 2026-04-26 generator: hugo ai: topics: ["http","i/o-module","wifi","digital-input","push-button","reed-contact","3-channel","mdns"] questions: ["Wie integriere ich Shelly i3 mit TapHome?","Wie erkennt man Tastendrücke mit Shelly i3 in TapHome?","Wie verbindet man Shelly i3 über HTTP mit TapHome?","Was ist der Unterschied zwischen Toggle- und Momentary-Modus bei Shelly i3?","Warum erkennt Shelly i3 in TapHome keine Doppel- oder Dreifach-Drücke?","Kann Shelly i3 Relais direkt steuern?","Wie viele Aktionen kann Shelly i3 auslösen?"] --- # Shelly i3 Kommunikation: Packet Parser → HTTP - [Shelly i3 Produktseite](https://www.shelly.com/products/shop/shelly-i3) - [Shelly i3 Wissensdatenbank](https://kb.shelly.cloud/knowledge-base/shelly-i3) - [Shelly Gen1 API-Referenz](https://shelly-api-docs.shelly.cloud/gen1/#shelly-i3) > Netzwerkadresse > > TapHome erreicht dieses Gerät unter der beim Import eingegebenen Adresse. Geben Sie dem Gerät eine feste Adresse — eine IP-Reservierung im Router oder seinen mDNS-Namen, falls es einen unterstützt —, sonst funktioniert die Integration nicht mehr, sobald der Router die Adresse ändert. > > [Netzwerkvorbereitung](https://taphome.com/de/docs/setup/network-preparation/) ## Integrationsanleitung Der Shelly i3 ist eine kompakte Wi-Fi 3-Eingangs-Aktions- und Szenensteuerung (Modell `SHIX3-1`). Er hat keine Relais oder Ausgänge — er fungiert ausschließlich als Eingabegerät, das drei externe Schalter oder Taster überwacht, die an die Klemmen SW1, SW2 und SW3 angeschlossen sind. Die Abmessungen 40 × 36 × 10 mm ermöglichen die Installation in einer Standard-Unterputzdose hinter einem bestehenden Wandschalter. Er wird mit 110–230 VAC (Neutralleiter erforderlich) oder 24–60 VDC betrieben und verbraucht weniger als 1 W. TapHome kommuniziert mit dem Gerät über HTTP im lokalen Wi-Fi-Netzwerk — eine Cloud-Verbindung ist nicht erforderlich. Für jeden Eingang erstellt die Vorlage zwei Geräte: einen Multi-Wert-Schalter, der Multi-Klick-Ereignisse dekodiert (Einzel-, Doppel-, Dreifach-, Lang- und kombinierte Sequenzen), und einen Reed-Kontakt, der den rohen 0/1-Eingangszustand sowie eine Service-Aktion zum Umschalten zwischen Toggle- und Momentary-Modus bereitstellt. ## Einrichtung ### Wi-Fi-Kopplung und IP-Adresse Nach dem Einschalten startet der i3 im Access-Point-Modus mit der SSID `shellyi3-XXXXXX` (wobei `XXXXXX` die letzten 6 Hex-Ziffern der MAC sind). Zum Koppeln mit dem Heimnetzwerk: 1. Verbinde Telefon oder Laptop mit dem i3 Access Point 2. Öffne `http://192.168.33.1` im Browser (oder verwende die Shelly Mobile App) 3. Gehe in der Web-Oberfläche zu **Internet & Security → WIFI MODE - CLIENT**, gib die WLAN-Zugangsdaten ein und speichere 4. Das Gerät startet neu und tritt dem Heimnetzwerk per DHCP bei Die zugewiesene IP-Adresse findest du in der DHCP-Lease-Tabelle des Routers oder über den mDNS-Hostnamen `shellyi3-XXXXXXXXXXXX.local` (12-stelliger MAC-Suffix, angekündigt als `_http._tcp.local.`). Beim Import der TapHome-Vorlage gib diese IP-Adresse als einzigen erforderlichen Parameter ein. ### HTTP-Authentifizierung deaktivieren TapHome kann sich nicht gegen das Gerät authentifizieren. Gehe in der Shelly-Weboberfläche zu **Internet & Security → RESTRICT LOGIN** und stelle sicher, dass diese Option **deaktiviert** ist, bevor du die Vorlage importierst — sonst schlägt jede Abfrage mit HTTP 401 fehl. ### Tastentyp-Konfiguration Jeder der drei Eingänge kann in einem von fünf `btn_type`-Modi laufen. Nur zwei sind für TapHome relevant und werden als Service-Aktion auf den Geräten I1 / I2 / I3 bereitgestellt: - **Momentary** — für Taster. Die Firmware dekodiert einzelnen kurzen Druck (`S`), langen Druck (`L`), doppelten kurzen Druck (`SS`), dreifachen kurzen Druck (`SSS`), kurz→lang (`SL`) und lang→kurz (`LS`). Erforderlich, damit die **Events I{N}**-Geräte etwas anderes als `None` auslösen. - **Toggle** — für klassische Wipp- oder Kippschalter. Es wird nur der rohe 0/1-Zustand gemeldet; der Multi-Wert-Schalter bleibt auf Index 0. Der Tastentyp kann jederzeit von TapHome über die Service-Aktion **Button Type** auf jedem I1 / I2 / I3-Gerät geändert werden, oder direkt in der Shelly-Weboberfläche unter **Settings → Input/Output settings**. > [!NOTE] > Die Firmware unterstützt auch die Modi `edge`, `detached` und `action`, diese werden jedoch nicht in der TapHome-Vorlage bereitgestellt. Sie können trotzdem über die Shelly-Weboberfläche eingestellt werden, ohne die Integration zu beeinträchtigen — nur das Multi-Klick-Dekodierungsverhalten ändert sich. ## Gerätefunktionen ### Multi-Klick-Ereignisdekodierung (Events I1, Events I2, Events I3) Für jeden Eingang dekodiert ein Multi-Wert-Schalter den firmware-seitigen Ereigniscode in einen von sieben Werten: | Index | Ereignis | Shelly-Code | |-------|----------|-------------| | 0 | None | `""` (idle) | | 1 | Shortpush | `S` | | 2 | Longpush | `L` | | 3 | Double Shortpush | `SS` | | 4 | Triple Shortpush | `SSS` | | 5 | Shortpush + Longpush | `SL` | | 6 | Longpush + Shortpush | `LS` | Die Vorlage fragt `/input/{0,1,2}` alle 2,5 Sekunden ab und liest das Feld `event`. Mit 6 Ereignissen × 3 Eingängen vermarktet Shelly den i3 als Unterstützung für **bis zu 18 verschiedene Multi-Klick-Aktionen** (24, wenn rohe On/Off-Zustandsänderungen als separate Auslöser gezählt werden). Der Long-Push-Schwellwert und das Multi-Push-Fenster sind global auf dem Gerät konfiguriert (Standardwerte: 800 ms für Langdruck, 500 ms Inter-Druck-Fenster). Sie können in der Shelly-Weboberfläche unter **Settings → Long Push Duration** und **Multi Push Time** angepasst werden. ### Roher Eingangszustand und Tastentyp-Steuerung (I1, I2, I3) Für jeden Eingang stellt ein Reed-Kontakt-Gerät den rohen logischen Zustand bereit, der aus dem `input`-Feld in `/input/{N}` gelesen wird (0 = offen, 1 = geschlossen, nach optionaler `btn_reverse`-Umkehrung). Jedes I1 / I2 / I3-Gerät enthält außerdem: - **Button Type** — Service-Attribut mit dem aktuellen `btn_type`-Wert (toggle / momentary / edge / detached / action) - **Button Type** — Service-Aktion, die den Eingang zwischen Toggle und Momentary umschaltet, indem sie `POST /settings/input/{N}?btn_type=...` schreibt Der rohe Zustand eignet sich für Magnetkontakte von Türen / Fenstern, die an die SW-Klemmen verdrahtet sind, oder für die Echtzeitverfolgung der Position eines Kippschalters. ### Service-Diagnostik Ein einzelnes Service-Attribut auf Modulebene stellt die **Wi-Fi-SSID** bereit, mit der der i3 derzeit verbunden ist (gelesen aus `/status` → `wifi_sta.ssid`). Andere Gen1-Diagnostiken (Uptime, MAC, RSSI, Firmware-Update-Flag) sind über die REST-API des Geräts verfügbar, werden aber in dieser Vorlage nicht bereitgestellt. > [!TIP] > Multi-Klick-Ereignisse werden nur im **Momentary**-Modus ausgelöst. Wenn ein physischer Eingang über einen klassischen Kippschalter verdrahtet ist, konfiguriere diesen Eingang als **Toggle** und verwende das Reed-Kontakt-Gerät I{N}, um seinen 0/1-Zustand zu lesen — das entsprechende Events I{N}-Gerät bleibt auf Index 0. ## Fehlerbehebung ### Multi-Klick-Ereignisse werden nicht erkannt 1. Überprüfe, ob der Eingang im **Momentary**-Modus ist — öffne das I{N}-Gerät in TapHome, führe die Service-Aktion **Button Type** aus und wähle Momentary, oder stelle es direkt in der Shelly-Weboberfläche unter **Settings → Input/Output settings** ein 2. Im Toggle-Modus meldet die Firmware nur Zustandsänderungen; der Events I{N}-Multi-Wert-Schalter bleibt auf Index 0 3. Passe **Long Push Duration** (Standard 800 ms) und **Multi Push Time** (Standard 500 ms) in der Shelly-Weboberfläche an, wenn Drücke als falsches Ereignis dekodiert werden 4. Lange Sequenzen wie `SSS`, `SL` oder `LS` erfordern, dass der Benutzer alle Drücke innerhalb des Multi-Push-Fensters hält — Pausen, die länger als dieses Fenster sind, werden als separate `S`-Ereignisse dekodiert ### Dasselbe Ereignis wiederholt sich für immer / „festgefahrenes" Ereignis Das von `/input/{N}` zurückgegebene Feld `event` ist **das letzte dekodierte Ereignis** — die Firmware löscht es nicht automatisch. TapHome liest dieses Feld bei jeder Abfrage, sodass der Multi-Wert-Schalter das vorherige Ereignis weiterhin meldet, bis ein neues auftritt. Dies ist normales Verhalten und weist nicht auf einen Fehler hin. Beim Schreiben benutzerdefinierter Logik, die bei jedem Druck ausgelöst wird, paare das Ereignis mit dem monotonen `event_cnt`-Zähler (ebenfalls in `/input/{N}` verfügbar), um eine Änderung zu erkennen, anstatt sich nur auf den `event`-Wert zu verlassen. ### Gerät reagiert nicht 1. Überprüfe, ob der i3 mit Wi-Fi verbunden ist — öffne `http://{device-ip}/shelly` im Browser; wenn ein JSON-Objekt zurückgegeben wird, ist das Gerät erreichbar 2. Versuche den mDNS-Hostnamen `shellyi3-XXXXXXXXXXXX.local` anstelle der IP-Adresse — die IP kann sich nach einer DHCP-Erneuerung geändert haben 3. Stelle sicher, dass die HTTP-Authentifizierung unter **Internet & Security → Restrict login** **deaktiviert** ist — TapHome kann keine Anmeldedaten senden und jede Anfrage gibt HTTP 401 zurück 4. Überprüfe, ob TapHome Core und das Shelly-Gerät sich im selben Netzwerk oder VLAN mit erlaubtem mDNS / Multicast befinden > [!WARNING] > Gen1 Shelly-Geräte akzeptieren **maximal 2 gleichzeitige HTTP-Verbindungen**. Die mitgelieferte Vorlage fragt jeden Eingang in 2,5-s-Intervallen ab, was bereits nahe am Limit liegt. **Senke** das Abfrageintervall **nicht** und vermeide den Betrieb eines anderen Systems (z. B. Home Assistant, eigene Skripte), das denselben i3 gleichzeitig abfragt — die Kommunikation kann unzuverlässig werden. > [!NOTE] > Die XML-Vorlage enthält drei reservierte Multi-Wert-Indizes (7, 8, 9 mit Rohcodes 71/72/73 und generischen Bezeichnungen „7" / „8" / „9"). Die Gen1-Firmware sendet keine Ereignisse außer `S`, `L`, `SS`, `SSS`, `SL` und `LS`, sodass diese Indizes ungenutzte Platzhalter sind und der Wert des Events I{N}-Geräts in der Praxis niemals 7-9 erreichen sollte. ## Installation in TapHome ### Voraussetzungen - Shelly-Gerät installiert und eingeschaltet - Lokales Wi-Fi-Netzwerk (2,4 GHz) - TapHome CCU im selben Netzwerk ### Schritt 1 — Shelly mit Wi-Fi verbinden **Option A — Shelly-App (empfohlen):** 1. Laden Sie die [Shelly-App](https://www.shelly.com/en/support/shelly-app) herunter (iOS / Android) 2. Tippen Sie auf **+** → **Add Device** und folgen Sie dem Bluetooth-Kopplungsassistenten 3. Geben Sie Ihre Wi-Fi-Zugangsdaten ein, wenn Sie dazu aufgefordert werden **Option B — AP-Modus (ohne App):** 1. Beim ersten Einschalten erstellt das Gerät einen Hotspot: `ShellyXXX-AABBCCDDEE` 2. Verbinden Sie Ihr Telefon/PC mit diesem Hotspot 3. Öffnen Sie `http://192.168.33.1` → **Internet & Security** → **Wi-Fi Mode - Client** 4. Geben Sie SSID und Passwort ein → **Save** > [!NOTE] > Shelly unterstützt nur **2,4 GHz**-Netzwerke. 5 GHz-Netzwerke werden beim Scannen nicht angezeigt. ### Schritt 2 — IP-Adresse ermitteln Nach der Verbindung mit Wi-Fi ermitteln Sie die zugewiesene IP-Adresse auf eine der folgenden Arten: - **Shelly-App:** Gerätedetail → **Device info** → IP-Adresse - **Shelly-Weboberfläche:** Verbinden Sie sich mit dem Geräte-AP vor der Wi-Fi-Einrichtung — die IP wird nach dem Speichern angezeigt - **Router-DHCP-Tabelle:** Suchen Sie nach einem Hostnamen wie `shelly1pm-AABBCCDDEE` - **mDNS:** Pingen Sie `shelly-.local` (z. B. `shelly1pm-AABBCCDDEE.local`) aus dem selben Netzwerk > [!TIP] > Weisen Sie dem Shelly-Gerät eine **statische IP** (DHCP-Reservierung) in Ihrem Router zu, damit sich die Adresse nach einem Router-Neustart nicht ändert. ### Schritt 3 — Konfiguration in TapHome 1. Fügen Sie in TapHome ein neues Modul **Packet Parser (HTTP)** hinzu 2. **IP Address:** Geben Sie die IP aus Schritt 2 ein (z. B. `192.168.1.50`) 3. **Port:** `80` (Standard, keine Änderung erforderlich) 4. Importieren Sie die Vorlage — TapHome fragt regelmäßig `/status` ab, um den Gerätestatus zu lesen > [!NOTE] > Die HTTP-Authentifizierung ist auf Shelly-Geräten standardmäßig deaktiviert. Wenn Sie den Anmeldeschutz aktiviert haben, unterstützt TapHome derzeit kein HTTP Basic Auth — lassen Sie die Authentifizierung für die TapHome-Integration deaktiviert. ## Verfügbare Geräte 6 Diese Geräte erscheinen nach dem Import in TapHome. Shelly i3 Modul Serviceattribute | | | |-------|-------------------------------------------------------------------| | Wi-Fi | SSID des Wi-Fi-Netzwerks, mit dem das Gerät derzeit verbunden ist | Serviceattribute Wifi ```taphome VAR response := SENDHTTPREQUEST("/status"); IF response.IsSuccess VAR content := response.Content; RETURN(PARSEJSON(content, "$.wifi_sta.ssid")); End ``` Events I1 Mehrwertschalter Nur lesen Dekodiertes Multi-Klick-Ereignis für Eingang I1 — None, Shortpush, Longpush, Double Shortpush, Triple Shortpush, Shortpush + Longpush, Longpush + Shortpush (wird nur ausgelöst, wenn Button Type auf Momentary gesetzt ist) string (decoded to UInt8 via SWITCH) json\_path Werte / Zustände: None · Shortpush · Longpush · Double Shortpush · Triple Shortpush · Shortpush + Longpush · Longpush + Shortpush Schaltzustand lesen ```taphome VAR response := SENDHTTPREQUEST("/input/0"); IF response.IsSuccess VAR content := response.Content; RETURN(SWITCH(PARSEJSON(content, "event"),"S", 1, "L", 2, "SS", 3, "SSS", 4, "SL", 5, "LS", 6, 0)); ELSE ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); RETURN(NaN); END ``` Events I2 Mehrwertschalter Nur lesen Dekodiertes Multi-Klick-Ereignis für Eingang I2 — None, Shortpush, Longpush, Double Shortpush, Triple Shortpush, Shortpush + Longpush, Longpush + Shortpush (wird nur ausgelöst, wenn Button Type auf Momentary gesetzt ist) string (decoded to UInt8 via SWITCH) json\_path Werte / Zustände: None · Shortpush · Longpush · Double Shortpush · Triple Shortpush · Shortpush + Longpush · Longpush + Shortpush Schaltzustand lesen ```taphome VAR response := SENDHTTPREQUEST("/input/1"); IF response.IsSuccess VAR content := response.Content; RETURN(SWITCH(PARSEJSON(content, "event"),"S", 1, "L", 2, "SS", 3, "SSS", 4, "SL", 5, "LS", 6, 0)); ELSE ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); RETURN(NaN); END ``` Schaltzustand schreiben ```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 ``` Events I3 Mehrwertschalter Nur lesen Dekodiertes Multi-Klick-Ereignis für Eingang I3 — None, Shortpush, Longpush, Double Shortpush, Triple Shortpush, Shortpush + Longpush, Longpush + Shortpush (wird nur ausgelöst, wenn Button Type auf Momentary gesetzt ist) string (decoded to UInt8 via SWITCH) json\_path Werte / Zustände: None · Shortpush · Longpush · Double Shortpush · Triple Shortpush · Shortpush + Longpush · Longpush + Shortpush Schaltzustand lesen ```taphome VAR response := SENDHTTPREQUEST("/input/2"); IF response.IsSuccess VAR content := response.Content; RETURN(SWITCH(PARSEJSON(content, "event"),"S", 1, "L", 2, "SS", 3, "SSS", 4, "SL", 5, "LS", 6, 0)); ELSE ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); RETURN(NaN); END ``` Schaltzustand schreiben ```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 ``` Eingang I1 Reed-Kontakt Nur lesen Roher logischer Zustand des Eingangs I1 — 0 (offen) oder 1 (geschlossen), spiegelt die Live-Position des an Klemme SW1 angeschlossenen Schalters wider boolean json\_path Serviceattribute | | | |-----------|-------------------------------------------------------------------------------------------------------------------------------------------------| | Tastentyp | Aktueller Verhaltensmodus des Eingangs I1 — Toggle (klassischer Schalter) oder Momentary (Taster, erforderlich für die Multi-Klick-Dekodierung) | Serviceaktionen | | | |-----------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Tastentyp | Schaltet Eingang I1 zwischen Toggle (klassischer Schalter) und Momentary (Taster — erforderlich, damit die Multi-Klick-Dekodierung von Events I1 ausgelöst wird) um | Lesen ```taphome VAR response := SENDHTTPREQUEST("/input/0"); IF response.IsSuccess VAR content := response.Content; RETURN(PARSEJSON(content, "input")); ELSE ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); RETURN(NaN); END ``` Lesen (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"); ``` Serviceattribute Button Type ```taphome VAR response := SENDHTTPREQUEST("/settings/input/0"); IF response.IsSuccess VAR content := response.Content; RETURN(PARSEJSON(content, "btn_type")); END ``` Serviceaktionen Button Type Parameter: Button Type ```taphome var Ru := SWITCH(Bu, 0, "toggle","momentary") ; VAR response := SENDHTTPREQUEST("/settings/input/0?btn_type=" + Ru); ``` Eingang I2 Reed-Kontakt Nur lesen Roher logischer Zustand des Eingangs I2 — 0 (offen) oder 1 (geschlossen), spiegelt die Live-Position des an Klemme SW2 angeschlossenen Schalters wider boolean json\_path Serviceattribute | | | |-----------|-------------------------------------------------------------------------------------------------------------------------------------------------| | Tastentyp | Aktueller Verhaltensmodus des Eingangs I2 — Toggle (klassischer Schalter) oder Momentary (Taster, erforderlich für die Multi-Klick-Dekodierung) | Serviceaktionen | | | |-----------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Tastentyp | Schaltet Eingang I2 zwischen Toggle (klassischer Schalter) und Momentary (Taster — erforderlich, damit die Multi-Klick-Dekodierung von Events I2 ausgelöst wird) um | Lesen ```taphome VAR response := SENDHTTPREQUEST("/input/1"); IF response.IsSuccess VAR content := response.Content; RETURN(PARSEJSON(content, "input")); ELSE ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); RETURN(NaN); END ``` Serviceattribute Button Type ```taphome VAR response := SENDHTTPREQUEST("/settings/input/1"); IF response.IsSuccess VAR content := response.Content; RETURN(PARSEJSON(content, "btn_type")); END ``` Serviceaktionen Button Type Parameter: Button Type ```taphome var Ru := SWITCH(Bu, 0, "toggle","momentary") ; VAR response := SENDHTTPREQUEST("/settings/input/1?btn_type=" + Ru); ``` Eingang I3 Reed-Kontakt Nur lesen Roher logischer Zustand des Eingangs I3 — 0 (offen) oder 1 (geschlossen), spiegelt die Live-Position des an Klemme SW3 angeschlossenen Schalters wider boolean json\_path Serviceattribute | | | |-----------|-------------------------------------------------------------------------------------------------------------------------------------------------| | Tastentyp | Aktueller Verhaltensmodus des Eingangs I3 — Toggle (klassischer Schalter) oder Momentary (Taster, erforderlich für die Multi-Klick-Dekodierung) | Serviceaktionen | | | |-----------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Tastentyp | Schaltet Eingang I3 zwischen Toggle (klassischer Schalter) und Momentary (Taster — erforderlich, damit die Multi-Klick-Dekodierung von Events I3 ausgelöst wird) um | Lesen ```taphome VAR response := SENDHTTPREQUEST("/input/2"); IF response.IsSuccess VAR content := response.Content; RETURN(PARSEJSON(content, "input")); ELSE ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); RETURN(NaN); END ``` Lesen (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"); ``` Serviceattribute Button Type ```taphome VAR response := SENDHTTPREQUEST("/settings/input/2"); IF response.IsSuccess VAR content := response.Content; RETURN(PARSEJSON(content, "btn_type")); END ``` Serviceaktionen Button Type Parameter: Button Type ```taphome var Ru := SWITCH(Bu, 0, "toggle","momentary") ; VAR response := SENDHTTPREQUEST("/settings/input/2?btn_type=" + Ru); ``` **Verbindung:** Packet Parser → HTTP • Hostname: `shellyi3-{MAC}.local` Mögliche Verbesserungen (14) - Input Event Counter — Monotonic UInt16 counter incrementing on every decoded event — required to reliably detect rapid repeats since the event field is sticky. Could be exposed as a Variable per input. - Extended Button Type modes — Template's Button Type service action only exposes Toggle/Momentary; firmware also supports edge, detached and action modes. - Input Logic Reverse — Inverts logical state of an input. Could be added as bool service action per input. - Long-push Minimum Duration — Default 800 ms, range 1–5000 ms. Global parameter applied to all three inputs. - Long-push Maximum Duration — Default 800 ms, range 1–5000 ms. - Multi-push Window — Default 500 ms, range 1–1000 ms. Window for joining short pushes into SS/SSS sequences. - Action / Webhook Table — Per-event HTTP webhook URLs (btn\_on\_url, btn\_off\_url, shortpush\_url, longpush\_url, double\_shortpush\_url, triple\_shortpush\_url, shortpush\_longpush\_url, longpush\_shortpush\_url). Out of scope for TapHome which polls inputs directly. - Wi-Fi Signal Strength — RSSI in dBm, available in /status. Could be added as a module-level service attribute. - Firmware Update Available — Boolean from /status. Other Shelly Gen1 templates expose this as 'FW update' service attribute. - Uptime — Seconds since boot. Diagnostic value commonly exposed by other Shelly Gen1 templates. - MAC Address — Diagnostic identifier, commonly exposed by other Shelly Gen1 templates as a service attribute. - Cloud Status — Shelly Cloud enable + connection booleans. - MQTT Connection Status — MQTT broker connection state. - While-pressed Long-push Pulse — MQTT-only feature: stays at 1 for the duration of a long press, useful for 'while-pressed' actions. Not available via HTTP polling. ## Importparameter Diese Werte geben Sie beim Import des XML ein. | In der App abgefragt | Standard | |----------------------|---------------| | IP-Adresse | `192.168.0.1` | ## Quellen - Shelly Gen1 API Reference [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen1/) 2026-03-12 - Home Assistant Shelly Integration [www.home-assistant.io](https://www.home-assistant.io/integrations/shelly/) 2026-03-12 - Shelly i3 Knowledge Base [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-i3) 2026-04-26 - Shelly i3 Gen1 API (i3-specific) [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen1/#shelly-i3) 2026-04-26 ## Verwandte Dokumentation - [Packet-Parser-Integration](https://taphome.com/de/compatibility/packet-parser-guide/) - [Packet Parser (HTTP, TCP, UDP, FTP, MQTT)](https://taphome.com/de/docs/integration/packet-parser/) - [Packet-Parser-Funktionen](https://taphome.com/de/docs/script/packet-parser/) - [Parsing-Funktionen](https://taphome.com/de/docs/script/parsing-functions/)