---
title: "Shelly RGBW2 White"
description: "Shelly RGBW2 în modul White: patru canale de dimmer independente pentru LED-uri albe, cu măsurarea energiei pe canal. HTTP local cu TapHome, fără cloud."
url: "https://taphome.com/ro/compatibility/shelly-rgbw2-white/"
language: ro
lastmod: 2026-04-24
generator: hugo
ai:
  topics: ["http","lighting","wifi","dimmer","led-controller","shelly","gen1"]
  questions: ["Cum integrez Shelly RGBW2 în modul White cu TapHome?","Cum comut Shelly RGBW2 din modul Color în modul White?","Pot comanda patru benzi LED albe separate cu un singur Shelly RGBW2?","De ce Shelly RGBW2 White afișează eroarea „Mode is not supported”?","Care este puterea maximă pe canal la Shelly RGBW2?","Mai este disponibil Shelly RGBW2 sau a fost scos din producție?"]
---

# Shelly RGBW2 White

Comunicație: Packet Parser → HTTP

- [Pagina produsului Shelly RGBW2](https://www.shelly.com/en/products/shop/shelly-rgbw2)
- [Documentația API Shelly RGBW2 (modul White)](https://shelly-api-docs.shelly.cloud/gen1/#shelly-rgbw2-white-mode)
- [Baza de cunoștințe Shelly RGBW2](https://kb.shelly.cloud/knowledge-base/shelly-rgbw2)

> 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 RGBW2 este un controler Wi-Fi pentru benzi LED, cu patru ieșiri PWM (12/24 V DC). În **modul White**, cele patru ieșiri — folosite în mod normal pentru R, G, B și W ale unei benzi RGBW — devin patru canale de dimmer monocolore independente. Fiecare canal poate comanda propria bandă LED albă, un bec LED sau un grup de spoturi. TapHome comunică cu dispozitivul prin HTTP în rețeaua locală; nu este necesară conexiunea la cloud.

Acest șablon este varianta pentru modul White a șablonului [Shelly RGBW2](https://taphome.com/ro/compatibility/shelly-rgbw2/) pentru modul Color. Ambele șabloane folosesc același hardware, dar firmware-ul funcționează în moduri care se exclud reciproc, selectate din setările dispozitivului. Înainte de a importa acest șablon, dispozitivul trebuie configurat în modul White — șablonul verifică modul la fiecare interogare și afișează o eroare dacă dispozitivul este setat pe Color.

> [!NOTE]
> Shelly a marcat RGBW2 ca **scos din producție** — Shelly Group nu îl mai produce și nu îl mai vinde. Unitățile existente continuă să funcționeze și primesc în continuare actualizări de firmware.

## Cablare

Shelly RGBW2 se alimentează de la o sursă de 12 V sau 24 V DC (V+ / GND). Fiecare dintre cele patru ieșiri (marcate R, G, B, W pe dispozitiv) comandă o sarcină LED albă. Scheme de cablare tipice pentru modul White:

- **Patru benzi LED albe sau becuri independente** — fiecare canal comandă o bandă/un bec, cu anodul comun (+) la V+
- **Mai multe spoturi pe canal** — mai multe spoturi de 12/24 V conectate în paralel pe fiecare ieșire
- **Două benzi albe cu putere dublă** — câte două canale pe bandă (în paralel), pentru a dubla puterea de ieșire

Limitele de sarcină pe canal (conform specificației Shelly) sunt **45 W la 12 V** și **90 W la 24 V**. Sarcina totală pe toate cele patru canale nu trebuie să depășească 144 W la 12 V sau 288 W la 24 V.

## Configurare

Șablonul se conectează prin Wi-Fi. La importul șablonului în TapHome, introduceți adresa IP a dispozitivului (valoarea implicită: `192.168.0.1`) și, opțional, timpul de tranziție în milisecunde (implicit `300`).

Timpul de tranziție determină cât de repede se schimbă treptat luminozitatea fiecărui canal. Se trimite cu fiecare comandă de scriere și definește și fereastra debounce — după fiecare scriere, șablonul ignoră valorile de luminozitate interogate timp de `transitionTime + 500 ms`, pentru a preveni citirile neactualizate în timpul unei tranziții graduale.

## Comutarea modului

Dacă dispozitivul este în prezent în modul Color, comutați-l în modul White înainte de a importa acest șablon. Aveți următoarele variante:

- Deschideți interfața web Shelly la `http://{device-ip}` și schimbați modul de funcționare în setări, sau
- Trimiteți direct `GET /settings?mode=white`, sau
- Importați temporar șablonul pentru modul Color și folosiți acțiunea sa de service **Setare mod White**, apoi importați din nou acest șablon pentru modul White

Schimbarea modului necesită repornirea dispozitivului. După ce dispozitivul repornește, importați din nou în TapHome șablonul pentru modul White.

## Funcțiile dispozitivului

### Patru dimmere independente

Șablonul oferă patru canale de dimmer independente, câte unul pentru fiecare ieșire PWM:

| Canal | Pin de ieșire | Endpoint     | Interval de interogare |
|---------|------------|--------------|---------------|
| 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         |

Fiecare dimmer citește `lights[N].ison` și `lights[N].brightness` (0-100, normalizat la 0-1) din răspunsul `/status`. Comenzile de scriere folosesc `/light/N?turn=on|off&brightness=VALUE&transition=T`. Șablonul folosește endpointul mai vechi `/light/{idx}`, pe care firmware-ul Shelly îl acceptă ca alias al endpointului actual `/white/{idx}`.

### Măsurarea puterii pe fiecare canal

Fiecare canal are propriul contor electric — de la **Contor electric Ch1** până la **Contor electric Ch4** — care citește din `meters[0]` până la `meters[3]`:

- **Putere în timp real** — `meters[N].power` în wați, convertită în kW
- **Consum total** — `meters[N].total` în wați-minut, convertit în kWh

Canalul 1 este interogat la 2,5 s, împreună cu dimmerul său; canalele 2-4 sunt interogate la intervale de 15 s, pentru a reduce încărcarea stivei HTTP Gen1 (care acceptă doar două conexiuni simultane).

### Diagnosticare de service

Șablonul oferă 10 atribute de service pentru monitorizarea dispozitivului:

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

### Acțiuni de service

Sunt disponibile trei acțiuni de service:

- **Activare cloud** — activează sau dezactivează conectivitatea Shelly Cloud
- **Repornire** — declanșează repornirea dispozitivului
- **Setare mod White** — scrie `/settings?mode=white` pentru a impune modul de funcționare White (util după o resetare la setările din fabrică sau dacă cineva a schimbat modul din aplicația Shelly)

Acest șablon **nu** folosește Shelly Cloud API — comunicația se face exclusiv prin interogare HTTP locală.

## Rezolvarea problemelor

### Dispozitivul nu răspunde

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

### Eroarea „Mode White is not supported”

Această eroare înseamnă că dispozitivul este setat în prezent pe modul Color. Pentru rezolvare:

1. Deschideți interfața web Shelly la `http://{device-ip}` și comutați modul de funcționare pe White, sau
2. Trimiteți direct `GET /settings?mode=white` dintr-un browser sau cu curl, sau
3. Dacă aveți importat șablonul pentru modul Color, rulați de acolo acțiunea de service **Setare mod White**
4. După schimbarea modului, dispozitivul trebuie să repornească — așteptați câteva secunde și reîncărcați TapHome

### Valorile puterii sunt zero

1. Verificați dacă LED-urile albe sunt conectate la ieșirea corespunzătoare a Shelly RGBW2 (pinul R, G, B sau W)
2. Deschideți aplicația Shelly sau interfața web și verificați dacă modelul dispozitivului este configurat la Settings -> Device Model — fără această setare, contorul returnează zero
3. Verificați dacă respectivul canal este pornit — contorul măsoară doar atunci când prin ieșire trece curent
4. Interogați manual `/status` și verificați dacă `meters[N].power` returnează o valoare diferită de zero pentru canalul respectiv

### Canalul nu reglează intensitatea lin

1. Verificați dacă parametrul timpului de tranziție corespunde comportamentului așteptat — valoarea implicită de 300 ms este o tranziție scurtă; valorile mai mari (de ex. 1500 ms) produc tranziții mai lente
2. Rețineți că fereastra debounce este egală cu `transitionTime + 500 ms` — modificările trimise mai repede de atât pot fi comasate
3. Verificați dacă sarcina LED este dimabilă (unele drivere nu sunt compatibile cu PWM) și dacă sursa de alimentare furnizează o tensiune stabilă de 12/24 V DC

> [!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ă. Păstrați intervalul de interogare la 10-30 de secunde pentru fiecare client suplimentar.

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

Aceste dispozitive apar în TapHome după import.

Shelly RGBW2 White Modul

Atribute de service

|                            |                                                                                                            |
|----------------------------|------------------------------------------------------------------------------------------------------------|
| Adresă IP                  | Adresa IP curentă atribuită dispozitivului (citește /status -&gt; wifi\_sta.ip)                            |
| Adresă MAC                 | Adresa MAC a dispozitivului, formatată cu două puncte (citește /status -&gt; mac)                          |
| Semnal Wi-Fi               | Puterea semnalului Wi-Fi în dB (citește /status -&gt; wifi\_sta.rssi)                                      |
| Cloud activat              | Indică dacă Shelly Cloud este activat pe dispozitiv (citește /status -&gt; cloud.enabled)                  |
| Cloud conectat             | Indică dacă dispozitivul este conectat în prezent la Shelly Cloud (citește /status -&gt; cloud.connected)  |
| MQTT conectat              | Indică dacă dispozitivul este conectat în prezent la un broker MQTT (citește /status -&gt; mqtt.connected) |
| Ora dispozitivului         | Ora curentă raportată de dispozitiv (citește /status -&gt; time)                                           |
| Actualizare FW disponibilă | True dacă pentru dispozitiv este disponibilă o actualizare de firmware (citește /status -&gt; has\_update) |
| Timp de funcționare        | Timpul scurs de la ultima repornire, formatat ca zile/ore/minute (citește /status -&gt; uptime)            |
| RAM                        | Memoria RAM totală și liberă în octeți (citește /status -&gt; ram\_total, ram\_free)                       |

Acțiuni de service

|                  |                                                                                                                                      |
|------------------|--------------------------------------------------------------------------------------------------------------------------------------|
| Activare cloud   | Activează sau dezactivează conectivitatea Shelly Cloud (scrie /settings/cloud?enabled=...)                                           |
| Repornire        | Declanșează repornirea imediată a dispozitivului (scrie /reboot)                                                                     |
| Setare mod White | Comută dispozitivul în modul de funcționare White; noul mod devine activ după repornirea dispozitivului (scrie /settings?mode=white) |

Variabile personalizate

|                                             |                                                                                                                                                                                                             |
|---------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `transitionTime` (numeric) = TransitionTime | Durata tranziției luminii în milisecunde (parametru de import, implicit 300 ms). Definește și fereastra debounce (transitionTime + 500 ms), în care valorile interogate sunt ignorate după fiecare scriere. |

Citire (modul)

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

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

Set mode White

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

Contor electric Ch1 Contor electric Doar citire

Consumul canalului 1 (pinul R) — putere instantanee (kW) și energie cumulată (kWh)

numeric Unitate: W / kWh

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

Dimmer Ch1 (R) Dimmer Citire și scriere

Dimmer pentru LED-uri albe pe canalul 1 (ieșirea pinului R) — luminozitate 0-100 % prin endpointul /light/0

numeric Unitate: 0–1

Citirea nivelului

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

Scrierea nivelului

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

Contor electric Ch2 Contor electric Doar citire

Consumul canalului 2 (pinul G) — putere instantanee (kW) și energie cumulată (kWh)

numeric Unitate: W / kWh

Citirea consumului total

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

Citirea cererii

```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 Citire și scriere

Dimmer alb pe canalul 2 (ieșirea pinului G) — luminozitate 0-100 % prin endpointul /light/1

numeric Unitate: 0–1

Citirea nivelului

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

Scrierea nivelului

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

Contor electric Ch3 Contor electric Doar citire

Consumul canalului 3 (pinul B) — putere instantanee (kW) și energie cumulată (kWh)

numeric Unitate: W / kWh

Citirea consumului total

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

Citirea cererii

```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 Citire și scriere

Dimmer alb pe canalul 3 (ieșirea pinului B) — luminozitate 0-100 % prin endpointul /light/2

numeric Unitate: 0–1

Citirea nivelului

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

Scrierea nivelului

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

Contor electric Ch4 Contor electric Doar citire

Consumul canalului 4 (pinul W) — putere instantanee (kW) și energie cumulată (kWh)

numeric Unitate: W / kWh

Citirea consumului total

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

Citirea cererii

```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 Citire și scriere

Dimmer alb pe canalul 4 (ieșirea pinului W) — luminozitate 0-100 % prin endpointul /light/3

numeric Unitate: 0–1

Citirea nivelului

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

Scrierea nivelului

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

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

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

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

