---
title: "Shelly Plus RGBW PM"
description: "Shelly Plus RGBW PM Gen2+ WLAN-RGBW-LED-Controller mit Leistungsmessung. Drei Profile (light, rgb, rgbw), Energie, Spannung, Strom, Temperatur pro Kanal."
url: "https://taphome.com/de/compatibility/shelly-plus-rgbw-pm/"
language: de
lastmod: 2026-10-08
generator: hugo
ai:
  topics: ["http","lighting","wifi","rgbw","rgb","dimmer","power-metering","gen2plus","profiles"]
  questions: ["Wie integriere ich den Shelly Plus RGBW PM mit TapHome?","Welche Profile unterstützt der Shelly Plus RGBW PM in TapHome?","Wie wechsle ich zwischen den Profilen light, rgb und rgbw beim Shelly Plus RGBW PM?","Wie steuere ich RGB-Farben auf dem Shelly Plus RGBW PM über TapHome?","Was ist der Unterschied zwischen den Profilen rgb und rgbw beim Shelly Plus RGBW PM?","Wie verwende ich den 4-Kanal-Dimmermodus beim Shelly Plus RGBW PM?","Warum zeigt der Shelly Plus RGBW PM einen Profilfehler in TapHome?","Welche Leistungsmessdaten sind für den Shelly Plus RGBW PM in TapHome verfügbar?"]
---

# Shelly Plus RGBW PM

Kommunikation: Packet Parser → HTTP

- [Shelly Plus RGBW PM Produktseite](https://www.shelly.com/en/products/shop/shelly-plus-rgbw-pm)
- [Shelly Plus RGBW PM API-Dokumentation](https://shelly-api-docs.shelly.cloud/gen2/Devices/Gen2/ShellyPlusRGBWPM/)

> 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 Plus RGBW PM ist ein Gen2+ WLAN-RGBW-LED-Controller mit eingebauter Leistungsmessung an jedem Ausgangskanal. Er treibt LED-Streifen oder einzelne LED-Kanäle bei 12/24 VDC mit bis zu 4 A pro Kanal (10 A gesamt). Das Gerät unterstützt drei umschaltbare Profile — **light** (4 unabhängige Dimmer), **rgb** (3-Kanal-Farbe) und **rgbw** (3-Kanal-Farbe + Weiß) — wobei jedes Profil unterschiedliche Geräte in TapHome bereitstellt. TapHome kommuniziert lokal über WLAN mit dem Gerät über die Gen2+ RPC API — keine Cloud-Verbindung erforderlich.

Die TapHome-Vorlage ist eine **HTTP-Vorlage**, die die RPC-Endpunkte des Geräts abfragt. Eine einzelne Vorlage bedient alle drei Profile; TapHome erkennt das aktive Profil zur Laufzeit und aktiviert die entsprechenden Geräte.

## Konfiguration

### Importparameter

Die Vorlage benötigt nur die IP-Adresse des Geräts (Standard-Platzhalter `192.168.0.1`). TapHome verbindet sich auf Port 80 und fragt mehrere RPC-Endpunkte für Systemstatus und Gerätedaten ab.

Auf Modulebene fragt TapHome `/rpc/Sys.GetStatus`, `/rpc/Sys.GetConfig`, `/rpc/WiFi.GetStatus` und `/rpc/PlusRGBWPM.GetConfig` im 3-Sekunden-Intervall ab. Die `Sys.GetConfig`-Antwort liefert das aktuelle Profil (`device.profile`), das bestimmt, welche Endpunkte auf Geräteebene aktiv sind.

### Profilauswahl

Der Shelly Plus RGBW PM arbeitet jeweils in einem von drei Profilen. Sie können das Profil direkt aus TapHome über die **Set Profile** Service-Aktion am Modul oder über die Shelly-Weboberfläche wechseln.

| Profil | Geräte in TapHome | Verwendung |
|--------|-------------------|------------|
| **light** | 4 unabhängige Dimmer (O1–O4) | Einfarbige LED-Streifen, 4 separate Beleuchtungszonen |
| **rgb** | 1 RGB-Licht | RGB-LED-Streifen (3-Kanal-Farbmischung) |
| **rgbw** | 1 RGBW-Licht | RGBW-LED-Streifen (RGB + dedizierter Weißkanal) |

Nach dem Profilwechsel startet das Gerät neu und TapHome erkennt das neue Profil automatisch. Geräte des inaktiven Profils melden einen Fehler ("Profile is not set to ...") — dies ist erwartet und kann ignoriert werden.

## Gerätefunktionen

### RGB-Licht (Profil = rgb)

Wenn das Gerät auf das **rgb**-Profil eingestellt ist, stellt TapHome ein einzelnes HSB-Lichtgerät bereit. Die Vorlage liest `/rpc/RGB.GetStatus?id=0` für den Ein-/Aus-Status, Helligkeit (0–100 %) und RGB-Farbwerte und schreibt über `/rpc/RGB.Set?id=0` zur Lichtsteuerung.

Die Farbsteuerung verwendet HSB (Hue-Saturation-Brightness):
- **Hue** (0–360 Grad) und **Saturation** (0,0–1,0) werden intern zwischen HSB und RGB konvertiert
- **Brightness** (0,0–1,0) wird auf den Shelly-Bereich 0–100 % abgebildet
- Das Setzen der Helligkeit auf 0 schaltet das Licht aus; jede Helligkeit ungleich null schaltet es ein

Das RGB-Licht stellt fünf Service-Attribute bereit:

| Attribut | Einheit | Beschreibung |
|----------|---------|--------------|
| Temperatur | C | Interne Gerätetemperatur |
| Energieverbrauch | Wh | Kumulierte Energie für den RGB-Ausgang |
| Leistung | W | Momentane Leistungsaufnahme |
| Spannung | V | Effektivspannung |
| Strom | A | Stromaufnahme |

### RGBW-Licht (Profil = rgbw)

Wenn das **rgbw**-Profil eingestellt ist, stellt TapHome ein einzelnes HSB-Licht mit zusätzlichem Weißkanal bereit. Die Vorlage liest `/rpc/RGBW.GetStatus?id=0` und schreibt über `/rpc/RGBW.Set?id=0`.

Das RGBW-Profil fügt einen **Weißkanal** (0–255) hinzu, gesteuert über CCT (korrelierte Farbtemperatur) bei festen 4500 K:
- Wenn der Weißkanal aktiv ist (`white != 0`), wird die Helligkeit vom Weißlevel abgeleitet (linear 0–255 auf 0,0–1,0 abgebildet)
- Wenn der Weißkanal inaktiv ist, stammt die Helligkeit aus dem Standard-Brightness-Feld (0–100 %)
- Das Umschalten in den Farbtemperaturmodus in TapHome aktiviert den Weißkanal; das Umschalten in den RGB-Modus deaktiviert ihn

Das RGBW-Licht stellt die gleichen fünf Service-Attribute wie das RGB-Licht bereit (Temperatur, Energie, Leistung, Spannung, Strom), gelesen aus der RGBW.GetStatus-Antwort.

### Dimmbare LED-Ausgänge (Profil = light)

Wenn das **light**-Profil eingestellt ist, stellt TapHome **4 unabhängige Dimmerkanäle** (O1–O4) bereit, von denen jeder einen LED-Ausgang steuert. Jeder Kanal liest von `/rpc/Light.GetStatus?id={0-3}` und schreibt über `/rpc/Light.Set?id={0-3}`.

Die Helligkeit wird vom TapHome-Bereich 0,0–1,0 auf den Shelly-Bereich 0–100 % abgebildet. Das Setzen des Levels auf 0 schaltet den Ausgang aus; jedes Level ungleich null schaltet ihn ein und setzt die Helligkeit.

Jeder Dimmerkanal stellt sechs Service-Attribute bereit:

| Attribut | Einheit | Beschreibung |
|----------|---------|--------------|
| Temperatur | C | Interne Gerätetemperatur |
| Energieverbrauch | Wh | Kumulierte Energie für diesen Kanal |
| Leistung | W | Momentane Leistungsaufnahme |
| Spannung | V | Effektivspannung |
| Strom | A | Stromaufnahme |
| Flags | — | Interne Status-Flags |

Jeder Dimmerkanal stellt auch eine **Kalibrierung** Service-Aktion bereit, die `/rpc/Light.Calibrate?id={N}` sendet, um den Ausgang für die angeschlossene LED-Last zu kalibrieren.

### Moduldiagnose und Aktionen

Das Modul stellt fünf Service-Attribute für die Gerätediagnose bereit:

| Attribut | Beschreibung |
|----------|--------------|
| WiFi | Name des verbundenen drahtlosen Netzwerks |
| IP-Adresse | Geräte-IP-Adresse |
| Signalstärke (dB) | WiFi RSSI |
| MAC | Hardware-Adresse des Geräts |
| Profil | Aktuell aktives Profil (light, rgb oder rgbw) |

Auf Modulebene sind drei Service-Aktionen verfügbar:

| Aktion | Beschreibung |
|--------|--------------|
| Firmware aktualisieren | Löst ein OTA-Update auf den stabilen Firmware-Kanal aus |
| Neustart | Startet das Gerät neu |
| Profil setzen | Wechselt zwischen den Profilen light, rgb und rgbw (Gerät startet neu) |

Das Modulskript prüft auch auf verfügbare Firmware-Updates und ausstehende Neustartanforderungen und zeigt in TapHome Warnungen an, wenn eine dieser Bedingungen erkannt wird.

### Weitere Funktionen

Der Shelly Plus RGBW PM stellt über seine RPC API auch den physischen Eingangsstatus, die Nachtmodus-Konfiguration mit Helligkeitsgrenzen und Zeitplan, die Übergangsdauer für Farb-/Helligkeitsänderungen und die Mindesthelligkeit beim Einschalten bereit. Diese Funktionen können in einem zukünftigen Vorlagen-Update hinzugefügt werden.

## Fehlerbehebung

### Gerät antwortet nicht

1. Überprüfen Sie, ob der Shelly mit dem WLAN verbunden ist und eine gültige IP-Adresse hat
2. Versuchen Sie den mDNS-Hostnamen (`shellyplusrgbwpm-AABBCCDDEE.local`) statt der IP-Adresse — die IP kann sich nach einer DHCP-Erneuerung geändert haben
3. Öffnen Sie `http://{device-ip}/rpc/Shelly.GetDeviceInfo` im Browser — wenn ein JSON zurückkommt, ist das Gerät erreichbar
4. Prüfen Sie, dass TapHome CCU und Shelly im selben Netzwerk / VLAN sind
5. Stellen Sie sicher, dass HTTP Digest Authentication in der Shelly-Weboberfläche deaktiviert ist — TapHome unterstützt keine authentifizierten Anfragen

### Profilfehler auf Geräten

Wenn ein Gerät "Profile is not set to rgb/rgbw/light" anzeigt — dies ist erwartet. Die Vorlage enthält Geräte für alle drei Profile, aber nur die Geräte des aktuell aktiven Profils funktionieren. Die anderen Geräte melden diesen Fehler und können ignoriert werden.

Um das aktive Profil zu wechseln, verwenden Sie die **Set Profile** Service-Aktion am Modul oder ändern Sie es in der Shelly-Weboberfläche. Das Gerät startet neu und TapHome erkennt das neue Profil innerhalb eines Abfragezyklus.

### Farben erscheinen falsch im RGB/RGBW-Modus

1. Überprüfen Sie, ob die LED-Streifen-Verdrahtung der Ausgangsklemmenreihenfolge entspricht (R, G, B, W) — vertauschte Drähte erzeugen falsche Farben
2. Die Vorlage konvertiert intern zwischen den Farbräumen HSB und RGB. Wenn Farben verwaschen wirken, prüfen Sie den Sättigungswert — niedrige Sättigung erzeugt Pastelltöne
3. Im RGBW-Modus werden der Weißkanal und die RGB-Kanäle unabhängig gesteuert. Beim Wechsel von Weiß zu Farbe oder umgekehrt sendet TapHome den entsprechenden Befehl, um den anderen Modus auf null zu setzen

### Dimmerausgänge reagieren nicht im Light-Modus

1. Bestätigen Sie, dass das Profil auf **light** eingestellt ist — Dimmergeräte funktionieren nur im Light-Modus
2. Prüfen Sie, ob jeder Kanal eine LED-Last angeschlossen hat — unbelastete Kanäle melden möglicherweise keinen korrekten Status
3. Versuchen Sie, die **Kalibrierung**-Aktion auf dem Kanal auszuführen — dies optimiert die Dimmkurve für die angeschlossene LED-Last
4. Gen2+-Geräte unterstützen bis zu 6 gleichzeitige HTTP-Verbindungen — vermeiden Sie gleichzeitiges Abfragen von mehreren Systemen

### Leistungsmessung zeigt null an

1. Bestätigen Sie, dass die LED-Last angeschlossen und der Kanal eingeschaltet ist
2. Fragen Sie den entsprechenden Endpunkt manuell ab (`/rpc/Light.GetStatus?id=0`, `/rpc/RGB.GetStatus?id=0` oder `/rpc/RGBW.GetStatus?id=0`) und prüfen Sie, ob `apower` einen Wert ungleich null zurückgibt
3. LED-Lasten mit sehr niedriger Leistung können aufgrund der Messauflösung 0 W melden — dies ist normal für kleine Indikator-LEDs

## 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 6

Diese Geräte erscheinen nach dem Import in TapHome.

Shelly Plus RGBW PM Modul

Serviceattribute

|              |
|--------------|
| WiFi         |
| IP-Adresse   |
| Signalstärke |
| MAC          |
| Profil       |

Serviceaktionen

|                        |
|------------------------|
| Firmware aktualisieren |
| Neustart               |
| Profil setzen          |

Benutzerdefinierte Variablen

Lesen (Modul)

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Sys.GetStatus");
IF response.IsSuccess
    Sys.GetStatus := response.Content;
END

response := SENDHTTPREQUEST("/rpc/Sys.GetConfig");
IF response.IsSuccess
    Sys.GetConfig := response.Content;
END

response := SENDHTTPREQUEST("/rpc/WiFi.GetStatus");
IF response.IsSuccess
    WiFi.GetStatus := response.Content;
END

response := SENDHTTPREQUEST("/rpc/PlusRGBWPM.GetConfig");
IF response.IsSuccess
    PlusRGBWPM.GetConfig := response.Content;
END

if ! ISNULL(parsejson(Sys.GetStatus, "available_updates.stable", true))
    addwarning("New firmware update is available");
end

if parsejson(Sys.GetStatus, "restart_required", true)
    addwarning("Restart required");
end
```

Serviceattribute

Wifi

```taphome
PARSEJSON(WiFi.GetStatus, "ssid")
```

${ipAddress}

```taphome
PARSEJSON(WiFi.GetStatus, "sta_ip")
```

${xml\_signal\_strength} \[dB]

```taphome
PARSEJSON(WiFi.GetStatus, "rssi")
```

MAC

```taphome
PARSEJSON(Sys.GetStatus, "mac")
```

Profile

```taphome
PARSEJSON(Sys.GetConfig, "$.device.profile");
```

Serviceaktionen

${xml\_update\_fw}

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Shelly.Update?stage=\"stable\"");
IF response.IsSuccess
    return("OK");
else
    return("Error");
END

```

${restart}

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Shelly.Reboot");
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

Set Profile

Parameter: Profile

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Shelly.SetProfile?name=\"" + 
switch(prof,
0, "light",
1, "rgb",
2, "rgbw",
"")
+ "\"");
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

RGB-Licht HSB-Licht Lesen und Schreiben

HSB-Farblicht (rgb-Profil) mit Helligkeits-, Farbton-, Sättigungssteuerung und kanalweiser Leistungsmessung

HSB

Serviceattribute

|                  |
|------------------|
| Temperatur       |
| Energieverbrauch |
| Leistung         |
| Spannung         |
| Strom            |

Lesen (Modul)

```taphome
if PARSEJSON(Sys.GetConfig, "$.device.profile") != "rgb"
	adderror("Profile is not set to rgb (" + PARSEJSON(Sys.GetConfig, "$.device.profile") + ")");
end

VAR response := SENDHTTPREQUEST("/rpc/RGB.GetStatus?id=" + ID);
IF response.IsSuccess
    RGB.GetStatus := response.Content;
	R := PARSEJSON(RGB.GetStatus, "$.rgb[0]", true);
	G := PARSEJSON(RGB.GetStatus, "$.rgb[1]", true);
	B := PARSEJSON(RGB.GetStatus, "$.rgb[2]", true);    
END

response := SENDHTTPREQUEST("/rpc/RGB.GetConfig?id=" + ID);
IF response.IsSuccess
    RGB.GetConfig := response.Content;
END

if ! ISNULL(parsejson(RGB.GetStatus, "errors", true))
    adderror("Error: " + parsejson(RGB.GetStatus, "errors"));
end
```

Helligkeit lesen

```taphome
bool output := PARSEJSON(RGB.GetStatus, "$.output", true);
var brightness := PARSEJSON(RGB.GetStatus, "$.brightness", true);

if output
    return(brightness / 100);
else
    return(0);
end
```

Helligkeit schreiben

```taphome
SENDHTTPREQUEST("/rpc/RGB.Set?id=" + ID + "&on=" + if(St, "true", "false") + "&brightness=" + round(Hb*100.0));
```

Farbton lesen

```taphome
VAR HSVColor := RGBTOHSV(R, G, B);
ROUND(HSVColor.Hue);
```

Farbton schreiben

```taphome
VAR color := HSVTORGB(Hd, Sa, 1);
SENDHTTPREQUEST("/rpc/RGB.Set?id=" + ID + "&rgb=[" + color.RED + "," + color.GREEN + "," + color.BLUE + "]");
```

Sättigung lesen

```taphome
VAR HSVColor := RGBTOHSV(R, G, B);
ROUND(HSVColor.Saturation * 100.0) / 100.0;
```

Sättigung schreiben

```taphome
VAR color := HSVTORGB(Hd, Sa, 1);
SENDHTTPREQUEST("/rpc/RGB.Set?id=" + ID + "&rgb=[" + color.RED + "," + color.GREEN + "," + color.BLUE + "]");
```

Serviceattribute

${device\_variable\_realtemperature} \[°C]

```taphome
parsejson(RGB.GetStatus, "$.temperature.tC", true)
```

${device\_variable\_electricityconsumption} \[Wh]

```taphome
parsejson(RGB.GetStatus, "$.aenergy.total", true)
```

${device\_variable\_electricitydemand} \[W]

```taphome
parsejson(RGB.GetStatus, "$.apower", true)
```

${valueLogType\_ElectricVoltage} \[V]

```taphome
parsejson(RGB.GetStatus, "$.voltage", true)
```

${valueLogType\_ElectricCurrent} \[A]

```taphome
parsejson(RGB.GetStatus, "$.current", true)
```

RGBW-Licht HSB-Licht Lesen und Schreiben

HSB-Farb+Weißlicht (rgbw-Profil) mit RGB, Weißkanal (CCT bei 4500K) und kanalweiser Leistungsmessung

HSB

Serviceattribute

|                  |
|------------------|
| Temperatur       |
| Energieverbrauch |
| Leistung         |
| Spannung         |
| Strom            |

Lesen (Modul)

```taphome
if PARSEJSON(Sys.GetConfig, "$.device.profile") != "rgbw"
	adderror("Profile is not set to rgbw (" + PARSEJSON(Sys.GetConfig, "$.device.profile") + ")");
end

VAR response := SENDHTTPREQUEST("/rpc/RGBW.GetStatus?id=" + ID);
IF response.IsSuccess
    RGBW.GetStatus := response.Content;
	R := PARSEJSON(RGBW.GetStatus, "$.rgb[0]", true);
	G := PARSEJSON(RGBW.GetStatus, "$.rgb[1]", true);
	B := PARSEJSON(RGBW.GetStatus, "$.rgb[2]", true);    
END

response := SENDHTTPREQUEST("/rpc/RGBW.GetConfig?id=" + ID);
IF response.IsSuccess
    RGBW.GetConfig := response.Content;
END

if ! ISNULL(parsejson(RGBW.GetStatus, "errors", true))
    adderror("Error: " + parsejson(RGBW.GetStatus, "errors"));
end
```

Helligkeit lesen

```taphome
bool output := PARSEJSON(RGBW.GetStatus, "$.output", true);
var brightness := PARSEJSON(RGBW.GetStatus, "$.brightness", true);
var white := PARSEJSON(RGBW.GetStatus, "$.white", true);

if output
	if white != 0
		return(linear(white, 0, 0, 255, 1));
	else
    	return(brightness / 100);
    end
else
    return(0);
end
```

Helligkeit schreiben

```taphome
if isnan(Ct)
	SENDHTTPREQUEST("/rpc/RGBW.Set?id=" + ID + "&on=" + if(St, "true", "false") + "&white=0&brightness=" + round(Hb*100.0));
else
	SENDHTTPREQUEST("/rpc/RGBW.Set?id=" + ID + "&on=" + if(St, "true", "false") + "&brightness=0&white=" + round(linear(Hb, 0, 0, 1, 255)));
end
```

Farbton lesen

```taphome
VAR HSVColor := RGBTOHSV(R, G, B);
ROUND(HSVColor.Hue);
```

Farbton schreiben

```taphome
VAR color := HSVTORGB(Hd, Sa, 1);
SENDHTTPREQUEST("/rpc/RGBW.Set?id=" + ID + "&rgb=[" + color.RED + "," + color.GREEN + "," + color.BLUE + "]");
```

Sättigung lesen

```taphome
VAR HSVColor := RGBTOHSV(R, G, B);
ROUND(HSVColor.Saturation * 100.0) / 100.0;
```

Sättigung schreiben

```taphome
VAR color := HSVTORGB(Hd, Sa, 1);
SENDHTTPREQUEST("/rpc/RGBW.Set?id=" + ID + "&rgb=[" + color.RED + "," + color.GREEN + "," + color.BLUE + "]");
```

Farbtemperatur lesen

```taphome
var white := PARSEJSON(RGBW.GetStatus, "$.white", true);
if white != 0 or !isnan(Ct)
	return(4500);
else
	return(NaN);
end
```

Farbtemperatur schreiben

```taphome
IF !isnan(Ct)
	SENDHTTPREQUEST("/rpc/RGBW.Set?id=" + ID + "&on=" + if(St, "true", "false") + "&brightness=0&white=" + round(linear(Hb, 0, 0, 1, 255)));
end
```

Serviceattribute

${device\_variable\_realtemperature} \[°C]

```taphome
parsejson(RGBW.GetStatus, "$.temperature.tC", true)
```

${device\_variable\_electricityconsumption} \[Wh]

```taphome
parsejson(RGBW.GetStatus, "$.aenergy.total", true)
```

${device\_variable\_electricitydemand} \[W]

```taphome
parsejson(RGBW.GetStatus, "$.apower", true)
```

${valueLogType\_ElectricVoltage} \[V]

```taphome
parsejson(RGBW.GetStatus, "$.voltage", true)
```

${valueLogType\_ElectricCurrent} \[A]

```taphome
parsejson(RGBW.GetStatus, "$.current", true)
```

Dimmbarer LED-Ausgang 2 Dimmer Lesen und Schreiben

Unabhängiger Dimmerkanal 2 (light-Profil, id=1) mit Helligkeitssteuerung, Kalibrierung und kanalweiser Leistungsmessung

numeric

Serviceattribute

|                  |
|------------------|
| Temperatur       |
| Energieverbrauch |
| Leistung         |
| Spannung         |
| Strom            |
| Flags            |

Serviceaktionen

|              |
|--------------|
| Kalibrierung |

Lesen (Modul)

```taphome
if PARSEJSON(Sys.GetConfig, "$.device.profile") != "light"
	adderror("Profile is not set to light (" + PARSEJSON(Sys.GetConfig, "$.device.profile") + ")");
end

VAR response := SENDHTTPREQUEST("/rpc/Light.GetStatus?id=" + ID);
IF response.IsSuccess
    Light.GetStatus := response.Content;
END

response := SENDHTTPREQUEST("/rpc/Light.GetConfig?id=" + ID);
IF response.IsSuccess
    Light.GetConfig := response.Content;
END

if ! ISNULL(parsejson(Light.GetStatus, "errors", true))
    adderror("Error: " + parsejson(Light.GetStatus, "errors"));
end
```

Level lesen

```taphome
bool output := PARSEJSON(Light.GetStatus, "$.output");
var brightness := PARSEJSON(Light.GetStatus, "$.brightness");

if output
    return(brightness / 100);
else
    return(0);
end
```

Level schreiben

```taphome
SENDHTTPREQUEST("/rpc/Light.Set?id=" + ID + "&on=" + if(St, "true", "false") + "&brightness=" + round(Le*100.0));
```

Serviceattribute

${device\_variable\_realtemperature} \[°C]

```taphome
parsejson(Light.GetStatus, "$.temperature.tC", true)
```

${device\_variable\_electricityconsumption} \[Wh]

```taphome
parsejson(Light.GetStatus, "$.aenergy.total", true)
```

${device\_variable\_electricitydemand} \[W]

```taphome
parsejson(Light.GetStatus, "$.apower", true)
```

${valueLogType\_ElectricVoltage} \[V]

```taphome
parsejson(Light.GetStatus, "$.voltage", true)
```

${valueLogType\_ElectricCurrent} \[A]

```taphome
parsejson(Light.GetStatus, "$.current", true)
```

Flags

```taphome
parsejson(Light.GetStatus, "$.flags", true)
```

Serviceaktionen

${detail\_deviceSettings\_TemperatureSensor\_categoryCalibration}

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Light.Calibrate?id=" + ID);
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

Dimmbarer LED-Ausgang 1 Dimmer Lesen und Schreiben

Unabhängiger Dimmerkanal 1 (light-Profil, id=0) mit Helligkeitssteuerung, Kalibrierung und kanalweiser Leistungsmessung

numeric

Serviceattribute

|                  |
|------------------|
| Temperatur       |
| Energieverbrauch |
| Leistung         |
| Spannung         |
| Strom            |
| Flags            |

Serviceaktionen

|              |
|--------------|
| Kalibrierung |

Lesen (Modul)

```taphome
if PARSEJSON(Sys.GetConfig, "$.device.profile") != "light"
	adderror("Profile is not set to light (" + PARSEJSON(Sys.GetConfig, "$.device.profile") + ")");
end

VAR response := SENDHTTPREQUEST("/rpc/Light.GetStatus?id=" + ID);
IF response.IsSuccess
    Light.GetStatus := response.Content;
END

response := SENDHTTPREQUEST("/rpc/Light.GetConfig?id=" + ID);
IF response.IsSuccess
    Light.GetConfig := response.Content;
END

if ! ISNULL(parsejson(Light.GetStatus, "errors", true))
    adderror("Error: " + parsejson(Light.GetStatus, "errors"));
end
```

Level lesen

```taphome
bool output := PARSEJSON(Light.GetStatus, "$.output");
var brightness := PARSEJSON(Light.GetStatus, "$.brightness");

if output
    return(brightness / 100);
else
    return(0);
end
```

Level schreiben

```taphome
SENDHTTPREQUEST("/rpc/Light.Set?id=" + ID + "&on=" + if(St, "true", "false") + "&brightness=" + round(Le*100.0));
```

Serviceattribute

${device\_variable\_realtemperature} \[°C]

```taphome
parsejson(Light.GetStatus, "$.temperature.tC", true)
```

${device\_variable\_electricityconsumption} \[Wh]

```taphome
parsejson(Light.GetStatus, "$.aenergy.total", true)
```

${device\_variable\_electricitydemand} \[W]

```taphome
parsejson(Light.GetStatus, "$.apower", true)
```

${valueLogType\_ElectricVoltage} \[V]

```taphome
parsejson(Light.GetStatus, "$.voltage", true)
```

${valueLogType\_ElectricCurrent} \[A]

```taphome
parsejson(Light.GetStatus, "$.current", true)
```

Flags

```taphome
parsejson(Light.GetStatus, "$.flags", true)
```

Serviceaktionen

${detail\_deviceSettings\_TemperatureSensor\_categoryCalibration}

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Light.Calibrate?id=" + ID);
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

Dimmbarer LED-Ausgang 3 Dimmer Lesen und Schreiben

Unabhängiger Dimmerkanal 3 (light-Profil, id=2) mit Helligkeitssteuerung, Kalibrierung und kanalweiser Leistungsmessung

numeric

Serviceattribute

|                  |
|------------------|
| Temperatur       |
| Energieverbrauch |
| Leistung         |
| Spannung         |
| Strom            |
| Flags            |

Serviceaktionen

|              |
|--------------|
| Kalibrierung |

Lesen (Modul)

```taphome
if PARSEJSON(Sys.GetConfig, "$.device.profile") != "light"
	adderror("Profile is not set to light (" + PARSEJSON(Sys.GetConfig, "$.device.profile") + ")");
end

VAR response := SENDHTTPREQUEST("/rpc/Light.GetStatus?id=" + ID);
IF response.IsSuccess
    Light.GetStatus := response.Content;
END

response := SENDHTTPREQUEST("/rpc/Light.GetConfig?id=" + ID);
IF response.IsSuccess
    Light.GetConfig := response.Content;
END

if ! ISNULL(parsejson(Light.GetStatus, "errors", true))
    adderror("Error: " + parsejson(Light.GetStatus, "errors"));
end
```

Level lesen

```taphome
bool output := PARSEJSON(Light.GetStatus, "$.output");
var brightness := PARSEJSON(Light.GetStatus, "$.brightness");

if output
    return(brightness / 100);
else
    return(0);
end
```

Level schreiben

```taphome
SENDHTTPREQUEST("/rpc/Light.Set?id=" + ID + "&on=" + if(St, "true", "false") + "&brightness=" + round(Le*100.0));
```

Serviceattribute

${device\_variable\_realtemperature} \[°C]

```taphome
parsejson(Light.GetStatus, "$.temperature.tC", true)
```

${device\_variable\_electricityconsumption} \[Wh]

```taphome
parsejson(Light.GetStatus, "$.aenergy.total", true)
```

${device\_variable\_electricitydemand} \[W]

```taphome
parsejson(Light.GetStatus, "$.apower", true)
```

${valueLogType\_ElectricVoltage} \[V]

```taphome
parsejson(Light.GetStatus, "$.voltage", true)
```

${valueLogType\_ElectricCurrent} \[A]

```taphome
parsejson(Light.GetStatus, "$.current", true)
```

Flags

```taphome
parsejson(Light.GetStatus, "$.flags", true)
```

Serviceaktionen

${detail\_deviceSettings\_TemperatureSensor\_categoryCalibration}

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Light.Calibrate?id=" + ID);
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

Dimmbarer LED-Ausgang 4 Dimmer Lesen und Schreiben

Unabhängiger Dimmerkanal 4 (light-Profil, id=3) mit Helligkeitssteuerung, Kalibrierung und kanalweiser Leistungsmessung

numeric

Serviceattribute

|                  |
|------------------|
| Temperatur       |
| Energieverbrauch |
| Leistung         |
| Spannung         |
| Strom            |
| Flags            |

Serviceaktionen

|              |
|--------------|
| Kalibrierung |

Lesen (Modul)

```taphome
if PARSEJSON(Sys.GetConfig, "$.device.profile") != "light"
	adderror("Profile is not set to light (" + PARSEJSON(Sys.GetConfig, "$.device.profile") + ")");
end

VAR response := SENDHTTPREQUEST("/rpc/Light.GetStatus?id=" + ID);
IF response.IsSuccess
    Light.GetStatus := response.Content;
END

response := SENDHTTPREQUEST("/rpc/Light.GetConfig?id=" + ID);
IF response.IsSuccess
    Light.GetConfig := response.Content;
END

if ! ISNULL(parsejson(Light.GetStatus, "errors", true))
    adderror("Error: " + parsejson(Light.GetStatus, "errors"));
end
```

Level lesen

```taphome
bool output := PARSEJSON(Light.GetStatus, "$.output");
var brightness := PARSEJSON(Light.GetStatus, "$.brightness");

if output
    return(brightness / 100);
else
    return(0);
end
```

Level schreiben

```taphome
SENDHTTPREQUEST("/rpc/Light.Set?id=" + ID + "&on=" + if(St, "true", "false") + "&brightness=" + round(Le*100.0));
```

Serviceattribute

${device\_variable\_realtemperature} \[°C]

```taphome
parsejson(Light.GetStatus, "$.temperature.tC", true)
```

${device\_variable\_electricityconsumption} \[Wh]

```taphome
parsejson(Light.GetStatus, "$.aenergy.total", true)
```

${device\_variable\_electricitydemand} \[W]

```taphome
parsejson(Light.GetStatus, "$.apower", true)
```

${valueLogType\_ElectricVoltage} \[V]

```taphome
parsejson(Light.GetStatus, "$.voltage", true)
```

${valueLogType\_ElectricCurrent} \[A]

```taphome
parsejson(Light.GetStatus, "$.current", true)
```

Flags

```taphome
parsejson(Light.GetStatus, "$.flags", true)
```

Serviceaktionen

${detail\_deviceSettings\_TemperatureSensor\_categoryCalibration}

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Light.Calibrate?id=" + ID);
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

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

Mögliche Verbesserungen (13)

- Input State — Physical switch/button input state, available via /rpc/Input.GetStatus?id=0
- WiFi SSID — Already exposed as module-level service attribute, not as standalone device
- WiFi Signal Strength — Already exposed as module-level service attribute, not as standalone device
- IP Address — Already exposed as module-level service attribute, not as standalone device
- MAC Address — Already exposed as module-level service attribute, not as standalone device
- Uptime — Seconds since last reboot, available in Sys.GetStatus response
- RAM Usage — Total and free RAM in bytes, available in Sys.GetStatus response
- Device Time — Current device time in HH:MM format, available in Sys.GetStatus response
- Firmware Update — Already implemented as module-level service action
- Reboot — Already implemented as module-level service action
- Night Mode — Night mode configuration with brightness limits and schedule, available in component GetConfig
- Transition Duration — Color/brightness transition time in ms, available as parameter in RGB.Set and RGBW.Set
- Minimum Brightness on Toggle — Minimum brightness percentage when toggling on, available in Light component config

## Importparameter

Diese Werte geben Sie beim Import des XML ein.

| In der App abgefragt | Standard      |
|----------------------|---------------|
| IP-Adresse           | `192.168.0.1` |

## Quellen

- Shelly Gen2+/Gen3 RPC API Reference
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/) 2026-03-30
- Shelly Gen2+ Switch Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Switch/) 2026-03-30
- Shelly Gen2+ System (Sys) Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Sys/) 2026-03-30
- Shelly Gen2+ WiFi Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/WiFi/) 2026-03-30
- Shelly Gen2+ MQTT Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Mqtt/) 2026-03-30
- Home Assistant Shelly Integration
  
  [www.home-assistant.io](https://www.home-assistant.io/integrations/shelly/) 2026-03-30
- Shelly Plus RGBW PM Knowledge Base — specs, wiring, terminals
  
  [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-plus-rgbw-pm) 2026-03-30
- Shelly Plus RGBW PM API Device Page — profiles, components
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/Devices/Gen2/ShellyPlusRGBWPM/) 2026-03-30
- Shelly Gen2+ Light Component API — light profile dimmers
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Light/) 2026-03-30
- Shelly Gen2+ RGB Component API — rgb profile color control
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/RGB/) 2026-03-30
- Shelly Gen2+ RGBW Component API — rgbw profile color+white control
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/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/)