---
title: "Shelly Plus Plug S"
description: "Lasten bis 12 A schalten und Leistung, Energie, Spannung, Strom und Temperatur über Gen2+ HTTP-RPC messen. RGB-LED-Ring-Steuerung aus TapHome."
url: "https://taphome.com/de/compatibility/shelly-plus-plug-s/"
language: de
lastmod: 2026-10-08
generator: hugo
ai:
  topics: ["http","smart-plug","electric-meter","wifi","gen2plus","rpc-api","mdns","power-metering","led-ring"]
  questions: ["Wie integriere ich Shelly Plus Plug S mit TapHome?","Was misst die TapHome-Vorlage für Shelly Plus Plug S?","Wie verbinde ich Shelly Plus Plug S über HTTP mit TapHome?","Welche drei LED-Ring-Modi hat Shelly Plus Plug S?","Wie ändere ich die LED-Ring-Farbe aus TapHome?","Warum zeigt Shelly Plus Plug S null Leistung an?"]
---

# Shelly Plus Plug S

Kommunikation: Packet Parser → HTTP

- [Shelly Plus Plug S – Wissensdatenbank](https://kb.shelly.cloud/knowledge-base/shelly-plus-plug-s)
- [Shelly Gen2+ RPC-API-Dokumentation](https://shelly-api-docs.shelly.cloud/gen2/)

> 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 Plus Plug S ist eine Gen2+ WLAN-Smart-Steckdose mit eingebauter Leistungsmessung und mehrfarbigem LED-Ring. Sie wird in eine normale CEE-7/3-Steckdose (Type-F / Schuko) gesteckt und kann Lasten bis 12 A / 2760 W bei 230 V schalten. TapHome kommuniziert mit dem Gerät lokal per WLAN über die Gen2+ JSON-RPC-API auf Port 80 — eine Cloud-Verbindung ist nicht erforderlich.

Die Vorlage stellt die Steckdose als sechs TapHome-Geräte bereit: einen Relais-Schalter, einen Stromzähler, einen LED-Modus-Wähler, zwei LED-Farbwähler (für Relais-AN und Relais-AUS) sowie einen Helligkeitsdimmer für den Leistungs-Anzeigemodus.

## Konfiguration

### Pairing und Netzwerkeinrichtung

Ab Werk startet das Gerät im Access-Point-Modus mit der SSID `ShellyPlusPlugS-XXXXXX` (LED blinkt blau). Verbinden Sie sich mit dieser SSID, öffnen Sie `http://192.168.33.1/` und wählen Sie Ihr Heim-WLAN in der Weboberfläche aus. Nach dem LAN-Beitritt ist die Steckdose auf Port 80 unter ihrer Station-IP sowie über mDNS unter `shellyplusplugs-<MAC>.local` erreichbar.

TapHome fragt die Gen2+ RPC-Endpunkte über unverschlüsseltes HTTP ab — HTTPS ist standardmäßig deaktiviert und die HTTP-Authentifizierung (`Shelly.SetAuth`) muss deaktiviert bleiben, damit die Vorlage funktioniert. Stellen Sie sicher, dass die Steckdose im selben LAN / VLAN wie der TapHome Core ist.

Geben Sie beim Vorlagen-Import in TapHome die IP-Adresse der Steckdose als Parameter `IpAddress` ein. Eine statische DHCP-Reservierung wird dringend empfohlen, damit sich die Adresse nach Neustarts nicht ändert.

## Gerätefunktionen

### Relais-Steuerung

Das Relais wird als Schaltgerät bereitgestellt. Sein Zustand wird aus `/rpc/Switch.GetStatus?id=0` gelesen (Boolean `output`) und über `/rpc/Switch.Set?id=0&on=true|false` gesteuert. Das Modul cached die komplette `Switch.GetStatus`-Antwort, sodass Relais, Zähler und Service-Attribute einen einzigen HTTP-Aufruf pro Abfrage teilen.

### Leistungs- und Energiemessung

Der integrierte Zähler in der Switch-Komponente liefert:

- **Momentanleistung** — `apower` in Watt, von der Vorlage in kW umgerechnet (durch 1000 geteilt)
- **Kumulierte Energie** — `aenergy.total` in Wattstunden, in kWh umgerechnet (durch 1000 geteilt)

Drei weitere Messwerte stehen als Service-Attribute am Zähler zur Verfügung:

| Attribut | Einheit | Quellfeld |
|----------|---------|-----------|
| Strom | A | `current` |
| Spannung | V | `voltage` |
| Temperatur | °C | `temperature.tC` |

Der Zähler ist schreibgeschützt und wird bei jedem Pollzyklus aktualisiert.

### LED-Anzeigemodus

Der mehrfarbige LED-Ring wird durch die Plus-Plug-S-spezifische RPC-Komponente `PLUGS_UI` gesteuert. TapHome stellt einen Modus-Wähler mit drei gültigen Optionen bereit — obwohl die Vorlage zehn Enum-Slots listet, entsprechen nur die ersten drei echten Firmware-Modi:

| Wert | Verhalten |
|------|-----------|
| `off` | LED-Ring deaktiviert (WLAN-/AP-/Firmware-Diagnosemuster werden weiterhin angezeigt) |
| `switch` | LED-Farbe spiegelt den Relaiszustand wider — verwendet die benutzerdefinierten Farben für AUS und AN |
| `power` | LED-Farbe spiegelt die gemessene Last als Anteil des konfigurierten Leistungslimits wider (Gradient grün → gelb → rot) |

Der Moduswechsel ist eine rein kosmetische Änderung und erfordert keinen Neustart.

### LED-Farben (Modus switch)

Zwei unabhängige HSB-Geräte ermöglichen die Wahl der LED-Ring-Farbe für jeden Relaiszustand:

- **LED-Farbe (AUS-Zustand)** — Farbe und Helligkeit bei ausgeschaltetem Relais
- **LED-Farbe (AN-Zustand)** — Farbe und Helligkeit bei eingeschaltetem Relais

Beide werden auf `leds.colors.switch:0.{off|on}.{rgb,brightness}` in der `PLUGS_UI`-Konfiguration abgebildet. Shelly speichert RGB-Werte in Prozent (0–100 pro Kanal) und nicht als 0–255, daher multipliziert die Vorlage jeden Kanal mit 2,55 bei der Umrechnung zwischen HSV und dem nativen Geräteformat. Die Umrechnung ist intern — in TapHome verhalten sich die Geräte wie jede andere HSB-Farbauswahl.

### LED-Helligkeit (Modus power)

Im Modus `power` wählt die Firmware die Farbe automatisch basierend auf der Last. Benutzerkonfigurierbar ist nur die Helligkeit, weshalb die Vorlage sie als Dimmer bereitstellt (`leds.colors.power.brightness`, 0–100 % auf einen TapHome-Dimmerwert von 0,0–1,0 skaliert).

### Moduldiagnose und -aktionen

Das HTTP-Modul stellt vier Service-Attribute bereit, die aus `/rpc/WiFi.GetStatus` und `/rpc/Sys.GetStatus` geparst werden:

| Attribut | Quelle |
|----------|--------|
| WLAN-SSID | `ssid` |
| IP-Adresse | `sta_ip` |
| Signalstärke | `rssi` (dBm) |
| MAC-Adresse | `mac` |

Außerdem stehen zwei Service-Aktionen zur Verfügung:

- **Firmware-Update** — löst ein OTA-Update vom Stable-Kanal aus (`/rpc/Shelly.Update?stage="stable"`). Die Firmware installiert ein Update nur, wenn eines verfügbar ist (`available_updates.stable` in `Sys.GetStatus`).
- **Neustart** — startet das Gerät neu (`/rpc/Shelly.Reboot`), nützlich nach Netzwerkänderungen oder zur Behebung vorübergehender Probleme.

> [!TIP]
> Wenn Sie nur Ein-/Aus-Steuerung und grundlegende Energiemessung benötigen, können Sie die LED-Geräte ignorieren — sie sind optional. Relais und Zähler arbeiten unabhängig vom LED-Modus.

## Fehlersuche

### Gerät reagiert nicht

1. Prüfen Sie, ob die Steckdose mit WLAN verbunden ist — die LED sollte weder blinken noch dauerhaft rot leuchten
2. Versuchen Sie den mDNS-Hostnamen `shellyplusplugs-<MAC>.local` statt der IP-Adresse — die DHCP-Lease hat sich möglicherweise geändert
3. Öffnen Sie `http://{geräte-ip}/rpc/Shelly.GetDeviceInfo` im Browser; antwortet es mit JSON, ist das Gerät erreichbar
4. Stellen Sie sicher, dass TapHome Core und Steckdose im selben LAN / VLAN sind
5. Vergewissern Sie sich, dass die HTTP-Authentifizierung in der Shelly-Weboberfläche deaktiviert ist — die Vorlage unterstützt keine Digest-Authentifizierung

### Leistungsmesser zeigt null an

1. Überprüfen Sie, ob tatsächlich eine Last an der Shelly angeschlossen und nicht umgangen ist
2. Prüfen Sie, dass das Relais eingeschaltet ist — der Zähler meldet 0 W, wenn das Relais offen ist
3. Rufen Sie `/rpc/Switch.GetStatus?id=0` direkt im Browser auf und verifizieren Sie, dass `apower` ungleich null ist

### LED ändert sich nach Moduswechsel nicht

1. Die LED spiegelt den Laufzeitzustand nur in den Modi `switch` und `power` wider; im Modus `off` bleibt sie dunkel, außer bei Systemdiagnosemustern (AP-Modus, Wiederverbindung, OTA)
2. Stellen Sie im Modus `switch` sicher, dass nicht beide Farben für AN und AUS auf schwarz / 0 % Helligkeit eingestellt sind
3. Systemanzeigen (blaues Blinken im AP-Modus, rot bei WLAN-Problemen) überschreiben immer die Benutzer-LED-Konfiguration — blinkt die LED rot, ist die Steckdose nicht in Ihrem WLAN

### Firmware-Update-Aktion wird nicht ausgelöst

1. Die Firmware installiert das Update nur, wenn `Sys.GetStatus` `available_updates.stable` meldet — ist die Steckdose bereits aktuell, hat die Aktion nichts zu installieren
2. Die Vorlage zielt nur auf den Stable-Kanal; Beta-Firmware muss über die Shelly-Weboberfläche installiert werden

## 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 Plug S Modul

Serviceattribute

|              |                                                                                                                    |
|--------------|--------------------------------------------------------------------------------------------------------------------|
| WLAN-SSID    |                                                                                                                    |
| IP-Adresse   |                                                                                                                    |
| Signalstärke | WLAN-Signalstärke in dBm — Werte näher an 0 bedeuten eine stärkere Verbindung (z. B. −55 dBm gut, −80 dBm schwach) |
| MAC-Adresse  |                                                                                                                    |

Serviceaktionen

|                 |                                                                                                     |
|-----------------|-----------------------------------------------------------------------------------------------------|
| Firmware-Update | Löst ein Over-the-Air-Firmware-Update aus dem Shelly-Stable-Kanal aus                               |
| Neustart        | Startet das Gerät neu — nützlich nach Netzwerkänderungen oder zur Behebung vorübergehender Probleme |

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/PLUGS_UI.GetConfig");
IF response.IsSuccess
    PLUGS_UI.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")
```

Serviceaktionen

${xml\_update\_fw}

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

```

Reboot

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

Schalter Schalter Lesen und Schreiben

boolean

Werte / Zustände: ON · OFF

Schaltzustand lesen

```taphome
var x := (sendhttprequest("/rpc/Switch.GetStatus?id=0"));
var status := x.Content;
return(PARSEJSON(status, "$.output", true));
```

Schaltzustand schreiben

```taphome
VAR response := SENDHTTPREQUEST("rpc/Switch.Set?id=0&on=" + if(St,"true","false"));
IF response.IsSuccess = false
  ADDERROR(response.StatusCode);
END
```

Stromzähler Stromzähler Nur lesen

Momentanleistung (kW) und kumulierte Energie (kWh), gemessen vom integrierten Zähler, mit Strom-, Spannungs- und Innentemperaturdiagnose

numeric Einheit: kW / kWh

Serviceattribute

|            |                                                                                        |
|------------|----------------------------------------------------------------------------------------|
| Strom      |                                                                                        |
| Spannung   |                                                                                        |
| Temperatur | Interne Gerätetemperatur in °C — die Steckdose schaltet bei Überhitzung automatisch ab |

Gesamtverbrauch lesen

```taphome
return(parsejson(parsejson(Switch.GetStatus,"aenergy"), "total")/1000);
```

Bedarf lesen

```taphome
return(parsejson(Switch.GetStatus,"apower")/1000);
```

Lesen (Modul)

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=0");
IF response.IsSuccess
    Switch.GetStatus := response.Content;
END
```

Serviceattribute

${electric\_current} \[A]

```taphome
return(parsejson(Switch.GetStatus,"current"));
```

${electric\_voltage} \[V]

```taphome
return(parsejson(Switch.GetStatus,"voltage"));
```

${temperature} \[°C]

```taphome
return(parsejson(parsejson(Switch.GetStatus,"temperature"), "tC"));
```

LED-Anzeigemodus Mehrwertschalter Lesen und Schreiben

Verhalten des LED-Rings — Off (deaktiviert), Switch (Farbe spiegelt den Relaiszustand wider) oder Power (Farbe spiegelt die Last als grün → gelb → rot wider)

string enum

Werte / Zustände: ${xml\_off} · ${switch} · ${xml\_power}

Schaltzustand lesen

```taphome
switch(parsejson(PLUGS_UI.GetConfig, "leds.mode"), "power", 2, "switch", 1, 0)
```

Schaltzustand schreiben

```taphome
VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"mode\":\"" + switch(Mu, 2, "power", 1, "switch", "off") + "\"}}");

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

LED-Farbe (AUS-Zustand) HSB-Licht Lesen und Schreiben

RGB-Farbe und Helligkeit des LED-Rings bei ausgeschaltetem Relais (im Modus Switch verwendet)

HSB (hue, saturation, brightness) hsv-to-rgb

Helligkeit lesen

```taphome
parsejson(PLUGS_UI.GetConfig, basePath + ".brightness") / 100
```

Helligkeit schreiben

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"off\":{\"brightness\":" + Hb*100 + "}}}}}");

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

Farbton lesen

```taphome
VAR HSVColor := RGBTOHSV(parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[0]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[1]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[2]") *2.55);

HSVColor.Hue
```

Farbton schreiben

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"off\":{\"rgb\":[" + rgb.red/2.55 + "," + rgb.green/2.55 + "," + rgb.blue/2.55 + "],\"brightness\":" + Hb*100 + "}}}}}");

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

Sättigung lesen

```taphome
VAR HSVColor := RGBTOHSV(parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[0]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[1]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[2]") *2.55);

HSVColor.Saturation
```

Sättigung schreiben

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"off\":{\"rgb\":[" + rgb.red/2.55 + "," + rgb.green/2.55 + "," + rgb.blue/2.55 + "],\"brightness\":" + Hb*100 + "}}}}}");

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

LED-Farbe (AN-Zustand) HSB-Licht Lesen und Schreiben

RGB-Farbe und Helligkeit des LED-Rings bei eingeschaltetem Relais (im Modus Switch verwendet)

HSB (hue, saturation, brightness) hsv-to-rgb

Helligkeit lesen

```taphome
parsejson(PLUGS_UI.GetConfig, basePath + ".brightness") / 100
```

Helligkeit schreiben

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"on\":{\"brightness\":" + Hb*100 + "}}}}}");

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

Farbton lesen

```taphome
VAR HSVColor := RGBTOHSV(parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[0]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[1]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[2]") *2.55);

HSVColor.Hue
```

Farbton schreiben

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"on\":{\"rgb\":[" + rgb.red/2.55 + "," + rgb.green/2.55 + "," + rgb.blue/2.55 + "],\"brightness\":" + Hb*100 + "}}}}}");

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

Sättigung lesen

```taphome
VAR HSVColor := RGBTOHSV(parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[0]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[1]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[2]") *2.55);

HSVColor.Saturation
```

Sättigung schreiben

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"on\":{\"rgb\":[" + rgb.red/2.55 + "," + rgb.green/2.55 + "," + rgb.blue/2.55 + "],\"brightness\":" + Hb*100 + "}}}}}");

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

LED-Helligkeit (Modus Power) Dimmer Lesen und Schreiben

Helligkeit des LED-Rings im Modus Power — die Farbe wählt die Firmware automatisch anhand der Last

numeric

Level lesen

```taphome
parsejson(PLUGS_UI.GetConfig, "leds.colors.power.brightness") / 100
```

Level schreiben

```taphome
VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"power\":{\"brightness\":" + Le*100 + "}}}}");

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

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

Mögliche Verbesserungen (23)

- Power Factor — Power factor (0.0–1.0) reported in Switch.GetStatus response for metered devices
- Line Frequency — AC line frequency in Hz, available in Switch.GetStatus response
- Returned Energy — Returned/exported energy in Wh, for bi-directional metering scenarios
- Per-minute Energy History — Rolling three-minute energy buffer in mWh, useful for fine-grained load profiling
- Toggle Relay — Toggles the relay state without needing to know current state; not mapped as a TapHome service action
- Auto-off Timer — Optional toggle\_after parameter (seconds) on Switch.Set — relay auto-reverts after N seconds
- Overpower Protection — Configurable power limit (W); firmware turns the relay off when exceeded. Template does not expose a setter
- Over-voltage / Over-current Protection — Voltage and current safety thresholds configurable via Switch.SetConfig; not exposed by template
- Initial State After Power-up — Relay behaviour after power loss (off / on / restore\_last / match\_input); not exposed by template
- Reset Energy Counters — Resets aenergy / ret\_aenergy counters; not exposed by template
- Button Input Mode — Physical button behaviour (momentary / detached); device-internal, not exposed as a TapHome input
- LED Night Mode — Dims the LED ring during a configurable HH:MM window (wraps midnight); not mapped by template
- Local Scheduler — On-device cron-like scheduler for relay actions; no TapHome equivalent (TapHome uses its own schedules)
- Webhooks — Outbound HTTP webhooks on device events; not used by template (TapHome polls instead)
- mJS Scripts — Up to 10 on-device mJS scripts; out of scope for TapHome integration
- Shelly Cloud Connection — Cloud connection status and enable/disable toggle; not mapped by template (TapHome communicates locally)
- Bluetooth LE Configuration — BLE gateway enable/disable and observer mode; not exposed by template
- MQTT Transport Config — Inbound/outbound MQTT RPC transport config; template uses HTTP exclusively
- System Diagnostics — Uptime, RAM/FS utilisation, last reset reason — available in cached Sys.GetStatus but not surfaced as attributes
- Device Time — Device wall-clock (HH:MM) and unix epoch; not surfaced as attribute
- Beta Firmware Availability — Template warns on available\_updates.stable but ignores the beta channel
- Factory Reset — Restores factory defaults; not exposed by template (deliberately destructive)
- HTTP Authentication — Enables digest auth on the RPC endpoint; template assumes no-auth local access

## 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-29
- Shelly Gen2+ Switch Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Switch/) 2026-03-29
- Shelly Gen2+ System (Sys) Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Sys/) 2026-03-29
- Shelly Gen2+ WiFi Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/WiFi/) 2026-03-29
- Shelly Gen2+ MQTT Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Mqtt/) 2026-03-29
- Home Assistant Shelly Integration
  
  [www.home-assistant.io](https://www.home-assistant.io/integrations/shelly/) 2026-03-29
- Shelly Plus Plug S Knowledge Base — specs, wiring, LED indication
  
  [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-plus-plug-s) 2026-04-24
- Shelly Plus Plug S RPC API — PLUGS\_UI component (device-specific)
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/Devices/Gen2/ShellyPlusPlugS/) 2026-04-24

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