---
title: "Shelly Plus 2PM"
description: "Zweikanal-Relais mit Leistungsmessung oder Rollladensteuerung über HTTP RPC API. TapHome-Integration für Shelly Plus 2PM mit Profilumschaltung."
url: "https://taphome.com/de/compatibility/shelly-plus-2-pm/"
language: de
lastmod: 2026-10-08
generator: hugo
ai:
  topics: ["http","electric-meter","wifi","relay","power-metering","cover","shutter","mdns","profile"]
  questions: ["Wie integriert man Shelly Plus 2PM mit TapHome?","Was ist der Unterschied zwischen Switch- und Cover-Profil beim Shelly Plus 2PM?","Wie steuert man einen Rollladen mit Shelly Plus 2PM und TapHome?","Wie wechselt man zwischen Relais- und Abdeckungsmodus beim Shelly Plus 2PM?","Warum zeigt die Shelly Plus 2PM Vorlage einen Profilfehler in TapHome?","Wie kalibriert man die Shelly Plus 2PM Abdeckung für Positionssteuerung?","Welche Diagnosen sind für Shelly Plus 2PM in TapHome verfügbar?"]
---

# Shelly Plus 2PM

Kommunikation: Packet Parser → HTTP

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

> 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 2PM ist ein kompaktes Zweikanal-WLAN-Relais mit integrierter Leistungsmessung auf beiden Kanälen. Er passt hinter einen Standard-Wandschalter und kann zwei unabhängige Stromkreise steuern, jeweils bis 10 A (16 A gesamt bei 230 V AC), oder einen einzelnen motorisierten Rollladen antreiben. TapHome kommuniziert mit dem Gerät über HTTP mittels der Gen2+ RPC-API im lokalen Netzwerk — keine Cloud-Verbindung erforderlich.

Das Gerät unterstützt zwei Betriebsprofile — **Switch** und **Cover** — wählbar über die Shelly-Weboberfläche oder die TapHome-Serviceaktion. Im Switch-Profil arbeiten beide Relaisausgänge (O1 und O2) unabhängig mit kanalweiser Leistungsüberwachung. Im Cover-Profil treiben die beiden Ausgänge einen einzelnen Motor für Rollläden, Jalousien oder Vorhänge an, mit Positionssteuerung und Kalibrierung.

> [!NOTE]
> Der Shelly Plus 2PM wurde eingestellt. Sein Nachfolger, der [Shelly 2PM Gen3](https://taphome.com/de/compatibility/shelly-2pm-gen3/), bietet die gleiche Dual-Profil-Funktionalität mit einem verbesserten Prozessor (8 MB Flash), bis zu 6 gleichzeitigen HTTP-Verbindungen und Matter-Upgradefähigkeit.

## Konfiguration

Der Shelly Plus 2PM verbindet sich über WLAN. Beim TapHome-Vorlagenimport geben Sie die IP-Adresse des Geräts ein (Standardplatzhalter `192.168.0.1`).

> [!WARNING]
> Die Authentifizierung muss am Shelly-Gerät **deaktiviert** sein, damit die TapHome-Integration funktioniert. TapHome unterstützt nicht die von Gen2+-Geräten verwendete HTTP-Digest-Auth. Öffnen Sie die Shelly-Weboberfläche (`http://{geraete-ip}`) → Settings → Authentication und stellen Sie sicher, dass sie deaktiviert ist.

> [!NOTE]
> Wenn der ECO-Modus auf dem Shelly-Gerät aktiviert ist, kann er durch die schnellen Abfrageintervalle der Vorlage (2,5–5 Sekunden) Kommunikationszeitüberschreitungen verursachen. Deaktivieren Sie den ECO-Modus in der Shelly-Weboberfläche, wenn Sie intermittierende Verbindungsprobleme feststellen.

### Profilauswahl

Der Shelly Plus 2PM arbeitet jeweils in einem von zwei Profilen. Das aktive Profil bestimmt, welche TapHome-Geräte funktionsfähig sind:

- **Switch-Profil** — aktiviert beide Relaisschalter (Switch 1 und Switch 2) und deren kanalweise Energiezähler. Das Rollladen-Gerät und der Rollladen-Energiezähler reagieren nicht.
- **Cover-Profil** — aktiviert das Rollladen-Gerät und seinen Energiezähler. Die beiden Schaltgeräte und ihre Energiezähler reagieren nicht.

Das aktive Profil ist als Service-Attribut auf Modulebene („Profile") in TapHome sichtbar. Um das Profil zu wechseln, verwenden Sie die **Profile**-Serviceaktion auf Modulebene oder wechseln Sie es in der Shelly-Weboberfläche. Nach dem Profilwechsel startet das Gerät neu und nur die zum neuen Profil passenden Geräte funktionieren.

> [!TIP]
> Die Vorlage enthält alle sechs Geräte (2 Schalter + 2 Schalter-Energiezähler + 1 Rollladen + 1 Rollladen-Energiezähler), aber nur die zum aktiven Profil passenden Geräte funktionieren. Dies ist erwartetes Verhalten — Geräte im falschen Profil reagieren einfach nicht.

### Abdeckungskalibrierung

Bei Verwendung des Cover-Profils müssen die Endlagen des Motors kalibriert werden, bevor die Positionssteuerung funktioniert. Bis die Kalibrierung abgeschlossen ist, gibt `current_pos` null zurück und das Service-Attribut „Calibrated" zeigt `false`. Kalibrieren Sie entweder über die Shelly-Weboberfläche oder durch Auslösen der **Calibrate**-Serviceaktion am Shutter-Gerät in TapHome. Während der Kalibrierung durchläuft die Abdeckung eine mehrstufige Sequenz (voll öffnen → voll schließen → voll öffnen → schrittweise schließen → schrittweise öffnen) zur Messung der Fahrwege.

## Gerätefunktionen

### Relaissteuerung (Switch-Profil)

Die Vorlage stellt zwei unabhängige Relaisschalter bereit. Jeder Schalter liest seinen Status von `/rpc/Switch.GetStatus?id={0,1}` (Feld `output`, Boolean) und steuert das Relais über `/rpc/Switch.Set?id={0,1}&on=true|false`.

Jeder Schalter stellt sieben Service-Attribute bereit:

- **Source** — Quelle des letzten Befehls (http, UI, WS_in, etc.)
- **Temperature** — interne Gerätetemperatur in °C
- **Initial State** — Schalterverhalten beim Einschalten (off, on, restore_last oder match_input)
- **Input Mode** — Verdrahtungsmodus des physischen Eingangs (follow oder detached)
- **Power Limit** — maximale Leistungsschwelle in Watt für Überlastschutz
- **Voltage Limit** — maximale Spannungsschwelle in Volt
- **Current Limit** — maximale Stromschwelle in Ampere

Zwei Serviceaktionen sind pro Schalter verfügbar:

- **Set Initial State** — konfiguriert das Relaisverhalten nach dem Einschalten (off, on, restore_last, match_input)
- **Set Mode** — konfiguriert den Verdrahtungsmodus des physischen Eingangs (follow, detached)

### Leistungsmessung (Switch-Profil)

Jeder Schaltkanal hat einen eigenen Energiezähler, der zwei Werte von `/rpc/Switch.GetStatus` liest:

- **Momentanleistung** — `apower` in Watt, von der Vorlage in kW umgerechnet
- **Gesamtverbrauch** — `aenergy.total` in Wattstunden, von der Vorlage in kWh umgerechnet

Jeder Energiezähler stellt auch drei Service-Attribute bereit:

- **Voltage** — Versorgungsspannung in Volt
- **Current** — Laststrom in Ampere
- **Power Factor** — Leistungsfaktor der Last

Die Zähler sind schreibgeschützt — sie aktualisieren sich automatisch mit jedem Abfragezyklus.

### Rollladensteuerung (Cover-Profil)

Das Rollladen-Gerät steuert einen motorisierten Rollladen, Vorhang oder eine Markise. Es liest die Position von `/rpc/Cover.GetStatus?id=0` (Feld `current_pos`, 0–100 %) und schreibt über `/rpc/Cover.GoToPosition?id=0&pos=N`.

Das Rollladen-Gerät stellt 21 Service-Attribute bereit:

- **Status** — Quelle, Zustand (open/closed/opening/closing/stopped/calibrating), aktuelle und Zielposition, Bewegungs-Timeout und Startzeit
- **Kalibriert** — ob Positionssteuerung aktiviert ist (`pos_control`)
- **Temperatur** — interne Gerätetemperatur in °C
- **Einschaltverhalten** — Konfiguration des Anfangszustands (open, closed, stopped)
- **Eingangseinstellungen** — Eingangsmodus (single, dual, detached), Eingänge tauschen, Richtungen invertieren
- **Schutzgrenzen** — Leistungsgrenze (W), Spannungsgrenze (V), Stromgrenze (A)
- **Motoreinstellung** — Leerlaufleistungsschwelle (0–50 W), Leerlauf-Bestätigungszeit (0,25–2 s)
- **Bewegungsgrenzen** — maximale Öffnungszeit (0,1–300 s), maximale Schließzeit (0,1–300 s)
- **Sicherheitsfunktionen** — Status der Hinderniserkennung, Status des Sicherheitsschalters

Sechs Serviceaktionen sind für den Rollladen verfügbar:

- **Open** — öffnet die Abdeckung vollständig
- **Close** — schließt die Abdeckung vollständig
- **Stop** — stoppt die Bewegung sofort
- **Calibrate** — startet den Kalibrierungsvorgang für die Positionssteuerung
- **Go to Position** — fährt die Abdeckung auf eine bestimmte Position (0–100 %)
- **Reverse directions** — schaltet die Konfiguration `invert_directions` um und startet das Gerät neu

### Leistungsmessung (Cover-Profil)

Der Rollladen hat einen eigenen Energiezähler, der von `/rpc/Cover.GetStatus` liest:

- **Momentanleistung** — `apower` in Watt, von der Vorlage in kW umgerechnet
- **Gesamtverbrauch** — `aenergy.total` in Wattstunden, von der Vorlage in kWh umgerechnet

Der Rollladen-Energiezähler stellt auch Spannung, Strom und Leistungsfaktor als Service-Attribute bereit.

### Service-Diagnose

Die Vorlage stellt zwei Service-Attribute auf Modulebene bereit:

- **MAC** — MAC-Adresse des Geräts aus der Systemkonfiguration
- **Profile** — aktuell aktives Geräteprofil (Switch oder Cover)

Das Modul-Leseskript prüft auch `restart_required` von `/rpc/Sys.GetStatus` und zeigt eine Warnung in TapHome an, wenn ein Neustart aussteht.

### Serviceaktionen

Zwei Serviceaktionen sind auf Modulebene verfügbar:

- **Reboot** — löst einen Geräteneustart über `/rpc/Shelly.Reboot` aus
- **Profile** — wechselt zwischen Switch- und Cover-Betriebsprofilen über `/rpc/Shelly.SetProfile`

### Weitere Funktionen

Der Shelly Plus 2PM stellt auch Netzfrequenz (`freq`), minutenweise Energiewerte (`aenergy.by_minute`), physische Eingangszustände (`input:0`, `input:1`), WLAN-Signalstärke (RSSI) und einen Schalter-Toggle-Endpunkt in seinen RPC-Antworten bereit. Energiezähler können über `/rpc/Switch.ResetCounters` (Switch-Profil) oder `/rpc/Cover.ResetCounters` (Cover-Profil) zurückgesetzt werden. Im Cover-Modus ist die Lamellen-/Kippposition für Jalousien verfügbar, wenn die Hardware dies unterstützt. Diese Funktionen können in einem zukünftigen Vorlagenupdate hinzugefügt werden.

## Fehlerbehebung

### Gerät reagiert 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 (`shellyplus2pm-AABBCCDDEE.local`) statt der IP-Adresse — die IP kann sich nach einer DHCP-Erneuerung geändert haben
3. Öffnen Sie `http://{geraete-ip}/rpc/Shelly.GetDeviceInfo` im Browser — wenn JSON zurückkommt, ist das Gerät erreichbar
4. Prüfen Sie, ob TapHome Core und Shelly im gleichen Netzwerk / VLAN sind
5. Stellen Sie sicher, dass die Authentifizierung am Shelly-Gerät deaktiviert ist

### Profilkonflikt — Geräte reagieren nicht

Wenn einige Geräte keine Messwerte anzeigen, während andere korrekt funktionieren:

1. Prüfen Sie, welches Profil aktuell aktiv ist — das Service-Attribut „Profile" auf Modulebene zeigt den aktuellen Modus
2. Wechseln Sie zum richtigen Profil über die **Profile**-Serviceaktion oder ignorieren Sie die nicht verwendeten Geräte
3. Nach dem Profilwechsel startet das Gerät automatisch neu — warten Sie einige Sekunden für die Wiederverbindung

### Abdeckungsposition funktioniert nicht

1. Überprüfen Sie, ob das Gerät im Cover-Profil ist — das Switch-Profil stellt keine Abdeckungsfunktionen bereit
2. Führen Sie die **Calibrate**-Serviceaktion am Shutter-Gerät aus — die Positionssteuerung erfordert eine abgeschlossene Kalibrierung
3. Prüfen Sie, ob der Motor korrekt an den Klemmen O1 und O2 angeschlossen ist
4. Rufen Sie `/rpc/Cover.GetStatus?id=0` manuell auf und prüfen Sie, ob `pos_control` den Wert `true` hat

### Abdeckungskalibrierung schlägt fehl

Die Kalibrierung bricht ab, wenn:

- Die Abdeckung die Endposition nicht innerhalb von `maxtime_open` oder `maxtime_close` erreicht
- Eine Sicherheitsfunktion (Hinderniserkennung oder Sicherheitsschalter) während der Kalibrierung ausgelöst wird
- Während der Kalibrierung ein externer Stoppbefehl gesendet wird
- Die Motorrichtung nicht der erwarteten Rückmeldung entspricht
- Das Gerät während der Kalibrierung neu startet

Überprüfen Sie die Motorverdrahtung, erhöhen Sie `maxtime_open`/`maxtime_close` wenn der Motor langsam ist, und stellen Sie sicher, dass keine Hindernisse vorhanden sind.

### Leistungswerte zeigen Null

1. Bestätigen Sie, dass die Last über das Shelly-Relais angeschlossen ist (nicht umgangen)
2. Prüfen Sie, ob das Relais eingeschaltet ist — der Zähler misst nur, wenn Strom durch das Relais fließt
3. Rufen Sie `/rpc/Switch.GetStatus?id=0` (Switch-Profil) oder `/rpc/Cover.GetStatus?id=0` (Cover-Profil) manuell auf und prüfen Sie, ob `apower` einen Wert ungleich Null zurückgibt

> [!WARNING]
> Shelly Gen2+-Geräte unterstützen bis zu **6 gleichzeitige HTTP-Verbindungen**. Obwohl dies eine Verbesserung gegenüber Gen1 (2 Verbindungen) darstellt, vermeiden Sie gleichzeitiges Polling von zu vielen Systemen (TapHome, Home Assistant, benutzerdefinierte Skripte), um Verbindungserschöpfung zu verhindern.

## 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 2PM Modul

Serviceattribute

|        |                                                    |
|--------|----------------------------------------------------|
| MAC    | MAC-Adresse des Geräts aus der Systemkonfiguration |
| Profil | Aktives Geräteprofil — switch oder cover           |

Serviceaktionen

|          |                                                                                |
|----------|--------------------------------------------------------------------------------|
| Neustart | Startet das Gerät neu                                                          |
| Profil   | Wechsel zwischen Switch- und Cover-Betriebsprofilen — erfordert Geräteneustart |

Benutzerdefinierte Variablen

Lesen (Modul)

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Sys.GetConfig");
IF response.IsSuccess
  VAR content := response.Content;
  VAR responseHeaders := response.Headers;
  SysConfig := response.Content;
END;
 
response := SENDHTTPREQUEST("/rpc/Sys.GetStatus");
IF response.IsSuccess
  content := response.Content;
  responseHeaders := response.Headers;
  if(PARSEJSON(response.Content, "$.restart_required") = true, ADDERROR("Restart required"));
END
```

Serviceattribute

MAC

```taphome
PARSEJSON(SysConfig, "$.device.mac");
```

Profile

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

Serviceaktionen

Reboot

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Shelly.Reboot");
IF response.IsSuccess
  VAR content := response.Content;
  VAR responseHeaders := response.Headers;
  Return("OK");
END;
```

Profile

Parameter: Profile

```taphome
var profile := SWITCH(pr, 1, "cover", "switch");
VAR response := SENDHTTPREQUEST("/rpc/Shelly.SetProfile?name=\""+profile+"\"");
IF response.IsSuccess
  VAR content := response.Content;
  VAR responseHeaders := response.Headers;
  Return("OK");
END;
```

Leistungsmesser (Rollladen) Stromzähler Nur lesen

Energiemessung im Cover-Modus — Momentanleistung (kW) und kumulierte Energie (kWh)

numeric Einheit: kW / kWh json\_path

Serviceattribute

|                 |                             |
|-----------------|-----------------------------|
| Spannung        | Versorgungsspannung in Volt |
| Strom           | Laststrom in Ampere         |
| Leistungsfaktor | Leistungsfaktor der Last    |

Gesamtverbrauch lesen

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    adderror("Device profile is set to switch");
else
    return(PARSEJSON(CoverStatus, "$.aenergy.total") / 1000);
end
```

Bedarf lesen

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    return(PARSEJSON(CoverStatus, "$.apower", true) / 1000);
end
```

Lesen (Modul)

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    var response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=" + Id);
    IF response.IsSuccess
        VAR content := response.Content;
        VAR responseHeaders := response.Headers;
        CoverStatus := response.Content;
    END
end
```

Serviceattribute

Voltage \[V]

```taphome
PARSEJSON(CoverStatus, "$.voltage", true);
```

Current \[A]

```taphome
PARSEJSON(CoverStatus, "$.current", true);
```

Power Factor

```taphome
PARSEJSON(CoverStatus, "$.pf", true);
```

Leistungsmesser (Schalter 1) Stromzähler Nur lesen

Energiemessung für Schaltkanal 1 — Momentanleistung (kW) und kumulierte Energie (kWh)

numeric Einheit: kW / kWh json\_path

Serviceattribute

|                 |                             |
|-----------------|-----------------------------|
| Spannung        | Versorgungsspannung in Volt |
| Strom           | Laststrom in Ampere         |
| Leistungsfaktor | Leistungsfaktor der Last    |

Gesamtverbrauch lesen

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    adderror("Device profile is set to cover");
else
    return(PARSEJSON(SwitchStatus, "$.aenergy.total", true) / 1000);
end
```

Bedarf lesen

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    return(PARSEJSON(SwitchStatus, "$.apower", true) / 1000);
end
```

Lesen (Modul)

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    var response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + Id);
    IF response.IsSuccess
        VAR content := response.Content;
        VAR responseHeaders := response.Headers;
        SwitchStatus := response.Content;
    END
end
```

Serviceattribute

Voltage \[V]

```taphome
PARSEJSON(SwitchStatus, "$.voltage", true);
```

Current \[A]

```taphome
PARSEJSON(SwitchStatus, "$.current", true);
```

Power Factor

```taphome
PARSEJSON(SwitchStatus, "$.pf", true);
```

Leistungsmesser (Schalter 2) Stromzähler Nur lesen

Energiemessung für Schaltkanal 2 — Momentanleistung (kW) und kumulierte Energie (kWh)

numeric Einheit: kW / kWh json\_path

Serviceattribute

|                 |                             |
|-----------------|-----------------------------|
| Spannung        | Versorgungsspannung in Volt |
| Strom           | Laststrom in Ampere         |
| Leistungsfaktor | Leistungsfaktor der Last    |

Gesamtverbrauch lesen

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    adderror("Device profile is set to cover");
else
    return(PARSEJSON(SwitchStatus, "$.aenergy.total", true) / 1000);
end
```

Bedarf lesen

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    return(PARSEJSON(SwitchStatus, "$.apower", true) / 1000);
end
```

Lesen (Modul)

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    var response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + Id);
    IF response.IsSuccess
        VAR content := response.Content;
        VAR responseHeaders := response.Headers;
        SwitchStatus := response.Content;
    END
end
```

Serviceattribute

Voltage \[V]

```taphome
PARSEJSON(SwitchStatus, "$.voltage", true);
```

Current \[A]

```taphome
PARSEJSON(SwitchStatus, "$.current", true);
```

Power Factor

```taphome
PARSEJSON(SwitchStatus, "$.pf", true);
```

Rollladen Schieber Lesen und Schreiben

Motorisierte Beschattungssteuerung mit Positionsverfolgung — erfordert Kalibrierung für Positionssteuerung

numeric Einheit: % json\_path

Serviceattribute

|                                       |                                                                                                     |
|---------------------------------------|-----------------------------------------------------------------------------------------------------|
| Quelle                                | Quelle des letzten Beschattungsbefehls                                                              |
| Zustand                               | Aktueller Beschattungszustand — open, closed, opening, closing, stopped, calibrating                |
| Aktuelle Position                     | Aktuelle Beschattungsposition in Prozent (0–100), null wenn nicht kalibriert                        |
| Zielposition                          | Zielposition während der Bewegung der Beschattung                                                   |
| Bewegungs-Timeout                     | Sekunden bis zum automatischen Stopp während der Bewegung                                           |
| Bewegung gestartet um                 | Zeitstempel des Beginns der aktuellen Bewegung                                                      |
| Kalibriert                            | Ob Positionssteuerung aktiviert ist (true nach erfolgreicher Kalibrierung)                          |
| Temperatur                            | Interne Gerätetemperatur in Celsius                                                                 |
| Anfangszustand                        | Beschattungsverhalten beim Einschalten — open, closed oder stopped                                  |
| Eingangsmodus                         | Verkabelungsmodus des physischen Eingangs — single, dual oder detached                              |
| Leistungsgrenze                       | Maximale Leistungsschwelle in Watt für Überlastschutz                                               |
| Spannungsgrenze                       | Maximale Spannungsschwelle in Volt für Überspannungsschutz                                          |
| Stromgrenze                           | Maximale Stromschwelle in Ampere für Überstromschutz                                                |
| Leerlauf-Leistungsschwelle des Motors | Leistungsschwelle, unter der der Motor als im Leerlauf gilt (0–50 W)                                |
| Bestätigungszeit Motorleerlauf        | Dauer, die der Motor unter der Leerlaufschwelle bleiben muss, um den Stopp zu bestätigen (0,25–2 s) |
| Maximale Öffnungszeit                 | Maximale Öffnungszeit vor automatischem Stopp (0,1–300 s)                                           |
| Maximale Schließzeit                  | Maximale Schließzeit vor automatischem Stopp (0,1–300 s)                                            |
| Eingänge tauschen                     | Ob die Zuordnung der Eingänge S1/S2 vertauscht ist                                                  |
| Richtungen invertieren                | Ob die Öffnungs-/Schließrichtungen invertiert sind                                                  |
| Hinderniserkennung                    | Ob die Hinderniserkennung aktiviert ist                                                             |
| Sicherheitsschalter                   | Ob die Sicherheitsschalterfunktion aktiviert ist                                                    |

Serviceaktionen

|                     |                                                                            |
|---------------------|----------------------------------------------------------------------------|
| Öffnen              | Öffnet die Beschattung vollständig                                         |
| Schließen           | Schließt die Beschattung vollständig                                       |
| Stoppen             | Stoppt die Bewegung der Beschattung sofort                                 |
| Kalibrieren         | Startet die Beschattungskalibrierung — erforderlich für Positionssteuerung |
| Zur Position fahren | Fährt die Beschattung auf eine bestimmte Position (0–100 %)                |
| Richtungen umkehren | Schaltet die invert\_directions-Konfiguration um und startet das Gerät neu |

Lesen (Modul)

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    adderror("Device profile is set to switch");
else
    var response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=" + Id);
    IF response.IsSuccess
        VAR content := response.Content;
        VAR responseHeaders := response.Headers;
        CoverStatus := response.Content;
    END
    
    response := SENDHTTPREQUEST("/rpc/Cover.GetConfig?id=" + Id);
    IF response.IsSuccess
        content := response.Content;
        responseHeaders := response.Headers;
        CoverConfig := response.Content;
    END
end
```

Jalousiestellung lesen

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    adderror("Device profile is set to switch");
else
    var response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=" + Id);
    IF response.IsSuccess
        CoverStatus := response.Content;
    END
    if PARSEJSON(CoverStatus, "$.pos_control", true) = true
        var pos := -1;
        var curpos := PARSEJSON(CoverStatus, "$.current_pos", true);
        if ISNULL(curpos)
            adderror("Device lost its position. Open or close the cover completely to enable back position control.");
            return(0);
        end
        var target := PARSEJSON(CoverStatus, "$.target_pos", true);
        if(ISNULL(target), pos := curpos, pos := target);
        if PARSEJSON(CoverConfig, "$.invert_directions", true)
            return(linear(pos, 0, 0, 100, 1));
        else
            return(linear(pos, 0, 1, 100, 0));
        end
    else
        adderror("Device is not calibrated");
    end
end
```

Jalousiestellung schreiben

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    adderror("Device profile is set to switch");
else
    var pos := 0;
    if PARSEJSON(CoverConfig, "$.invert_directions", true)
        pos := linear(Bl, 0, 0, 1, 100);
    else
        pos := linear(Bl, 0, 100, 1, 0);
    end
    VAR response := SENDHTTPREQUEST("rpc/Cover.GoToPosition?id=" + Id + "&pos=" + pos);
    IF response.IsSuccess
      VAR content := response.Content;
      Return("OK");
    else
      return(parsejson(response.Content,"$.message"));
    END
end
```

Serviceattribute

Source

```taphome
PARSEJSON(CoverStatus, "$.source", true);
```

State

```taphome
PARSEJSON(CoverStatus, "$.state", true);
```

Current Position

```taphome
PARSEJSON(CoverStatus, "$.current_pos", true);
```

Target Position

```taphome
PARSEJSON(CoverStatus, "$.target_pos", true);
```

Move Timeout

```taphome
PARSEJSON(CoverStatus, "$.move_timeout", true);
```

Move Started at

```taphome
PARSEJSON(CoverStatus, "$.move_started_at", true);
```

Calibrated

```taphome
PARSEJSON(CoverStatus, "$.pos_control", true);
```

Temperature \[°C]

```taphome
PARSEJSON(CoverStatus, "$.temperature.tC", true);
```

Initial State

```taphome
PARSEJSON(CoverConfig, "$.initial_state", true);
```

Input Mode

```taphome
PARSEJSON(CoverConfig, "$.in_mode", true);
```

Power Limit \[W]

```taphome
PARSEJSON(CoverConfig, "$.power_limit", true);
```

Voltage Limit \[V]

```taphome
PARSEJSON(CoverConfig, "$.voltage_limit", true);
```

Current Limit \[A]

```taphome
PARSEJSON(CoverConfig, "$.current_limit", true);
```

Motor Idle Power Threshold \[W]

```taphome
PARSEJSON(CoverConfig, "$.motor.idle_power_thr", true);
```

Motor Idle Confirm Period \[s]

```taphome
PARSEJSON(CoverConfig, "$.motor.idle_confirm_period", true);
```

Max Time Open \[s]

```taphome
PARSEJSON(CoverConfig, "$.maxtime_open", true);
```

Max Time Close \[s]

```taphome
PARSEJSON(CoverConfig, "$.maxtime_close", true);
```

Swap Inputs

```taphome
PARSEJSON(CoverConfig, "$.swap_inputs", true);
```

Invert Directions

```taphome
PARSEJSON(CoverConfig, "$.invert_directions", true);
```

Obstruction Detection

```taphome
PARSEJSON(CoverConfig, "$.obstruction_detection", true);
```

Safety Switch

```taphome
PARSEJSON(CoverConfig, "$.safety_switch", true);
```

Serviceaktionen

Open

```taphome
VAR response := SENDHTTPREQUEST("rpc/Cover.Open?id=" + Id );
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Close

```taphome
VAR response := SENDHTTPREQUEST("rpc/Cover.Close?id=" + Id );
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Stop

```taphome
VAR response := SENDHTTPREQUEST("rpc/Cover.Stop?id=" + Id );
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Calibrate

```taphome
VAR response := SENDHTTPREQUEST("rpc/Cover.Calibrate?id=" + Id );
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Go to Position

Parameter: Position (0–100 pos)

```taphome
VAR response := SENDHTTPREQUEST("rpc/Cover.GoToPosition?id=" + Id + "&pos=" + pos);
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Reverse directions

```taphome
var reverse := "false";
if(PARSEJSON(CoverConfig, "$.invert_directions"), reverse := "false", reverse := "true");
VAR response := SENDHTTPREQUEST("rpc/Cover.SetConfig?id=0&config={\"invert_directions\":" + reverse + "}");
IF response.IsSuccess
  SENDHTTPREQUEST("rpc/Shelly.Reboot");
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Schalter 1 Schalter Lesen und Schreiben

Relaisausgang Kanal 1 — Ein/Aus-Steuerung mit Einschaltverhalten und Eingangsmodus-Konfiguration

boolean json\_path

Werte / Zustände: ON · OFF

Serviceaktionen

|                           |                                                            |
|---------------------------|------------------------------------------------------------|
| Anfangszustand einstellen | Konfiguriert das Schalterverhalten beim Einschalten        |
| Modus einstellen          | Konfiguriert den Verkabelungsmodus des physischen Eingangs |

Schaltzustand lesen

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    adderror("Device profile is set to cover");
else
    RETURN(PARSEJSON(SwitchStatus, "$.output", true));
end
```

Schaltzustand schreiben

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    VAR response := SENDHTTPREQUEST("rpc/Switch.Set?id=" + Id + "&on=" + if(St,"true","false"));
    IF response.IsSuccess = false
      ADDERROR(response.StatusCode);
    END
end
```

Lesen (Modul)

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    var response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + Id);
    IF response.IsSuccess
        VAR content := response.Content;
        VAR responseHeaders := response.Headers;
        SwitchStatus := response.Content;
    END
    
    response := SENDHTTPREQUEST("/rpc/Switch.GetConfig?id=" + Id);
    IF response.IsSuccess
        content := response.Content;
        responseHeaders := response.Headers;
        SwitchConfig := response.Content;
    END
end
```

Serviceattribute

Source

```taphome
PARSEJSON(SwitchStatus, "$.source", true);
```

Temprature \[°C]

```taphome
PARSEJSON(SwitchStatus, "$.temperature.tC", true);
```

Initial State

```taphome
PARSEJSON(SwitchConfig, "$.initial_state", true);
```

Input Mode

```taphome
PARSEJSON(SwitchConfig, "$.in_mode", true);
```

Power Limit \[W]

```taphome
PARSEJSON(SwitchConfig, "$.power_limit", true);
```

Voltage Limit \[V]

```taphome
PARSEJSON(SwitchConfig, "$.voltage_limit", true);
```

Current Limit \[A]

```taphome
PARSEJSON(SwitchConfig, "$.current_limit", true);
```

Serviceaktionen

Set Initial State

Parameter: Mode

```taphome
var mode := SWITCH(md, 1, "on", 2, "restore_last", 3, "match_input", "off");
VAR response := SENDHTTPREQUEST("rpc/Switch.SetConfig?id=" + Id +"&config={\"initial_state\":\""+mode+"\"}");
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Set Mode

Parameter: Mode

```taphome
var mode := SWITCH(md, 1, "detached", "follow");
VAR response := SENDHTTPREQUEST("rpc/Switch.SetConfig?id=" + Id +"&config={\"in_mode\":\""+mode+"\"}");
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Schalter 2 Schalter Lesen und Schreiben

Relaisausgang Kanal 2 — Ein/Aus-Steuerung mit Einschaltverhalten und Eingangsmodus-Konfiguration

boolean json\_path

Werte / Zustände: ON · OFF

Serviceaktionen

|                           |                                                            |
|---------------------------|------------------------------------------------------------|
| Anfangszustand einstellen | Konfiguriert das Schalterverhalten beim Einschalten        |
| Modus einstellen          | Konfiguriert den Verkabelungsmodus des physischen Eingangs |

Schaltzustand lesen

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    adderror("Device profile is set to cover");
else
    RETURN(PARSEJSON(SwitchStatus, "$.output", true));
end
```

Schaltzustand schreiben

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    VAR response := SENDHTTPREQUEST("rpc/Switch.Set?id=" + Id + "&on=" + if(St,"true","false"));
    IF response.IsSuccess = false
      ADDERROR(response.StatusCode);
    END
end
```

Lesen (Modul)

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    var response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + Id);
    IF response.IsSuccess
        VAR content := response.Content;
        VAR responseHeaders := response.Headers;
        SwitchStatus := response.Content;
    END
    
    response := SENDHTTPREQUEST("/rpc/Switch.GetConfig?id=" + Id);
    IF response.IsSuccess
        content := response.Content;
        responseHeaders := response.Headers;
        SwitchConfig := response.Content;
    END
end
```

Serviceattribute

Source

```taphome
PARSEJSON(SwitchStatus, "$.source", true);
```

Temprature \[°C]

```taphome
PARSEJSON(SwitchStatus, "$.temperature.tC", true);
```

Initial State

```taphome
PARSEJSON(SwitchConfig, "$.initial_state", true);
```

Input Mode

```taphome
PARSEJSON(SwitchConfig, "$.in_mode", true);
```

Power Limit \[W]

```taphome
PARSEJSON(SwitchConfig, "$.power_limit", true);
```

Voltage Limit \[V]

```taphome
PARSEJSON(SwitchConfig, "$.voltage_limit", true);
```

Current Limit \[A]

```taphome
PARSEJSON(SwitchConfig, "$.current_limit", true);
```

Serviceaktionen

Set Initial State

Parameter: Mode

```taphome
var mode := SWITCH(md, 1, "on", 2, "restore_last", 3, "match_input", "off");
VAR response := SENDHTTPREQUEST("rpc/Switch.SetConfig?id=" + Id +"&config={\"initial_state\":\""+mode+"\"}");
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Set Mode

Parameter: Mode

```taphome
var mode := SWITCH(md, 1, "detached", "follow");
VAR response := SENDHTTPREQUEST("rpc/Switch.SetConfig?id=" + Id +"&config={\"in_mode\":\""+mode+"\"}");
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

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

Mögliche Verbesserungen (8)

- Frequency — Network frequency in Hz, available in both Switch and Cover status responses
- Energy per Minute — Last 3 minute energy values in Wh, available but not exposed as separate device
- Input 1 State — Physical input state (input:0), available in both profiles
- Input 2 State — Physical input state (input:1), available in both profiles
- Switch Toggle — Toggle switch without knowing current state — could be added as service action
- Reset Energy Counters — Resets energy measurement counters — could be added as service action
- Slat Position — Slat/tilt position for venetian blinds, if hardware supports it
- WiFi Signal Strength — RSSI in dBm, available via WiFi component

## Importparameter

Diese Werte geben Sie beim Import des XML ein.

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

## Quellen

- Shelly Gen2+ RPC API Reference
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/) 2026-03-27
- Switch Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Switch/) 2026-03-27
- System (Sys) Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Sys/) 2026-03-27
- WiFi Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Wifi/) 2026-03-27
- MQTT Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/MQTT/) 2026-03-27
- HA Shelly Integration (Gen2+)
  
  [www.home-assistant.io](https://www.home-assistant.io/integrations/shelly/) 2026-03-27
- Shelly Plus 2PM Knowledge Base
  
  [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-plus-2pm) 2026-03-29
- Cover Component API (Gen2+)
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Cover/) 2026-03-29
- Shelly Plus 2PM Device API Reference
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/Devices/Gen2/ShellyPlus2PM/) 2026-03-29

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