---
title: "Shelly RGBW2 White"
description: "Shelly RGBW2 in modalità White: quattro canali dimmer LED bianchi indipendenti con misurazione energetica per canale. Integrazione HTTP locale con TapHome."
url: "https://taphome.com/it/compatibility/shelly-rgbw2-white/"
language: it
lastmod: 2026-04-24
generator: hugo
ai:
  topics: ["http","lighting","wifi","dimmer","led-controller","shelly","gen1"]
  questions: ["Come integrare Shelly RGBW2 in modalità White con TapHome?","Come passare Shelly RGBW2 dalla modalità Color alla modalità White?","Posso controllare quattro strisce LED bianche separate con un solo Shelly RGBW2?","Perché Shelly RGBW2 White mostra l'errore „Mode is not supported\"?","Qual è la potenza massima per canale di Shelly RGBW2?","Shelly RGBW2 è ancora disponibile o è stato dismesso?"]
---

# Shelly RGBW2 White

Comunicazione: Packet Parser → HTTP

- [Pagina prodotto Shelly RGBW2](https://www.shelly.com/en/products/shop/shelly-rgbw2)
- [Documentazione API Shelly RGBW2 (modalità White)](https://shelly-api-docs.shelly.cloud/gen1/#shelly-rgbw2-white-mode)
- [Shelly RGBW2 Knowledge Base](https://kb.shelly.cloud/knowledge-base/shelly-rgbw2)

> 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 RGBW2 è un controller Wi-Fi per strisce LED con quattro uscite PWM (12/24 V DC). In **modalità White**, le quattro uscite — normalmente usate per i canali R, G, B e W di una striscia RGBW — diventano quattro canali dimmer monocromatici indipendenti. Ogni canale può pilotare la propria striscia LED bianca, lampadina LED o gruppo di faretti. TapHome comunica con il dispositivo via HTTP sulla rete locale; non è richiesta alcuna connessione cloud.

Questo template è il corrispettivo in modalità White del template [Shelly RGBW2](https://taphome.com/it/compatibility/shelly-rgbw2/) in modalità Color. Entrambi i template condividono lo stesso hardware ma il firmware opera in modalità mutualmente esclusive selezionate dalle impostazioni del dispositivo. Prima di importare questo template, il dispositivo deve essere configurato in modalità White — il template valida la modalità a ogni interrogazione e mostra un errore se il dispositivo è impostato su Color.

> [!NOTE]
> Shelly ha contrassegnato RGBW2 come **dismesso** — non è più prodotto né venduto dal Gruppo Shelly. Le unità esistenti continuano a funzionare e ricevono aggiornamenti firmware.

## Cablaggio

Shelly RGBW2 è alimentato da una fonte 12 V o 24 V DC (V+ / GND). Ognuna delle quattro uscite (contrassegnate R, G, B, W sul dispositivo) pilota un carico LED bianco. Schemi di cablaggio tipici per la modalità White:

- **Quattro strisce LED o lampadine bianche indipendenti** — ogni canale controlla una striscia/lampadina, anodo comune (+) su V+
- **Più faretti per canale** — diversi faretti 12/24 V cablati in parallelo per uscita
- **Due strisce bianche con potenza raddoppiata** — due canali abbinati per striscia (in parallelo) per raddoppiare la potenza in uscita

I limiti di carico per canale (dalla specifica Shelly) sono **45 W a 12 V** e **90 W a 24 V**. Il carico combinato su tutti e quattro i canali non deve superare 144 W a 12 V o 288 W a 24 V.

## Configurazione

Il template si connette via Wi-Fi. Durante l'importazione del template in TapHome, inserire l'indirizzo IP del dispositivo (placeholder predefinito `192.168.0.1`) e un transition time opzionale in millisecondi (predefinito `300`).

Il transition time controlla la velocità con cui ogni canale transita tra i livelli di luminosità. Viene inviato con ogni comando di scrittura e definisce anche la finestra di debounce — il template ignora i valori di luminosità interrogati per `transitionTime + 500 ms` dopo ogni scrittura per evitare letture obsolete durante una transizione.

## Cambio di modalità

Se il dispositivo è attualmente in modalità Color, passarlo in modalità White prima di importare questo template. Oppure:

- Aprire l'interfaccia web Shelly su `http://{device-ip}` e modificare la modalità operativa nelle impostazioni, oppure
- Inviare direttamente `GET /settings?mode=white`, oppure
- Importare temporaneamente il template Color, utilizzare la sua service action **Set mode White**, quindi reimportare questo template White

Il cambio di modalità richiede un riavvio del dispositivo. Dopo il riavvio, reimportare il template White in TapHome.

## Funzionalità del dispositivo

### Quattro dimmer indipendenti

Il template espone quattro canali dimmer indipendenti, uno per ciascuna uscita PWM:

| Canale | Pin di uscita | Endpoint     | Intervallo polling |
|--------|---------------|--------------|--------------------|
| Ch1    | R             | `/light/0`   | 2,5 s              |
| Ch2    | G             | `/light/1`   | 2,5 s              |
| Ch3    | B             | `/light/2`   | 2,5 s              |
| Ch4    | W             | `/light/3`   | 2,5 s              |

Ogni dimmer legge `lights[N].ison` e `lights[N].brightness` (0–100, normalizzati su 0–1) dalla risposta `/status`. I comandi di scrittura usano `/light/N?turn=on|off&brightness=VALUE&transition=T`. Il template usa l'endpoint legacy `/light/{idx}`, che il firmware Shelly accetta come alias dell'endpoint attuale `/white/{idx}`.

### Misurazione energetica per canale

Ogni canale ha un proprio contatore energetico — da **Electric Meter Ch1** a **Electric Meter Ch4** — che legge da `meters[0]` a `meters[3]`:

- **Potenza istantanea** — `meters[N].power` in watt, convertita in kW
- **Consumo totale** — `meters[N].total` in watt-minuti, convertito in kWh

Il canale 1 viene interrogato ogni 2,5 s insieme al suo dimmer; i canali 2–4 vengono interrogati a intervalli di 15 s per ridurre il carico sullo stack HTTP Gen1 (che tollera solo due connessioni simultanee).

### Diagnostica di servizio

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

- **Rete** — indirizzo IP, indirizzo MAC (formattato con due punti), intensità del segnale Wi-Fi (dB)
- **Connettività** — cloud abilitato/connesso, MQTT connesso
- **Info dispositivo** — ora del dispositivo, tempo di attività (formattato come giorni/ore/minuti), utilizzo RAM
- **Firmware** — aggiornamento firmware disponibile

### Service action

Sono disponibili tre service action:

- **Abilita cloud** — abilita o disabilita la connettività Shelly Cloud
- **Riavvio** — attiva un riavvio del dispositivo
- **Imposta modalità White** — scrive `/settings?mode=white` per forzare la modalità operativa White (utile dopo un ripristino di fabbrica o se qualcuno ha cambiato la modalità tramite l'app Shelly)

L'API Shelly Cloud **non** è utilizzata da questo template — la comunicazione avviene esclusivamente tramite polling HTTP locale.

## Risoluzione problemi

### Il dispositivo non risponde

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

### Errore „Mode White is not supported"

Questo errore indica che il dispositivo è attualmente impostato in modalità Color. Per risolvere:

1. Aprire l'interfaccia web Shelly su `http://{device-ip}` e passare la modalità operativa a White, oppure
2. Inviare direttamente `GET /settings?mode=white` da un browser o curl, oppure
3. Se è stato importato il template in modalità Color, eseguire la service action **Imposta modalità White** da lì
4. Il dispositivo deve riavviarsi dopo un cambio di modalità — attendere qualche secondo e ricaricare TapHome

### Le letture di potenza mostrano zero

1. Confermare che le LED bianche siano collegate all'uscita Shelly RGBW2 pertinente (pin R, G, B o W)
2. Aprire l'app Shelly o l'interfaccia web e verificare che il modello del dispositivo sia configurato in Settings -> Device Model — senza di esso il contatore restituisce zero
3. Verificare che il canale sia acceso — il contatore legge solo quando scorre corrente attraverso l'uscita
4. Interrogare manualmente `/status` e confermare che `meters[N].power` restituisca un valore diverso da zero per il canale in questione

### Il canale non dimmera in modo fluido

1. Verificare che il parametro transition time corrisponda al comportamento atteso — il valore predefinito di 300 ms è una dissolvenza breve; valori più lunghi (es. 1500 ms) producono transizioni più lente
2. Ricordare che la finestra di debounce è uguale a `transitionTime + 500 ms` — le modifiche inviate più velocemente possono essere accorpate
3. Verificare che il carico LED sia dimmerabile (alcuni driver non sono compatibili con PWM) e che l'alimentazione fornisca un 12/24 V DC stabile

> [!WARNING]
> I dispositivi Shelly Gen1 supportano solo **2 connessioni HTTP simultanee**. Se TapHome e un altro sistema (es. Home Assistant) interrogano lo stesso dispositivo contemporaneamente, la comunicazione può diventare inaffidabile. Mantenere l'intervallo di polling a 10–30 secondi per ogni client aggiuntivo.

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

Questi dispositivi compaiono in TapHome dopo l'importazione.

Shelly RGBW2 White Modulo

Attributi di servizio

|                              |                                                                                                      |
|------------------------------|------------------------------------------------------------------------------------------------------|
| Indirizzo IP                 | Indirizzo IP attuale assegnato al dispositivo (legge /status -&gt; wifi\_sta.ip)                     |
| Indirizzo MAC                | Indirizzo MAC del dispositivo, formattato con due punti (legge /status -&gt; mac)                    |
| Segnale WiFi                 | Intensità del segnale Wi-Fi in dB (legge /status -&gt; wifi\_sta.rssi)                               |
| Cloud abilitato              | Se Shelly Cloud è abilitato sul dispositivo (legge /status -&gt; cloud.enabled)                      |
| Cloud connesso               | Se il dispositivo è attualmente connesso a Shelly Cloud (legge /status -&gt; cloud.connected)        |
| MQTT connesso                | Se il dispositivo è attualmente connesso a un broker MQTT (legge /status -&gt; mqtt.connected)       |
| Ora del dispositivo          | Ora attuale riportata dal dispositivo (legge /status -&gt; time)                                     |
| Aggiornamento FW disponibile | True se è disponibile un aggiornamento firmware per il dispositivo (legge /status -&gt; has\_update) |
| Tempo di attività            | Tempo trascorso dall'ultimo riavvio, formattato come giorni/ore/minuti (legge /status -&gt; uptime)  |
| RAM                          | RAM totale e libera in byte (legge /status -&gt; ram\_total, ram\_free)                              |

Azioni di servizio

|                        |                                                                                                                                                                  |
|------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Abilita cloud          | Abilita o disabilita la connessione Shelly Cloud (scrive /settings/cloud?enabled=...)                                                                            |
| Riavvio                | Attiva il riavvio immediato del dispositivo (scrive /reboot)                                                                                                     |
| Imposta modalità White | Passa il dispositivo alla modalità operativa White; è necessario un riavvio del dispositivo prima che il nuovo modo diventi attivo (scrive /settings?mode=white) |

Variabili personalizzate

|                                             |                                                                                                                                                                                                                                                  |
|---------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `transitionTime` (numeric) = TransitionTime | Durata della transizione luminosa in millisecondi (parametro di importazione, predefinito 300 ms). Definisce anche la finestra di debounce (transitionTime + 500 ms) durante la quale i valori interrogati vengono ignorati dopo ogni scrittura. |

Lettura (modulo)

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

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

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

IF response.IsSuccess
    jsonStatus := response.Content;
    
    if PARSEJSON(jsonStatus, "$.mode", 1) = "color"
    adderror("Mode Color is not supported");
    end
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");
```

Set mode White

```taphome
VAR response := SENDHTTPREQUEST("/settings?mode=white");
IF(response.isSuccess, "White mode is set", "Error");
```

Contatore elettrico Ch1 Contatore elettrico Solo lettura

Consumo canale 1 (pin R) — 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
```

Dimmer Ch1 (R) Dimmer Lettura e scrittura

Dimmer bianco canale 1 (uscita pin R) — luminosità 0-100 % via endpoint /light/0

numeric Unità: 0–1

Lettura livello

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

VAR now := NOW();
var tmp := now.Ticks - debounceTimestamp;
if now.Ticks > debounceTimestamp
    BOOL isOn := PARSEJSON(jsonStatus, "$.lights[0].ison");
    var brightness := PARSEJSON(jsonStatus, "$.lights[0].brightness");

    if isOn
        return(brightness / 100);
    else
        return(0);
    end
else
    return(le);
end
```

Scrittura livello

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

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

Contatore elettrico Ch2 Contatore elettrico Solo lettura

Consumo canale 2 (pin G) — 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[1].power");
VAR total := PARSEJSON(jsonStatus, "$.meters[1].total");
BOOL isOn := PARSEJSON(jsonStatus, "$.lights[1].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[1].power", 1);

IF ISNULL(power)
    RETURN(NaN);
END

power / 1000.0
```

Dimmer Ch2 (G) Dimmer Lettura e scrittura

Dimmer bianco canale 2 (uscita pin G) — luminosità 0-100 % via endpoint /light/1

numeric Unità: 0–1

Lettura livello

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

VAR now := NOW();
var tmp := now.Ticks - debounceTimestamp;
if now.Ticks > debounceTimestamp
    BOOL isOn := PARSEJSON(jsonStatus, "$.lights[1].ison");
    var brightness := PARSEJSON(jsonStatus, "$.lights[1].brightness");

    if isOn
        return(brightness / 100);
    else
        return(0);
    end
else
    return(le);
end
```

Scrittura livello

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

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

Contatore elettrico Ch3 Contatore elettrico Solo lettura

Consumo canale 3 (pin B) — 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[2].power");
VAR total := PARSEJSON(jsonStatus, "$.meters[2].total");
BOOL isOn := PARSEJSON(jsonStatus, "$.lights[2].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[2].power", 1);

IF ISNULL(power)
    RETURN(NaN);
END

power / 1000.0
```

Dimmer Ch3 (B) Dimmer Lettura e scrittura

Dimmer bianco canale 3 (uscita pin B) — luminosità 0-100 % via endpoint /light/2

numeric Unità: 0–1

Lettura livello

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

VAR now := NOW();
var tmp := now.Ticks - debounceTimestamp;
if now.Ticks > debounceTimestamp
    BOOL isOn := PARSEJSON(jsonStatus, "$.lights[2].ison");
    var brightness := PARSEJSON(jsonStatus, "$.lights[2].brightness");

    if isOn
        return(brightness / 100);
    else
        return(0);
    end
else
    return(le);
end
```

Scrittura livello

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

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

Contatore elettrico Ch4 Contatore elettrico Solo lettura

Consumo canale 4 (pin W) — 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[3].power");
VAR total := PARSEJSON(jsonStatus, "$.meters[3].total");
BOOL isOn := PARSEJSON(jsonStatus, "$.lights[3].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[3].power", 1);

IF ISNULL(power)
    RETURN(NaN);
END

power / 1000.0
```

Dimmer Ch4 (W) Dimmer Lettura e scrittura

Dimmer bianco canale 4 (uscita pin W) — luminosità 0-100 % via endpoint /light/3

numeric Unità: 0–1

Lettura livello

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

VAR now := NOW();
var tmp := now.Ticks - debounceTimestamp;
if now.Ticks > debounceTimestamp
    BOOL isOn := PARSEJSON(jsonStatus, "$.lights[3].ison");
    var brightness := PARSEJSON(jsonStatus, "$.lights[3].brightness");

    if isOn
        return(brightness / 100);
    else
        return(0);
    end
else
    return(le);
end
```

Scrittura livello

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

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

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

Possibili miglioramenti (10)

- Auto-off timer per channel — Each /white/{idx} (or legacy /light/{idx}) accepts a timer=N parameter for auto-off countdown; timer\_remaining is readable from /status
- Per-channel default state & auto-on/auto-off — Per-channel settings (default\_state off/on/last, auto\_on, auto\_off, name) — not exposed as service action
- Night mode (per channel) — Time-window auto-dim (enabled, start\_time, end\_time, brightness) per white channel — fw v1.12.0+
- Input State — Physical button/switch input state (0/1), available in /status response
- WiFi RSSI (numeric) — WiFi RSSI in dBm as numeric value — template reads it only as a formatted string with 'db' suffix
- Power protection — Max power setting in Watts, available in /settings; read + write possible via /settings?max\_power=N
- OTA firmware update — Trigger OTA firmware update via /ota?update=true
- Internal device temperature — Internal temperature in °C, available in /status response (Gen1 devices)
- Overheated — Overtemperature flag, boolean, available in /status response
- Set mode Color — Switch back to Color mode — template only exposes Set mode White; inverse action omitted (by design, this template is White-only)

## 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 RGBW2 API — Color & White Mode Endpoints
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen1/#shelly-rgbw2-white-mode) 2026-03-30
- Shelly RGBW2 Knowledge Base
  
  [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-rgbw2) 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/)