--- title: "Yeelight Color" description: "Yeelight Color Wi-Fi Smart-LED mit HSB-Farben und Tunable White. Farbton, Sättigung, Helligkeit und Farbtemperatur per JSON-RPC von TapHome." url: "https://taphome.com/de/compatibility/yeelight-color/" language: de lastmod: 2026-04-21 generator: hugo ai: topics: ["data-pp","lighting","wifi","json-rpc","lan-control","color-light","hsb","color-temperature"] questions: ["Wie steuert man Yeelight-Farbe und Farbtemperatur von TapHome?","Was ist der Unterschied zwischen den Vorlagen Yeelight Dimmer und Yeelight Color?","Wie wechselt TapHome zwischen HSV-Farbmodus und Weißmodus bei einer Yeelight-Lampe?","Welchen Farbtemperaturbereich unterstützt Yeelight über TapHome?","Warum schlägt set_hsv fehl, wenn Yeelight im Weißmodus ist?","Wie aktiviert man LAN Control auf einer Yeelight-Lampe für TapHome?"] --- # Yeelight Color Kommunikation: Packet Parser → TCP - [Yeelight Developer Portal](https://www.yeelight.com/en_US/developer) - [Yeelight LAN Control FAQ](https://www.yeelight.com/faqs/lan_control) > Netzwerkadresse > > TapHome erreicht dieses Gerät unter der beim Import eingegebenen Adresse. Geben Sie dem Gerät eine feste Adresse — eine IP-Reservierung im Router oder seinen mDNS-Namen, falls es einen unterstützt —, sonst funktioniert die Integration nicht mehr, sobald der Router die Adresse ändert. > > [Netzwerkvorbereitung](https://taphome.com/de/docs/setup/network-preparation/) ## Integrationsanleitung Die Yeelight-Color-Vorlage erweitert die reine Dimmer-Vorlage [Yeelight](https://taphome.com/de/compatibility/yeelight/) um volle HSB-Farbsteuerung und einstellbares Weiß (Farbtemperatur). Sie richtet sich an dieselbe Familie von Wi-Fi-Smart-LEDs — Farblampen, Streifen und Deckenleuchten — und nutzt das identische Yeelight **Inter-Operation Protocol** auf TCP-Port **55443**. Der Hauptunterschied ist das Gerätemodell: Statt eines einfachen Dimmers stellt die Vorlage einen **PacketParserHSBLight** bereit, der TapHome native Eigenschaften für Farbton, Sättigung, Helligkeit und Farbtemperatur in einem Gerät gibt. TapHome kommuniziert mit der Lampe direkt im lokalen Netzwerk über JSON-RPC — nach Aktivierung von LAN Control auf der Lampe ist keine Cloud-Verbindung erforderlich. Die Vorlage pollt alle sechs Farbeigenschaften gleichzeitig und reagiert auf `props`-Benachrichtigungen der Lampe, sodass Änderungen aus der Yeelight-App oder einem anderen Controller nahezu sofort in TapHome erscheinen. ## Hardwareanschluss Yeelight-Lampen werden aus dem Standardnetz gespeist (typisch E27, E14, GU10 oder 24-V-Netzteil für LED-Streifen je nach Produkt). Zwischen TapHome und der Lampe ist keine Verkabelung nötig — die gesamte Kommunikation läuft über Wi-Fi. Die Lampe muss sich im **gleichen LAN / VLAN** wie die TapHome CCU befinden, da das JSON-RPC-Protokoll keine Authentifizierung und keine Verschlüsselung hat und der Datenverkehr nie über die Yeelight-Cloud geleitet wird. > [!WARNING] > Das Yeelight-LAN-Protokoll ist unverschlüsselt. Setzen Sie den TCP-Port 55443 nicht dem öffentlichen Internet aus und platzieren Sie die Lampen in einem vertrauenswürdigen Netzwerksegment — jeder mit Zugang zum LAN kann Befehle an die Lampe senden. ## Konfiguration ### LAN Control aktivieren LAN Control (in manchen Regionen als **Developer Mode** bezeichnet) ist auf der Lampe standardmäßig deaktiviert. Ohne ihn werden TCP-Verbindungen auf Port 55443 abgelehnt. 1. Öffnen Sie die mobile **Yeelight**-App und koppeln Sie die Lampe mit dem lokalen Wi-Fi-Netzwerk über die SmartConfig-/QuickConnect-Prozedur, falls noch nicht geschehen. 2. Wählen Sie die Ziel-Lampe in der App aus. 3. Tippen Sie auf das Einstellungssymbol (oben rechts) und öffnen Sie **LAN Control** (in manchen Firmware-Versionen als **Developer Mode** bezeichnet). 4. Schalten Sie **LAN Control** auf ON. 5. Notieren Sie die IP-Adresse der Lampe — sie wird in den Geräteinformationen der Yeelight-App angezeigt oder kann aus der DHCP-Lease-Tabelle des Routers abgelesen werden. Nach Aktivierung von LAN Control lauscht die Lampe auf TCP-Port `55443` und kündigt sich regelmäßig über UDP-Multicast `239.255.255.250:1982` an. ### Netzwerkkonfiguration - **IP-Adresse** — die TapHome-Vorlage erkennt Lampen nicht automatisch. Weisen Sie eine **statische IP** oder eine **DHCP-Reservierung** im Router zu, damit sich die Adresse der Lampe nach einer Lease-Erneuerung nicht ändert. - **Gleiches LAN-Segment** — die TapHome CCU und die Lampe müssen sich in derselben Broadcast-Domäne befinden. Wenn Wi-Fi- und kabelgebundene Clients in getrennten VLANs sind, fügen Sie eine Firewall-Regel hinzu, die TCP 55443 zwischen ihnen erlaubt. ### Importparameter Beim Template-Import in TapHome gibt der Benutzer drei Werte ein: | Parameter | Beschreibung | Standard | |-----------|-------------|----------| | `ipAddress` | IP-Adresse der Yeelight-Lampe im LAN | `192.168.0.1` (Platzhalter — durch echte IP ersetzen) | | `Port` | TCP-Steuerungsport auf der Lampe | `55443` | | `Internal poll interval` | Wie oft die Vorlage `get_prop` sendet (in Millisekunden) | `10000` (10 s) | Der Standard-Port `55443` ist der Standard-Yeelight-LAN-Control-Port und sollte nicht geändert werden, es sei denn, die Lampe ist auf einen nicht-standardmäßigen Port konfiguriert. > [!TIP] > Zwischen den Polls reagiert die Vorlage auch auf `props`-Benachrichtigungen, die die Lampe bei Statusänderungen sendet. In der Praxis bedeutet dies, dass Farb-, Helligkeits- und Ein/Aus-Änderungen aus der Yeelight-App, einem Wandschalteradapter oder einem anderen Controller nahezu sofort in TapHome erscheinen, ohne auf den nächsten Poll zu warten. ## Gerätefunktionen ### HSB-Farblicht (Farbton, Sättigung, Helligkeit und Ein/Aus) Die Vorlage stellt ein einzelnes HSB-Lichtgerät bereit. In jedem Poll-Zyklus sendet sie eine `get_prop`-Anfrage für alle sechs Eigenschaften gleichzeitig: ```json {"id":951,"method":"get_prop","params":["hue","sat","bright","power","ct","color_mode"]} ``` Das Listener-Skript parst die Antwort und bildet sie auf native TapHome-Eigenschaften ab: - **Hue** (`Hd`) — `result[0]`, Ganzzahl 0–359 Grad - **Saturation** (`Sa`) — `result[1]`, Prozent 0–100, geteilt durch 100 auf den TapHome-Bereich 0,0–1,0 - **Brightness** (`Hb`) — `result[2]`, Prozent 1–100, geteilt durch 100 auf den TapHome-Bereich 0,0–1,0 - **Power** (`St`) — `result[3]`, `"on"` wird auf 1 abgebildet, `"off"` auf 0 (Helligkeit wird ebenfalls auf 0 gesetzt, wenn ausgeschaltet) - **Color temperature** (`Ct`) — `result[4]`, Kelvin-Wert, nur gesetzt wenn `color_mode = 2` (Weiß-Modus); sonst auf `NaN` gesetzt - **Color mode** — `result[5]`, bestimmt, ob `Ct` geschrieben wird (`1` = RGB, `2` = Temperature, `3` = HSV) ### Farbmodus-Umschaltung Die Vorlage verwendet die `Ct`-Eigenschaft zur Bestimmung des aktiven Farbmodus: - **`Ct = NaN`** — die Lampe ist im HSV-Farbmodus. Schreibvorgänge verwenden `set_hsv` für Farbton und Sättigung. - **`Ct = Zahl`** — die Lampe ist im Weiß-Modus (Farbtemperatur). Schreibvorgänge verwenden `set_ct_abx`. TapHome sendet keinen expliziten Modusumschaltbefehl. Stattdessen setzt der Benutzer die Farbtemperatur auf einen numerischen Wert, um in den Weiß-Modus zu wechseln, oder auf NaN (durch Auswahl einer Farbe im HSB-Picker), um in den HSV-Modus zu wechseln. Die Schreibskripte prüfen `Ct` vor dem Senden und überspringen den irrelevanten Befehl — `writesaturation` kehrt sofort zurück wenn `Ct` nicht NaN ist, und `writecct` kehrt sofort zurück wenn `Ct` NaN ist. ### Schreibbefehle Drei Schreibskripte steuern verschiedene Aspekte des Lichts: - **Helligkeit / Strom** (`writebrightness`) — bei Helligkeit > 0 sendet es `set_power ["on","smooth",300]` gefolgt von `set_bright [Level,"smooth",300]`. Bei Helligkeit = 0 sendet es `set_power ["off","smooth",300]`. - **Farbton und Sättigung** (`writesaturation`) — sendet `set_power ["on","smooth",300]` gefolgt von `set_hsv [Farbton, Sättigung,"smooth",300]`. Läuft nur wenn `Ct = NaN` (HSV-Modus). - **Farbtemperatur** (`writecct`) — sendet `set_power ["on","smooth",300]` gefolgt von `set_ct_abx [ct,"smooth",300]`. Läuft nur wenn `Ct` eine Zahl ist (Weiß-Modus). Gültiger Bereich: **1700–6500 K** (genaue Grenzen hängen vom Lampenmodell ab). Alle Schreibvorgänge verwenden einen 300-ms-Smooth-Übergang für ein sanftes Dimmen statt eines harten Sprungs. Nach jedem Schreibvorgang wird die Debounce-Variable auf 1 gesetzt, wodurch der nächste Poll-Zyklus übersprungen wird — dies verhindert das Lesen veralteter Zustände während des Übergangs der Lampe. ### Service-Diagnose Zwei Service-Attribute auf Modulebene werden über eine separate `get_prop`-Anfrage (`id=981`) gelesen: - **Farbmodus** — `RGB`, `Temperature` oder `HSV`, dekodiert aus der numerischen `color_mode`-Eigenschaft (1 / 2 / 3) mittels eines `SWITCH`-Ausdrucks im Modul-Listener-Skript. - **Farbtemperatur** — Kelvin-Wert, gemeldet als `"{ct}K"` (z. B. `"4000K"`). Nur aussagekräftig, wenn die Lampe im Temperature-Modus ist. Diese Attribute sind reine Lese-Diagnose — die eigentliche Farbtemperatursteuerung erfolgt über die `Ct`-Eigenschaft auf Geräteebene und das oben beschriebene `writecct`-Skript. ## Fehlerbehebung ### Lampe reagiert nicht auf Befehle 1. Überprüfen Sie, dass **LAN Control** auf der Lampe aktiviert ist (Yeelight-App → Lampeneinstellungen → LAN Control). Ohne ihn lehnt die Lampe alle TCP-Verbindungen auf Port 55443 ab. 2. Bestätigen Sie die Lampen-IP in der Yeelight-App oder in der DHCP-Lease-Tabelle des Routers und stellen Sie sicher, dass sie mit dem Importparameter `ipAddress` übereinstimmt. Yeelight-Lampen behalten standardmäßig keine feste IP — der Lease kann abgelaufen und die IP geändert worden sein. 3. Weisen Sie der Lampe eine statische IP oder DHCP-Reservierung zu, um Adressänderungen zu verhindern. 4. Prüfen Sie, dass TapHome CCU und Lampe im gleichen LAN / VLAN sind und TCP `55443` nicht von einer Firewall zwischen ihnen blockiert wird. 5. Testen Sie die Konnektivität manuell: `telnet {bulb-ip} 55443` und senden Sie eine rohe Anfrage gefolgt von `\r\n`: ```json {"id":1,"method":"get_prop","params":["hue","sat","bright","power","ct","color_mode"]} ``` Eine funktionierende Lampe antwortet mit `{"id":1,"result":["","","","","",""]}`. ### Farbbefehle werden ignoriert (Farbton/Sättigung ändert sich nicht) Das `writesaturation`-Skript prüft `Ct` vor dem Senden von `set_hsv`. Wenn `Ct` auf einen numerischen Wert gesetzt ist (Weiß-Modus), kehrt das Skript zurück ohne einen Befehl zu senden. Um HSV-Farbe zu steuern, setzen Sie die Farbtemperatur zuerst auf NaN, indem Sie eine Farbe im TapHome-HSB-Picker auswählen. Ebenso kehrt `writecct` ohne Senden zurück wenn `Ct = NaN` (HSV-Modus). Um eine Farbtemperatur zu schreiben, muss die Lampe bereits im Weiß-Modus sein. ### Lesefehler: client quota exceeded Jede TCP-Verbindung zu einer Yeelight-Lampe ist auf **60 Befehle pro Minute** begrenzt, und die Lampe akzeptiert maximal **4 gleichzeitige Verbindungen** insgesamt. Wenn ein anderes System die Lampe gleichzeitig pollt — Home Assistant, eine Yeelight-Cloud-Sitzung, ein benutzerdefiniertes Skript — kann der kombinierte Datenverkehr Rate-Limit-Fehler auslösen. 1. Deaktivieren oder verlangsamen Sie andere Integrationen, die die Lampe teilen. 2. Belassen Sie das TapHome-Poll-Intervall bei den Standard-`10000` ms oder höher. Die Farbvorlage sendet ein `get_prop` pro Poll plus bis zu drei `set_*`-Schreibvorgänge pro Änderung, was deutlich unter der 60-cmd/min-Quote liegt. 3. Schließen Sie ungenutzte `telnet`-Debug-Sitzungen — sie zählen zum 4-Verbindungslimit. ### HueSat- oder Farbtemperatur-Schreibfehler Das Listener-Skript verfolgt Schreibfehler separat für jeden Befehlstyp — `writeErrorBrightness` für Strom-/Helligkeitsschreibvorgänge, `writeErrorHueSat` für `set_hsv`-Schreibvorgänge und `writeErrorCt` für `set_ct_abx`-Schreibvorgänge. Wenn ein Fehler auftritt: 1. Bestätigen Sie, dass die Lampe eingeschaltet ist — alle `set_*`-Befehle außer `set_power` werden nur akzeptiert, wenn die Lampe im `on`-Zustand ist. 2. Überprüfen Sie, dass der Farbtemperaturwert im modellspezifischen Bereich liegt (typisch 1700–6500 K für Farblampen, 2700–6500 K für Deckenleuchten, 2700–6000 K für ceiling3). 3. Prüfen Sie die rohe Fehlermeldung in der TapHome-Service-Diagnose für den spezifischen Fehlercode der Lampe. ### Änderungen aus der Yeelight-App werden nicht übernommen Die Vorlage reagiert auf `props`-Benachrichtigungen der Lampe, sodass externe Änderungen normalerweise innerhalb einer Sekunde erscheinen. Falls nicht: 1. Die Benachrichtigung kann eingetroffen sein, während der TCP-Socket wiederhergestellt wurde — der nächste Poll (Standard 10 s) synchronisiert den Zustand. 2. Einige ältere Firmware-Versionen senden Benachrichtigungen nur, wenn aktiv ein Befehl gesendet wird. Aktualisieren Sie die Lampen-Firmware über die Yeelight-App. 3. Die Lampe hat möglicherweise das 4-Verbindungslimit erreicht — reduzieren Sie die Anzahl gleichzeitiger Clients im LAN. > [!WARNING] > Yeelight-Geräte unterstützen nur **4 gleichzeitige TCP-Verbindungen** und **60 Befehle pro Minute** pro Verbindung. Wenn TapHome und ein anderes System (z. B. Home Assistant) dieselbe Lampe gleichzeitig pollen, kann die Kommunikation unzuverlässig werden. Verwenden Sie ein Poll-Intervall von 10 Sekunden oder höher. ## Verfügbare Geräte 1 Diese Geräte erscheinen nach dem Import in TapHome. Yeelight-Color-Modul Modul Serviceattribute | | | |----------------|-------------------------------------------------------------------------------------------------------| | Farbmodus | Aktueller Farbmodus der Lampe — RGB, Temperature oder HSV — aus der color\_mode-Eigenschaft dekodiert | | Farbtemperatur | Farbtemperatur in Kelvin, nur gemeldet wenn die Lampe im Temperature-Modus ist (color\_mode=2) | Listener ```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 ``` Serviceattribute Color mode ```taphome VAR json := "{\"id\":981, \"method\":\"get_prop\", \"params\":[\"color_mode\", \"ct\"]}"; SENDDATA(json); RETURN(NULL); ``` Color temperature ``` ``` HSB-Leuchte HSB-Licht Lesen und Schreiben HSB-Vollfarbsteuerung mit Farbtemperatur — steuert Farbton, Sättigung, Helligkeit und Ein/Aus über set\_hsv, set\_ct\_abx und set\_bright mit weichen Übergängen numeric Einheit: hue 0-359, sat/bright 0-100 %, CCT 2700-6500 K Lesen (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 ``` Listener ```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 ``` Helligkeit schreiben ```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; ``` Sättigung schreiben ```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; ``` Farbtemperatur schreiben ```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; ``` **Verbindung:** Packet Parser → TCP Mögliche Verbesserungen (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. ## Importparameter Diese Werte geben Sie beim Import des XML ein. | In der App abgefragt | Standard | |------------------------|---------------| | IP-Adresse | `192.168.0.1` | | Port | `55443` | | Internal poll interval | `10000` | ## Quellen - 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 Herstellerdokumente sind © ihrer jeweiligen Eigentümer. Sie werden so bereitgestellt, wie der Hersteller sie veröffentlicht hat, nur zur Information. ## Verwandte Dokumentation - [Packet-Parser-Integration](https://taphome.com/de/compatibility/packet-parser-guide/) - [Packet Parser (HTTP, TCP, UDP, FTP, MQTT)](https://taphome.com/de/docs/integration/packet-parser/) - [Packet-Parser-Funktionen](https://taphome.com/de/docs/script/packet-parser/) - [Parsing-Funktionen](https://taphome.com/de/docs/script/parsing-functions/)