---
title: "Shelly DUO RGBW"
description: "Volle RGB + CCT-Steuerung, sanfte Übergänge und Leistungsmessung für die Shelly DUO RGBW GU10 Birne. HTTP- und MQTT-Vorlagen für TapHome."
url: "https://taphome.com/de/compatibility/shelly-duo-rgbw/"
language: de
lastmod: 2026-10-08
generator: hugo
ai:
  topics: ["http","mqtt","lighting","wifi","rgbw","color-temperature","power-metering"]
  questions: ["Wie integriere ich die Shelly DUO RGBW mit TapHome?","Wie steuere ich Farbe und Helligkeit der Shelly DUO RGBW über TapHome?","Wie verbinde ich die Shelly DUO RGBW per HTTP mit TapHome?","Wie verbinde ich mehrere Shelly DUO RGBW Birnen per MQTT mit TapHome?","Warum zeigt die Shelly DUO RGBW null Leistung an?","Wie wechsle ich zwischen RGB- und Weißmodus bei der Shelly DUO RGBW?"]
---

# Shelly DUO RGBW

Kommunikation: Packet Parser → HTTP

- [Shelly DUO RGBW Produktseite](https://www.shelly.com/en/products/shop/shelly-duo-rgbw-gu10)

> 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 Shelly DUO RGBW ist eine Gen1 WLAN-Smart-LED-Birne im GU10-Formfaktor. Sie unterstützt volle RGB-Farben und einstellbares Weiß (CCT 3000–6500 K) mit sanften Übergangseffekten. TapHome kommuniziert mit dem Gerät über das lokale Netzwerk — keine Cloud-Verbindung erforderlich.

Zwei TapHome-Vorlagen sind verfügbar: eine **HTTP-Vorlage** zur Steuerung einer einzelnen Birne über die REST API und eine **MQTT-Vorlage**, die bis zu **5 Birnen** über einen gemeinsamen MQTT-Broker steuern kann. Beide Vorlagen stellen volle Lichtsteuerung und Leistungsmessung bereit.

## Konfiguration

### HTTP-Vorlage

Die HTTP-Vorlage benötigt die IP-Adresse der Birne (Standard-Platzhalter `192.168.0.1`) und eine optionale Übergangszeit in Millisekunden (Standard 300 ms). TapHome fragt den `/status`-Endpoint alle 2,5 Sekunden ab, um Lichtzustand, Farbwerte und Energiemessdaten zu lesen.

Das Leseskript auf Modulebene speichert die `/status`-Antwort in der benutzerdefinierten Variable `jsonStatus`, sodass einzelne Geräteskripte die Daten parsen können, ohne redundante HTTP-Aufrufe zu machen.

### MQTT-Vorlage

Die MQTT-Vorlage benötigt die Broker-Verbindungsdaten und eine oder mehrere **Device IDs** — eine pro Birne. Die Device ID jeder Birne wird über die benutzerdefinierte Variable `bulbNtopic` konfiguriert (Format: `shellycolorbulb-DEVICEID`). Die Device ID finden Sie in der Shelly-Weboberfläche unter **Settings** > **Device Info**.

Die Vorlage unterstützt bis zu 5 Birnen gleichzeitig. Konfigurieren Sie die `bulbNtopic`-Variablen nur für Birnen, die Sie tatsächlich haben — ungenutzte Plätze können auf ihren Standard-Platzhalterwerten belassen werden.

Nach dem Aktivieren von MQTT auf der Shelly DUO RGBW (Internet & Security > Advanced — MQTT) abonniert TapHome `shellies/#` und leitet Nachrichten anhand des Topic-Präfixes an die richtige Birneninstanz weiter.

> [!WARNING]
> Bei Gen1 Shelly-Geräten **deaktiviert** das Aktivieren von MQTT die **Shelly Cloud**. Beides kann nicht gleichzeitig laufen.

## Gerätefunktionen

### Lichtsteuerung

Die Birne arbeitet in zwei sich gegenseitig ausschließenden Modi:

- **Farbmodus** — volle RGB-Steuerung über Rot-, Grün- und Blaukanäle (jeweils 0–255) plus Gain (Helligkeit, 0–100 %). TapHome stellt dies als HSB-Licht dar — Farbton (0–360), Sättigung (0,0–1,0) und Helligkeit (0,0–1,0) werden per `RGBTOHSV`-Funktion aus RGB konvertiert.
- **Weißmodus** — einstellbares Weiß über Farbtemperatur (3000–6500 K) und Helligkeit (0–100 %). Das Setzen eines CCT-Werts in TapHome schaltet die Birne automatisch in den Weißmodus.

Der Modus wechselt automatisch basierend darauf, welche Eigenschaft Sie setzen:
- Das Setzen von Farbton oder Sättigung sendet einen `/light/0?mode=color`-Befehl (HTTP) oder einen JSON-Payload mit `"mode":"color"` über `color/0/set` (MQTT)
- Das Setzen von CCT sendet einen `/light/0?mode=white`-Befehl (HTTP) oder einen Payload mit `"mode":"white"` (MQTT)

Alle Schreibbefehle enthalten den konfigurierten `transitionTime`-Parameter für sanftes Überblenden zwischen Zuständen. Ein Debounce-Mechanismus verhindert veraltete Messwerte während Übergängen — die Vorlage ignoriert `/status`-Antworten für eine kurze Zeit nach jedem Schreibvorgang.

> [!NOTE]
> Im MQTT-Modus beträgt das Debounce-Fenster die Übergangszeit plus 3 Sekunden nach jedem Schreibvorgang (länger als die HTTP-Vorlage), um die Latenz der MQTT-Nachrichtenzustellung zu berücksichtigen.

### Leistungsmessung

Beide Vorlagen stellen einen Energiezähler bereit, der zwei Werte liest:

- **Aktuelle Leistung** — in Watt, auf kW konvertiert durch Division durch 1000
- **Gesamtverbrauch** — in Wattminuten, auf kWh konvertiert durch Division durch 60 000

Die HTTP-Vorlage liest `meters[0].power` und `meters[0].total` aus der `/status`-Antwort. Die MQTT-Vorlage lauscht auf die Topics `shellies/{id}/light/0/power` und `shellies/{id}/light/0/energy` für jede Birne unabhängig.

> [!TIP]
> Die Leistungsüberwachung erfordert die Konfiguration des Gerätemodells in der Shelly-App oder Weboberfläche unter **Settings** > **Device Model**. Wenn das Modell nicht eingestellt ist und die Birne eingeschaltet ist, aber die Leistung null anzeigt, zeigt die Vorlage eine Warnung an.

### Service-Diagnose (nur HTTP)

Die HTTP-Vorlage stellt 10 Service-Attribute zur Geräteüberwachung bereit:

- **Netzwerkinfo** — IP-Adresse, MAC-Adresse, WLAN-Signalstärke (dB)
- **Konnektivität** — Cloud aktiviert/verbunden, MQTT verbunden
- **System** — Gerätezeit, Firmware-Update verfügbar, Betriebszeit, RAM-Auslastung

### Service-Aktionen (nur HTTP)

Zwei Service-Aktionen sind in der HTTP-Vorlage verfügbar:

- **Cloud aktivieren** — aktiviert oder deaktiviert die Shelly-Cloud-Verbindung
- **Neustart** — löst einen Geräteneustart aus

### Weitere Funktionen

Die Shelly DUO RGBW unterstützt auch Lichteffekte (Meteor Shower, Gradual Change, Breath, Flash, On/Off Gradual, Red/Green Change), einen dedizierten weißen LED-Kanal im Farbmodus und den MQTT-Verbindungsstatus (LWT). Diese Funktionen können in einem zukünftigen Vorlagen-Update hinzugefügt werden.

## Fehlerbehebung

### Birne antwortet nicht (HTTP)

1. Überprüfen Sie, ob die Birne mit dem WLAN verbunden ist und eine gültige IP-Adresse hat
2. Versuchen Sie den mDNS-Hostnamen (`shellycolorbulb-AABBCCDDEE.local`) statt der IP-Adresse — die IP kann sich nach einer DHCP-Erneuerung geändert haben
3. Öffnen Sie `http://{device-ip}/shelly` im Browser — wenn eine Antwort kommt, ist das Gerät erreichbar
4. Prüfen Sie, dass TapHome CCU und die Birne im selben Netzwerk / VLAN sind

### Farben erscheinen falsch

1. Überprüfen Sie, ob die Birne im richtigen Modus ist — RGB-Farben funktionieren nur im Farbmodus, nicht im Weißmodus
2. Beim Setzen einer Farbe über TapHome stellen Sie sicher, dass die Sättigung größer als null ist — eine Sättigung von 0 erzeugt weißes Licht unabhängig vom Farbton
3. Prüfen Sie, dass Gain (Helligkeit im Farbmodus) nicht auf null gesetzt ist

### Leistung zeigt null an

1. Bestätigen Sie, dass das Gerätemodell in der Shelly-App konfiguriert ist (Settings > Device Model)
2. Prüfen Sie, ob die Birne eingeschaltet ist — der Zähler misst nur bei Stromfluss
3. Rufen Sie `/status` manuell auf und prüfen Sie, ob `meters[0].power` einen Wert ungleich null zurückgibt

### MQTT-Birnen antworten nicht

1. Überprüfen Sie, ob MQTT in der Weboberfläche jeder Birne aktiviert ist (Internet & Security > Advanced — MQTT)
2. Bestätigen Sie, dass Broker-Adresse und Port sowohl im Shelly-Gerät als auch in den TapHome-Moduleinstellungen korrekt sind
3. Prüfen Sie, ob die benutzerdefinierte Variable `bulbNtopic` exakt mit der Device ID der Birne übereinstimmt (z. B. `shellycolorbulb-B929CC`)
4. Verwenden Sie einen MQTT-Client (z. B. MQTT Explorer), um `shellies/#` zu abonnieren und zu verifizieren, dass jede Birne Nachrichten veröffentlicht

> [!WARNING]
> Shelly Gen1-Geräte unterstützen nur **2 gleichzeitige HTTP-Verbindungen**. Wenn TapHome und ein anderes System (z. B. Home Assistant) dieselbe Birne gleichzeitig abfragen, kann die Kommunikation unzuverlässig werden. Erwägen Sie den Wechsel zur MQTT-Vorlage für Umgebungen mit mehreren Systemen.

## Installation in TapHome

### Voraussetzungen

- Shelly-Gerät installiert und eingeschaltet
- Lokales Wi-Fi-Netzwerk (2,4 GHz)
- TapHome CCU im selben Netzwerk

### Schritt 1 — Shelly mit Wi-Fi verbinden

**Option A — Shelly-App (empfohlen):**

1. Laden Sie die [Shelly-App](https://www.shelly.com/en/support/shelly-app) herunter (iOS / Android)
2. Tippen Sie auf **+** → **Add Device** und folgen Sie dem Bluetooth-Kopplungsassistenten
3. Geben Sie Ihre Wi-Fi-Zugangsdaten ein, wenn Sie dazu aufgefordert werden

**Option B — AP-Modus (ohne App):**

1. Beim ersten Einschalten erstellt das Gerät einen Hotspot: `ShellyXXX-AABBCCDDEE`
2. Verbinden Sie Ihr Telefon/PC mit diesem Hotspot
3. Öffnen Sie `http://192.168.33.1` → **Internet & Security** → **Wi-Fi Mode - Client**
4. Geben Sie SSID und Passwort ein → **Save**

> [!NOTE]
> Shelly unterstützt nur **2,4 GHz**-Netzwerke. 5 GHz-Netzwerke werden beim Scannen nicht angezeigt.

### Schritt 2 — IP-Adresse ermitteln

Nach der Verbindung mit Wi-Fi ermitteln Sie die zugewiesene IP-Adresse auf eine der folgenden Arten:

- **Shelly-App:** Gerätedetail → **Device info** → IP-Adresse
- **Shelly-Weboberfläche:** Verbinden Sie sich mit dem Geräte-AP vor der Wi-Fi-Einrichtung — die IP wird nach dem Speichern angezeigt
- **Router-DHCP-Tabelle:** Suchen Sie nach einem Hostnamen wie `shelly1pm-AABBCCDDEE`
- **mDNS:** Pingen Sie `shelly<model>-<mac>.local` (z. B. `shelly1pm-AABBCCDDEE.local`) aus dem selben Netzwerk

> [!TIP]
> Weisen Sie dem Shelly-Gerät eine **statische IP** (DHCP-Reservierung) in Ihrem Router zu, damit sich die Adresse nach einem Router-Neustart nicht ändert.

### Schritt 3 — Konfiguration in TapHome

1. Fügen Sie in TapHome ein neues Modul **Packet Parser (HTTP)** hinzu
2. **IP Address:** Geben Sie die IP aus Schritt 2 ein (z. B. `192.168.1.50`)
3. **Port:** `80` (Standard, keine Änderung erforderlich)
4. Importieren Sie die Vorlage — TapHome fragt regelmäßig `/status` ab, um den Gerätestatus zu lesen

> [!NOTE]
> Die HTTP-Authentifizierung ist auf Shelly-Geräten standardmäßig deaktiviert. Wenn Sie den Anmeldeschutz aktiviert haben, unterstützt TapHome derzeit kein HTTP Basic Auth — lassen Sie die Authentifizierung für die TapHome-Integration deaktiviert.

## Verfügbare Geräte 2

Diese Geräte erscheinen nach dem Import in TapHome.

Shelly DUO RGBW Modul

Serviceattribute

|                     |
|---------------------|
| IP-Adresse          |
| MAC-Adresse         |
| WLAN-Signal         |
| Cloud aktiviert     |
| Cloud verbunden     |
| MQTT verbunden      |
| Gerätezeit          |
| FW-Update verfügbar |
| Betriebszeit        |
| RAM                 |

Serviceaktionen

|                  |
|------------------|
| Cloud aktivieren |
| Neustart         |

Benutzerdefinierte Variablen

|                                             |                                                                              |
|---------------------------------------------|------------------------------------------------------------------------------|
| `transitionTime` (numeric) = TransitionTime | Light transition duration in milliseconds (import parameter, default 300 ms) |

Lesen (Modul)

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

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

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

IF response.IsSuccess
    jsonStatus := response.Content;
ELSE
    jsonStatus := NULL;
END
```

Serviceattribute

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

Serviceaktionen

Enable cloud

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

RGBW-Licht HSB-Licht Lesen und Schreiben

Volle RGB-Farbe + einstellbares Weiß (CCT 3000–6500 K) mit sanften Übergängen und modusbewusster Helligkeitssteuerung

HSB

Helligkeit lesen

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

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

INT value;
VAR mode := PARSEJSON(jsonStatus, "$.lights[0].mode", 1);

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

Helligkeit schreiben

```taphome
IF St > 0.5
    VAR mode := PARSEJSON(jsonStatus, "$.lights[0].mode", 1);
    
    IF mode = "white"
        SENDHTTPREQUEST("light/0?turn=on&transition=" + transitionTime + "&brightness=" + ROUND(Hb*100.0));
    ELSE
        SENDHTTPREQUEST("light/0?turn=on&transition=" + transitionTime + "&gain=" + ROUND(Hb*100.0));
    END
ELSE
    SENDHTTPREQUEST("light/0?turn=off&transition=" + transitionTime);
END

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

Farbton lesen

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

Farbton schreiben

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


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

Sättigung lesen

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

Sättigung schreiben

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


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

Farbtemperatur lesen

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

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

INT value := PARSEJSON(jsonStatus, "$.lights[0].temp", 1);
STRING mode := PARSEJSON(jsonStatus, "$.lights[0].mode", 1);

IF ISNULL(value) OR mode != "white"
    RETURN(NaN);
END
 
value
```

Farbtemperatur schreiben

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

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

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

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

Stromzähler Stromzähler Nur lesen

Leistungs- und Energiemessung — momentane Leistung (kW) und kumulierter Energieverbrauch (kWh)

numeric Einheit: W / kWh

Gesamtverbrauch lesen

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

Bedarf lesen

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

**Verbindung:** Packet Parser → HTTP • Hostname: `shellycolorbulb-{MAC}.local`

Mögliche Verbesserungen (4)

- Light Effect — Effect index (0=Off, 1=Meteor Shower, 2=Gradual Change, 3=Breath, 4=Flash, 5=On/Off Gradual, 6=Red/Green Change). Available in both /light/0 and MQTT color/0/set.
- WiFi Signal Strength — WiFi RSSI in dBm, available in /status response (HTTP only; MQTT template reads it as service attribute already)
- White Channel — Dedicated white LED channel (0–255) in color mode, separate from CCT. Available in /light/0?white=N.
- Connection Status (MQTT) — LWT topic — true on connect, false on disconnect. Could detect offline bulbs.

## Importparameter

Diese Werte geben Sie beim Import des XML ein.

| In der App abgefragt | Standard      |
|----------------------|---------------|
| IP-Adresse           | `192.168.0.1` |
| Transition time (ms) | `300`         |

## Quellen

- 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 DUO RGBW — Device-Specific API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen1/#shelly-bulb-rgbw) 2026-03-30
- Shelly DUO RGBW — Knowledge Base
  
  [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-bulb-duo-rgbw) 2026-03-30

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