---
title: "Shelly DUO RGBW"
description: "Controllo completo RGB + CCT, transizioni fluide e misurazione potenza per la lampadina Shelly DUO RGBW GU10. Template HTTP e MQTT per TapHome."
url: "https://taphome.com/it/compatibility/shelly-duo-rgbw/"
language: it
lastmod: 2026-10-08
generator: hugo
ai:
  topics: ["http","mqtt","lighting","wifi","rgbw","color-temperature","power-metering"]
  questions: ["Come integrare lo Shelly DUO RGBW con TapHome?","Come controllare colore e luminosità dello Shelly DUO RGBW da TapHome?","Come collegare lo Shelly DUO RGBW via HTTP a TapHome?","Come collegare più lampadine Shelly DUO RGBW via MQTT a TapHome?","Perché lo Shelly DUO RGBW mostra potenza zero?","Come passare dalla modalità RGB a quella bianca sullo Shelly DUO RGBW?"]
---

# Shelly DUO RGBW

Comunicazione: Packet Parser → HTTP

- [Pagina prodotto Shelly DUO RGBW](https://www.shelly.com/en/products/shop/shelly-duo-rgbw-gu10)

> 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

Lo Shelly DUO RGBW è una lampadina LED smart Wi-Fi Gen1 nel formato GU10. Supporta colori RGB completi e bianco regolabile (CCT 3000–6500 K) con effetti di transizione fluidi. TapHome comunica con il dispositivo tramite la rete locale — non è necessaria alcuna connessione cloud.

Sono disponibili due template TapHome: un **template HTTP** per controllare una singola lampadina tramite API REST e un **template MQTT** che può controllare fino a **5 lampadine** tramite un broker MQTT condiviso. Entrambi i template espongono il controllo luce completo e la misurazione della potenza.

## Configurazione

### Template HTTP

Il template HTTP richiede l'indirizzo IP della lampadina (placeholder predefinito `192.168.0.1`) e un tempo di transizione opzionale in millisecondi (predefinito 300 ms). TapHome interroga l'endpoint `/status` ogni 2,5 secondi per leggere lo stato della luce, i valori del colore e i dati di misurazione energetica.

Lo script di lettura a livello modulo memorizza la risposta `/status` nella variabile personalizzata `jsonStatus`, così gli script dei singoli dispositivi possono analizzare i dati senza effettuare chiamate HTTP ridondanti.

### Template MQTT

Il template MQTT richiede i dati di connessione al broker e uno o più **Device ID** — uno per lampadina. Il Device ID di ogni lampadina è configurato tramite la variabile personalizzata `bulbNtopic` (formato: `shellycolorbulb-DEVICEID`). Il Device ID si trova nell'interfaccia web Shelly in **Settings** > **Device Info**.

Il template supporta fino a 5 lampadine contemporaneamente. Configurare le variabili `bulbNtopic` solo per le lampadine effettivamente possedute — gli slot non utilizzati possono essere lasciati ai valori placeholder predefiniti.

Dopo aver abilitato MQTT sullo Shelly DUO RGBW (Internet & Security > Advanced — MQTT), TapHome si iscrive a `shellies/#` e instrada i messaggi all'istanza corretta della lampadina in base al prefisso del topic.

> [!WARNING]
> Sui dispositivi Shelly Gen1, l'abilitazione di MQTT **disabilita Shelly Cloud**. Entrambi non possono funzionare simultaneamente.

## Funzionalità del dispositivo

### Controllo luce

La lampadina opera in due modalità mutuamente esclusive:

- **Modalità colore** — controllo RGB completo tramite canali rosso, verde e blu (0–255 ciascuno) più gain (luminosità, 0–100 %). TapHome lo rappresenta come luce HSB — tonalità (0–360), saturazione (0,0–1,0) e luminosità (0,0–1,0) vengono convertiti da RGB usando la funzione `RGBTOHSV`.
- **Modalità bianca** — bianco regolabile tramite temperatura colore (3000–6500 K) e luminosità (0–100 %). L'impostazione di un valore CCT in TapHome commuta automaticamente la lampadina in modalità bianca.

La modalità commuta automaticamente in base alla proprietà impostata:
- L'impostazione della tonalità o saturazione invia un comando `/light/0?mode=color` (HTTP) o un payload JSON con `"mode":"color"` tramite `color/0/set` (MQTT)
- L'impostazione del CCT invia un comando `/light/0?mode=white` (HTTP) o un payload con `"mode":"white"` (MQTT)

Tutti i comandi di scrittura includono il parametro `transitionTime` configurato per una dissolvenza fluida tra gli stati. Un meccanismo di debounce previene letture obsolete durante le transizioni — il template ignora le risposte `/status` per un breve periodo dopo ogni scrittura.

> [!NOTE]
> In modalità MQTT, la finestra di debounce è pari al tempo di transizione più 3 secondi dopo ogni scrittura (più lunga del template HTTP) per tenere conto della latenza di consegna dei messaggi MQTT.

### Misurazione potenza

Entrambi i template espongono un contatore elettrico che legge due valori:

- **Potenza istantanea** — in watt, convertita in kW dividendo per 1000
- **Consumo totale** — in watt-minuti, convertito in kWh dividendo per 60 000

Il template HTTP legge `meters[0].power` e `meters[0].total` dalla risposta `/status`. Il template MQTT ascolta i topic `shellies/{id}/light/0/power` e `shellies/{id}/light/0/energy` per ogni lampadina indipendentemente.

> [!TIP]
> Il monitoraggio della potenza richiede la configurazione del modello dispositivo nell'app Shelly o nell'interfaccia web in **Settings** > **Device Model**. Se il modello non è impostato e la lampadina è accesa ma la potenza mostra zero, il template visualizza un avviso.

### Diagnostica di servizio (solo HTTP)

Il template HTTP espone 10 attributi di servizio per il monitoraggio del dispositivo:

- **Info rete** — indirizzo IP, indirizzo MAC, intensità segnale WiFi (dB)
- **Connettività** — cloud abilitato/connesso, MQTT connesso
- **Sistema** — ora dispositivo, aggiornamento firmware disponibile, tempo di attività, utilizzo RAM

### Azioni di servizio (solo HTTP)

Due azioni di servizio sono disponibili nel template HTTP:

- **Abilita cloud** — abilita o disabilita la connettività Shelly Cloud
- **Riavvio** — avvia un riavvio del dispositivo

### Funzionalità aggiuntive

Lo Shelly DUO RGBW supporta anche effetti luce (meteor shower, gradual change, breath, flash, on/off gradual, red/green change), un canale LED bianco dedicato in modalità colore e lo stato connessione MQTT (LWT). Queste funzionalità potranno essere aggiunte in un futuro aggiornamento del template.

## Risoluzione dei problemi

### La lampadina non risponde (HTTP)

1. Verificare che la lampadina sia connessa al Wi-Fi e abbia un indirizzo IP valido
2. Provare a usare l'hostname mDNS (`shellycolorbulb-AABBCCDDEE.local`) invece dell'indirizzo IP — l'IP potrebbe essere cambiato dopo un rinnovo DHCP
3. Aprire `http://{device-ip}/shelly` nel browser — se risponde, il dispositivo è raggiungibile
4. Verificare che TapHome CCU e la lampadina siano sulla stessa rete / VLAN

### I colori appaiono non corretti

1. Verificare che la lampadina sia nella modalità corretta — i colori RGB funzionano solo in modalità colore, non in modalità bianca
2. Quando si imposta un colore tramite TapHome, assicurarsi che la saturazione sia maggiore di zero — una saturazione di 0 produce luce bianca indipendentemente dalla tonalità
3. Verificare che il gain (luminosità in modalità colore) non sia impostato a zero

### La potenza mostra zero

1. Confermare che il modello dispositivo è configurato nell'app Shelly (Settings > Device Model)
2. Verificare che la lampadina sia accesa — il contatore misura solo quando scorre corrente
3. Interrogare `/status` manualmente e verificare che `meters[0].power` restituisca un valore diverso da zero

### Le lampadine MQTT non rispondono

1. Verificare che MQTT sia abilitato nell'interfaccia web di ogni lampadina (Internet & Security > Advanced — MQTT)
2. Confermare che indirizzo broker e porta siano corretti sia nel dispositivo Shelly che nelle impostazioni modulo TapHome
3. Verificare che la variabile personalizzata `bulbNtopic` corrisponda esattamente al Device ID della lampadina (es. `shellycolorbulb-B929CC`)
4. Utilizzare un client MQTT (es. MQTT Explorer) per iscriversi a `shellies/#` e verificare che ogni lampadina pubblichi messaggi

> [!WARNING]
> I dispositivi Shelly Gen1 supportano solo **2 connessioni HTTP simultanee**. Se TapHome e un altro sistema (es. Home Assistant) interrogano la stessa lampadina contemporaneamente, la comunicazione potrebbe diventare inaffidabile. Considerare il passaggio al template MQTT per ambienti con più sistemi.

## 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<model>-<mac>.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 2

Questi dispositivi compaiono in TapHome dopo l'importazione.

Shelly DUO RGBW Modulo

Attributi di servizio

|                              |
|------------------------------|
| Indirizzo IP                 |
| Indirizzo MAC                |
| Segnale WiFi                 |
| Cloud abilitato              |
| Cloud connesso               |
| MQTT connesso                |
| Ora del dispositivo          |
| Aggiornamento FW disponibile |
| Tempo di attività            |
| RAM                          |

Azioni di servizio

|               |
|---------------|
| Abilita cloud |
| Riavvio       |

Variabili personalizzate

|                                             |                                                                              |
|---------------------------------------------|------------------------------------------------------------------------------|
| `transitionTime` (numeric) = TransitionTime | Light transition duration in milliseconds (import parameter, default 300 ms) |

Lettura (modulo)

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

Attributi di servizio

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

Azioni di servizio

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

Luce RGBW Luce HSB Lettura e scrittura

Colore RGB completo + bianco regolabile (CCT 3000–6500 K) con transizioni fluide e controllo luminosità in base alla modalità

HSB

Lettura luminosità

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

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

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

IF mode = "white"
    value := PARSEJSON(jsonStatus, "$.lights[0].brightness", 1);
ELSE
    value := PARSEJSON(jsonStatus, "$.lights[0].gain", 1);
END

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

Scrittura luminosità

```taphome
IF St > 0.5
    VAR mode := PARSEJSON(jsonStatus, "$.lights[0].mode", 1);
    
    IF mode = "white"
        SENDHTTPREQUEST("light/0?turn=on&transition=" + transitionTime + "&brightness=" + ROUND(Hb*100.0));
    ELSE
        SENDHTTPREQUEST("light/0?turn=on&transition=" + transitionTime + "&gain=" + ROUND(Hb*100.0));
    END
ELSE
    SENDHTTPREQUEST("light/0?turn=off&transition=" + transitionTime);
END

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

Lettura tonalità

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

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

INT r := PARSEJSON(jsonStatus, "$.lights[0].red", 1);
INT g := PARSEJSON(jsonStatus, "$.lights[0].green", 1);
INT b := PARSEJSON(jsonStatus, "$.lights[0].blue", 1);
 
VAR HSVColor := RGBTOHSV(r, g, b);
ROUND(HSVColor.Hue);
```

Scrittura tonalità

```taphome
IF !ISNAN(Ct)
    RETURN(0);
END

VAR color := HSVTORGB(Hd, Sa, 1);

SENDHTTPREQUEST("light/0?mode=color&transition=" + transitionTime + "&gain=" + ROUND(Hb*100) + "&red=" + color.RED + "&green=" + color.GREEN + "&blue=" + color.BLUE);


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

Lettura saturazione

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

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

INT r := PARSEJSON(jsonStatus, "$.lights[0].red", 1);
INT g := PARSEJSON(jsonStatus, "$.lights[0].green", 1);
INT b := PARSEJSON(jsonStatus, "$.lights[0].blue", 1);
 
VAR HSVColor := RGBTOHSV(r, g, b);
ROUND(HSVColor.Saturation * 100.0) / 100.0;
```

Scrittura saturazione

```taphome
IF !ISNAN(Ct)
    RETURN(0);
END

VAR color := HSVTORGB(Hd, Sa, 1);

SENDHTTPREQUEST("light/0?mode=color&transition=" + transitionTime + "&gain=" + ROUND(Hb*100) + "&red=" + color.RED + "&green=" + color.GREEN + "&blue=" + color.BLUE);


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

Lettura temperatura colore

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

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

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

IF ISNULL(value) OR mode != "white"
    RETURN(NaN);
END
 
value
```

Scrittura temperatura colore

```taphome
IF ISNAN(Ct)
    RETURN(0);
END

VAR temp := MIN(Ct, 6500);
temp := MAX(temp, 3000);

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

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

Contatore elettrico Contatore elettrico Solo lettura

Misurazione consumo energetico — potenza istantanea (kW) ed energia cumulativa (kWh)

numeric Unità: W / kWh

Lettura consumo totale

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

Lettura domanda

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

**Connessione:** Packet Parser → HTTP • Hostname: `shellycolorbulb-{MAC}.local`

Possibili miglioramenti (4)

- Light Effect — Effect index (0=Off, 1=Meteor Shower, 2=Gradual Change, 3=Breath, 4=Flash, 5=On/Off Gradual, 6=Red/Green Change). Available in both /light/0 and MQTT color/0/set.
- WiFi Signal Strength — WiFi RSSI in dBm, available in /status response (HTTP only; MQTT template reads it as service attribute already)
- White Channel — Dedicated white LED channel (0–255) in color mode, separate from CCT. Available in /light/0?white=N.
- Connection Status (MQTT) — LWT topic — true on connect, false on disconnect. Could detect offline bulbs.

## Parametri di importazione

Inserisci questi valori quando importi l'XML.

| Richiesto nell'app   | Predefinito   |
|----------------------|---------------|
| Indirizzo IP         | `192.168.0.1` |
| Transition time (ms) | `300`         |

## 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 DUO RGBW — Device-Specific API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen1/#shelly-bulb-rgbw) 2026-03-30
- Shelly DUO RGBW — Knowledge Base
  
  [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-bulb-duo-rgbw) 2026-03-30

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