---
title: "Shelly 2PM Gen3"
description: "Shelly 2PM Gen3 lokal per HTTP RPC API: zwei Relais mit Leistungsmessung oder Rollladen und Jalousie mit Position, Lamellen und Kalibrierung."
url: "https://taphome.com/de/compatibility/shelly-2pm-gen3/"
language: de
lastmod: 2026-03-29
generator: hugo
ai:
  topics: ["http","electric-meter","wifi","relay","power-metering","cover","blind","mdns","profile"]
  questions: ["Wie integriert man den Shelly 2PM Gen3 mit TapHome?","Was ist der Unterschied zwischen Switch- und Cover-Profil beim Shelly 2PM Gen3?","Wie steuert man eine motorisierte Jalousie mit Shelly 2PM Gen3 und TapHome?","Wie wechselt man zwischen Relais- und Beschattungsmodus beim Shelly 2PM Gen3?","Warum zeigt die Shelly 2PM Gen3 Vorlage einen Profilfehler in TapHome?","Wie kalibriert man den Shelly 2PM Gen3 Rollladen für die Positionssteuerung?"]
---

# Shelly 2PM Gen3

Kommunikation: Packet Parser → HTTP

- [Shelly 2PM Gen3 Produktseite](https://www.shelly.com/en/products/shop/shelly-2-pm-gen3)

> 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 2PM Gen3 ist ein kompaktes Zweikanal-WLAN-Relaismodul mit integrierter Leistungsmessung. Er passt hinter einen Standard-Wandschalter und kann zwei unabhängige Stromkreise bis jeweils 10 A (16 A gesamt bei 230 V AC) oder einen einzelnen motorisierten Rollladen/eine Jalousie steuern. TapHome kommuniziert mit dem Gerät über HTTP mittels der Gen2+/Gen3 JSON-RPC 2.0 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 Leistungsmessung. Im Cover-Profil steuern die zwei Ausgänge einen einzelnen Motor für Rollläden, Jalousien oder Vorhänge, mit Positionssteuerung, Lamellenunterstützung und Kalibrierung.

Im Unterschied zum Shelly 1PM Gen3, der einen einzelnen Stromkreis steuert, bietet der 2PM Gen3 Zweikanalsteuerung oder motorisierte Beschattungsunterstützung. Beide teilen die gleiche Gen3-Plattform mit ESP-Prozessor (8 MB Flash), bis zu 6 gleichzeitigen HTTP-Verbindungen und Matter-Upgradefähigkeit.

## Konfiguration

Der Shelly 2PM Gen3 verbindet sich über WLAN. Während des TapHome-Vorlagenimports geben Sie die IP-Adresse des Geräts ein (Standard-Platzhalter `192.168.0.1`).

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

> [!NOTE]
> Wenn der ECO-Modus am Shelly-Gerät aktiviert ist, kann dies zu Kommunikations-Timeouts aufgrund der schnellen Abfrageintervalle der Vorlage (2,5–3 Sekunden) führen. Deaktivieren Sie den ECO-Modus in der Shelly-Weboberfläche, wenn Sie intermittierende Konnektivitätsprobleme feststellen.

### Profilauswahl

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

- **Switch-Profil** — aktiviert beide Relaisschalter (Schalter 1 und Schalter 2) mit unabhängiger Leistungsmessung. Die Rollladen- und Jalousiegeräte zeigen einen Profilfehler an.
- **Cover-Profil** — aktiviert den Rollladen und die Jalousie. Die Schaltergeräte zeigen einen Profilfehler an.

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

> [!TIP]
> Die Vorlage enthält alle vier Gerätetypen (2 Schalter + Rollladen + Jalousie), aber nur die Geräte, die zum aktiven Profil passen, funktionieren. Geräte im falschen Profil zeigen eine Fehlermeldung wie „Profile is not set to switch" oder „Profile is not set to cover" — dies ist erwartetes Verhalten, keine Fehlfunktion.

### Rollladen-Kalibrierung

Bei Verwendung des Cover-Profils müssen die Motor-Fahrgrenzen kalibriert werden, bevor die Positionssteuerung funktioniert. Bis die Kalibrierung abgeschlossen ist, zeigt die Vorlage den Fehler „Calibration is required" an. Kalibrieren Sie entweder über die Shelly-Weboberfläche oder durch Auslösen der Serviceaktion **Automatische Kalibrierung starten** in TapHome. Während der Kalibrierung fährt der Rollladen vollständig auf und vollständig zu, um die Fahrstrecken zu messen.

## Gerätefähigkeiten

### 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 auch Service-Attribute für die kanalweise Überwachung bereit:

- **Temperatur** — interne Gerätetemperatur in °C (`temperature.tC`)
- **Energieverbrauch** — kumulative Energie in Wh (`aenergy.total`)
- **Leistungsaufnahme** — aktuelle Leistung in W (`apower`)
- **Elektrische Spannung** — Versorgungsspannung in V (`voltage`)
- **Elektrischer Strom** — Laststrom in A (`current`)
- **Frequenz** — AC-Netzfrequenz in Hz (`freq`)
- **Leistungsfaktor** — Leistungsfaktorwert (`pf`)

Die Schalter aktualisieren sich alle 2,5 Sekunden.

### Rollladensteuerung (Cover-Profil)

Das Rollladengerät steuert einen motorisierten Rollladen, Vorhang oder eine Markise. Es liest die Position von `/rpc/Cover.GetStatus?id=0` (Felder `current_pos` und `target_pos`, 0–100) und schreibt über `/rpc/Cover.GoToPosition?id=0&pos=N`. Die Vorlage invertiert die Positionsskala, sodass 0 = vollständig geöffnet und 100 = vollständig geschlossen in TapHome.

Der Rollladen stellt Service-Attribute bereit:

- **Temperatur** — interne Gerätetemperatur in °C
- **Energieverbrauch** — kumulative Motorenergie in Wh
- **Leistungsaufnahme** — aktuelle Motorleistung in W
- **Elektrische Spannung** — Versorgungsspannung in V
- **Elektrischer Strom** — Motorstrom in A

Die Serviceaktion **Automatische Kalibrierung starten** steht zur Verfügung, um die Kalibrierung direkt aus TapHome zu starten.

### Jalousiesteuerung (Cover-Profil)

Das Jalousiegerät erweitert den Rollladen um Lamellensteuerung für Horizontaljalousien. Neben der Position liest und schreibt es die Lamellenposition (`slat_pos`) über `/rpc/Cover.GoToPosition?id=0&pos=N&slat_pos=M`. Sowohl die Positions- als auch die Neigungsskala sind invertiert (0 = geöffnet, 100 = geschlossen in TapHome).

Die Jalousie stellt die gleichen Service-Attribute wie der Rollladen bereit, plus:

- **Lamelle** — zeigt an, ob die Lamellensteuerung aktiviert oder deaktiviert ist (aus `Cover.GetConfig → $.slat.enable`)
- **Lamellenöffnungszeit** — konfigurierte Lamellenöffnungsdauer in Sekunden
- **Lamellenschließzeit** — konfigurierte Lamellenschließdauer in Sekunden

> [!NOTE]
> **Bekanntes Vorlagenproblem:** Das Service-Attribut „Slat close time" liest `$.slat.open_time` statt `$.slat.close_time` aus der Cover-Konfiguration. Beide Lamellenzeitattribute zeigen aktuell den gleichen Wert (die Öffnungszeit) an. Dies wird in einer zukünftigen Vorlagenrevision korrigiert.

Zwei Serviceaktionen stehen am Jalousiegerät zur Verfügung:

- **Automatische Kalibrierung starten** — startet die Rollladenpositionskalibrierung
- **Lamelle einstellen** — aktiviert die Lamellensteuerung und konfiguriert Öffnungs-/Schließzeiten (jeweils 0,1–5 Sekunden) über `/rpc/Cover.SetConfig`

> [!WARNING]
> Die Lamellensteuerung muss aktiviert werden, bevor das Jalousiegerät die Neigung steuern kann. Wenn die Lamellenposition nicht vom Gerät verfügbar ist, zeigt die Jalousie den Fehler „Slat position must be enabled for blinds" an. Verwenden Sie die Serviceaktion **Lamelle einstellen**, um sie zu aktivieren und die Öffnungs-/Schließdauern einzustellen.

### Service-Diagnose

Die Vorlage stellt Service-Attribute auf Modulebene für die Geräteüberwachung bereit:

- **WiFi** — Name des verbundenen WLAN-Netzwerks
- **IP-Adresse** — aktuelle Stations-IP
- **Signalstärke** — WiFi RSSI in dB
- **MAC** — MAC-Adresse des Geräts
- **Profil** — aktuell aktives Geräteprofil (Switch oder Cover)

Das Modul-Leseskript prüft auch auf verfügbare Firmware-Updates und ausstehende Neustart-Anforderungen und zeigt diese als Warnungen in der TapHome-Oberfläche an.

### Serviceaktionen

Drei Serviceaktionen stehen auf Modulebene zur Verfügung:

- **Firmware aktualisieren** — löst ein Firmware-Update auf die neueste stabile Version aus über `/rpc/Shelly.Update`
- **Neustart** — löst einen Geräteneustart aus über `/rpc/Shelly.Reboot`
- **Profil einstellen** — wechselt zwischen Cover- und Switch-Betriebsmodi über `/rpc/Shelly.SetProfile`

### Weitere Fähigkeiten

Der Shelly 2PM Gen3 stellt auch physische Eingangszustände (`input:0`, `input:1`), Rückspeise-/Exportenergiezähler, Betriebszeit, RAM-Nutzung und Gerätezeit in seinen RPC-Antworten bereit. Ein Auto-Off-Timer ist über den Parameter `toggle_after` verfügbar, Überlastschutz kann über `Switch.SetConfig → power_limit` konfiguriert werden und Energiezähler können über `/rpc/Switch.ResetCounters` zurückgesetzt werden. Im Cover-Modus sind direkte Auf-/Zu-/Stopp-Befehle und der Rollladenbewegungsstatus (open/opening/closed/closing/stopped/calibrating) verfügbar. Diese Fähigkeiten können in einem zukünftigen Vorlagenupdate 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 (`shelly2pmg3-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 es mit JSON antwortet, ist das Gerät erreichbar
4. Prüfen Sie, ob TapHome Core und Shelly im gleichen Netzwerk / VLAN sind
5. Bestätigen Sie, dass die Authentifizierung am Shelly-Gerät deaktiviert ist

### Profil-Fehler

Wenn ein Gerät „Profile is not set to switch" oder „Profile is not set to cover" anzeigt:

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

### Rollladenposition funktioniert nicht

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

### Jalousie-Neigung reagiert nicht

1. Bestätigen Sie, dass die Lamellensteuerung aktiviert ist — prüfen Sie das Service-Attribut „Lamelle" (sollte „Enabled" anzeigen)
2. Wenn deaktiviert, verwenden Sie die Serviceaktion **Lamelle einstellen** zur Aktivierung und Konfiguration der Öffnungs-/Schließzeiten
3. Überprüfen Sie, ob der Jalousiemotor Neigungsbetrieb unterstützt — Rollläden ohne Neigung ignorieren Lamellenbefehle

### Übertemperaturwarnung

Der Shelly 2PM Gen3 verfügt über einen internen Überhitzungsschutz. Wenn die Gerätetemperatur sichere Grenzen überschreitet, steigt der `temperature`-Wert in den Service-Attributen des Geräts. Sorgen Sie für ausreichende Belüftung um das Gerät, besonders beim Schalten hoher Lasten. Der maximale Schaltstrom beträgt 10 A pro Kanal bei insgesamt 16 A (18 A Spitze).

> [!WARNING]
> Shelly Gen2+/Gen3-Geräte unterstützen bis zu **6 gleichzeitige HTTP-Verbindungen**. Obwohl dies eine deutliche Verbesserung gegenüber Gen1 (2 Verbindungen) ist, vermeiden Sie gleichzeitiges Abfragen von zu vielen Systemen (TapHome, Home Assistant, eigene Skripte), um eine Verbindungserschöpfung zu vermeiden. Die Shelly 2PM Gen3 Vorlage verwendet bis zu 4 gleichzeitige Endpunkte pro Abfragezyklus, was begrenzten Spielraum für zusätzliche Verbindungen lässt.

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

Diese Geräte erscheinen nach dem Import in TapHome.

Shelly 2PM Gen3 Modul

Serviceattribute

|              |                                                                                           |
|--------------|-------------------------------------------------------------------------------------------|
| WiFi         |                                                                                           |
| IP-Adresse   |                                                                                           |
| Signalstärke |                                                                                           |
| MAC          |                                                                                           |
| Profil       | Aktives Geräteprofil — Switch (Doppelrelais) oder Cover (motorisierte Jalousie/Rollladen) |

Serviceaktionen

|                        |                                                                                         |
|------------------------|-----------------------------------------------------------------------------------------|
| Firmware aktualisieren |                                                                                         |
| Neustart               |                                                                                         |
| Profil einstellen      | Wechsel zwischen Cover- und Switch-Betriebsmodus — Gerät startet nach Profilwechsel neu |

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

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, "cover",
1, "switch",
"")
+ "\"");
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

Schalter 1 Schalter Lesen und Schreiben

Relaisausgang 1 mit kanalweiser Leistungsmessung — erfordert Switch-Profil

boolean

Werte / Zustände: ON · OFF

Schaltzustand lesen

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + ID);
IF response.IsSuccess
    Switch.GetStatus := response.Content;  
END
return(PARSEJSON(Switch.GetStatus, "$.output", true));
```

Schaltzustand schreiben

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

Lesen (Modul)

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

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

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

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

Serviceattribute

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

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

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

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

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

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

${valueLogType\_ElectricVoltage} \[V]

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

${valueLogType\_ElectricCurrent} \[A]

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

${frequency} \[Hz]

```taphome
parsejson(Switch.GetStatus, "$.freq", true)
```

Power Factor

```taphome
parsejson(Switch.GetStatus, "$.pf", true)
```

Schalter 2 Schalter Lesen und Schreiben

Relaisausgang 2 mit kanalweiser Leistungsmessung — erfordert Switch-Profil

boolean

Werte / Zustände: ON · OFF

Schaltzustand lesen

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + ID);
IF response.IsSuccess
    Switch.GetStatus := response.Content;  
END
return(PARSEJSON(Switch.GetStatus, "$.output", true));
```

Schaltzustand schreiben

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

Lesen (Modul)

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

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

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

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

Serviceattribute

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

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

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

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

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

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

${valueLogType\_ElectricVoltage} \[V]

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

${valueLogType\_ElectricCurrent} \[A]

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

${frequency} \[Hz]

```taphome
parsejson(Switch.GetStatus, "$.freq", true)
```

Power Factor

```taphome
parsejson(Switch.GetStatus, "$.pf", true)
```

Beschattung Schieber Lesen und Schreiben

Motorisierter Rollladen oder Vorhang mit Positionssteuerung — erfordert Cover-Profil und Kalibrierung

numeric Einheit: %

Serviceattribute

|                      |
|----------------------|
| Temperatur           |
| Energieverbrauch     |
| Leistungsaufnahme    |
| Elektrische Spannung |
| Elektrischer Strom   |

Serviceaktionen

|                                   |
|-----------------------------------|
| Automatische Kalibrierung starten |

Lesen (Modul)

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

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

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

if ! parsejson(Cover.GetStatus, "$.pos_control", true)
    #adderror("${presence_calibration_required}");
    adderror("Calibration is required");
end

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

Jalousiestellung lesen

```taphome
var pos := PARSEJSON(Cover.GetStatus, "$.current_pos", true);
if ! isnull(PARSEJSON(Cover.GetStatus, "$.target_pos", true))
	pos := PARSEJSON(Cover.GetStatus, "$.target_pos", true);
end

return(linear(pos,0,1,100,0));
```

Jalousiestellung schreiben

```taphome
VAR response := SENDHTTPREQUEST("rpc/Cover.GoToPosition?id=" + ID + "&pos=" + round(linear(Bl,0,100,1,0)));
IF response.IsSuccess = false
  ADDERROR(response.StatusCode);
END

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

Serviceattribute

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

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

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

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

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

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

${valueLogType\_ElectricVoltage} \[V]

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

${valueLogType\_ElectricCurrent} \[A]

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

Serviceaktionen

${start\_automatic\_calibration}

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

Jalousie Jalousie Lesen und Schreiben

Jalousie mit Positions- und Lamellensteuerung — erfordert Cover-Profil, Kalibrierung und aktivierte Lamellen

numeric Einheit: %

Serviceattribute

|                      |                                                                          |
|----------------------|--------------------------------------------------------------------------|
| Temperatur           |                                                                          |
| Energieverbrauch     |                                                                          |
| Leistungsaufnahme    |                                                                          |
| Elektrische Spannung |                                                                          |
| Elektrischer Strom   |                                                                          |
| Lamelle              | Ob die Lamellensteuerung in der Shelly-Cover-Konfiguration aktiviert ist |
| Lamellenöffnungszeit |                                                                          |
| Lamellenschließzeit  |                                                                          |

Serviceaktionen

|                                   |                                                                                        |
|-----------------------------------|----------------------------------------------------------------------------------------|
| Automatische Kalibrierung starten |                                                                                        |
| Lamelle einstellen                | Lamellensteuerung aktivieren und Öffnungs-/Schließdauer konfigurieren (0,1–5 Sekunden) |

Lesen (Modul)

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

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

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

if ! parsejson(Cover.GetStatus, "$.pos_control", true)
    #adderror("${presence_calibration_required}");
    adderror("Calibration is required");
end

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

Jalousiestellung lesen

```taphome
var pos := PARSEJSON(Cover.GetStatus, "$.current_pos", true);
var target := PARSEJSON(Cover.GetStatus, "$.target_pos", true);
var slatPos := PARSEJSON(Cover.GetStatus, "$.slat_pos", true);

BlSend := 0;
if BsSend = 0 and (Bs = 0 or Bs = 1) 
	if (!isnull(target))
		DeltaPos := 0;
		return(linear(target,0,1,100,0));
	else
		return(linear(pos - DeltaPos,0,1,100,0));	
	end
end

return(Bl);
```

Jalousiestellung schreiben

```taphome
var pos := PARSEJSON(Cover.GetStatus, "$.current_pos", true);
var target := PARSEJSON(Cover.GetStatus, "$.target_pos", true);
var slatPos := PARSEJSON(Cover.GetStatus, "$.slat_pos", true);

VAR response := SENDHTTPREQUEST("rpc/Cover.GoToPosition?id=0&pos=" + round(linear(Bl,0,100,1,0)));
BlSend := 1;
IF response.IsSuccess = false
  ADDERROR(response.StatusCode);
END

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

Lamellenneigung lesen

```taphome
var pos := PARSEJSON(Cover.GetStatus, "$.current_pos", true);
var slatPos := PARSEJSON(Cover.GetStatus, "$.slat_pos", true);
var state := PARSEJSON(Cover.GetStatus, "$.state", true);
var date := NOW();

if ISNULL(slatPos)
    adderror("Slat position must be enabled for blinds");
    return(NaN);
end

if state = "closing" or state = "opening"
	BsSend := 1;
	return(Bs);
end

if BsSend > 1
	BsSend := 1;
	return(Bs);
else
	if BsSend = 1
		BsSend := 0;
		DeltaPos := pos - round(linear(Bl,0,100,1,0));	
	end
	return(linear(slatPos,0,1,100,0));
end
```

Lamellenneigung schreiben

```taphome
var date := NOW();
var pos := PARSEJSON(Cover.GetStatus, "$.current_pos", true);

if BlSend = 0
	VAR response := SENDHTTPREQUEST("rpc/Cover.GoToPosition?id=0&pos=" + pos + "&slat_pos=" + round(linear(Bs,0,100,1,0)));
	BsSend := date.UNIXTIME;
	IF response.IsSuccess = false
	  ADDERROR(response.StatusCode);
	END
end

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

Serviceattribute

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

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

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

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

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

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

${valueLogType\_ElectricVoltage} \[V]

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

${valueLogType\_ElectricCurrent} \[A]

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

Slat

```taphome
if(parsejson(Cover.GetConfig, "$.slat.enable", true), "Enabled", "Disabled")
```

Slat open time \[s]

```taphome
parsejson(Cover.GetConfig, "$.slat.open_time ", true)
```

Slat close time \[s]

```taphome
parsejson(Cover.GetConfig, "$.slat.open_time ", true)
```

Serviceaktionen

${start\_automatic\_calibration}

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

Set Slat

Parameter: Open time \[s] (0.1–5 ot), Close time \[s] (0.1–5 ct)

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Cover.SetConfig?id=" + ID + 
	"&config={\"slat\":{\"enable\":true, \"open_time\": " + ot +", \"close_time\": " + ct +"}}");
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

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

Mögliche Verbesserungen (11)

- Input 1 State — Physical switch/button input 1 state, available via /rpc/Input.GetStatus?id=0
- Input 2 State — Physical switch/button input 2 state, available via /rpc/Input.GetStatus?id=1
- Returned Energy — Returned/exported energy in Wh, for bi-directional metering scenarios
- 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
- Auto-off Timer — Auto-reset timer in seconds via toggle\_after parameter, could be added as switch parameter
- Reset Energy Counters — Resets energy measurement counters (aenergy, ret\_aenergy) for both channels
- Overpower Protection — Configurable power limit threshold in Watts, relay turns off when exceeded
- Cover State — Cover movement state (open/opening/closed/closing/stopped/calibrating), available in Cover.GetStatus
- Cover Open/Close/Stop Commands — Direct open/close/stop commands without position parameter; template uses GoToPosition instead

## 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-27
- Shelly Gen2+ Switch Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Switch/) 2026-03-27
- Shelly Gen2+ System (Sys) Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Sys/) 2026-03-27
- Shelly Gen2+ WiFi Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/WiFi/) 2026-03-27
- Home Assistant Shelly Integration
  
  [www.home-assistant.io](https://www.home-assistant.io/integrations/shelly/) 2026-03-27
- Shelly 2PM Gen3 Knowledge Base
  
  [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-2pm-gen3) 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/)