---
title: "Shelly RGBW2"
description: "Controler LED RGBW Wi-Fi Shelly RGBW2 cu două moduri de funcționare. Comandați benzi LED RGB sau patru canale albe independente prin HTTP din TapHome."
url: "https://taphome.com/ro/compatibility/shelly-rgbw2/"
language: ro
lastmod: 2026-10-08
generator: hugo
ai:
  topics: ["http","lighting","wifi","rgbw","led-controller","dimmer"]
  questions: ["Cum integrez Shelly RGBW2 cu TapHome?","Care este diferența dintre modul Color și modul White pe Shelly RGBW2?","Cum comand benzile LED RGB prin TapHome?","Cum reglez intensitatea a patru canale albe independente cu Shelly RGBW2 în TapHome?","De ce șablonul Shelly RGBW2 afișează o eroare de mod în TapHome?","Cum setez timpul de tranziție pentru schimbările de lumină ale Shelly RGBW2?"]
---

# Shelly RGBW2

Comunicație: Packet Parser → HTTP

- [Pagina produsului Shelly RGBW2](https://www.shelly.com/en/products/shop/shelly-rgbw2)
- [Documentația API Shelly RGBW2](https://shelly-api-docs.shelly.cloud/gen1/#shelly-rgbw2-color-mode)

> 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 RGBW, cu patru ieșiri PWM (12/24 V DC). Acceptă două moduri de funcționare care se exclud reciproc — Color și White — și fiecare necesită propriul șablon TapHome. TapHome comunică cu dispozitivul prin HTTP în rețeaua locală; nu este necesară conexiunea la cloud.

În **modul Color**, cele patru ieșiri comandă o bandă LED RGBW ca o singură lumină color, cu nuanță, saturație, luminozitate și un canal alb (CCT) opțional. În **modul White**, cele patru ieșiri funcționează ca dimmere independente, fiecare comandând o bandă LED albă sau o zonă separată.

Înainte de a importa șablonul corespunzător, trebuie să alegeți modul de funcționare în interfața web Shelly (sau prin API). Fiecare șablon verifică modul curent la fiecare interogare și afișează o eroare dacă dispozitivul este setat pe un mod greșit.

## Configurare

Ambele șabloane 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`).

Parametrul timpului de tranziție determină cât de repede se schimbă treptat luminozitatea. Se aplică tuturor comenzilor de scriere (pornire/oprire, luminozitate, schimbarea culorii) și influențează fereastra debounce — după fiecare scriere, șablonul ignoră valorile interogate timp de `transitionTime + 500 ms`, pentru a preveni citirile neactualizate în timpul tranzițiilor.

## Șablonul pentru modul Color

### Lumină color

Șablonul oferă banda RGBW ca o singură lumină color HSB, cu două submoduri:

- **Culoare RGB** — nuanța și saturația comandă culoarea benzii. Șablonul convertește între valorile RGB ale API-ului Shelly (roșu, verde, albastru 0-255) și modelul HSB din TapHome. Luminozitatea se comandă prin parametrul `gain` (0-100).
- **Alb (CCT)** — când se setează temperatura de culoare corelată, șablonul trece la comanda canalului alb. Domeniul CCT este 3000-6500 K. Luminozitatea se comandă prin parametrul `white` (0-100).

Starea luminii se citește din răspunsul `/status` (`lights[0]`) și se comandă prin endpointul `/light/0`. La pornire se trimite `turn=on` cu valorile curente de culoare sau de alb; la oprire se trimite `turn=off`. Toate comenzile de scriere includ parametrul timpului de tranziție.

### Măsurarea puterii (Color)

Șablonul Color include un contor electric care citește din `meters[0]`:

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

Dacă lumina este aprinsă, dar puterea citită este zero, șablonul afișează un avertisment care recomandă configurarea modelului dispozitivului în setările aplicației Shelly.

## Șablonul pentru modul White

### Patru dimmere independente

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

| Canal | Ieșire | Endpoint | Interval de interogare |
|---------|--------|----------|---------------|
| Ch1 | R (roșu) | `/light/0` | 2,5 s |
| Ch2 | G (verde) | `/light/1` | 2,5 s |
| Ch3 | B (albastru) | `/light/2` | 2,5 s |
| Ch4 | W (alb) | `/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`. Toate canalele folosesc același timp de tranziție și aceeași logică debounce.

### Măsurarea puterii (White)

Fiecare canal are propriul contor electric, care citește din `meters[0]` până la `meters[3]`. Primul canal este interogat la 2,5 secunde; canalele 2-4 sunt interogate la intervale de 15 secunde. Fiecare contor oferă puterea în timp real (din W în kW) și energia cumulată (din wați-minut în kWh).

## Diagnosticare de service

Ambele șabloane 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

Ambele șabloane au trei acțiuni de service comune:

- **Activare cloud** — activează sau dezactivează conectivitatea Shelly Cloud
- **Repornire** — declanșează repornirea dispozitivului
- **Setare mod** — șablonul Color include „Setare mod Color” (`/settings?mode=color`), iar șablonul White include „Setare mod White” (`/settings?mode=white`). Aceste acțiuni comută modul de funcționare al dispozitivului prin API.

### Funcții suplimentare

În API-ul său, Shelly RGBW2 oferă și efecte de lumină (modul Color, indexul efectului 0-3), starea intrării fizice, temperatura internă, indicatorul de supratemperatură și setările de protecție la depășirea puterii. Aceste funcții pot fi adăugate într-o actualizare viitoare a șablonului.

## 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/Color is not supported”

Această eroare înseamnă că dispozitivul este setat pe un mod de funcționare greșit pentru șablonul importat. Pentru rezolvare:

1. Deschideți interfața web Shelly la `http://{device-ip}`
2. Comutați modul de funcționare astfel încât să corespundă șablonului (Color sau White)
3. Alternativ, folosiți acțiunea de service „Setare mod Color” sau „Setare mod White” din celălalt șablon pentru a comuta modul prin API, apoi importați din nou șablonul corect

### Valorile puterii sunt zero

1. Verificați dacă LED-urile sunt conectate la ieșirile Shelly RGBW2
2. Deschideți aplicația Shelly sau interfața web și verificați dacă modelul dispozitivului este configurat la Settings -> Device Model
3. Verificați dacă lumina este aprinsă — contorul măsoară doar atunci când prin ieșiri trece curent
4. Interogați manual `/status` și verificați dacă `meters[0].power` returnează o valoare diferită de zero

### Lumina color nu își schimbă culoarea

1. Verificați dacă dispozitivul este în modul Color (verificați răspunsul `/status` — `mode` trebuie să fie `"color"`)
2. Asigurați-vă că lumina este aprinsă înainte de a schimba nuanța sau saturația
3. Dacă atât `gain`, cât și `white` sunt diferite de zero, șablonul le resetează automat la zero și stinge lumina — astfel se previne un comportament nedefinit, în care canalele RGB și canalul alb concurează

> [!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ă. Dacă dispozitivul este interogat și de un alt sistem, măriți intervalele de interogare din șablon (implicit 2,5 s pentru canalele de lumină), ca să nu suprasolicitați conexiunile.

## 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 RGBW2 Color 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        |
| Setare mod Color |

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;
    
    if PARSEJSON(jsonStatus, "$.mode", 1) = "white"
    adderror("Mode White 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 Color

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

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

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

Lumină color Lumină HSB Citire și scriere

Lumină color RGBW cu comandă HSB — nuanță, saturație, luminozitate și canal alb CCT opțional (3000–6500 K)

hsb

Citire (modul)

```taphome
if PARSEJSON(jsonStatus, "$.lights[0].white", 1) > 0 and PARSEJSON(jsonStatus, "$.lights[0].gain", 1)
    SENDHTTPREQUEST("light/0?gain=0&white=0");
    SENDHTTPREQUEST("light/0?turn=off");
end
```

Citirea luminozității

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

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

INT value;
IF !ISNAN(Ct)
    value := PARSEJSON(jsonStatus, "$.lights[0].white", 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);
```

Scrierea luminozității

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

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

Citirea nuanței

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

Scrierea nuanței

```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 + "&white=0");


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

Citirea saturației

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

Scrierea saturației

```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 + "&white=0");


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

Citirea temperaturii de culoare

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

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

INT value := PARSEJSON(jsonStatus, "$.lights[0].temp", 1);
IF PARSEJSON(jsonStatus, "$.lights[0].white", 1) = 0
    RETURN(NaN);
END
 
Ct
```

Scrierea temperaturii de culoare

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

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

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

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

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

Îmbunătățiri posibile (7)

- Light effect — Color mode: effect index (0=off, 1–3=predefined effects), settable via /light/0?effect=N
- Input State — Physical input state (0/1), available in /status response
- WiFi RSSI (numeric) — WiFi RSSI in dBm as numeric value — template reads it as 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

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

