--- title: "Shelly RGBW2 White" description: "Shelly RGBW2 im White-Modus: vier unabhängige weiße LED-Dimmerkanäle mit Energiemessung pro Kanal. Lokale HTTP-Integration mit TapHome." url: "https://taphome.com/de/compatibility/shelly-rgbw2-white/" language: de lastmod: 2026-04-24 generator: hugo ai: topics: ["http","lighting","wifi","dimmer","led-controller","shelly","gen1"] questions: ["Wie integriere ich Shelly RGBW2 im White-Modus mit TapHome?","Wie wechsle ich Shelly RGBW2 vom Color- in den White-Modus?","Kann ich vier separate weiße LED-Streifen mit einem Shelly RGBW2 steuern?","Warum zeigt Shelly RGBW2 White den Fehler „Mode is not supported\"?","Wie hoch ist die maximale Leistung pro Kanal bei Shelly RGBW2?","Ist Shelly RGBW2 noch erhältlich oder wurde er ausgelaufen?"] --- # Shelly RGBW2 White Kommunikation: Packet Parser → HTTP - [Shelly RGBW2 Produktseite](https://www.shelly.com/en/products/shop/shelly-rgbw2) - [Shelly RGBW2 API-Dokumentation (White-Modus)](https://shelly-api-docs.shelly.cloud/gen1/#shelly-rgbw2-white-mode) - [Shelly RGBW2 Knowledge Base](https://kb.shelly.cloud/knowledge-base/shelly-rgbw2) > 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 Der Shelly RGBW2 ist ein Wi-Fi-LED-Streifen-Controller mit vier PWM-Ausgängen (12/24 V DC). Im **White-Modus** werden die vier Ausgänge — normalerweise für R, G, B und W eines RGBW-Streifens verwendet — zu vier unabhängigen einfarbigen Dimmerkanälen. Jeder Kanal kann seinen eigenen weißen LED-Streifen, seine LED-Lampe oder seine Spotgruppe ansteuern. TapHome kommuniziert mit dem Gerät über HTTP im lokalen Netzwerk; eine Cloud-Verbindung ist nicht erforderlich. Diese Vorlage ist das White-Modus-Gegenstück zur [Shelly RGBW2](https://taphome.com/de/compatibility/shelly-rgbw2/) Color-Modus-Vorlage. Beide Vorlagen teilen sich dieselbe Hardware, aber die Firmware arbeitet in sich gegenseitig ausschließenden Modi, die in den Geräteeinstellungen ausgewählt werden. Vor dem Import dieser Vorlage muss das Gerät im White-Modus konfiguriert sein — die Vorlage validiert den Modus bei jeder Abfrage und zeigt einen Fehler, wenn das Gerät auf Color eingestellt ist. > [!NOTE] > Shelly hat den RGBW2 als **ausgelaufen** gekennzeichnet — er wird von der Shelly Group nicht mehr hergestellt oder verkauft. Bestehende Einheiten funktionieren weiterhin und erhalten Firmware-Updates. ## Verkabelung Der Shelly RGBW2 wird aus einer 12 V oder 24 V DC-Versorgung (V+ / GND) gespeist. Jeder der vier Ausgänge (am Gerät mit R, G, B, W beschriftet) treibt eine weiße LED-Last. Typische Verkabelungsvarianten für den White-Modus: - **Vier unabhängige weiße LED-Streifen oder Lampen** — jeder Kanal steuert einen Streifen/eine Lampe, gemeinsame Anode (+) an V+ - **Mehrere Spots pro Kanal** — mehrere 12/24 V-Spots parallel pro Ausgang verdrahtet - **Zwei weiße Streifen mit verdoppelter Leistung** — zwei Kanäle pro Streifen (parallel) gekoppelt, um die Ausgangsleistung zu verdoppeln Die Lastgrenzen pro Kanal (laut Shelly-Spezifikation) betragen **45 W bei 12 V** und **90 W bei 24 V**. Die kombinierte Last aller vier Kanäle darf 144 W bei 12 V bzw. 288 W bei 24 V nicht überschreiten. ## Konfiguration Die Vorlage verbindet sich über Wi-Fi. Geben Sie beim TapHome-Vorlagenimport die IP-Adresse des Geräts (Standard-Platzhalter `192.168.0.1`) und eine optionale Transition Time in Millisekunden (Standard `300`) ein. Die Transition Time steuert, wie schnell jeder Kanal zwischen Helligkeitsstufen überblendet. Sie wird bei jedem Schreibbefehl gesendet und definiert zugleich das Entprellfenster — die Vorlage ignoriert abgefragte Helligkeitswerte für `transitionTime + 500 ms` nach jedem Schreibvorgang, um veraltete Lesewerte während einer Überblendung zu verhindern. ## Modusumschaltung Wenn sich das Gerät derzeit im Color-Modus befindet, schalten Sie es vor dem Import dieser Vorlage in den White-Modus. Entweder: - Öffnen Sie die Shelly-Weboberfläche unter `http://{device-ip}` und ändern Sie den Betriebsmodus in den Einstellungen, oder - Senden Sie direkt `GET /settings?mode=white`, oder - Importieren Sie vorübergehend die Color-Modus-Vorlage und verwenden Sie deren Service-Aktion **Set mode White**, dann re-importieren Sie diese White-Modus-Vorlage Modusänderungen erfordern einen Geräteneustart. Nach dem Neustart importieren Sie die White-Modus-Vorlage erneut in TapHome. ## Gerätefähigkeiten ### Vier unabhängige Dimmer Die Vorlage stellt vier unabhängige Dimmerkanäle bereit, einen pro PWM-Ausgang: | Kanal | Ausgangspin | Endpoint | Abfrageintervall | |-------|-------------|--------------|------------------| | 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 | Jeder Dimmer liest `lights[N].ison` und `lights[N].brightness` (0–100, normiert auf 0–1) aus der `/status`-Antwort. Schreibbefehle verwenden `/light/N?turn=on|off&brightness=VALUE&transition=T`. Die Vorlage verwendet den Legacy-Endpoint `/light/{idx}`, den die Shelly-Firmware als Alias des aktuellen `/white/{idx}`-Endpoints akzeptiert. ### Energiemessung pro Kanal Jeder Kanal verfügt über einen eigenen Stromzähler — **Electric Meter Ch1** bis **Electric Meter Ch4** — der aus `meters[0]` bis `meters[3]` liest: - **Momentane Leistung** — `meters[N].power` in Watt, in kW konvertiert - **Gesamtverbrauch** — `meters[N].total` in Watt-Minuten, in kWh konvertiert Kanal 1 wird alle 2,5 s zusammen mit seinem Dimmer abgefragt; Kanäle 2–4 werden im 15-s-Intervall abgefragt, um die Last auf den Gen1-HTTP-Stack (der nur zwei gleichzeitige Verbindungen toleriert) zu reduzieren. ### Service-Diagnose Die Vorlage stellt 10 Service-Attribute zur Geräteüberwachung bereit: - **Netzwerk** — IP-Adresse, MAC-Adresse (mit Doppelpunkten formatiert), Wi-Fi-Signalstärke (dB) - **Konnektivität** — Cloud aktiviert/verbunden, MQTT verbunden - **Geräteinfo** — Gerätezeit, Betriebszeit (formatiert als Tage/Stunden/Minuten), RAM-Nutzung - **Firmware** — Firmware-Update verfügbar ### Service-Aktionen Drei Service-Aktionen stehen zur Verfügung: - **Cloud aktivieren** — aktiviert oder deaktiviert die Shelly-Cloud-Verbindung - **Neustart** — löst einen Geräteneustart aus - **Modus White einstellen** — schreibt `/settings?mode=white`, um den White-Betriebsmodus durchzusetzen (nützlich nach einem Werksreset oder falls jemand den Modus über die Shelly-App geändert hat) Die Shelly Cloud API wird von dieser Vorlage **nicht** verwendet — die Kommunikation erfolgt ausschließlich über lokales HTTP-Polling. ## Fehlerbehebung ### Gerät antwortet nicht 1. Überprüfen Sie, dass der Shelly mit Wi-Fi verbunden ist und eine gültige IP-Adresse besitzt 2. Versuchen Sie den mDNS-Hostnamen (`shellyrgbw2-AABBCCDDEE.local`) anstelle der IP-Adresse — die IP kann sich nach einer DHCP-Erneuerung geändert haben 3. Öffnen Sie `http://{device-ip}/shelly` im Browser — wenn er antwortet, ist das Gerät erreichbar 4. Prüfen Sie, dass TapHome CCU und Shelly im selben Netzwerk / VLAN sind ### Fehler „Mode White is not supported" Dieser Fehler bedeutet, dass das Gerät derzeit auf Color-Modus eingestellt ist. So beheben Sie ihn: 1. Öffnen Sie die Shelly-Weboberfläche unter `http://{device-ip}` und schalten Sie den Betriebsmodus auf White, oder 2. Senden Sie direkt `GET /settings?mode=white` aus einem Browser oder per curl, oder 3. Wenn Sie die Color-Modus-Vorlage importiert haben, führen Sie von dort die Service-Aktion **Modus White einstellen** aus 4. Das Gerät muss nach einer Modusänderung neu starten — warten Sie einige Sekunden und laden Sie TapHome neu ### Leistungsmessung zeigt Null 1. Stellen Sie sicher, dass weiße LEDs an den entsprechenden Shelly-RGBW2-Ausgang (Pin R, G, B oder W) angeschlossen sind 2. Öffnen Sie die Shelly-App oder Weboberfläche und prüfen Sie, dass das Gerätemodell unter Settings -> Device Model konfiguriert ist — ohne dies liefert der Zähler null 3. Prüfen Sie, dass der Kanal eingeschaltet ist — der Zähler liest nur, wenn Strom durch den Ausgang fließt 4. Fragen Sie `/status` manuell ab und bestätigen Sie, dass `meters[N].power` für den betreffenden Kanal einen von null verschiedenen Wert zurückgibt ### Kanal dimmt nicht sauber 1. Prüfen Sie, dass der Transition-Time-Parameter dem erwarteten Verhalten entspricht — der Standard von 300 ms ist eine kurze Überblendung; längere Werte (z. B. 1500 ms) erzeugen langsamere Überblendungen 2. Beachten Sie, dass das Entprellfenster `transitionTime + 500 ms` beträgt — schneller gesendete Änderungen können zusammengefasst werden 3. Stellen Sie sicher, dass die LED-Last dimmbar ist (einige Treiber sind nicht PWM-kompatibel) und dass die Stromversorgung stabile 12/24 V DC liefert > [!WARNING] > Gen1-Shelly-Geräte unterstützen nur **2 gleichzeitige HTTP-Verbindungen**. Wenn TapHome und ein anderes System (z. B. Home Assistant) dasselbe Gerät gleichzeitig abfragen, kann die Kommunikation unzuverlässig werden. Halten Sie das Abfrageintervall pro zusätzlichem Client bei 10–30 Sekunden. ## 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-.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 8 Diese Geräte erscheinen nach dem Import in TapHome. Shelly RGBW2 White Modul Serviceattribute | | | |---------------------|--------------------------------------------------------------------------------------------------| | IP-Adresse | Aktuelle dem Gerät zugewiesene IP-Adresse (liest /status -> wifi\_sta.ip) | | MAC-Adresse | MAC-Adresse des Geräts, mit Doppelpunkten formatiert (liest /status -> mac) | | WLAN-Signal | Wi-Fi-Signalstärke in dB (liest /status -> wifi\_sta.rssi) | | Cloud aktiviert | Ob Shelly Cloud auf dem Gerät aktiviert ist (liest /status -> cloud.enabled) | | Cloud verbunden | Ob das Gerät derzeit mit Shelly Cloud verbunden ist (liest /status -> cloud.connected) | | MQTT verbunden | Ob das Gerät derzeit mit einem MQTT-Broker verbunden ist (liest /status -> mqtt.connected) | | Gerätezeit | Aktuelle vom Gerät gemeldete Zeit (liest /status -> time) | | FW-Update verfügbar | True, wenn ein Firmware-Update für das Gerät verfügbar ist (liest /status -> has\_update) | | Betriebszeit | Zeit seit dem letzten Neustart, formatiert als Tage/Stunden/Minuten (liest /status -> uptime) | | RAM | RAM gesamt und frei in Bytes (liest /status -> ram\_total, ram\_free) | Serviceaktionen | | | |------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------| | Cloud aktivieren | Shelly Cloud-Verbindung aktivieren oder deaktivieren (schreibt /settings/cloud?enabled=...) | | Neustart | Sofortigen Neustart des Geräts auslösen (schreibt /reboot) | | Modus White einstellen | Gerät in den White-Betriebsmodus schalten; vor dem Aktivieren des neuen Modus ist ein Geräteneustart erforderlich (schreibt /settings?mode=white) | Benutzerdefinierte Variablen | | | |---------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `transitionTime` (numeric) = TransitionTime | Dauer des Lichtübergangs in Millisekunden (Importparameter, Standard 300 ms). Definiert außerdem das Entprellfenster (transitionTime + 500 ms), während dessen abgefragte Werte nach jedem Schreibvorgang ignoriert werden. | Lesen (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 ``` 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"); ``` Set mode White ```taphome VAR response := SENDHTTPREQUEST("/settings?mode=white"); IF(response.isSuccess, "White mode is set", "Error"); ``` Stromzähler Ch1 Stromzähler Nur lesen Kanal 1 (Pin R) Leistungsaufnahme — 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 ``` Dimmer Ch1 (R) Dimmer Lesen und Schreiben Weiß-Dimmer Kanal 1 (Ausgang R Pin) — Helligkeit 0-100 % über /light/0 Endpoint numeric Einheit: 0–1 Level lesen ```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 ``` Level schreiben ```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; ``` Stromzähler Ch2 Stromzähler Nur lesen Kanal 2 (Pin G) Leistungsaufnahme — 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[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 ``` Bedarf lesen ```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 Lesen und Schreiben Weiß-Dimmer Kanal 2 (Ausgang G Pin) — Helligkeit 0-100 % über /light/1 Endpoint numeric Einheit: 0–1 Level lesen ```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 ``` Level schreiben ```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; ``` Stromzähler Ch3 Stromzähler Nur lesen Kanal 3 (Pin B) Leistungsaufnahme — 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[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 ``` Bedarf lesen ```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 Lesen und Schreiben Weiß-Dimmer Kanal 3 (Ausgang B Pin) — Helligkeit 0-100 % über /light/2 Endpoint numeric Einheit: 0–1 Level lesen ```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 ``` Level schreiben ```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; ``` Stromzähler Ch4 Stromzähler Nur lesen Kanal 4 (Pin W) Leistungsaufnahme — 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[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 ``` Bedarf lesen ```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 Lesen und Schreiben Weiß-Dimmer Kanal 4 (Ausgang W Pin) — Helligkeit 0-100 % über /light/3 Endpoint numeric Einheit: 0–1 Level lesen ```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 ``` Level schreiben ```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; ``` **Verbindung:** Packet Parser → HTTP • Hostname: `shellyrgbw2-{MAC}.local` Mögliche Verbesserungen (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) ## 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 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 ## 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/)