TapHome

Shelly DUO RGBW

Packet Parser → HTTP
Inviato da
Ultimo aggiornamento: 03. 2026
Shelly DUO RGBW

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.

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.

In modalità MQTT, la finestra di debounce è di 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.

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

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

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

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

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

Shelly DUO RGBW Module Modulo
Attributi di servizio
IP Address
MAC Address
WIFI signal
Cloud enabled
Cloud connected
MQTT connected
Device time
FW update available
Uptime
RAM
Azioni di servizio
Enable cloud
Reboot
Variabili personalizzate
jsonStatus (string)
debounceTimestamp (numeric)
transitionTime (numeric) = TransitionTime

Shelly DUO RGBW Module

Lettura (modulo)
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
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
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
VAR signal := PARSEJSON(jsonStatus, "$.wifi_sta.rssi", 1);
IF (ISNULL(signal), "-", signal + "db");
Cloud enabled
VAR value := PARSEJSON(jsonStatus, "$.cloud.enabled", 1);
IF (ISNULL(value), "-", value)
Cloud connected
VAR value := PARSEJSON(jsonStatus, "$.cloud.connected", 1);
IF (ISNULL(value), "-", value)
MQTT connected
VAR value := PARSEJSON(jsonStatus, "$.mqtt.connected", 1);
IF (ISNULL(value), "-", value)
Device time
VAR value := PARSEJSON(jsonStatus, "$.time", 1);
IF (ISNULL(value), "-", value)
FW update available
VAR value := PARSEJSON(jsonStatus, "$.has_update");
IF (ISNULL(value), "-", value)
Uptime
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
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)
VAR response := SENDHTTPREQUEST("/settings/cloud?enabled=" + enable);
VAR contentJson := response.Content;
VAR wasEnabled := PARSEJSON(contentJson, "enabled");

IF(wasEnabled, "Cloud enabled", "Cloud disabled");
Reboot
VAR response := SENDHTTPREQUEST("/reboot");
VAR contentJson := response.Content;
VAR wasRebooted := PARSEJSON(contentJson, "ok");

IF(wasRebooted, "Reboot successful", "Error");
Shelly DUO RGBW ${deviceType_Light} Luce HSB

Shelly DUO RGBW ${deviceType_Light}

Lettura luminosità
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à
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à
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à
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
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
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
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
IF Ct = NaN
    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;
Shelly DUO RGBW Electric meter Contatore elettrico

Shelly DUO RGBW Electric meter

Lettura consumo totale
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
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
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.

Fonti