---
title: "Shelly DUO"
description: "Bec CCT Wi-Fi Shelly DUO — luminozitate, temperatură de culoare (2700–6500 K) și măsurarea puterii prin HTTP/MQTT. Șablon TapHome pentru Shelly DUO Gen1."
url: "https://taphome.com/ro/compatibility/shelly-duo/"
language: ro
lastmod: 2026-03-30
generator: hugo
ai:
  topics: ["http","mqtt","lighting","wifi","cct","power-metering","led-bulb"]
  questions: ["Cum integrez Shelly DUO cu TapHome?","Cum comand luminozitatea și temperatura de culoare a Shelly DUO din TapHome?","Cum conectez Shelly DUO la TapHome prin HTTP?","Cum conectez mai multe becuri Shelly DUO la TapHome prin MQTT?","De ce Shelly DUO afișează o putere zero?","Ce este mecanismul debounce din șablonul Shelly DUO?"]
---

# Shelly DUO

Comunicație: Packet Parser → HTTP

- [Pagina produsului Shelly DUO](https://www.shelly.com/en/products/shop/shelly-bulb-duo)
- [Documentația API Shelly DUO](https://shelly-api-docs.shelly.cloud/gen1/#shelly-duo)

> 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 DUO este un bec LED Wi-Fi cu soclu E27, care permite reglarea luminozității și a temperaturii de culoare a luminii albe (CCT) în intervalul de la 2700 K (alb cald) până la 6500 K (lumina zilei). TapHome se integrează local cu becul, prin Wi-Fi, folosind fie API-ul HTTP REST, fie MQTT. Nu este necesară conexiunea la cloud.

Sunt disponibile două șabloane TapHome: un **șablon HTTP** pentru un singur bec și un **șablon MQTT** care poate comanda până la 5 becuri DUO printr-o singură conexiune la brokerul MQTT. Ambele șabloane oferă pentru fiecare bec aceleași tipuri de dispozitive — un dispozitiv de lumină cu reglarea luminozității și a CCT și un contor electric pentru monitorizarea puterii.

## Configurare

### Șablonul HTTP

Șablonul HTTP necesită adresa IP a becului (sau numele de gazdă mDNS `ShellyBulbDuo-{MAC}.local`). TapHome interoghează endpointul `/status` la fiecare 2,5 secunde și salvează răspunsul JSON în variabila personalizată `jsonStatus`. Scripturile fiecărui dispozitiv analizează răspunsul salvat, fără apeluri HTTP redundante.

Șablonul are doi parametri de import:

- **IP Address** — adresa IP locală a becului (implicit `192.168.0.1`)
- **Transition time** — durata tranziției luminii în milisecunde (implicit 300 ms)

### Șablonul MQTT

Șablonul MQTT necesită adresa IP și portul brokerului, precum și **ID-ul dispozitivului** pentru fiecare bec (format: `ShellyBulbDuo-DEVICEID`). ID-ul dispozitivului se găsește în interfața web Shelly, la **Settings** > **Device Info**, sau prin `GET http://{bulb-ip}/settings`, în câmpul `mqtt.id`.

Șablonul acceptă până la **5 becuri DUO** într-un singur modul. Fiecare bec este identificat prin propria variabilă de topic (de la `bulb1topic` până la `bulb5topic`). Sloturile de becuri nefolosite pot rămâne la valoarea implicită.

Șablonul are trei parametri de import:

- **MQTT Broker IP** — adresa brokerului (implicit `192.168.0.1`)
- **MQTT Broker port** — portul brokerului (implicit `1883`)
- **Transition time** — durata tranziției luminii în milisecunde (implicit 300 ms)

> [!WARNING]
> La dispozitivele Shelly Gen1, activarea MQTT **dezactivează Shelly Cloud**. Cele două nu pot funcționa simultan.

## Funcțiile dispozitivului

### Comanda luminii

Șablonul integrează becul DUO ca dispozitiv de lumină albă cu doi parametri comandabili:

- **Luminozitate** — citită din `lights[0].brightness` (0–100, convertită intern în 0,0–1,0) și `lights[0].ison`; comandată prin `/light/0?turn=on|off&brightness=N` (HTTP) sau prin publicarea unui JSON pe topicul `light/0/set` (MQTT)
- **Temperatura de culoare** — citită din `lights[0].temp` (2700–6500 K); comandată prin `/light/0?temp=K` (HTTP) sau prin câmpul `temp` din payloadul JSON (MQTT)

Ambii parametri se trimit împreună, într-o singură comandă de scriere. Parametrul timpului de tranziție stabilește durata tranziției graduale pentru toate modificările.

Când lumina se stinge (luminozitatea este setată la 0), șablonul trimite `turn=off` (HTTP) sau publică `off` pe topicul `light/0/command` (MQTT).

### Mecanismul debounce

Șablonul HTTP conține o protecție debounce care previne citirile neactualizate în timpul tranzițiilor luminii. După fiecare comandă de scriere, șablonul ignoră citirile `/status` pe durata timpului de tranziție plus 500 ms. În această perioadă, scripturile de citire returnează ultimele valori cunoscute în loc să interogheze dispozitivul. Astfel, interfața nu afișează pentru scurt timp stări intermediare în timp ce becul trece de la o stare la alta.

Șablonul MQTT nu are nevoie de debounce — primește actualizările de stare direct de la bec, în momentul în care apar.

### Măsurarea puterii

Contorul electric integrat citește două valori:

- **Putere în timp real** — `meters[0].power` în wați, convertită în kW (împărțire la 1000)
- **Consum total** — `meters[0].total` în wați-minut, convertit în kWh (împărțire la 60 000)

Contorul este doar pentru citire și se actualizează automat la fiecare ciclu de interogare (HTTP) sau la fiecare mesaj MQTT.

> [!NOTE]
> Pentru a activa monitorizarea puterii, modelul dispozitivului trebuie configurat în aplicația Shelly sau în browserul web, la Settings > Device Model. Dacă becul este aprins, dar puterea citită este zero, șablonul afișează un avertisment referitor la acest pas de configurare.

### Diagnosticare de service (șablonul HTTP)

Șablonul HTTP oferă 10 atribute de service:

- **Informații despre rețea** — adresa IP, adresa MAC (formatată cu două puncte ca separator), puterea semnalului Wi-Fi (dB)
- **Conectivitate** — cloud activat/conectat, MQTT conectat
- **Informații despre dispozitiv** — ora dispozitivului, timpul de funcționare (formatat în zile/ore/minute), utilizarea memoriei RAM
- **Firmware** — actualizare de firmware disponibilă

### Acțiuni de service (șablonul HTTP)

Sunt disponibile două acțiuni de service:

- **Activare cloud** — activează sau dezactivează conectivitatea Shelly Cloud
- **Repornire** — declanșează repornirea dispozitivului

### Funcții suplimentare

Shelly DUO oferă și un temporizator al luminii (starea activ/inactiv și secundele rămase), un temporizator de oprire automată pe endpointul luminii, temperatura internă a dispozitivului, puterea semnalului Wi-Fi ca dispozitiv senzor separat și un topic MQTT LWT online/offline pentru detectarea stării conexiunii. Aceste funcții pot fi adăugate într-o actualizare viitoare a șablonului.

## Rezolvarea problemelor

### Becul nu răspunde (HTTP)

1. Verificați dacă DUO este conectat la Wi-Fi și are o adresă IP validă
2. Încercați numele de gazdă mDNS (`ShellyBulbDuo-AABBCCDDEE.local`) în locul adresei IP — adresa IP s-ar fi putut schimba după reînnoirea DHCP
3. Deschideți `http://{bulb-ip}/shelly` într-un browser — dacă răspunde cu un JSON care conține `"type":"SHBDUO-1"`, becul este accesibil
4. Verificați dacă unitatea de control TapHome (CCU) și DUO se află în aceeași rețea / VLAN

### Puterea afișată este zero

1. Verificați dacă modelul dispozitivului este configurat în aplicația Shelly (Settings > Device Model)
2. Verificați dacă becul este aprins — contorul măsoară doar atunci când trece curent
3. Interogați manual `/status` și verificați dacă `meters[0].power` returnează o valoare diferită de zero

### Becul MQTT nu răspunde

1. Verificați dacă MQTT este activat în interfața web Shelly (Internet & Security > Advanced — MQTT)
2. Verificați dacă adresa și portul brokerului sunt corecte atât în dispozitivul Shelly, cât și în setările modulului TapHome
3. Verificați dacă variabila personalizată `bulbNtopic` corespunde exact ID-ului dispozitivului becului (de ex. `ShellyBulbDuo-B929CC`)
4. Folosiți un client MQTT (de ex. MQTT Explorer) pentru a vă abona la `shellies/#` și verificați dacă becul publică mesaje

### Tranzițiile luminii sunt sacadate

1. Măriți parametrul timpului de tranziție — valoarea implicită de 300 ms poate fi prea scurtă pentru schimbări mari ale luminozității
2. Dacă folosiți HTTP, asigurați-vă că niciun alt sistem nu interoghează becul în același timp — dispozitivele Gen1 acceptă doar 2 conexiuni simultane

> [!WARNING]
> Dispozitivele Shelly Gen1 acceptă doar **2 conexiuni HTTP simultane**. Dacă TapHome și un alt sistem (de ex. Home Assistant) interoghează același dispozitiv în același timp, comunicarea poate deveni instabilă. În mediile cu mai multe sisteme, luați în considerare trecerea la șablonul MQTT.

## 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 2

Aceste dispozitive apar în TapHome după import.

Shelly DUO Modul

Atribute de service

|                            |
|----------------------------|
| Adresă IP                  |
| Adresă MAC                 |
| Semnal Wi-Fi               |
| Cloud activat              |
| Cloud conectat             |
| MQTT conectat              |
| Ora dispozitivului         |
| Actualizare FW disponibilă |
| Timp de funcționare        |
| RAM                        |

Acțiuni de service

|                |
|----------------|
| Activare cloud |
| Repornire      |

Variabile personalizate

|                                             |                                                                                 |
|---------------------------------------------|---------------------------------------------------------------------------------|
| `transitionTime` (numeric) = TransitionTime | Durata tranziției luminii în milisecunde (parametru de import, implicit 300 ms) |

Citire (modul)

```taphome
VAR now := NOW();

IF now.Ticks < debounceTimestamp
    RETURN(0);
END

VAR response := SENDHTTPREQUEST("/status");

IF response.IsSuccess
    jsonStatus := response.Content;
ELSE
    jsonStatus := NULL;
END
```

Atribute de service

IP Address

```taphome
VAR response := SENDHTTPREQUEST("/status");

IF response.IsSuccess
    jsonStatus := response.Content;
ELSE
    jsonStatus := NULL;
END

VAR address := PARSEJSON(jsonStatus, "$.wifi_sta.ip", 1);
IF (ISNULL(address), "-", address)
```

MAC Address

```taphome
VAR value := PARSEJSON(jsonStatus, "$.mac", 1);
IF ISNULL(value)
    RETURN("-");
END;

STRING mac;
INT i := 0;
INT len := LENGTH(value);

WHILE i < len
    mac += GETAT(value, i);
    i += 1;
    
    IF MOD(i, 2) = 0 AND i < len
        mac += ":";
    END
LOOP

mac
```

WIFI signal

```taphome
VAR signal := PARSEJSON(jsonStatus, "$.wifi_sta.rssi", 1);
IF (ISNULL(signal), "-", signal + "db");
```

Cloud enabled

```taphome
VAR value := PARSEJSON(jsonStatus, "$.cloud.enabled", 1);
IF (ISNULL(value), "-", value)
```

Cloud connected

```taphome
VAR value := PARSEJSON(jsonStatus, "$.cloud.connected", 1);
IF (ISNULL(value), "-", value)
```

MQTT connected

```taphome
VAR value := PARSEJSON(jsonStatus, "$.mqtt.connected", 1);
IF (ISNULL(value), "-", value)
```

Device time

```taphome
VAR value := PARSEJSON(jsonStatus, "$.time", 1);
IF (ISNULL(value), "-", value)
```

FW update available

```taphome
VAR value := PARSEJSON(jsonStatus, "$.has_update");
IF (ISNULL(value), "-", value)
```

Uptime

```taphome
VAR value := PARSEJSON(jsonStatus, "$.uptime", 1);
IF ISNULL(value)
    RETURN("-");
END

VAR days := FLOOR(value/86400, 1);
value := MOD(value, 86400);
VAR hours := FLOOR(value/3600, 1);
value := MOD(value, 3600);
VAR minutes := FLOOR(value/60, 1);

days + "day(s) " + hours + "h " + minutes + "m"
```

RAM

```taphome
VAR ramFree := PARSEJSON(jsonStatus, "$.ram_free", 1);
VAR ramTotal := PARSEJSON(jsonStatus, "$.ram_total", 1);

IF ISNULL(ramFree) OR ISNULL(ramTotal)
    RETURN("-");
END

ramFree + " bytes free of " + ramTotal
```

Acțiuni de service

Enable cloud

Parametri: Enable (Enable / Disable)

```taphome
VAR response := SENDHTTPREQUEST("/settings/cloud?enabled=" + enable);
VAR contentJson := response.Content;
VAR wasEnabled := PARSEJSON(contentJson, "enabled");

IF(wasEnabled, "Cloud enabled", "Cloud disabled");
```

Reboot

```taphome
VAR response := SENDHTTPREQUEST("/reboot");
VAR contentJson := response.Content;
VAR wasRebooted := PARSEJSON(contentJson, "ok");

IF(wasRebooted, "Reboot successful", "Error");
```

Lumină Lumină albă Citire și scriere

Lumină albă CCT (2700–6500 K) — reglarea luminozității și a temperaturii de culoare

numeric Unitate: %, K json\_path

Citirea luminozității

```taphome
VAR now := NOW();

IF now.Ticks < debounceTimestamp
    RETURN(Hb);
END

VAR value := PARSEJSON(jsonStatus, "$.lights[0].brightness", 1);

IF ISNULL(value)
    RETURN(NaN);
END

BOOL isOn := PARSEJSON(jsonStatus, "$.lights[0].ison", 1);

IF ISNULL(isOn)
    RETURN(NaN);
END

IF(isOn, value/100.0, 0);
```

Scrierea luminozității

```taphome
IF St > 0.5
    SENDHTTPREQUEST("light/0?turn=on&transition=" + transitionTime + "&brightness=" + ROUND(Hb*100.0));
ELSE
    SENDHTTPREQUEST("light/0?turn=off&transition=" + transitionTime);
END

VAR now := NOW();
debounceTimestamp := now.Ticks + transitionTime + 500;
```

Citirea temperaturii de culoare

```taphome
VAR now := NOW();

IF now.Ticks < debounceTimestamp
    RETURN(Ct);
END

VAR value := PARSEJSON(jsonStatus, "$.lights[0].temp", 1);

IF ISNULL(value)
    RETURN(NaN);
END
 
value
```

Scrierea temperaturii de culoare

```taphome
SENDHTTPREQUEST("light/0?transition=" + transitionTime + "&brightness=" + ROUND(Hb*100) + "&temp=" + Ct);

VAR now := NOW();
debounceTimestamp := now.Ticks + transitionTime + 500;
```

Contor electric Contor electric Doar citire

Măsurarea consumului de putere și de energie — putere instantanee (kW) și energie cumulată (kWh)

numeric Unitate: W / kWh json\_path

Citirea consumului total

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR power := PARSEJSON(jsonStatus, "$.meters[0].power");
VAR total := PARSEJSON(jsonStatus, "$.meters[0].total");
BOOL isOn := PARSEJSON(jsonStatus, "$.lights[0].ison");

IF ISNULL(power) OR ISNULL(total) OR (ison AND power=0)
	ADDWARNING("To enable power monitoring, open device settings in Shelly app or web browser and configure device model in Settings->Device Model");
	
    RETURN(NaN);
END

total / 60000.0
```

Citirea cererii

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR power := PARSEJSON(jsonStatus, "$.meters[0].power", 1);

IF ISNULL(power)
    RETURN(NaN);
END

power / 1000.0
```

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

Îmbunătățiri posibile (7)

- Light Timer Active — Boolean — whether a countdown timer is currently active on the light output.
- Timer Remaining — Seconds remaining on active timer. Available in /status response.
- Auto-off Timer — Auto-off timer in seconds, could be added as service action or light parameter.
- WiFi Signal Strength (as device) — WiFi RSSI in dBm. HTTP template exposes it as service attribute but not as a standalone sensor device.
- Internal Device Temperature — Internal temperature in celsius. Available in /status for Gen1 devices. Not exposed in DUO template.
- MQTT Real-time Power (as device attribute) — MQTT template reads power in electric meter device but does not expose it as a service attribute on the light device.
- Connection Status — LWT topic — true on connect, false on disconnect. Could detect offline bulbs.

## Parametri de import

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

| Solicitat în aplicație | Implicit      |
|------------------------|---------------|
| Adresă IP              | `192.168.0.1` |
| Transition time (ms)   | `300`         |

## 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 DUO — Device-Specific API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen1/#shelly-duo) 2026-03-30
- Shelly DUO — Product Datasheet
  
  [shellystore.co.uk](https://shellystore.co.uk/wp-content/uploads/2021/05/Duo-specs.pdf) 2026-03-30
  
  [PDF](https://taphome.com/compatibility/devices/shelly-duo/manufacturer/duo-specs.pdf)

Documentele producătorilor sunt © ale proprietarilor respectivi. Sunt furnizate așa cum au fost publicate de producător, doar ca referință.

## 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/)

