--- title: "Shelly i3" description: "Shelly i3 controller Wi-Fi a 3 ingressi. Rilevamento di eventi singoli, doppi, tripli, lunghi e combinati via HTTP da TapHome — senza relè." url: "https://taphome.com/it/compatibility/shelly-i3/" language: it lastmod: 2026-04-26 generator: hugo ai: topics: ["http","i/o-module","wifi","digital-input","push-button","reed-contact","3-channel","mdns"] questions: ["Come integrare Shelly i3 con TapHome?","Come rilevare le pressioni dei pulsanti con Shelly i3 in TapHome?","Come connettere Shelly i3 via HTTP a TapHome?","Qual è la differenza tra modalità toggle e momentary su Shelly i3?","Perché Shelly i3 non rileva pressioni doppie o triple in TapHome?","Shelly i3 può controllare relè direttamente?","Quante azioni può attivare Shelly i3?"] --- # Shelly i3 Comunicazione: Packet Parser → HTTP - [Pagina prodotto Shelly i3](https://www.shelly.com/products/shop/shelly-i3) - [Shelly i3 — base di conoscenza](https://kb.shelly.cloud/knowledge-base/shelly-i3) - [Shelly Gen1 — riferimento API](https://shelly-api-docs.shelly.cloud/gen1/#shelly-i3) > Indirizzo di rete > > TapHome raggiunge il dispositivo all'indirizzo inserito durante l'importazione. Assegna al dispositivo un indirizzo fisso — una prenotazione IP nel router, oppure il suo nome mDNS se lo supporta —, altrimenti l'integrazione smette di funzionare quando il router cambia l'indirizzo. > > [Preparazione della rete](https://taphome.com/it/docs/setup/network-preparation/) ## Guida all'integrazione Shelly i3 è un compatto controller Wi-Fi a 3 ingressi per azioni e scene (modello `SHIX3-1`). Non ha relè né uscite — funziona puramente come dispositivo di ingresso che monitora tre interruttori o pulsanti esterni collegati ai morsetti SW1, SW2 e SW3. Le dimensioni 40 × 36 × 10 mm permettono l'installazione all'interno di una scatola da incasso standard dietro un interruttore a parete esistente. È alimentato da 110–230 VAC (richiesto neutro) o 24–60 VDC e consuma meno di 1 W. TapHome comunica con il dispositivo tramite HTTP sulla rete Wi-Fi locale — non è richiesta alcuna connessione cloud. Per ogni ingresso il template crea due dispositivi: un commutatore multi-valore che decodifica gli eventi multi-click (sequenze singole, doppie, triple, lunghe e combinate) e un contatto reed che espone lo stato grezzo 0/1 dell'ingresso più un'azione di servizio per commutare tra modalità toggle e momentary. ## Configurazione ### Accoppiamento Wi-Fi e indirizzo IP All'accensione, l'i3 si avvia in modalità Access Point con SSID `shellyi3-XXXXXX` (dove `XXXXXX` sono le ultime 6 cifre esadecimali del MAC). Per accoppiarlo alla rete domestica: 1. Connetti un telefono o laptop all'access point dell'i3 2. Apri `http://192.168.33.1` in un browser (o usa l'app mobile Shelly) 3. Nell'interfaccia web vai a **Internet & Security → WIFI MODE - CLIENT**, inserisci le credenziali della Wi-Fi domestica e salva 4. Il dispositivo si riavvia e si unisce alla rete domestica via DHCP Per recuperare l'indirizzo IP assegnato usa la tabella DHCP del router o l'hostname mDNS `shellyi3-XXXXXXXXXXXX.local` (suffisso MAC di 12 caratteri, annunciato come `_http._tcp.local.`). Durante l'importazione del template TapHome, inserisci questo indirizzo IP come unico parametro richiesto. ### Disabilitare l'autenticazione HTTP TapHome non può autenticarsi verso il dispositivo. Nell'interfaccia web Shelly vai a **Internet & Security → RESTRICT LOGIN** e assicurati che questa opzione sia **disabilitata** prima di importare il template — altrimenti ogni polling fallirà con HTTP 401. ### Configurazione del tipo di pulsante Ciascuno dei tre ingressi può funzionare in una delle cinque modalità `btn_type`. Solo due sono rilevanti per TapHome ed esposte come azione di servizio sui dispositivi I1 / I2 / I3: - **Momentary** — per pulsanti. Il firmware decodifica pressione singola breve (`S`), pressione lunga (`L`), doppia pressione breve (`SS`), tripla pressione breve (`SSS`), breve→lunga (`SL`) e lunga→breve (`LS`). Necessario affinché i dispositivi **Events I{N}** restituiscano qualcosa di diverso da `None`. - **Toggle** — per interruttori a bilanciere o a leva tradizionali. Viene riportato solo lo stato grezzo 0/1; il commutatore multi-valore rimane all'indice 0. Il tipo di pulsante può essere modificato in qualsiasi momento da TapHome tramite l'azione di servizio **Button Type** su ogni dispositivo I1 / I2 / I3, o direttamente nell'interfaccia web Shelly in **Settings → Input/Output settings**. > [!NOTE] > Il firmware supporta anche le modalità `edge`, `detached` e `action`, ma queste non sono esposte nel template TapHome. Possono comunque essere impostate dall'interfaccia web Shelly senza compromettere l'integrazione — cambia solo il comportamento di decodifica multi-click. ## Funzionalità del dispositivo ### Decodifica eventi multi-click (Events I1, Events I2, Events I3) Per ogni ingresso, un commutatore multi-valore decodifica il codice evento del firmware in uno dei sette valori: | Indice | Evento | Codice Shelly | |--------|--------|---------------| | 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` | Il template effettua il polling di `/input/{0,1,2}` ogni 2,5 secondi e legge il campo `event`. Con 6 eventi × 3 ingressi Shelly commercializza l'i3 come supporto per **fino a 18 distinte azioni multi-click** (24 se i cambi grezzi di stato on/off vengono contati come trigger separati). La soglia di pressione lunga e la finestra multi-push sono configurate globalmente sul dispositivo (valori predefiniti: 800 ms per pressione lunga, 500 ms come finestra tra pressioni). Possono essere regolate dall'interfaccia web Shelly in **Settings → Long Push Duration** e **Multi Push Time**. ### Stato grezzo dell'ingresso e controllo del tipo di pulsante (I1, I2, I3) Per ogni ingresso un dispositivo reed-contact espone lo stato logico grezzo letto dal campo `input` di `/input/{N}` (0 = aperto, 1 = chiuso, dopo l'inversione opzionale `btn_reverse`). Ogni dispositivo I1 / I2 / I3 contiene anche: - **Button Type** — attributo di servizio con il valore corrente di `btn_type` (toggle / momentary / edge / detached / action) - **Button Type** — azione di servizio che commuta l'ingresso tra Toggle e Momentary scrivendo `POST /settings/input/{N}?btn_type=...` Lo stato grezzo è adatto per contatti magnetici di porte / finestre cablati ai morsetti SW o per tracciare in tempo reale la posizione di un interruttore a leva. ### Diagnostica di servizio Un singolo attributo di servizio a livello di modulo espone il **Wi-Fi SSID** a cui l'i3 è attualmente connesso (letto da `/status` → `wifi_sta.ssid`). Altre diagnostiche Gen1 (uptime, MAC, RSSI, flag di aggiornamento firmware) sono disponibili sull'API REST del dispositivo ma non esposte in questo template. > [!TIP] > Gli eventi multi-click si attivano solo in modalità **momentary**. Se un ingresso fisico è cablato attraverso un interruttore a leva tradizionale, configura quell'ingresso come **Toggle** e usa il dispositivo reed-contact I{N} per leggere il suo stato 0/1 — il dispositivo Events I{N} corrispondente rimarrà all'indice 0. ## Risoluzione dei problemi ### Eventi multi-click non rilevati 1. Verifica che l'ingresso sia in modalità **momentary** — apri il dispositivo I{N} in TapHome, esegui l'azione di servizio **Button Type** e seleziona Momentary, oppure impostalo direttamente nell'interfaccia web Shelly in **Settings → Input/Output settings** 2. In modalità toggle il firmware riporta solo cambi di stato; il commutatore multi-valore Events I{N} rimane all'indice 0 3. Regola **Long Push Duration** (predefinito 800 ms) e **Multi Push Time** (predefinito 500 ms) nell'interfaccia web Shelly se le pressioni vengono decodificate come evento errato 4. Sequenze lunghe come `SSS`, `SL` o `LS` richiedono che l'utente mantenga tutte le pressioni all'interno della finestra multi-push — pause più lunghe di tale finestra vengono decodificate come eventi `S` separati ### Lo stesso evento si ripete all'infinito / evento „bloccato" Il campo `event` restituito da `/input/{N}` è **l'ultimo evento decodificato** — il firmware non lo cancella automaticamente. TapHome legge questo campo a ogni polling, quindi il commutatore multi-valore continuerà a riportare l'evento precedente fino a quando non se ne verifica uno nuovo. Questo è un comportamento normale e non indica un guasto. Quando si scrive logica personalizzata che si attiva ad ogni pressione, abbina l'evento al contatore monotono `event_cnt` (anch'esso esposto in `/input/{N}`) per rilevare un cambiamento invece di affidarsi solo al valore di `event`. ### Il dispositivo non risponde 1. Verifica che l'i3 sia connesso al Wi-Fi — apri `http://{device-ip}/shelly` in un browser; se restituisce un oggetto JSON, il dispositivo è raggiungibile 2. Prova l'hostname mDNS `shellyi3-XXXXXXXXXXXX.local` invece dell'indirizzo IP — l'IP potrebbe essere cambiato dopo un rinnovo DHCP 3. Assicurati che l'autenticazione HTTP sia **disabilitata** in **Internet & Security → Restrict login** — TapHome non può inviare credenziali e ogni richiesta restituirà HTTP 401 4. Controlla che il TapHome Core e il dispositivo Shelly siano sulla stessa rete o VLAN con mDNS / multicast consentiti > [!WARNING] > I dispositivi Shelly Gen1 accettano un **massimo di 2 connessioni HTTP simultanee**. Il template fornito interroga ogni ingresso a intervalli di 2,5 s, già vicino al limite. **Non** abbassare l'intervallo di polling ed evita di eseguire un altro sistema (es. Home Assistant, script personalizzati) che interroga lo stesso i3 simultaneamente — la comunicazione potrebbe diventare inaffidabile. > [!NOTE] > Il template XML contiene tre indici multi-valore riservati (7, 8, 9 con codici grezzi 71/72/73 ed etichette generiche „7" / „8" / „9"). Il firmware Gen1 non emette eventi oltre `S`, `L`, `SS`, `SSS`, `SL` e `LS`, quindi questi indici sono segnaposto inutilizzati e il valore del dispositivo Events I{N} non dovrebbe mai raggiungere 7-9 nella pratica. ## Come installare in TapHome ### Prerequisiti - Dispositivo Shelly installato e acceso - Rete Wi-Fi locale (2,4 GHz) - TapHome CCU sulla stessa rete ### Passaggio 1 — Collegare Shelly al Wi-Fi **Opzione A — App Shelly (consigliata):** 1. Scarica l'[app Shelly](https://www.shelly.com/en/support/shelly-app) (iOS / Android) 2. Tocca **+** → **Add Device** e segui la procedura guidata di associazione Bluetooth 3. Inserisci le credenziali Wi-Fi quando richiesto **Opzione B — Modalità AP (senza app):** 1. Al primo avvio il dispositivo crea un hotspot: `ShellyXXX-AABBCCDDEE` 2. Collega il tuo telefono/PC a questo hotspot 3. Apri `http://192.168.33.1` → **Internet & Security** → **Wi-Fi Mode - Client** 4. Inserisci SSID e password → **Save** > [!NOTE] > Shelly supporta solo reti a **2,4 GHz**. Le reti a 5 GHz non appariranno nella scansione. ### Passaggio 2 — Trovare l'indirizzo IP Dopo la connessione al Wi-Fi, trova l'indirizzo IP assegnato tramite uno di questi metodi: - **App Shelly:** Dettaglio dispositivo → **Device info** → Indirizzo IP - **Interfaccia web Shelly:** Connettiti all'AP del dispositivo prima della configurazione Wi-Fi — l'IP viene mostrato dopo il salvataggio - **Tabella DHCP del router:** Cerca un hostname come `shelly1pm-AABBCCDDEE` - **mDNS:** Esegui il ping di `shelly-.local` (es. `shelly1pm-AABBCCDDEE.local`) dalla stessa rete > [!TIP] > Assegna un **IP statico** (prenotazione DHCP) nel tuo router per il dispositivo Shelly per evitare che l'indirizzo cambi dopo un riavvio del router. ### Passaggio 3 — Configurazione in TapHome 1. In TapHome, aggiungi un nuovo modulo **Packet Parser (HTTP)** 2. **IP Address:** inserisci l'IP dal passaggio 2 (es. `192.168.1.50`) 3. **Port:** `80` (predefinito, nessuna modifica necessaria) 4. Importa il template — TapHome interrogherà periodicamente `/status` per leggere lo stato del dispositivo > [!NOTE] > L'autenticazione HTTP è disabilitata per impostazione predefinita sui dispositivi Shelly. Se hai abilitato la protezione con accesso, TapHome attualmente non supporta HTTP Basic Auth — mantieni l'autenticazione disabilitata per l'integrazione con TapHome. ## Dispositivi disponibili 6 Questi dispositivi compaiono in TapHome dopo l'importazione. Shelly i3 Modulo Attributi di servizio | | | |-------|-------------------------------------------------------------------| | Wi-Fi | SSID della rete Wi-Fi a cui il dispositivo è attualmente connesso | Attributi di servizio Wifi ```taphome VAR response := SENDHTTPREQUEST("/status"); IF response.IsSuccess VAR content := response.Content; RETURN(PARSEJSON(content, "$.wifi_sta.ssid")); End ``` Events I1 Interruttore multivalore Solo lettura Evento multi-click decodificato per l'ingresso I1 — None, Shortpush, Longpush, Double Shortpush, Triple Shortpush, Shortpush + Longpush, Longpush + Shortpush (si attiva solo quando Button Type è impostato su Momentary) string (decoded to UInt8 via SWITCH) json\_path Valori / Stati: None · Shortpush · Longpush · Double Shortpush · Triple Shortpush · Shortpush + Longpush · Longpush + Shortpush Lettura stato interruttore ```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 Interruttore multivalore Solo lettura Evento multi-click decodificato per l'ingresso I2 — None, Shortpush, Longpush, Double Shortpush, Triple Shortpush, Shortpush + Longpush, Longpush + Shortpush (si attiva solo quando Button Type è impostato su Momentary) string (decoded to UInt8 via SWITCH) json\_path Valori / Stati: None · Shortpush · Longpush · Double Shortpush · Triple Shortpush · Shortpush + Longpush · Longpush + Shortpush Lettura stato interruttore ```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 ``` Scrittura stato interruttore ```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 Interruttore multivalore Solo lettura Evento multi-click decodificato per l'ingresso I3 — None, Shortpush, Longpush, Double Shortpush, Triple Shortpush, Shortpush + Longpush, Longpush + Shortpush (si attiva solo quando Button Type è impostato su Momentary) string (decoded to UInt8 via SWITCH) json\_path Valori / Stati: None · Shortpush · Longpush · Double Shortpush · Triple Shortpush · Shortpush + Longpush · Longpush + Shortpush Lettura stato interruttore ```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 ``` Scrittura stato interruttore ```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 ``` Ingresso I1 Contatto reed Solo lettura Stato logico grezzo dell'ingresso I1 — 0 (aperto) o 1 (chiuso), riflette la posizione live dell'interruttore cablato al morsetto SW1 boolean json\_path Attributi di servizio | | | |------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------| | Tipo di pulsante | Modalità di comportamento corrente dell'ingresso I1 — Toggle (interruttore tradizionale) o Momentary (pulsante, richiesto per la decodifica multi-click) | Azioni di servizio | | | |------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------| | Tipo di pulsante | Commuta l'ingresso I1 tra Toggle (interruttore tradizionale) e Momentary (pulsante — richiesto affinché la decodifica multi-click di Events I1 si attivi) | Lettura ```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 ``` Lettura (modulo) ```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"); ``` Attributi di servizio Button Type ```taphome VAR response := SENDHTTPREQUEST("/settings/input/0"); IF response.IsSuccess VAR content := response.Content; RETURN(PARSEJSON(content, "btn_type")); END ``` Azioni di servizio Button Type Parametri: Button Type ```taphome var Ru := SWITCH(Bu, 0, "toggle","momentary") ; VAR response := SENDHTTPREQUEST("/settings/input/0?btn_type=" + Ru); ``` Ingresso I2 Contatto reed Solo lettura Stato logico grezzo dell'ingresso I2 — 0 (aperto) o 1 (chiuso), riflette la posizione live dell'interruttore cablato al morsetto SW2 boolean json\_path Attributi di servizio | | | |------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------| | Tipo di pulsante | Modalità di comportamento corrente dell'ingresso I2 — Toggle (interruttore tradizionale) o Momentary (pulsante, richiesto per la decodifica multi-click) | Azioni di servizio | | | |------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------| | Tipo di pulsante | Commuta l'ingresso I2 tra Toggle (interruttore tradizionale) e Momentary (pulsante — richiesto affinché la decodifica multi-click di Events I2 si attivi) | Lettura ```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 ``` Attributi di servizio Button Type ```taphome VAR response := SENDHTTPREQUEST("/settings/input/1"); IF response.IsSuccess VAR content := response.Content; RETURN(PARSEJSON(content, "btn_type")); END ``` Azioni di servizio Button Type Parametri: Button Type ```taphome var Ru := SWITCH(Bu, 0, "toggle","momentary") ; VAR response := SENDHTTPREQUEST("/settings/input/1?btn_type=" + Ru); ``` Ingresso I3 Contatto reed Solo lettura Stato logico grezzo dell'ingresso I3 — 0 (aperto) o 1 (chiuso), riflette la posizione live dell'interruttore cablato al morsetto SW3 boolean json\_path Attributi di servizio | | | |------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------| | Tipo di pulsante | Modalità di comportamento corrente dell'ingresso I3 — Toggle (interruttore tradizionale) o Momentary (pulsante, richiesto per la decodifica multi-click) | Azioni di servizio | | | |------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------| | Tipo di pulsante | Commuta l'ingresso I3 tra Toggle (interruttore tradizionale) e Momentary (pulsante — richiesto affinché la decodifica multi-click di Events I3 si attivi) | Lettura ```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 ``` Lettura (modulo) ```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"); ``` Attributi di servizio Button Type ```taphome VAR response := SENDHTTPREQUEST("/settings/input/2"); IF response.IsSuccess VAR content := response.Content; RETURN(PARSEJSON(content, "btn_type")); END ``` Azioni di servizio Button Type Parametri: Button Type ```taphome var Ru := SWITCH(Bu, 0, "toggle","momentary") ; VAR response := SENDHTTPREQUEST("/settings/input/2?btn_type=" + Ru); ``` **Connessione:** Packet Parser → HTTP • Hostname: `shellyi3-{MAC}.local` Possibili miglioramenti (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. ## Parametri di importazione Inserisci questi valori quando importi l'XML. | Richiesto nell'app | Predefinito | |--------------------|---------------| | Indirizzo IP | `192.168.0.1` | ## Fonti - 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 ## Documentazione correlata - [Integrazione Packet Parser](https://taphome.com/it/compatibility/packet-parser-guide/) - [Packet Parser (HTTP, TCP, UDP, FTP, MQTT)](https://taphome.com/it/docs/integration/packet-parser/) - [Funzioni Packet parser](https://taphome.com/it/docs/script/packet-parser/) - [Funzioni di parsing](https://taphome.com/it/docs/script/parsing-functions/)