--- title: "Shelly 3EM MQTT" description: "Phasenweise Wirkleistung, Spannung, Strom, Leistungsfaktor, bidirektionale Energie und Schützsteuerung via MQTT. TapHome-Vorlage für Shelly 3EM Gen1." url: "https://taphome.com/de/compatibility/shelly-3em-gen1-mqtt/" language: de lastmod: 2026-10-08 generator: hugo ai: topics: ["mqtt","electric-meter","3-phase","wifi","energy-metering","bidirectional-metering","mdns"] questions: ["Wie integriere ich den Shelly 3EM über MQTT mit TapHome?","Was misst die Shelly-3EM-MQTT-TapHome-Vorlage pro Phase?","Wie finde ich die Shelly 3EM Device ID für die MQTT-Vorlage?","Warum lautet das MQTT-Topic-Präfix des Shelly 3EM shellyem3- statt shelly3em-?","Unterstützt die Shelly 3EM MQTT-Vorlage bidirektionale Messung für Solar?","Wie setze ich die phasenweisen Energiezähler des Shelly 3EM aus TapHome zurück?"] --- # Shelly 3EM MQTT Kommunikation: Packet Parser → MQTT - [Shelly 3EM Produktseite](https://www.shelly.com/en/products/shop/shelly-3em) > Netzwerkadresse > > Beim in TapHome integrierten MQTT-Broker geben Sie in TapHome `127.0.0.1` als Broker-Adresse ein. Im Gerät geben Sie die IP-Adresse des TapHome Core ein und richten für den Core eine IP-Reservierung im Router ein. > > [Netzwerkvorbereitung](https://taphome.com/de/docs/setup/network-preparation/) ## Integrationsanleitung Der Shelly 3EM ist ein 3-phasiger Wi-Fi-Stromzähler aus der ersten Generation der Shelly-Geräte (Gen1). Er misst Wirkleistung, Spannung, Strom, Leistungsfaktor und Lebenszeit-Energie unabhängig für jede der drei Phasen mit Hilfe der drei mitgelieferten 120 A Klappstromwandler und enthält ein eingebautes 10 A Relais, das typischerweise zur Ansteuerung der Spule eines externen Leistungsschützes verwendet wird. TapHome kommuniziert mit dem Gerät über MQTT — das Gerät schickt phasenweise Messwerte an einen Broker, das TapHome PacketParser-Modul abonniert den Topic-Baum `shellies/#` und leitet die Werte an vier Untergeräte weiter (3 Stromzähler + 1 Schützschalter). Dies ist die **MQTT-Variante** der Shelly 3EM-Vorlage. Eine HTTP-Variante steht ebenfalls zur Verfügung — wähle MQTT, wenn bereits ein lokaler MQTT-Broker läuft, du Push-basierte Updates statt Polling möchtest oder den Zähler mit mehreren Konsumenten teilen musst (TapHome plus ein anderes System). Das Aktivieren von MQTT auf der Gen1-Firmware **deaktiviert die Shelly Cloud** — beide können nicht gleichzeitig laufen. ## Konfiguration ### MQTT im Shelly 3EM aktivieren Öffne die Web-Oberfläche des Shelly 3EM (`http://{device-ip}` oder `http://shelly3em-{MAC}.local`) und konfiguriere den MQTT-Client: 1. Gehe zu **Internet & Security** → **Advanced - Developer Settings** 2. Setze den Haken bei **Enable action execution via MQTT** 3. Trage in **Server** den Wert `{IP-Adresse des MQTT-Brokers}:{port}` ein — typischerweise `192.168.1.10:1883` 4. (Optional) Setze **Username** und **Password**, falls der Broker Authentifizierung verlangt 5. Klicke **SAVE** — das Gerät startet neu und verbindet sich mit dem Broker > [!WARNING] > Gen1-Shelly-Geräte unterstützen **kein** MQTT über TLS. Die Kommunikation zwischen Gerät und Broker ist unverschlüsselter Plain TCP auf Port 1883. Benutzername und Passwort werden im Klartext übertragen. Nutze den MQTT-Broker nur in einem vertrauenswürdigen lokalen Netzwerk. > [!NOTE] > Das Aktivieren von MQTT **deaktiviert die Shelly Cloud** auf der Gen1-Firmware automatisch. Zum Zurücksetzen entferne den MQTT-Haken und aktiviere die Cloud unter Internet & Security wieder. ### Device ID ermitteln Die TapHome-Vorlage abonniert `shellies/shellyem3-{dID}/#`, wobei `{dID}` das MAC-Suffix des Geräts ist, das als MQTT-Topic-Präfix verwendet wird. So findest du sie in der Shelly 3EM Web-Oberfläche: 1. Öffne die Web-Oberfläche des Geräts im Browser 2. Gehe zu **Settings** → **Device Info** 3. Kopiere die **erste Device-ID-Zeichenkette** (NICHT den Wert in Klammern) — sie entspricht der MAC-Adresse der WLAN-Schnittstelle (z. B. `DC4F227649A1`) Alternativ rufe `GET http://{device-ip}/settings` auf und lies das Feld `mqtt.id`. ### Vorlage einrichten Setze nach dem Import der Vorlage in TapHome drei Importparameter: | Parameter | Beschreibung | Beispiel | |-----------|--------------|----------| | **IpAddress** | IP-Adresse des MQTT-Brokers | `192.168.1.10` | | **Port** | Port des MQTT-Brokers | `1883` | | **dID** | Device ID (MAC-Suffix) des Shelly 3EM | `DC4F227649A1` | Das Modul abonniert anschließend `shellies/#` (QoS 0), und Listener-Skripte leiten phasenweise Emeter- und Relais-Nachrichten an die entsprechenden Untergeräte weiter. Das Standard-MQTT-Aktualisierungsintervall des Geräts beträgt 30 Sekunden — es kann über `GET http://{device-ip}/settings?mqtt_update_period=N` reduziert werden (Wert `0` veröffentlicht nur bei Änderungen). > [!NOTE] > Das MQTT-Topic-Präfix in der Übertragung lautet `shellyem3-{MAC}`, während der mDNS-Hostname des Geräts `shelly3em-{MAC}.local` ist — Shelly verwendet zwei verschiedene Formate für dasselbe Gerät. Die Vorlage folgt dem tatsächlichen MQTT-Topic-Präfix (`shellyem3-`). Wenn keine MQTT-Nachrichten ankommen, abonniere `shellies/#` mit einem MQTT-Client und prüfe, welches Präfix die Firmware tatsächlich verwendet. ## Gerätefunktionen ### Phasenweise Wirkleistung und Lebenszeit-Energie Die Vorlage erstellt drei Stromzähler — einen für jede Phase (CT-Wandler 1 → Phase A, Wandler 2 → Phase B, Wandler 3 → Phase C). Jeder Zähler liest zwei Werte: - **Wirkleistung** — Momentanleistung aus `shellies/shellyem3-{dID}/emeter/{i}/power` (W), durch 1000 geteilt und als kW gespeichert - **Gesamte verbrauchte Energie** — kumulative Lebenszeit-Energie aus `.../emeter/{i}/total` (Wh), durch 1000 geteilt und als kWh gespeichert Jeder CT-Wandler ist für **120 A** ausgelegt und nicht-invasiv (Klappausführung, kein Auftrennen des Leiters erforderlich). Die mitgelieferten 3 CT-Wandler sind individuell gekennzeichnet und kalibriert — sie sind zwischen den Kanälen NICHT austauschbar. ### Phasenweise elektrische Parameter Jeder Stromzähler stellt vier Service-Attribute für erweitertes Monitoring bereit: - **Spannung** (V) — RMS-Spannung Außenleiter-Neutralleiter auf der jeweiligen Phase (`.../emeter/{i}/voltage`) - **Strom** (A) — RMS-Strom, gemessen vom zugehörigen CT-Wandler (`.../emeter/{i}/current`) - **Leistungsfaktor** — Verhältnis von Wirk- zu Scheinleistung, Bereich −1.00 bis 1.00 (`.../emeter/{i}/pf`) - **Zurückgespeiste Energie** (Wh) — Lebenszeit-Energie, die **ins** Netz auf der jeweiligen Phase zurückgespeist wurde (`.../emeter/{i}/total_returned`), nützlich für PV / bidirektionale Messung Die Kombination aus `total` (verbraucht) und `total_returned` (eingespeist) pro Phase macht die Vorlage geeignet für Solar- / Netzeinspeise-Installationen. ### Energie-Zähler zurücksetzen Jede Phase hat eine Service-Aktion **Reset Total**, die `reset_totals` an `shellies/shellyem3-{dID}/emeter/{i}/command` veröffentlicht. Damit werden die Zähler `total` und `total_returned` für die jeweilige Phase auf null gesetzt — nützlich bei Umnutzung des Zählers oder beim Start einer neuen Messperiode. ### Schützrelais Das integrierte 10 A Relais wird als Schaltgerät bereitgestellt. Der Status wird aus `shellies/shellyem3-{dID}/relay/0` gelesen (`on` → 1, alles andere → 0) und durch Veröffentlichen von `on` oder `off` auf `.../relay/0/command` gesteuert. Das Relais ist für 10 A / 240 V AC ausgelegt und wird typischerweise über die Klemmen `I` (Phaseneingang) und `O` (Relaisausgang) verdrahtet, um die Spule eines externen Leistungsschützes für höhere Lasten zu schalten. > [!TIP] > Die MQTT-Vorlage veröffentlicht keine 3-Phasen-Gesamtleistungssumme (`total_power` ist auf Gen1 nur per HTTP verfügbar). Erstelle ein virtuelles TapHome-Gerät, das die drei phasenweisen Leistungswerte addiert, falls du eine einzige Haushalts-Leistungszahl benötigst. ## Fehlerbehebung ### Keine MQTT-Nachrichten empfangen 1. Bestätige, dass MQTT in der Shelly Web-Oberfläche aktiviert ist (**Internet & Security** → **Advanced - Developer Settings** → **Enable action execution via MQTT**) und das Gerät nach dem Speichern neu gestartet wurde 2. Prüfe, dass Broker-IP und -Port im Gerät mit den Importparametern `IpAddress`/`Port` in TapHome übereinstimmen 3. Abonniere `shellies/#` mit einem MQTT-Client (z. B. MQTT Explorer, `mosquitto_sub`) und prüfe, ob das Gerät überhaupt etwas veröffentlicht — bestätige, dass das tatsächliche Topic-Präfix (`shellyem3-{dID}`) mit der `dID` übereinstimmt, die du in TapHome eingetragen hast 4. Stelle sicher, dass der MQTT-Broker läuft und sowohl vom Shelly 3EM als auch vom TapHome Core erreichbar ist 5. Falls sich die Geräte-IP kürzlich geändert hat, versuche eine Verbindung über den mDNS-Hostnamen `shelly3em-{MAC}.local`, um die Erreichbarkeit im Netzwerk zu prüfen ### Energiewerte zeigen Null oder unplausible Werte 1. Bestätige, dass jeder CT-Wandler am **richtigen** Eingang angeschlossen ist — der mit `IA` markierte Wandler muss an den Klemmen `IA-/IA+`, `IB` an `IB-/IB+`, `IC` an `IC-/IC+` liegen. Die Wandler sind kanalweise kalibriert und nicht austauschbar. 2. Prüfe, dass der **Pfeil auf dem CT-Wandler-Gehäuse** in Richtung des Stromflusses zeigt (von der Quelle zur Last). Ein verkehrt herum montierter Wandler erzeugt einen negativen Leistungsfaktor und kehrt die Klassifizierung Verbrauch / Einspeisung um. 3. Stelle sicher, dass die Spannungseingänge `VA`, `VB`, `VC` an den gleichen Phasen liegen, die die CT-Wandler messen — eine fehlerhafte Spannungs-/Strom-Zuordnung erzeugt falsche Leistungs- und Leistungsfaktorwerte. 4. Wenn eine einzelne Phase null anzeigt, während die anderen korrekt sind, tausche diesen CT-Wandler mit einem bekannt funktionierenden, um Wandler vs. Stromkreis zu isolieren. ### MQTT lässt sich nicht aktivieren — Cloud ist aktiv Auf der Gen1-Firmware schließen sich MQTT und Shelly Cloud gegenseitig aus. Wenn die Checkbox **Enable action execution via MQTT** ausgegraut ist, deaktiviere zuerst Shelly Cloud unter **Internet & Security** → **Cloud** und öffne dann erneut die MQTT-Einstellungen. ### Shelly Cloud-Verlauf ist nach MQTT-Aktivierung verschwunden Das ist erwartetes Verhalten — das Aktivieren von MQTT deaktiviert die Cloud einschließlich ihrer 365-tägigen Verlaufsspeicherung. Wenn du gleichzeitig Echtzeit-MQTT-Steuerung in TapHome und langfristige Historie benötigst, leite MQTT-Nachrichten über deinen eigenen Broker und halte die historischen Daten in TapHome (oder einem separaten Logging-System). > [!WARNING] > Jeder CT-Wandler muss **immer** an den Klemmen des Shelly 3EM angeschlossen sein, **bevor** er um einen spannungsführenden Leiter geklappt wird. Die an einer offenen CT-Sekundärwicklung induzierte Spannung kann gefährliche Werte erreichen und den Wandler beschädigen. ## Installation in TapHome ### Voraussetzungen - Shelly-Gerät mit Wi-Fi (2,4 GHz) verbunden, z. B. über die Shelly App oder den eigenen Access Point des Geräts - MQTT-Broker in Ihrem lokalen Netzwerk aktiv (z. B. Mosquitto, Home Assistant oder der integrierte TapHome-Broker) - TapHome CCU im selben Netzwerk wie der Broker > [!WARNING] > Auf **Gen1**-Geräten **deaktiviert** das Aktivieren von MQTT die **Shelly Cloud**. Beides kann nicht gleichzeitig betrieben werden. Auf Gen2/Plus-Geräten gilt diese Einschränkung nicht. ### Schritt 1 — MQTT auf dem Shelly-Gerät aktivieren #### Gen1-Geräte (Shelly 1, 1PM, 2.5, EM, 3EM, Plug S, RGBW2, Dimmer, TRV…) 1. Öffnen Sie die Shelly-Weboberfläche: `http:///` 2. Navigieren Sie zu **Internet & Security** → **Advanced — MQTT** 3. Aktivieren Sie **MQTT** 4. Setzen Sie **MQTT Server**: `:` (z. B. `192.168.1.10:1883`) 5. Optional setzen Sie **MQTT User** und **MQTT Password**, falls Ihr Broker eine Authentifizierung erfordert 6. Klicken Sie auf **Save** — das Gerät startet neu und verbindet sich mit dem Broker #### Gen2 / Plus-Geräte (Shelly Plus 1, Plus 1PM, Plus 2PM, Plus Plug S, Plus H&T, Pro 3EM…) 1. Öffnen Sie die Shelly-Weboberfläche: `http:///` 2. Navigieren Sie zu **Settings** → **MQTT** 3. Aktivieren Sie **MQTT** 4. Setzen Sie **Server**: `:` (z. B. `192.168.1.10:1883`) 5. Die **Client ID** ist mit der Geräte-ID vorausgefüllt (z. B. `shellyplus1pm-AABBCCDDEE`) — belassen Sie sie so, es sei denn, Sie haben einen bestimmten Grund zur Änderung 6. Klicken Sie auf **Save** und starten Sie das Gerät neu Beim integrierten TapHome-Broker ist `` die IP-Adresse des TapHome Core. Geben Sie dem Core eine IP-Reservierung im Router, sonst verliert das Gerät den Broker, wenn der Router die Adresse ändert → [Netzwerkvorbereitung](https://taphome.com/de/docs/setup/network-preparation/). > [!TIP] > Um zu überprüfen, ob MQTT funktioniert, verwenden Sie einen MQTT-Client (z. B. MQTT Explorer) und abonnieren Sie `shellies/#` (Gen1) oder `/#` (Gen2). Sie sollten Statusnachrichten vom Gerät sehen. ### Schritt 2 — Device ID / MQTT Client ID ermitteln Einige Vorlagen erfordern einen Parameter **Device ID** oder **MQTT Client ID**. Dies ist die eindeutige Kennung, die in MQTT-Topics verwendet wird. - **Gen1:** auf dem Etikett als MAC-Adresse zu finden (z. B. `AABBCCDDEE`). Device ID = `shelly-`, z. B. `shelly1pm-AABBCCDDEE` - **Gen2/Plus:** in der Shelly-Weboberfläche unter **Settings** → **Device Info** → **Device ID** zu finden, oder auf dem Geräteetikett ### Schritt 3 — Konfiguration in TapHome 1. Fügen Sie in TapHome ein neues Modul **Packet Parser (MQTT)** hinzu 2. **IP Address:** `127.0.0.1` für den integrierten TapHome-Broker (die Steuereinheit verbindet sich mit sich selbst, die Adresse ändert sich nie); für einen externen Broker dessen IP-Adresse (z. B. `192.168.1.10`) 3. **Port:** `1883` (Standard; verwenden Sie `8883` für TLS) 4. **Device ID / MQTT Client ID:** Geben Sie den Wert aus Schritt 2 ein (falls von der Vorlage benötigt) 5. Importieren Sie die Vorlage — TapHome abonniert automatisch die Geräte-Topics ## Verfügbare Geräte 4 Diese Geräte erscheinen nach dem Import in TapHome. Shelly 3EM MQTT Modul Benutzerdefinierte Variablen `dID` (string) MAC-Suffix des Shelly 3EM, das das MQTT-Topic-Präfix shellies/shellyem3-{dID}/... bildet — zu finden in der Shelly Web-Oberfläche → Settings → Device Info (erste Zeichenkette, NICHT der Wert in Klammern) Open Shelly 3EM web UI → Settings → Device Info → copy the first Device ID string (NOT the value in brackets); equals the WiFi MAC address (e.g. DC4F227649A1) Stromzähler (Phase 1) Stromzähler Nur lesen Wirkleistung (kW) und Lebenszeit-Energie (kWh) auf Phase A — gelesen vom CT-Wandler 1, mit W→kW- und Wh→kWh-Umrechnung numeric Einheit: kW / kWh Serviceattribute | | | |-------------------------|-------------------------------------------------------------------------------------------------------------------| | Zurückgespeiste Energie | Lebenszeit-Energie, die ins Netz auf Phase A zurückgespeist wurde (Wh) — nützlich für PV / bidirektionale Messung | | Spannung | RMS-Spannung Außenleiter-Neutralleiter auf Phase A (V) | | Strom | RMS-Strom, gemessen vom CT-Wandler 1 (A) | | Leistungsfaktor | Leistungsfaktor auf Phase A — Verhältnis von Wirk- zu Scheinleistung, Bereich −1.00 bis 1.00 | Serviceaktionen | | | |---------------------|-----------------------------------------------------------------------------------------| | Zähler zurücksetzen | Setzt sowohl den total- als auch den total\_returned-Energiezähler für Phase A auf null | Gesamtverbrauch lesen ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/getValue"); # IF response.IsSuccess # VAR content := response.Content; # VAR responseHeaders := response.Headers; # RETURN(PARSEXML(content, "//element1/value1")); # ELSE # ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); # RETURN(NaN); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...); # OR # VAR request := HTTPREQUEST("/example/getValue", "POST", "some data"); # request.headers := { "header1:value1", "header2:value2", ...}; # request.method := "GET"; # request.data := null; # VAR response := SENDHTTPREQUEST(request); # # # Send TCP, UDP data: # VAR data1 := BYTECOLLECTION("0a bb ea df 01"); # SENDDATA(data1); # VAR data2 := "{\"name\":\"John\", \"age\":32}"; # SENDDATA(data2); # VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1"); # SENDDATA(data3); # Process received TCP or UDP data and set device values in the Listener script # # # Download data from FTP: # FTPDOWNLOAD("filePath"); ``` Bedarf lesen ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/getValue"); # IF response.IsSuccess # VAR content := response.Content; # VAR responseHeaders := response.Headers; # RETURN(PARSEXML(content, "//element1/value1")); # ELSE # ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); # RETURN(NaN); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...); # OR # VAR request := HTTPREQUEST("/example/getValue", "POST", "some data"); # request.headers := { "header1:value1", "header2:value2", ...}; # request.method := "GET"; # request.data := null; # VAR response := SENDHTTPREQUEST(request); # # # Send TCP, UDP data: # VAR data1 := BYTECOLLECTION("0a bb ea df 01"); # SENDDATA(data1); # VAR data2 := "{\"name\":\"John\", \"age\":32}"; # SENDDATA(data2); # VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1"); # SENDDATA(data3); # Process received TCP or UDP data and set device values in the Listener script # # # Download data from FTP: # FTPDOWNLOAD("filePath"); ``` Listener ```taphome IF(RECEIVEDMSG.TOPIC = "shellies/shellyem3-"+dID+"/emeter/0/power") Ed := todouble(TOSTRING(RECEIVEDMSG.PAYLOAD))/1000; elseif(RECEIVEDMSG.TOPIC = "shellies/shellyem3-"+dID+"/emeter/0/total") To := todouble(TOSTRING(RECEIVEDMSG.PAYLOAD))/1000; END ``` Serviceattribute returned energy \[Wh] ```taphome IF(parsejson(x, "Topic") = "shellies/shellyem3-"+dID+"/emeter/0/total_returned") return(parsejson(x, "Payload")); END ``` voltage \[V] ```taphome IF(parsejson(x, "Topic") = "shellies/shellyem3-"+dID+"/emeter/0/voltage") return(todouble(parsejson(x, "Payload"))); END ``` current \[A] ```taphome IF(parsejson(x, "Topic") = "shellies/shellyem3-"+dID+"/emeter/0/current") return(todouble(parsejson(x, "Payload"))); END ``` power factor ```taphome IF(parsejson(x, "Topic") = "shellies/shellyem3-"+dID+"/emeter/0/pf") return(todouble(parsejson(x, "Payload"))); END ``` Serviceaktionen Reset total ```taphome mqttpublish("shellies/shellyem3-"+dID+"/emeter/0/command", "reset_totals"); ``` Stromzähler (Phase 2) Stromzähler Nur lesen Wirkleistung (kW) und Lebenszeit-Energie (kWh) auf Phase B — gelesen vom CT-Wandler 2, mit W→kW- und Wh→kWh-Umrechnung numeric Einheit: kW / kWh Serviceattribute | | | |-------------------------|-------------------------------------------------------------------------------------------------------------------| | Zurückgespeiste Energie | Lebenszeit-Energie, die ins Netz auf Phase B zurückgespeist wurde (Wh) — nützlich für PV / bidirektionale Messung | | Spannung | RMS-Spannung Außenleiter-Neutralleiter auf Phase B (V) | | Strom | RMS-Strom, gemessen vom CT-Wandler 2 (A) | | Leistungsfaktor | Leistungsfaktor auf Phase B — Verhältnis von Wirk- zu Scheinleistung, Bereich −1.00 bis 1.00 | Serviceaktionen | | | |---------------------|-----------------------------------------------------------------------------------------| | Zähler zurücksetzen | Setzt sowohl den total- als auch den total\_returned-Energiezähler für Phase B auf null | Gesamtverbrauch lesen ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/getValue"); # IF response.IsSuccess # VAR content := response.Content; # VAR responseHeaders := response.Headers; # RETURN(PARSEXML(content, "//element1/value1")); # ELSE # ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); # RETURN(NaN); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...); # OR # VAR request := HTTPREQUEST("/example/getValue", "POST", "some data"); # request.headers := { "header1:value1", "header2:value2", ...}; # request.method := "GET"; # request.data := null; # VAR response := SENDHTTPREQUEST(request); # # # Send TCP, UDP data: # VAR data1 := BYTECOLLECTION("0a bb ea df 01"); # SENDDATA(data1); # VAR data2 := "{\"name\":\"John\", \"age\":32}"; # SENDDATA(data2); # VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1"); # SENDDATA(data3); # Process received TCP or UDP data and set device values in the Listener script # # # Download data from FTP: # FTPDOWNLOAD("filePath"); ``` Bedarf lesen ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/getValue"); # IF response.IsSuccess # VAR content := response.Content; # VAR responseHeaders := response.Headers; # RETURN(PARSEXML(content, "//element1/value1")); # ELSE # ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); # RETURN(NaN); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...); # OR # VAR request := HTTPREQUEST("/example/getValue", "POST", "some data"); # request.headers := { "header1:value1", "header2:value2", ...}; # request.method := "GET"; # request.data := null; # VAR response := SENDHTTPREQUEST(request); # # # Send TCP, UDP data: # VAR data1 := BYTECOLLECTION("0a bb ea df 01"); # SENDDATA(data1); # VAR data2 := "{\"name\":\"John\", \"age\":32}"; # SENDDATA(data2); # VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1"); # SENDDATA(data3); # Process received TCP or UDP data and set device values in the Listener script # # # Download data from FTP: # FTPDOWNLOAD("filePath"); ``` Listener ```taphome IF(RECEIVEDMSG.TOPIC = "shellies/shellyem3-"+dID+"/emeter/1/power") Ed := todouble(TOSTRING(RECEIVEDMSG.PAYLOAD))/1000; elseif(RECEIVEDMSG.TOPIC = "shellies/shellyem3-"+dID+"/emeter/1/total") To := todouble(TOSTRING(RECEIVEDMSG.PAYLOAD))/1000; END ``` Serviceattribute total returned \[Wh] ```taphome IF(parsejson(x, "Topic") = "shellies/shellyem3-"+dID+"/emeter/1/total_returned") return(todouble(parsejson(x, "Payload"))); END ``` voltage \[V] ```taphome IF(parsejson(x, "Topic") = "shellies/shellyem3-"+dID+"/emeter/1/voltage") return(todouble(parsejson(x, "Payload"))); END ``` current \[A] ```taphome IF(parsejson(x, "Topic") = "shellies/shellyem3-"+dID+"/emeter/1/current") return(todouble(parsejson(x, "Payload"))); END ``` power factor ```taphome IF(parsejson(x, "Topic") = "shellies/shellyem3-"+dID+"/emeter/1/pf") return(todouble(parsejson(x, "Payload"))); END ``` Serviceaktionen Reset total ```taphome mqttpublish("shellies/shellyem3-"+dID+"/emeter/1/command", "reset_totals"); ``` Stromzähler (Phase 3) Stromzähler Nur lesen Wirkleistung (kW) und Lebenszeit-Energie (kWh) auf Phase C — gelesen vom CT-Wandler 3, mit W→kW- und Wh→kWh-Umrechnung numeric Einheit: kW / kWh Serviceattribute | | | |-------------------------|-------------------------------------------------------------------------------------------------------------------| | Zurückgespeiste Energie | Lebenszeit-Energie, die ins Netz auf Phase C zurückgespeist wurde (Wh) — nützlich für PV / bidirektionale Messung | | Spannung | RMS-Spannung Außenleiter-Neutralleiter auf Phase C (V) | | Strom | RMS-Strom, gemessen vom CT-Wandler 3 (A) | | Leistungsfaktor | Leistungsfaktor auf Phase C — Verhältnis von Wirk- zu Scheinleistung, Bereich −1.00 bis 1.00 | Serviceaktionen | | | |---------------------|-----------------------------------------------------------------------------------------| | Zähler zurücksetzen | Setzt sowohl den total- als auch den total\_returned-Energiezähler für Phase C auf null | Gesamtverbrauch lesen ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/getValue"); # IF response.IsSuccess # VAR content := response.Content; # VAR responseHeaders := response.Headers; # RETURN(PARSEXML(content, "//element1/value1")); # ELSE # ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); # RETURN(NaN); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...); # OR # VAR request := HTTPREQUEST("/example/getValue", "POST", "some data"); # request.headers := { "header1:value1", "header2:value2", ...}; # request.method := "GET"; # request.data := null; # VAR response := SENDHTTPREQUEST(request); # # # Send TCP, UDP data: # VAR data1 := BYTECOLLECTION("0a bb ea df 01"); # SENDDATA(data1); # VAR data2 := "{\"name\":\"John\", \"age\":32}"; # SENDDATA(data2); # VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1"); # SENDDATA(data3); # Process received TCP or UDP data and set device values in the Listener script # # # Download data from FTP: # FTPDOWNLOAD("filePath"); ``` Bedarf lesen ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/getValue"); # IF response.IsSuccess # VAR content := response.Content; # VAR responseHeaders := response.Headers; # RETURN(PARSEXML(content, "//element1/value1")); # ELSE # ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); # RETURN(NaN); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...); # OR # VAR request := HTTPREQUEST("/example/getValue", "POST", "some data"); # request.headers := { "header1:value1", "header2:value2", ...}; # request.method := "GET"; # request.data := null; # VAR response := SENDHTTPREQUEST(request); # # # Send TCP, UDP data: # VAR data1 := BYTECOLLECTION("0a bb ea df 01"); # SENDDATA(data1); # VAR data2 := "{\"name\":\"John\", \"age\":32}"; # SENDDATA(data2); # VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1"); # SENDDATA(data3); # Process received TCP or UDP data and set device values in the Listener script # # # Download data from FTP: # FTPDOWNLOAD("filePath"); ``` Listener ```taphome IF(RECEIVEDMSG.TOPIC = "shellies/shellyem3-"+dID+"/emeter/2/power") Ed := todouble(TOSTRING(RECEIVEDMSG.PAYLOAD))/1000; elseif(RECEIVEDMSG.TOPIC = "shellies/shellyem3-"+dID+"/emeter/2/total") To := todouble(TOSTRING(RECEIVEDMSG.PAYLOAD))/1000; END ``` Serviceattribute total returned \[Wh] ```taphome IF(parsejson(x, "Topic") = "shellies/shellyem3-"+dID+"/emeter/2/total_returned") return(todouble(parsejson(x, "Payload"))); END ``` voltage \[V] ```taphome IF(parsejson(x, "Topic") = "shellies/shellyem3-"+dID+"/emeter/2/voltage") return(todouble(parsejson(x, "Payload"))); END ``` current \[A] ```taphome IF(parsejson(x, "Topic") = "shellies/shellyem3-"+dID+"/emeter/2/current") return(todouble(parsejson(x, "Payload"))); END ``` Power Factor ```taphome IF(parsejson(x, "Topic") = "shellies/shellyem3-"+dID+"/emeter/2/pf") return(todouble(parsejson(x, "Payload"))); END ``` Serviceaktionen reset total ```taphome mqttpublish("shellies/shellyem3-"+dID+"/emeter/2/command", "reset_totals"); ``` Schützrelais Schalter Lesen und Schreiben Eingebautes 10 A Relais — typischerweise verdrahtet zur Ansteuerung der Spule eines externen Leistungsschützes über die I/O-Klemmen boolean Werte / Zustände: ON · OFF Schaltzustand lesen ```taphome # Simple HTTP Request: # VAR response := SENDHTTPREQUEST("/example/getValue"); # IF response.IsSuccess # VAR content := response.Content; # VAR responseHeaders := response.Headers; # RETURN(PARSEXML(content, "//element1/value1")); # ELSE # ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")"); # RETURN(NaN); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...); # OR # VAR request := HTTPREQUEST("/example/getValue", "POST", "some data"); # request.headers := { "header1:value1", "header2:value2", ...}; # request.method := "GET"; # request.data := null; # VAR response := SENDHTTPREQUEST(request); # # # Send TCP, UDP data: # VAR data1 := BYTECOLLECTION("0a bb ea df 01"); # SENDDATA(data1); # VAR data2 := "{\"name\":\"John\", \"age\":32}"; # SENDDATA(data2); # VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1"); # SENDDATA(data3); # Process received TCP or UDP data and set device values in the Listener script # # # Download data from FTP: # FTPDOWNLOAD("filePath"); ``` Schaltzustand schreiben ```taphome # Simple HTTP Request: MQTTPUBLISH("shellies/shellyem3-"+dID+"/relay/0/command", switch(St,1,"on","off")); # VAR response := SENDHTTPREQUEST("/example/set/value=" + St); # IF response.IsSuccess = false # ADDERROR(response.StatusCode); # END # # Set Http request method, body and headers # VAR response := SENDHTTPREQUEST("/example/setValue", "GET", "value=" + St, "header1:value1", "header2:value2", ...);\r # Or VAR request := HTTPREQUEST("/example/setValue"); # request.Method := "PUT"; # VAR response := SENDHTTPREQUEST(request); #r # # Send TCP, UDP data: # VAR data1 := "{\"name\":\"John\", \"age\":" + St + "}"; # SENDDATA(data1); # VAR data2 := TOBYTES("{\"name\":\"John\", \"age\":" + St + "}", "iso-8859-1"); # SENDDATA(data2); # You can process received TCP or UDP data in the Listener script # # # Upload data to FTP: # FTPUPLOAD("filePath", "somedata=" + St, "write"); # use "append" mode to append data to existing file ``` Listener ```taphome # Parse received bytes: IF(RECEIVEDMSG.TOPIC = "shellies/shellyem3-"+dID+"/relay/0") St := switch(TOSTRING(RECEIVEDMSG.PAYLOAD),"on",1,0); END ``` **Verbindung:** Packet Parser → MQTT • Hostname: `shelly3em-{MAC}.local` Mögliche Verbesserungen (10) - Reactive Power (per phase) — Instantaneous reactive power in VAR per phase — useful for power-quality diagnostics. - Short-term Energy Counter — Watt-minute counter since boot (volatile). Template uses lifetime 'total' instead. - Short-term Returned Energy — Watt-minute returned counter since boot (volatile). - Contactor Coil Power — Power draw through the on-board relay (small — coil only). - Contactor Coil Energy — Energy through the on-board relay (Wm). - Connection Status (LWT) — Last-Will-and-Testament topic — true on connect, false retained on disconnect. Could detect offline 3EM. - Device Announcement (JSON) — Periodic JSON announce containing id, mac, ip, fw\_ver, new\_fw, model. - Full Status JSON — Complete /status payload as JSON — could expose Wi-Fi RSSI, internal temperature, all 4 emeter channels. - 4th CT — Theft / Leakage Detection — Optional 4th split-core CT on IN+/IN- terminal for neutral leakage / energy-theft detection. NOT published over MQTT — only HTTP. - Total Active Power — 3EM does not publish total\_power over MQTT (only HTTP). Sum the three phase Ed values in a TapHome virtual device. ## Importparameter Diese Werte geben Sie beim Import des XML ein. | In der App abgefragt | Standard | |------------------------|----------------------| | Mqtt Broker IP-Adresse | `192.168.0.1` | | Mqtt Broker port | `1883` | | Device ID | Beim Import eingeben | ## Quellen - Shelly Gen1 API Reference [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen1/) 2026-03-12 - Home Assistant Shelly Integration [www.home-assistant.io](https://www.home-assistant.io/integrations/shelly/) 2026-03-12 - Shelly 3EM MQTT API — device-specific topics [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen1/#shelly-3em-mqtt) 2026-04-25 - Shelly 3EM Knowledge Base — specs & wiring [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-3em) 2026-04-25 - Shelly 3EM — User & Safety Guide [www.netxl.com](https://www.netxl.com/shelly/docs/shelly-3em-user-manual.pdf) 2026-04-25 [PDF](https://taphome.com/compatibility/devices/shelly-3em-gen1-mqtt/manufacturer/shelly-3em-user-safety-guide.pdf) Herstellerdokumente sind © ihrer jeweiligen Eigentümer. Sie werden so bereitgestellt, wie der Hersteller sie veröffentlicht hat, nur zur Information. ## Verwandte Dokumentation - [MQTT Integration](https://taphome.com/de/compatibility/mqtt-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/) - [MQTT-Broker](https://taphome.com/de/docs/integration/packet-parser/mqtt-broker/) - [Listener-Skripte](https://taphome.com/de/docs/script/listener-scripts/)