---
title: "Yeelight Color"
description: "LED Wi-Fi Yeelight Color cu culori HSB și alb reglabil. Controlul nuanței, saturației, luminozității și temperaturii de culoare prin JSON-RPC din TapHome."
url: "https://taphome.com/ro/compatibility/yeelight-color/"
language: ro
lastmod: 2026-04-21
generator: hugo
ai:
  topics: ["data-pp","lighting","wifi","json-rpc","lan-control","color-light","hsb","color-temperature"]
  questions: ["Cum controlez culoarea și temperatura de culoare Yeelight din TapHome?","Care este diferența dintre șabloanele Yeelight dimmer și Yeelight Color?","Cum comută TapHome între modul de culoare HSV și modul alb pe un bec Yeelight?","Ce interval de temperatură de culoare acceptă Yeelight prin TapHome?","De ce eșuează set_hsv când Yeelight este în modul alb?","Cum activez LAN Control pe un bec Yeelight pentru TapHome?"]
---

# Yeelight Color

Comunicație: Packet Parser → TCP

- [Portalul pentru dezvoltatori Yeelight](https://www.yeelight.com/en_US/developer)
- [Întrebări frecvente Yeelight despre LAN Control](https://www.yeelight.com/faqs/lan_control)

> 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

Șablonul Yeelight Color extinde șablonul [Yeelight](https://taphome.com/ro/compatibility/yeelight/), care oferă doar dimmer, cu control complet al culorilor HSB și al temperaturii de culoare (alb reglabil). Se adresează aceleiași familii de LED-uri inteligente Wi-Fi — becuri color, benzi și plafoniere — și folosește același protocol Yeelight **Inter-Operation Protocol** pe portul TCP **55443**. Diferența principală este modelul de dispozitiv: în locul unui simplu dimmer, șablonul oferă un **PacketParserHSBLight**, care pune la dispoziția TapHome proprietățile native de nuanță, saturație, luminozitate și temperatură de culoare într-un singur dispozitiv.

TapHome comunică cu becul direct în rețeaua locală prin JSON-RPC — după activarea LAN Control pe bec nu este necesară conexiunea la cloud. Șablonul interoghează toate cele șase proprietăți de culoare deodată și reacționează la notificările `props` trimise de bec, astfel încât schimbările făcute din aplicația Yeelight sau dintr-un alt controler apar în TapHome aproape imediat.

## Conectarea hardware

Becurile Yeelight se alimentează de la rețeaua electrică standard (de obicei E27, E14, GU10 sau sursa de alimentare de 24 V a benzii, în funcție de produs). Între TapHome și bec nu este necesar niciun cablu — întreaga comunicație se face prin Wi-Fi. Becul trebuie să fie în **aceeași rețea LAN / VLAN** ca TapHome CCU, deoarece protocolul JSON-RPC nu are autentificare și nici criptare, iar traficul nu trece niciodată prin cloudul Yeelight.

> [!WARNING]
> Protocolul LAN Yeelight nu este criptat. Nu expuneți portul TCP 55443 pe internetul public și plasați becurile într-un segment de rețea de încredere — oricine are acces la rețeaua LAN poate trimite comenzi becului.

## Configurare

### Activarea LAN Control

LAN Control (în unele regiuni numit și **Developer Mode**) este dezactivat implicit pe bec. Fără el, conexiunile TCP pe portul 55443 sunt refuzate.

1. Deschideți aplicația mobilă **Yeelight** și asociați becul cu rețeaua Wi-Fi locală prin procedura SmartConfig / QuickConnect, dacă nu a fost asociat încă.
2. Selectați becul în aplicație.
3. Atingeți pictograma de setări (dreapta sus) și deschideți **LAN Control** (în unele versiuni de firmware se numește **Developer Mode**).
4. Comutați **LAN Control** pe ON.
5. Notați adresa IP a becului — este afișată în informațiile despre dispozitiv din aplicația Yeelight sau se poate citi din tabelul de alocări DHCP al routerului.

După activarea LAN Control, becul ascultă pe portul TCP `55443` și se anunță periodic prin multicast UDP `239.255.255.250:1982`.

### Configurarea rețelei

- **Adresă IP** — șablonul TapHome nu descoperă becurile automat. Atribuiți în router o **adresă IP statică** sau o **rezervare DHCP**, ca adresa becului să nu se schimbe după reînnoirea alocării.
- **Același segment LAN** — TapHome CCU și becul trebuie să fie în același domeniu de broadcast. Dacă clienții Wi-Fi și cei pe cablu sunt în VLAN-uri separate, adăugați o regulă de firewall care permite TCP 55443 între ele.

### Parametri de import

La importul șablonului în TapHome, utilizatorul introduce trei valori:

| Parametru | Descriere | Valoare implicită |
|-----------|-------------|---------|
| `ipAddress` | Adresa IP a becului Yeelight în rețeaua LAN | `192.168.0.1` (valoare provizorie — înlocuiți-o cu adresa IP reală) |
| `Port` | Portul TCP de control al becului | `55443` |
| `Internal poll interval` | Cât de des trimite șablonul `get_prop` (în milisecunde) | `10000` (10 s) |

Portul implicit `55443` este portul standard Yeelight LAN Control și nu trebuie schimbat decât dacă becul a fost configurat pentru un port nestandard.

> [!TIP]
> Între interogări, șablonul reacționează și la notificările `props` pe care becul le trimite la fiecare schimbare de stare. În practică, schimbările de culoare, luminozitate și pornire/oprire făcute din aplicația Yeelight, dintr-un adaptor de întrerupător de perete sau dintr-un alt controler apar în TapHome aproape imediat, fără a aștepta următoarea interogare.

## Funcțiile dispozitivului

### Lumină color HSB (nuanță, saturație, luminozitate și pornire/oprire)

Șablonul oferă un singur dispozitiv de lumină HSB. La fiecare ciclu de interogare trimite o cerere `get_prop` pentru toate cele șase proprietăți deodată:

```json
{"id":951,"method":"get_prop","params":["hue","sat","bright","power","ct","color_mode"]}
```

Scriptul listener analizează răspunsul și atribuie valorile proprietăților native TapHome:

- **Nuanță** (`Hd`) — `result[0]`, număr întreg 0–359 grade
- **Saturație** (`Sa`) — `result[1]`, procent 0–100, împărțit la 100 pentru intervalul TapHome 0,0–1,0
- **Luminozitate** (`Hb`) — `result[2]`, procent 1–100, împărțit la 100 pentru intervalul TapHome 0,0–1,0
- **Pornire/oprire** (`St`) — `result[3]`, `"on"` se convertește în 1, `"off"` în 0 (la oprire, luminozitatea se setează și ea la 0)
- **Temperatură de culoare** (`Ct`) — `result[4]`, valoare în kelvini setată doar când `color_mode = 2` (modul alb); altfel se setează la `NaN`
- **Mod de culoare** — `result[5]`, stabilește dacă se scrie `Ct` (`1` = RGB, `2` = Temperature, `3` = HSV)

### Comutarea modului de culoare

Șablonul folosește proprietatea `Ct` pentru a stabili modul de culoare activ:

- **`Ct = NaN`** — becul este în modul de culoare HSV. Scrierile folosesc `set_hsv` pentru nuanță și saturație.
- **`Ct` = număr** — becul este în modul alb (temperatură de culoare). Scrierile folosesc `set_ct_abx`.

TapHome nu trimite o comandă explicită de comutare a modului. În schimb, utilizatorul setează temperatura de culoare la o valoare numerică pentru a trece în modul alb sau o setează la NaN (alegând o culoare în selectorul HSB) pentru a trece în modul HSV. Scripturile de scriere verifică `Ct` înainte de trimitere și omit comanda irelevantă — `writesaturation` se încheie imediat dacă `Ct` nu este NaN, iar `writecct` se încheie imediat dacă `Ct` este NaN.

### Comenzi de scriere

Trei scripturi de scriere gestionează diferite aspecte ale luminii:

- **Luminozitate și pornire/oprire** (`writebrightness`) — dacă luminozitatea > 0, trimite `set_power ["on","smooth",300]`, urmat de `set_bright [level,"smooth",300]`. Dacă luminozitatea = 0, trimite `set_power ["off","smooth",300]`.
- **Nuanță și saturație** (`writesaturation`) — trimite `set_power ["on","smooth",300]`, urmat de `set_hsv [hue, saturation,"smooth",300]`. Rulează doar când `Ct = NaN` (modul HSV).
- **Temperatură de culoare** (`writecct`) — trimite `set_power ["on","smooth",300]`, urmat de `set_ct_abx [ct,"smooth",300]`. Rulează doar când `Ct` este un număr (modul alb). Interval valid: **1700–6500 K** (limitele exacte depind de modelul becului).

Toate scrierile folosesc o tranziție graduală de 300 ms pentru o estompare lină în locul unui salt brusc. După fiecare scriere, o variabilă de debounce se setează la 1, iar următorul ciclu de interogare este omis — astfel nu se citește o stare învechită cât timp becul este în tranziție.

### Diagnoză de service

Două atribute de service la nivel de modul se citesc printr-o cerere `get_prop` separată (`id=981`):

- **Mod de culoare** — `RGB`, `Temperature` sau `HSV`, decodat din proprietatea numerică `color_mode` (1 / 2 / 3) cu o expresie `SWITCH` în scriptul listener al modulului.
- **Temperatură de culoare** — valoare în kelvini raportată ca `"{ct}K"` (de exemplu `"4000K"`). Are sens doar când becul este în modul Temperature.

Aceste atribute sunt doar pentru citire și servesc la diagnoză — controlul propriu-zis al temperaturii de culoare se face prin proprietatea `Ct` la nivel de dispozitiv și prin scriptul `writecct` descris mai sus.

## Rezolvarea problemelor

### Becul nu răspunde la comenzi

1. Verificați dacă **LAN Control** este activat pe bec (aplicația Yeelight → setările becului → LAN Control). Fără el, becul refuză toate conexiunile TCP pe portul 55443.
2. Confirmați adresa IP a becului în aplicația Yeelight sau în tabelul de alocări DHCP al routerului și asigurați-vă că se potrivește cu parametrul de import `ipAddress`. Implicit, becurile Yeelight nu păstrează o adresă IP fixă — este posibil ca alocarea DHCP să fi expirat și adresa IP să se fi schimbat.
3. Atribuiți becului o adresă IP statică sau o rezervare DHCP, ca adresa să nu se schimbe.
4. Verificați dacă TapHome CCU și becul sunt în aceeași rețea LAN / VLAN și dacă TCP `55443` nu este blocat de un firewall între ele.
5. Testați manual conexiunea: `telnet {bulb-ip} 55443` și trimiteți o cerere brută urmată de `\r\n`:

   ```json
   {"id":1,"method":"get_prop","params":["hue","sat","bright","power","ct","color_mode"]}
   ```

   Un bec funcțional răspunde cu `{"id":1,"result":["<hue>","<sat>","<bright>","<power>","<ct>","<color_mode>"]}`.

### Comenzile de culoare sunt ignorate (nuanța/saturația nu se schimbă)

Scriptul `writesaturation` verifică `Ct` înainte de a trimite `set_hsv`. Dacă `Ct` are o valoare numerică (modul alb), scriptul se încheie fără să trimită vreo comandă. Pentru a controla culoarea HSV, setați mai întâi temperatura de culoare la NaN, alegând o culoare în selectorul HSB din TapHome.

Similar, `writecct` se încheie fără să trimită vreo comandă dacă `Ct = NaN` (modul HSV). Pentru a scrie o temperatură de culoare, becul trebuie să fie deja în modul alb.

### Read error: client quota exceeded

Fiecare conexiune TCP la un bec Yeelight este limitată la **60 de comenzi pe minut**, iar becul acceptă în total cel mult **4 conexiuni simultane**. Dacă un alt sistem interoghează becul în același timp — Home Assistant, o sesiune din cloudul Yeelight, un script propriu — traficul combinat poate declanșa erori de depășire a limitei de comenzi.

1. Dezactivați celelalte integrări care folosesc același bec sau reduceți frecvența interogărilor acestora.
2. Păstrați intervalul de interogare TapHome la valoarea implicită de `10000` ms sau mai mare. Șablonul color trimite un `get_prop` la fiecare interogare plus cel mult trei scrieri `set_*` pentru fiecare schimbare, ceea ce rămâne mult sub limita de 60 de comenzi/min.
3. Închideți sesiunile de depanare `telnet` nefolosite — și ele intră în limita de 4 conexiuni.

### Eroare de scriere HueSat sau Temperatură de culoare

Scriptul listener urmărește erorile de scriere separat pentru fiecare tip de comandă — `writeErrorBrightness` pentru scrierile de pornire/luminozitate, `writeErrorHueSat` pentru scrierile `set_hsv` și `writeErrorCt` pentru scrierile `set_ct_abx`. Dacă apare o eroare:

1. Asigurați-vă că becul este pornit — toate comenzile `set_*`, cu excepția `set_power`, sunt acceptate doar când becul este în starea `on`.
2. Verificați dacă valoarea temperaturii de culoare este în intervalul specific modelului (de obicei 1700–6500 K pentru becuri color, 2700–6500 K pentru plafoniere, 2700–6000 K pentru ceiling3).
3. Verificați mesajul de eroare brut din diagnoza de service TapHome pentru codul de eroare specific returnat de bec.

### Schimbările făcute în aplicația Yeelight nu apar

Șablonul reacționează la notificările `props` trimise de bec, așa că schimbările externe apar de obicei în mai puțin de o secundă. Dacă nu apar:

1. Notificarea poate să fi sosit în timp ce conexiunea TCP se restabilea — următoarea interogare (implicit 10 s) va resincroniza starea.
2. Unele versiuni mai vechi de firmware trimit notificări doar când se trimite activ o comandă. Actualizați firmware-ul becului din aplicația Yeelight.
3. Becul poate să fi atins limita de 4 conexiuni — reduceți numărul de clienți simultani din rețeaua LAN.

> [!WARNING]
> Dispozitivele Yeelight acceptă doar **4 conexiuni TCP simultane** și **60 de comenzi pe minut** pentru fiecare conexiune. Dacă TapHome și un alt sistem (de ex. Home Assistant) interoghează același bec simultan, comunicarea poate deveni instabilă. Folosiți un interval de interogare de 10 secunde sau mai mare.

## Dispozitive disponibile 1

Aceste dispozitive apar în TapHome după import.

Modul Yeelight color Modul

Atribute de service

|                        |                                                                                                        |
|------------------------|--------------------------------------------------------------------------------------------------------|
| Mod de culoare         | Modul de culoare curent al becului — RGB, Temperature sau HSV — decodat din proprietatea color\_mode   |
| Temperatură de culoare | Temperatura de culoare în kelvini, raportată doar când becul este în modul Temperature (color\_mode=2) |

Ascultător

```taphome
VAR jsonResponse := TOSTRING(RECEIVEDBYTES);
VAR id := PARSEJSON(jsonResponse, "id", 1);

IF(id = 981)
   VAR error := PARSEJSON(jsonResponse, "error.message", 1);
   
   IF(!ISNULL(error))
      COMPLETESERVICEATTRIBUTE("Color mode", "", "error");
      COMPLETESERVICEATTRIBUTE("Color temperature", "", "error");
   ELSE
      VAR colorMode := PARSEJSON(jsonResponse, "result[0]", 1);
      VAR colorTemp := PARSEJSON(jsonResponse, "result[1]", 1);
      
      IF(!ISNULL(colorMode))
         VAR colorModeValue := SWITCH(TODOUBLE(colorMode), 1, "RGB", 2, "Temperature", 3, "HSV", "Unknown");
         COMPLETESERVICEATTRIBUTE("Color mode", colorModeValue, "");
      ELSE
         COMPLETESERVICEATTRIBUTE("Color mode", "", "error");
      END
      
      IF(!ISNULL(colorTemp))
         COMPLETESERVICEATTRIBUTE("Color temperature", colorTemp + "K", "");
      ELSE
         COMPLETESERVICEATTRIBUTE("Color temperature", "", "error");
      END
   END
END
```

Atribute de service

Color mode

```taphome
VAR json := "{\"id\":981, \"method\":\"get_prop\", \"params\":[\"color_mode\", \"ct\"]}";
SENDDATA(json);

RETURN(NULL);
```

Color temperature

```

```

Lumină HSB Lumină HSB Citire și scriere

Lumină HSB cu gamă completă de culori și suport pentru temperatura de culoare — controlează nuanța, saturația, luminozitatea și pornirea/oprirea prin set\_hsv, set\_ct\_abx și set\_bright, cu tranziții graduale

numeric Unitate: hue 0-359, sat/bright 0-100 %, CCT 2700-6500 K

Citire (modul)

```taphome
IF(debounce > 0)
    debounce := 0;
ELSE
    VAR json := "{\"id\":951, \"method\":\"get_prop\", \"params\":[\"hue\", \"sat\", \"bright\", \"power\", \"ct\", \"color_mode\"]}";
    SENDDATA(json);
END
```

Ascultător

```taphome
VAR jsonResponse := TOSTRING(RECEIVEDBYTES);
VAR method := PARSEJSON(jsonResponse, "method", 1);
VAR id := PARSEJSON(jsonResponse, "id", 1);
VAR error := PARSEJSON(jsonResponse, "error.message", 1);

#response to ReadScript
IF(id = 951)
   receiveError1 := error;
   
   IF(LENGTH(receiveError1) = 0)
      VAR hueStr := PARSEJSON(jsonResponse, "result[0]", 1);
      VAR satStr := PARSEJSON(jsonResponse, "result[1]", 1);
      VAR brightnessStr := PARSEJSON(jsonResponse, "result[2]", 1);
      VAR onOffStr := PARSEJSON(jsonResponse, "result[3]", 1);
      VAR ctStr := PARSEJSON(jsonResponse, "result[4]", 1);
      VAR colorModeStr := PARSEJSON(jsonResponse, "result[5]", 1);
      
      IF(!ISNULL(hueStr))
         Hd := TODOUBLE(hueStr);
      END

      IF(!ISNULL(satStr))
        Sa := TODOUBLE(satStr) / 100.0;
      END
      
      IF(!ISNULL(brightnessStr))
        Hb := TODOUBLE(brightnessStr) / 100.0;
      END
   
      VAR cm := TODOUBLE(colorModeStr);
      IF(!ISNULL(ctStr) AND cm = 2)
        Ct := TODOUBLE(ctStr);
      ELSE
        Ct := NaN;
      END
      
      IF(onOffStr = "on")
         St := 1;
      ELSEIF(onOffStr = "off")
         Hb := 0;
         St := 0;
      END
   END
ELSEIF(id = 952)
   receiveError2 := error;
   
   IF(LENGTH(receiveError2) = 0)
      brightnessStr := PARSEJSON(jsonResponse, "result[0]", 1);
      
      IF(!ISNULL(brightnessStr))
        Hb := TODOUBLE(brightnessStr) / 100.0;
      END
   END
END

IF(id >= 941 AND id <= 942)
   writeErrorBrightness := error;
ELSEIF(id = 943)
   writeErrorHueSat := error;
ELSEIF(id = 944)
   writeErrorCt := error;
END

#general notification
IF(method = "props")
   notificationError := error;
   
   IF(LENGTH(notificationError) = 0)
      VAR brightJson := PARSEJSON(jsonResponse, "params.bright", 1);
      VAR onOffJson := PARSEJSON(jsonResponse, "params.power", 1);
      VAR hue := PARSEJSON(jsonResponse, "params.hue", 1);
      VAR sat := PARSEJSON(jsonResponse, "params.sat", 1);
      VAR colorMode := PARSEJSON(jsonResponse, "params.color_mode", 1);
      VAR ctJson := PARSEJSON(jsonResponse, "params.ct", 1);
      
      IF(!ISNULL(brightJson))
         Hb := brightJson / 100.0;
      END
      
      IF(!ISNULL(hue))
         Hd := hue;
         Ct := NaN;
      END      

      IF(!ISNULL(sat))
        Sa := sat / 100;
        Ct := NaN;
      END 
      
      IF(!ISNULL(ctJson))
        Ct := ctJson;
      END 
      
      IF(onOffJson = "on")
         St := 1;
         IF(ISNULL(brightJson))
            SENDDATA("{\"id\":952, \"method\":\"get_prop\", \"params\":[\"bright\"]}");
         END
      ELSEIF(onOffJson = "off")
         Hb := 0;
         St := 0;
      END
   END
END

IF(LENGTH(receiveError1) > 0)
   ADDERROR(951, "Read error: " + receiveError1);
END

IF(LENGTH(receiveError2) > 0)
   ADDERROR(952, "Read error: " + receiveError2);
END

IF(LENGTH(writeErrorBrightness) > 0)
   ADDERROR(941, "Brightness write error: " + writeErrorBrightness);
END

IF(LENGTH(writeErrorHueSat) > 0)
   ADDERROR(943, "HueSat write error: " + writeErrorHueSat);
END

IF(LENGTH(writeErrorCt) > 0)
   ADDERROR(944, "Color temperature write error: " + writeErrorCt);
END

IF(LENGTH(notificationError) > 0)
   ADDERROR(1, notificationError);
END
```

Scrierea luminozității

```taphome
IF(Hb > 0)
    VAR jsonBrightness := "{\"id\":941,\"method\":\"set_power\",\"params\":[\"on\", \"smooth\", 300]}\r\n{\"id\":942,\"method\":\"set_bright\",\"params\":[" + ROUND(Hb*100) + ",\"smooth\", 300]}";
    SENDDATA(jsonBrightness);
ELSE
    VAR jsonPowerOff := "{\"id\":942,\"method\":\"set_power\",\"params\":[\"off\", \"smooth\", 300]}";
    SENDDATA(jsonPowerOff);
END

debounce := 1;
```

Scrierea saturației

```taphome
#do not send HUESAT when COLOR mode is active
IF !ISNAN(Ct)
    RETURN(0);
END

VAR hueSatJson := "{\"id\":941,\"method\":\"set_power\",\"params\":[\"on\", \"smooth\", 300]}\r\n{\"id\":943,\"method\":\"set_hsv\",\"params\":[" + ROUND(MOD(Hd, 360)) + ", " + ROUND(Sa*100) + ", \"smooth\", 300]}";

SENDDATA(hueSatJson);
debounce := 1;
```

Scrierea temperaturii de culoare

```taphome
#do not set CT in COLOR mode
IF ISNAN(Ct)
    RETURN(0);
END

VAR ctJson := "{\"id\":941,\"method\":\"set_power\",\"params\":[\"on\", \"smooth\", 300]}\r\n{\"id\":944,\"method\":\"set_ct_abx\",\"params\":[" + Ct + ", \"smooth\", 300]}";
SENDDATA(ctJson);

debounce := 1;
```

**Conexiune:** Packet Parser → TCP

Îmbunătățiri posibile (12)

- Set RGB color — Write full RGB color (0-16777215). Template uses set\_hsv instead, which maps naturally to the HSBLight device model.
- Color flow — Scripted sequences of brightness / color / CT changes (sunrise effect, strobe, ambient cycles). Not exposed by this template.
- Set scene — Jump directly to a predefined state (color, hsv, ct, cf, auto\_delay\_off). Not exposed by this template.
- Toggle power — Single-parameter power toggle. Not exposed — TapHome writes explicit on/off via set\_power instead.
- Sleep timer (cron) — On-device auto-off timer in minutes. Not exposed — TapHome uses its own Smart Rules for scheduling instead.
- Music mode — Reverse-TCP channel bypassing the 60 cmd/min rate limit. Not used by TapHome.
- Relative adjustments — Relative +/- changes without knowing the current value. Not exposed — TapHome always writes absolute values.
- Save current state as power-on default — Persist current brightness/color to flash so it survives a hard power cut. Not exposed by this template.
- Set device name — Set device name (max 64 bytes). Not exposed by this template.
- Background light control — Secondary light channel on dual-light fixtures (e.g., some ceiling lights). Not exposed by this template.
- Extended notification properties — Additional properties pushed via props notifications. Template consumes hue, sat, bright, power, color\_mode and ct — remaining properties (rgb, flowing, delayoff, music\_on, name) are ignored.
- LAN auto-discovery — User must enter the bulb IP manually during import — template does not perform SSDP discovery. A static DHCP lease is strongly recommended.

## Parametri de import

Introduceți aceste valori când importați XML-ul.

| Solicitat în aplicație | Implicit      |
|------------------------|---------------|
| Adresă IP              | `192.168.0.1` |
| Port                   | `55443`       |
| Internal poll interval | `10000`       |

## Surse

- Yeelight WiFi Light Inter-Operation Specification
  
  [www.yeelight.com](https://www.yeelight.com/download/Yeelight_Inter-Operation_Spec.pdf) 2026-04-15
- Yeelight Developer — Third-party Control Protocol
  
  [www.yeelight.com](https://www.yeelight.com/en_US/developer) 2026-04-15
- python-yeelight library documentation
  
  [yeelight.readthedocs.io](https://yeelight.readthedocs.io/en/latest/) 2026-04-15

Documentele producătorilor sunt © ale proprietarilor respectivi. Sunt furnizate așa cum au fost publicate de producător, doar ca referință.

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

