---
title: "Shelly i3"
description: "Controler Wi-Fi Shelly i3 cu 3 intrări, fără relee. Detectează din TapHome, prin HTTP, apăsări simple, duble, triple, lungi și combinate."
url: "https://taphome.com/ro/compatibility/shelly-i3/"
language: ro
lastmod: 2026-04-26
generator: hugo
ai:
  topics: ["http","i/o-module","wifi","digital-input","push-button","reed-contact","3-channel","mdns"]
  questions: ["Cum integrez Shelly i3 cu TapHome?","Cum detectez apăsările de buton cu Shelly i3 în TapHome?","Cum conectez Shelly i3 la TapHome prin HTTP?","Care este diferența dintre modul toggle și modul momentary la Shelly i3?","De ce Shelly i3 nu detectează apăsările duble sau triple în TapHome?","Poate Shelly i3 să comande direct relee?","Câte acțiuni poate declanșa Shelly i3?"]
---

# Shelly i3

Comunicație: Packet Parser → HTTP

- [Pagina produsului Shelly i3](https://www.shelly.com/products/shop/shelly-i3)
- [Baza de cunoștințe Shelly i3](https://kb.shelly.cloud/knowledge-base/shelly-i3)
- [Referința API Shelly Gen1](https://shelly-api-docs.shelly.cloud/gen1/#shelly-i3)

> Adresa în rețea
> 
> TapHome comunică cu dispozitivul la adresa introdusă la import. Atribuiți dispozitivului o adresă fixă — o rezervare IP în router sau numele său mDNS, dacă îl acceptă —, altfel integrarea nu mai funcționează când routerul schimbă adresa.
> 
> [Pregătirea rețelei](https://taphome.com/ro/docs/setup/network-preparation/)

## Ghid de integrare

Shelly i3 este un controler Wi-Fi compact pentru acțiuni și scene, cu 3 intrări (model `SHIX3-1`). Nu are relee sau ieșiri — funcționează exclusiv ca dispozitiv de intrare care monitorizează trei întrerupătoare sau butoane externe conectate la bornele SW1, SW2 și SW3. Dimensiunile de 40 x 36 x 10 mm permit montarea într-o doză de aparataj standard, în spatele unui întrerupător de perete existent. Se alimentează la 110–230 V c.a. (este necesar nulul) sau la 24–60 V c.c. și consumă mai puțin de 1 W.

TapHome comunică cu dispozitivul prin HTTP în rețeaua Wi-Fi locală — nu este necesară conexiunea la cloud. Pentru fiecare intrare, șablonul creează două dispozitive: un comutator cu mai multe valori care decodează evenimentele de apăsări multiple (apăsare simplă, dublă, triplă, lungă și secvențe combinate) și un contact reed care oferă starea brută 0/1 a intrării, plus o acțiune de service pentru comutarea între modurile toggle și momentary.

## Configurare

### Asocierea Wi-Fi și adresa IP

După alimentare, i3 pornește în modul punct de acces, cu SSID-ul `shellyi3-XXXXXX` (unde `XXXXXX` reprezintă ultimele 6 cifre hexazecimale ale adresei MAC). Pentru a-l asocia cu rețeaua de acasă:

1. Conectați un telefon sau un laptop la punctul de acces al i3
2. Deschideți `http://192.168.33.1` într-un browser (sau folosiți aplicația mobilă Shelly)
3. În interfața web accesați **Internet & Security → WIFI MODE - CLIENT**, introduceți datele de acces la rețeaua Wi-Fi de acasă și salvați
4. Dispozitivul repornește și se conectează la rețeaua de acasă prin DHCP

Adresa IP atribuită se poate afla din tabelul de alocări DHCP al routerului sau prin numele de gazdă mDNS `shellyi3-XXXXXXXXXXXX.local` (sufix MAC de 12 caractere, anunțat ca `_http._tcp.local.`). La importul șablonului în TapHome, introduceți această adresă IP ca singurul parametru obligatoriu.

### Dezactivarea autentificării HTTP

TapHome nu se poate autentifica pe dispozitiv. În interfața web Shelly accesați **Internet & Security → RESTRICT LOGIN** și asigurați-vă că opțiunea este **dezactivată** înainte de importul șablonului — altfel fiecare interogare va eșua cu HTTP 401.

### Configurarea tipului de buton

Fiecare dintre cele trei intrări poate funcționa într-unul dintre cele cinci moduri `btn_type`. Doar două sunt relevante pentru TapHome și sunt disponibile ca acțiune de service pe dispozitivele I1 / I2 / I3:

- **Momentary** — pentru butoane. Firmware-ul decodează apăsarea scurtă simplă (`S`), apăsarea lungă (`L`), apăsarea scurtă dublă (`SS`), apăsarea scurtă triplă (`SSS`), scurtă→lungă (`SL`) și lungă→scurtă (`LS`). Este necesar pentru ca dispozitivele **Events I{N}** să transmită altceva decât `None`.
- **Toggle** — pentru întrerupătoarele clasice basculante sau cu manetă. Se raportează doar starea brută 0/1; comutatorul cu mai multe valori rămâne la indexul 0.

Tipul de buton poate fi schimbat oricând din TapHome, prin acțiunea de service **Tip buton** a fiecărui dispozitiv I1 / I2 / I3, sau direct în interfața web Shelly, la **Settings → Input/Output settings**.

> [!NOTE]
> Firmware-ul acceptă și modurile `edge`, `detached` și `action`, dar acestea nu sunt disponibile în șablonul TapHome. Ele pot fi totuși setate din interfața web Shelly fără a afecta integrarea — se modifică doar comportamentul de decodare a apăsărilor multiple.

## Funcțiile dispozitivului

### Decodarea evenimentelor de apăsări multiple (Events I1, Events I2, Events I3)

Pentru fiecare intrare, un comutator cu mai multe valori decodează codul de eveniment din firmware într-una dintre cele șapte valori:

| Index | Eveniment | Cod Shelly |
|-------|-------|-------------|
| 0 | None | `""` (inactiv) |
| 1 | Shortpush | `S` |
| 2 | Longpush | `L` |
| 3 | Double Shortpush | `SS` |
| 4 | Triple Shortpush | `SSS` |
| 5 | Shortpush + Longpush | `SL` |
| 6 | Longpush + Shortpush | `LS` |

Șablonul interoghează `/input/{0,1,2}` la fiecare 2,5 secunde și citește câmpul `event`. Cu 6 evenimente × 3 intrări, potrivit Shelly, i3 permite **până la 18 acțiuni distincte prin apăsări multiple** (24, dacă schimbările brute ale stării pornit/oprit sunt considerate declanșatoare separate).

Pragul pentru apăsarea lungă și fereastra pentru apăsări multiple se configurează global pe dispozitiv (implicit: 800 ms pentru apăsarea lungă, 500 ms între apăsări). Acestea pot fi ajustate în interfața web Shelly, la **Settings → Long Push Duration** și **Multi Push Time**.

### Starea brută a intrării și comanda tipului de buton (I1, I2, I3)

Pentru fiecare intrare, un dispozitiv de tip contact reed oferă starea logică brută citită din câmpul `input` al `/input/{N}` (0 = deschis, 1 = închis, după inversarea opțională `btn_reverse`). Fiecare dispozitiv I1 / I2 / I3 are și:

- Atributul de service **Tip buton** — valoarea curentă `btn_type` (toggle / momentary / edge / detached / action)
- Acțiunea de service **Tip buton** — comută intrarea între Toggle și Momentary, scriind `POST /settings/input/{N}?btn_type=...`

Starea brută este potrivită pentru contactele magnetice de ușă / fereastră conectate la bornele SW sau pentru urmărirea în timp real a poziției unui întrerupător basculant.

### Diagnosticare de service

Un singur atribut de service la nivelul modulului oferă **SSID-ul Wi-Fi** al rețelei la care este conectat în prezent i3 (citit din `/status` → `wifi_sta.ssid`). Alte date de diagnosticare Gen1 (timpul de funcționare, adresa MAC, RSSI, indicatorul de actualizare a firmware-ului) sunt disponibile în API-ul REST al dispozitivului, dar nu sunt incluse în acest șablon.

> [!TIP]
> Evenimentele de apăsări multiple se declanșează doar în modul **momentary**. Dacă o intrare fizică este conectată la un întrerupător basculant clasic, configurați intrarea respectivă ca **Toggle** și folosiți dispozitivul de tip contact reed I{N} pentru a citi starea ei 0/1 — dispozitivul Events I{N} corespunzător va rămâne la indexul 0.

## Rezolvarea problemelor

### Evenimentele de apăsări multiple nu sunt detectate

1. Verificați dacă intrarea este în modul **momentary** — deschideți dispozitivul I{N} în TapHome, rulați acțiunea de service **Tip buton** și selectați Momentary sau setați modul direct în interfața web Shelly, la **Settings → Input/Output settings**
2. În modul toggle, firmware-ul raportează doar schimbările de stare; comutatorul cu mai multe valori Events I{N} rămâne la indexul 0
3. Dacă apăsările sunt decodate ca alt eveniment, ajustați **Long Push Duration** (implicit 800 ms) și **Multi Push Time** (implicit 500 ms) în interfața web Shelly
4. Secvențele lungi, precum `SSS`, `SL` sau `LS`, necesită ca toate apăsările să fie făcute în fereastra pentru apăsări multiple — pauzele după eliberarea butonului mai lungi decât această fereastră sunt decodate ca evenimente `S` separate

### Același eveniment se repetă la nesfârșit / eveniment „blocat”

Câmpul `event` returnat de `/input/{N}` este **ultimul eveniment decodat** — firmware-ul nu îl șterge automat. TapHome citește acest câmp la fiecare interogare, așa că comutatorul cu mai multe valori va raporta în continuare evenimentul anterior până la apariția unuia nou. Acesta este un comportament normal și nu indică un defect. Când scrieți o logică proprie care se declanșează la fiecare apăsare, asociați evenimentul cu contorul monoton `event_cnt` (disponibil tot în `/input/{N}`) pentru a detecta o schimbare, în loc să vă bazați doar pe valoarea `event`.

### Dispozitivul nu răspunde

1. Verificați dacă i3 este conectat la Wi-Fi — deschideți `http://{device-ip}/shelly` într-un browser; dacă returnează un obiect JSON, dispozitivul este accesibil
2. Încercați numele de gazdă mDNS `shellyi3-XXXXXXXXXXXX.local` în locul adresei IP — adresa IP s-ar fi putut schimba după reînnoirea DHCP
3. Asigurați-vă că autentificarea HTTP este **dezactivată** la **Internet & Security → Restrict login** — TapHome nu poate trimite date de autentificare și fiecare cerere va returna HTTP 401
4. Verificați dacă TapHome Core și dispozitivul Shelly se află în aceeași rețea sau VLAN, cu mDNS / multicast permis

> [!WARNING]
> Dispozitivele Shelly Gen1 acceptă **maximum 2 conexiuni HTTP simultane**. Șablonul livrat interoghează fiecare intrare la intervale de 2,5 s, ceea ce este deja aproape de limită. **Nu** reduceți intervalul de interogare și evitați rularea unui alt sistem (de ex. Home Assistant, scripturi proprii) care interoghează în același timp același i3 — comunicarea poate deveni instabilă.

> [!NOTE]
> Șablonul XML este livrat cu trei indici rezervați ai comutatorului cu mai multe valori (7, 8, 9, cu codurile brute 71/72/73 și etichetele generice „7” / „8” / „9”). Firmware-ul Gen1 nu emite alte evenimente în afară de `S`, `L`, `SS`, `SSS`, `SL` și `LS`, așa că acești indici sunt poziții rezervate, nefolosite, iar valoarea dispozitivului Events I{N} corespunzător nu ar trebui să ajungă în practică niciodată la 7-9.

## Cum se instalează în TapHome

### Cerințe preliminare

- Dispozitiv Shelly instalat și pornit
- Rețea Wi-Fi locală (2,4 GHz)
- TapHome CCU în aceeași rețea

### Pasul 1 — Conectați dispozitivul Shelly la Wi-Fi

**Varianta A — aplicația Shelly (recomandat):**

1. Descărcați [aplicația Shelly](https://www.shelly.com/en/support/shelly-app) (iOS / Android)
2. Atingeți **+** → **Add Device** și urmați asistentul de împerechere prin Bluetooth
3. Introduceți datele de conectare la Wi-Fi când vi se solicită

**Varianta B — modul AP (fără aplicație):**

1. La prima pornire, dispozitivul creează un hotspot: `ShellyXXX-AABBCCDDEE`
2. Conectați telefonul/PC-ul la acest hotspot
3. Deschideți `http://192.168.33.1` → **Internet & Security** → **Wi-Fi Mode - Client**
4. Introduceți SSID-ul și parola → **Save**

> [!NOTE]
> Shelly acceptă doar rețele de **2,4 GHz**. Rețelele de 5 GHz nu vor apărea la scanare.

### Pasul 2 — Găsiți adresa dispozitivului

Dispozitivele Shelly Gen1 acceptă **mDNS** (Zeroconf). Puteți accesa dispozitivul folosind un nume de gazdă în locul adresei IP:

```
shelly<model>-<MAC>.local
```

De exemplu: `shelly1pm-AABBCCDDEE.local` (adresa MAC în hexazecimal cu majuscule, fără două puncte).

> [!TIP]
> **Recomandat: folosiți Scanner IP din TapHome.** Deschideți aplicația TapHome și folosiți **Scanner IP** (Setări → Rețea → Scanare). Scannerul descoperă dispozitivele din rețea și afișează atât adresa IP, cât și numele de gazdă mDNS. Pentru o conexiune mai fiabilă folosiți **numele de gazdă** în locul adresei IP — acesta rămâne același chiar dacă adresa IP a dispozitivului se schimbă după o repornire a routerului.

**Metode alternative** pentru aflarea adresei IP:

- **Aplicația Shelly:** detaliile dispozitivului → **Device info** → adresa IP
- **Interfața web Shelly:** conectați-vă la AP-ul dispozitivului înainte de configurarea Wi-Fi — adresa IP se afișează după salvare
- **Tabelul DHCP al routerului:** căutați un nume de gazdă de forma `shelly1pm-AABBCCDDEE`

### Pasul 3 — Configurați dispozitivul în TapHome

1. În TapHome adăugați un nou modul **Packet Parser (HTTP)**
2. **Address:** introduceți numele de gazdă mDNS (de ex. `shelly1pm-AABBCCDDEE.local`) sau adresa IP de la pasul 2
3. **Port:** `80` (implicit, nu este necesară nicio modificare)
4. Importați șablonul — TapHome va interoga periodic `/status` pentru a citi starea dispozitivului

> [!NOTE]
> Autentificarea HTTP este dezactivată implicit pe dispozitivele Shelly. Dacă ați activat protecția prin autentificare, rețineți că TapHome nu acceptă momentan HTTP Basic Auth — pentru integrarea cu TapHome lăsați autentificarea dezactivată.

## Dispozitive disponibile 6

Aceste dispozitive apar în TapHome după import.

Shelly i3 Modul

Atribute de service

|       |                                                                     |
|-------|---------------------------------------------------------------------|
| Wi-Fi | SSID-ul rețelei Wi-Fi la care este conectat în prezent dispozitivul |

Atribute de service

Wifi

```taphome
 VAR response := SENDHTTPREQUEST("/status");
 IF response.IsSuccess
  VAR content := response.Content;
  RETURN(PARSEJSON(content, "$.wifi_sta.ssid"));
  End
```

Events I1 Comutator cu mai multe valori Doar citire

Evenimentul de apăsări multiple decodat pentru intrarea I1 — None, Shortpush, Longpush, Double Shortpush, Triple Shortpush, Shortpush + Longpush, Longpush + Shortpush (se declanșează doar când Tip buton este Momentary)

string (decoded to UInt8 via SWITCH) json\_path

Valori / Stări: None · Shortpush · Longpush · Double Shortpush · Triple Shortpush · Shortpush + Longpush · Longpush + Shortpush

Citirea stării comutatorului

```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 Comutator cu mai multe valori Doar citire

Evenimentul de apăsări multiple decodat pentru intrarea I2 — None, Shortpush, Longpush, Double Shortpush, Triple Shortpush, Shortpush + Longpush, Longpush + Shortpush (se declanșează doar când Tip buton este Momentary)

string (decoded to UInt8 via SWITCH) json\_path

Valori / Stări: None · Shortpush · Longpush · Double Shortpush · Triple Shortpush · Shortpush + Longpush · Longpush + Shortpush

Citirea stării comutatorului

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

Scrierea stării comutatorului

```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 Comutator cu mai multe valori Doar citire

Evenimentul de apăsări multiple decodat pentru intrarea I3 — None, Shortpush, Longpush, Double Shortpush, Triple Shortpush, Shortpush + Longpush, Longpush + Shortpush (se declanșează doar când Tip buton este Momentary)

string (decoded to UInt8 via SWITCH) json\_path

Valori / Stări: None · Shortpush · Longpush · Double Shortpush · Triple Shortpush · Shortpush + Longpush · Longpush + Shortpush

Citirea stării comutatorului

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

Scrierea stării comutatorului

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

Intrare I1 Contact reed Doar citire

Starea logică brută a intrării I1 — 0 (deschis) sau 1 (închis), care reflectă în timp real poziția întrerupătorului conectat la borna SW1

boolean json\_path

Atribute de service

|           |                                                                                                                                               |
|-----------|-----------------------------------------------------------------------------------------------------------------------------------------------|
| Tip buton | Modul de funcționare curent al intrării I1 — Toggle (întrerupător clasic) sau Momentary (buton, necesar pentru decodarea apăsărilor multiple) |

Acțiuni de service

|           |                                                                                                                                         |
|-----------|-----------------------------------------------------------------------------------------------------------------------------------------|
| Tip buton | Comută intrarea I1 între Toggle (întrerupător clasic) și Momentary (buton — necesar pentru ca Events I1 să decodeze apăsările multiple) |

Citire

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

Citire (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");
```

Atribute de service

Button Type

```taphome
 VAR response := SENDHTTPREQUEST("/settings/input/0");
 IF response.IsSuccess
  VAR content := response.Content;
  RETURN(PARSEJSON(content, "btn_type"));
 END
```

Acțiuni de service

Button Type

Parametri: Button Type

```taphome
 var Ru := SWITCH(Bu, 0, "toggle","momentary") ;
 VAR response := SENDHTTPREQUEST("/settings/input/0?btn_type=" + Ru);
```

Intrare I2 Contact reed Doar citire

Starea logică brută a intrării I2 — 0 (deschis) sau 1 (închis), care reflectă în timp real poziția întrerupătorului conectat la borna SW2

boolean json\_path

Atribute de service

|           |                                                                                                                                               |
|-----------|-----------------------------------------------------------------------------------------------------------------------------------------------|
| Tip buton | Modul de funcționare curent al intrării I2 — Toggle (întrerupător clasic) sau Momentary (buton, necesar pentru decodarea apăsărilor multiple) |

Acțiuni de service

|           |                                                                                                                                                         |
|-----------|---------------------------------------------------------------------------------------------------------------------------------------------------------|
| Tip buton | Comută intrarea I2 între Toggle (întrerupător clasic) și Momentary (buton — necesar pentru ca decodarea apăsărilor multiple Events I2 să se declanșeze) |

Citire

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

Atribute de service

Button Type

```taphome
 VAR response := SENDHTTPREQUEST("/settings/input/1");
 IF response.IsSuccess
  VAR content := response.Content;
  RETURN(PARSEJSON(content, "btn_type"));
 END
```

Acțiuni de service

Button Type

Parametri: Button Type

```taphome
 var Ru := SWITCH(Bu, 0, "toggle","momentary") ;
 VAR response := SENDHTTPREQUEST("/settings/input/1?btn_type=" + Ru);
```

Intrare I3 Contact reed Doar citire

Starea logică brută a intrării I3 — 0 (deschis) sau 1 (închis), care reflectă în timp real poziția întrerupătorului conectat la borna SW3

boolean json\_path

Atribute de service

|           |                                                                                                                                               |
|-----------|-----------------------------------------------------------------------------------------------------------------------------------------------|
| Tip buton | Modul de funcționare curent al intrării I3 — Toggle (întrerupător clasic) sau Momentary (buton, necesar pentru decodarea apăsărilor multiple) |

Acțiuni de service

|           |                                                                                                                                                         |
|-----------|---------------------------------------------------------------------------------------------------------------------------------------------------------|
| Tip buton | Comută intrarea I3 între Toggle (întrerupător clasic) și Momentary (buton — necesar pentru ca decodarea apăsărilor multiple Events I3 să se declanșeze) |

Citire

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

Citire (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");
```

Atribute de service

Button Type

```taphome
 VAR response := SENDHTTPREQUEST("/settings/input/2");
 IF response.IsSuccess
  VAR content := response.Content;
  RETURN(PARSEJSON(content, "btn_type"));
 END
```

Acțiuni de service

Button Type

Parametri: Button Type

```taphome
 var Ru := SWITCH(Bu, 0, "toggle","momentary") ;
 VAR response := SENDHTTPREQUEST("/settings/input/2?btn_type=" + Ru);
```

**Conexiune:** Packet Parser → HTTP • Nume gazdă: `shellyi3-{MAC}.local`

Îmbunătățiri posibile (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 de import

Introduceți aceste valori când importați XML-ul.

| Solicitat în aplicație | Implicit      |
|------------------------|---------------|
| Adresă IP              | `192.168.0.1` |

## Surse

- 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

## Documentație asociată

- [Packet Parser Integration](https://taphome.com/ro/compatibility/packet-parser-guide/)
- [Packet Parser (HTTP, TCP, UDP, FTP, MQTT)](https://taphome.com/ro/docs/integration/packet-parser/)
- [Funcții Packet parser](https://taphome.com/ro/docs/script/packet-parser/)
- [Funcții de parsare](https://taphome.com/ro/docs/script/parsing-functions/)

