--- title: "Shelly DUO MQTT" description: "Bis zu 5 Shelly DUO Weißlampen über MQTT steuern — Helligkeit, CCT 3000-6500 K mit weichen Übergängen und kW/kWh-Messung pro Lampe. TapHome Gen1." url: "https://taphome.com/de/compatibility/shelly-duo-mqtt/" language: de lastmod: 2026-04-25 generator: hugo ai: topics: ["mqtt","lighting","wifi","tunable-white","cct","power-metering","led-bulb","gen1","mdns"] questions: ["Wie wird Shelly DUO per MQTT in TapHome integriert?","Wie findet man die MQTT Device ID einer Shelly DUO?","Wie steuert man mehrere Shelly DUO Lampen aus einer TapHome-Vorlage?","Warum zeigt Shelly DUO in TapHome eine Leistung von null an?","Warum reicht die wärmste Farbtemperatur nur bis 3000 K statt 2700 K?","Deaktiviert das Aktivieren von MQTT auf Shelly DUO die Shelly Cloud?"] --- # Shelly DUO MQTT Kommunikation: Packet Parser → MQTT - [Shelly DUO Produktseite](https://www.shelly.com/en/products/shop/shelly-bulb-duo) - [Shelly Gen1 MQTT API Dokumentation](https://shelly-api-docs.shelly.cloud/gen1/#shelly-duo-mqtt) > 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 Die Shelly DUO (Modell **SHBDUO-1**) ist eine Gen1 Wi-Fi-LED-Smart-Lampe in den Bauformen **E27** und **GU10**. Die Standard-DUO ist **rein weiß** mit einstellbarer Farbtemperatur und dimmbarer Helligkeit — sie hat keine RGB-Kanäle (die RGB-fähige Variante ist die *DUO RGBW* / `shellycolorbulb-` und nutzt eine eigene Vorlage). Dies ist die **MQTT-Variante** der TapHome-Integration; für Einzellampen-Setups ist auch eine [HTTP-Variante](https://taphome.com/de/compatibility/shelly-duo/) verfügbar. Die Vorlage unterstützt bis zu **5 DUO-Lampen** pro Modul über einen gemeinsamen MQTT Broker im lokalen Netzwerk. Jede Lampe wird über die Modulvariable `bulbNtopic` identifiziert, die auf die MQTT Device ID der Lampe zeigt, und stellt sowohl ein Weißlicht-Gerät als auch einen Stromzähler bereit — insgesamt 10 Geräte. ## Konfiguration ### MQTT Broker Die Vorlage benötigt einen MQTT Broker, der im lokalen Netzwerk erreichbar ist — jeder Standard-Broker funktioniert (Mosquitto, EMQX oder der in Home Assistant integrierte Broker). Der Broker läuft auf **Port 1883** ohne TLS (Gen1 Shelly-Hardware unterstützt MQTT über TLS nicht), behalten Sie ihn deshalb in einem vertrauenswürdigen Segment. Konfigurieren Sie nach dem Import der Vorlage die Broker-Verbindung in den Importparametern des Moduls: | Parameter | Standard | Beschreibung | |-----------|----------|--------------| | **MQTT Broker IP** (`IpAddress`) | `192.168.0.1` | Broker-Adresse im lokalen Netzwerk | | **MQTT Broker port** (`Port`) | `1883` | Standard-MQTT-Port (ohne TLS) | | **Transition time** (`TransitionTime`) | `300` | Standard-Übergangsdauer pro Lampe in Millisekunden | ### MQTT auf der Lampe aktivieren Jede Shelly DUO muss auf den Broker verwiesen werden, bevor sie Nachrichten veröffentlicht oder Befehle entgegennimmt: 1. Öffnen Sie das Web-UI der Lampe unter `http://` (IP findet sich in der DHCP-Tabelle des Routers oder in der Shelly App) 2. Gehen Sie zu **Internet & Security** → **Advanced — MQTT** und aktivieren Sie **MQTT** 3. Tragen Sie den **Server** des Brokers ein (IP und Port, z. B. `192.168.0.10:1883`) und lassen Sie **username** / **password** leer (die TapHome-Vorlage stellt keine Broker-Authentifizierung bereit) 4. Optional können Sie das **MQTT prefix** anpassen, falls Sie nicht den Standard `shellies/ShellyBulbDuo-` möchten 5. Speichern und Lampe neu starten — nach erneutem Verbindungsaufbau veröffentlicht sie auf `shellies/ShellyBulbDuo-/light/0/status` ### Device ID (`bulbNtopic`) Jede Shelly DUO besitzt eine eindeutige MQTT Device ID im Format **`ShellyBulbDuo-`**, wobei `` die letzten 6 Hex-Zeichen der MAC-Adresse sind (z. B. `ShellyBulbDuo-B929CC`). Derselbe Wert ist auch der mDNS-Hostname der Lampe (`ShellyBulbDuo-.local`). Die Device ID finden Sie: - Im Shelly Web-UI: **Settings** → **Device Info** → Feld `mqtt.id` - Per HTTP: `GET http:///settings` → `mqtt.id` - Auf dem Geräteetikett / der Verpackung (letzte 6 Zeichen der MAC, klein-Hex) - Als mDNS-Hostname, z. B. `ShellyBulbDuo-b929cc.local` Öffnen Sie das Modul **Shelly DUO MQTT** in TapHome und tragen Sie die Topic-Variablen für jede Lampe ein, die Sie verwenden möchten: | Variable | Standard | Beschreibung | |----------|----------|--------------| | `bulb1topic` | `ShellyBulbDuo-deviceid1` | MQTT Device ID der ersten DUO-Lampe | | `bulb2topic` | `ShellyBulbDuo-deviceid2` | MQTT Device ID der zweiten DUO-Lampe | | `bulb3topic` | `ShellyBulbDuo-deviceid3` | MQTT Device ID der dritten DUO-Lampe | | `bulb4topic` | `ShellyBulbDuo-deviceid4` | MQTT Device ID der vierten DUO-Lampe | | `bulb5topic` | `ShellyBulbDuo-deviceid5` | MQTT Device ID der fünften DUO-Lampe | Ersetzen Sie den Platzhalter durch die tatsächliche Device ID jeder Lampe, die Sie steuern möchten (z. B. `ShellyBulbDuo-B929CC`). Das Modul abonniert `shellies/#` und die Listener-Skripte pro Lampe filtern die Nachrichten nach Topic-Präfix. Slots, die noch auf dem Platzhalter stehen, werfen in TapHome einen Fehler, bis sie konfiguriert oder aus der Vorlage entfernt werden. ### Übergangszeit pro Lampe Jedes Light-Gerät besitzt eine `transitionTime`-Variable (in Millisekunden, Bereich 0-5000 ms), die standardmäßig dem Modul-Importparameter `TransitionTime` entspricht. Überschreiben Sie sie auf einzelnen Lampen, wenn Sie unterschiedliche Übergangszeiten möchten — der Wert wird bei jeder Helligkeits- oder CCT-Änderung als `transition`-Feld im JSON-Payload `/light/0/set` mitgesendet. > [!WARNING] > Das Aktivieren von MQTT auf einem Gen1 Shelly-Gerät **deaktiviert die Shelly Cloud** — beide können nicht gleichzeitig betrieben werden. HTTP REST und CoIoT bleiben verfügbar, sodass die Lampe weiterhin aus dem lokalen Netz erreichbar ist. ## Gerätefunktionen Die Vorlage stellt 10 Geräte pro Modul bereit — 5 Weißlichter mit einstellbarer Farbtemperatur und 5 Stromzähler, ein Paar pro physischer Lampe. Alle 5 Paare sind funktional identisch und unterscheiden sich nur durch die `bulbNtopic`, auf die sie hören. ### Lichtsteuerung Jedes Light-Gerät wird in TapHome als **White Light** mit zwei Steuerungseigenschaften eingebunden: - **Helligkeit** — gelesen aus dem Feld `$.brightness` (0-100) der JSON-Nachricht `light/0/status`, skaliert auf den TapHome-Bereich 0.0-1.0; geschrieben über `light/0/set` mit `"turn":"on", "brightness":N, "transition":` - **Farbtemperatur** — gelesen aus `$.temp` (3000-6500 K), geschrieben über `light/0/set` mit `"temp":K, "transition":` Das Ausschalten des Lichts nutzt einen separaten Topic `light/0/command` mit dem Payload `off`, was schneller ist als das Erstellen einer JSON-`set`-Nachricht. Helligkeits- und CCT-Updates enthalten immer das Feld `transition`, damit die Lampe weich überblendet statt zu springen. ### Leistungsmessung Jeder Stromzähler abonniert zwei skalare Topics, die die Lampe etwa einmal pro Sekunde veröffentlicht: | TapHome-Wert | Quell-Topic | Quell-Einheit | Umrechnung | Anzeige-Einheit | |--------------|-------------|---------------|------------|-----------------| | Aktuelle Leistung | `shellies/ShellyBulbDuo-/light/0/power` | W | `÷ 1000` | kW | | Gesamtverbrauch | `shellies/ShellyBulbDuo-/light/0/energy` | Wattminuten | `÷ 60000` | kWh | Die Umrechnung von Wattminuten in kWh ist nötig, weil die Shelly Gen1 Firmware die kumulative Energie in W·min statt in W·h meldet. > [!TIP] > Die Leistungsmessung liefert lautlos null, solange unter **Settings → Device Model** (E27 oder GU10) in der Shelly App oder im Web-UI nichts gewählt ist. Der TapHome-Listener zeigt beim ersten Lesen einen Hinweisbanner. Sobald das Modell gesetzt ist, meldet die Lampe sofort von null verschiedene `power`/`energy`-Werte. ## Fehlerbehebung ### Lampe reagiert nicht 1. Stellen Sie sicher, dass die Lampe mit dem WLAN verbunden und im LAN erreichbar ist — öffnen Sie `http:///shelly`. Eine Antwort mit `"type":"SHBDUO-1"` bestätigt das Gerät. 2. Versuchen Sie den mDNS-Hostnamen (`ShellyBulbDuo-.local`) statt der IP-Adresse — DHCP-Renewals oder Router-Neustarts können die IP ändern. 3. Stellen Sie sicher, dass MQTT in den **Internet & Security → Advanced — MQTT** Einstellungen der Lampe aktiv ist und dass IP/Port des Brokers mit den TapHome-Importparametern übereinstimmen. 4. Verwenden Sie einen MQTT-Client (z. B. **MQTT Explorer** oder `mosquitto_sub -h -t 'shellies/#' -v`), um zu prüfen, ob die Lampe auf `shellies/ShellyBulbDuo-/...` veröffentlicht. ### Fehler "Set correct 'bulbNtopic' value" Das Listener-Skript wirft diesen Fehler, wenn ein `bulbNtopic` noch auf dem Standard-Platzhalter (`ShellyBulbDuo-deviceid`) steht. Tragen Sie entweder die echte Device ID für den Slot ein oder entfernen Sie ungenutzte Geräte aus der Vorlage, wenn Sie nur wenige Lampen haben. ### Leistung und Energie bleiben bei null 1. Öffnen Sie die Shelly App (oder das Web-UI) → **Settings** → **Device Model** und wählen Sie das passende Sub-Modell (**Shelly Bulb DUO E27** oder **Shelly Bulb DUO GU10**). Die Lampe berechnet `power`/`energy` erst, sobald das Modell bekannt ist. 2. Stellen Sie sicher, dass die Lampe tatsächlich an ist — der Zähler aktualisiert sich nur, wenn Strom fließt. 3. Abonnieren Sie `shellies/ShellyBulbDuo-/light/0/power` direkt mit einem MQTT-Client und prüfen Sie, ob die Lampe einen von null verschiedenen Wert veröffentlicht. ### Wärmste CCT geht nur bis 3000 K herunter Die TapHome-XML klemmt die CCT auf **3000-6500 K**, um den vermarkteten E27-Bereich abzubilden. Die Hardware selbst unterstützt **2700-6500 K** beim GU10-Sub-Modell und über die rohe `/light/0/set`-API, sodass die wärmsten 300 K des GU10-Bereichs über die TapHome-Vorlage nicht erreichbar sind. ### Lichtübergänge wirken ruckartig Erhöhen Sie die `transitionTime`-Variable an der Lampe (oder den Modul-Standard `TransitionTime`). 300 ms reichen für kleine Dimm-Schritte, können bei großen Helligkeits- oder CCT-Sprüngen aber stufig wirken — versuchen Sie 800-1500 ms für einen weicheren Übergang. > [!WARNING] > Gen1 Shelly-Geräte verwenden **reines MQTT** auf Port 1883 — TLS wird nicht unterstützt. Die TapHome-Vorlage stellt zudem keine Broker-`username` / `password` bereit, nutzen Sie daher einen unauthentifizierten Broker in einem vertrauenswürdigen lokalen Netzwerk oder VLAN. ## 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 10 Diese Geräte erscheinen nach dem Import in TapHome. Shelly DUO MQTT Modul Benutzerdefinierte Variablen `bulb1topic` (string) = ShellyBulbDuo-deviceid1 MQTT Device ID der ersten Shelly DUO Lampe — Format ist 'ShellyBulbDuo-DEVICEID' Open http://shellyIpAddress in a browser → Settings → Device Info → copy the mqtt.id (or Device ID) field. Default mDNS hostname matches the MQTT id (ShellyBulbDuo-{MAC6}.local). `bulb2topic` (string) = ShellyBulbDuo-deviceid2 MQTT Device ID der zweiten Shelly DUO Lampe `bulb3topic` (string) = ShellyBulbDuo-deviceid3 MQTT Device ID der dritten Shelly DUO Lampe `bulb4topic` (string) = ShellyBulbDuo-deviceid4 MQTT Device ID der vierten Shelly DUO Lampe `bulb5topic` (string) = ShellyBulbDuo-deviceid5 MQTT Device ID der fünften Shelly DUO Lampe Stromzähler 1 Stromzähler Nur lesen Aktuelle Leistung (kW) und kumulative Energie (kWh) von Lampe 1 — erfordert das Setzen von Settings → Device Model in der Shelly App, sonst bleiben beide Werte 0 numeric Einheit: kW / kWh Listener ```taphome ADDINFO("To enable power monitoring, open device settings in Shelly app or web browser and configure device model in Settings->Device Model"); IF(INDEXOF(bulb1topic, "ShellyBulbDuo-deviceid") = 0) ADDERROR("Set correct 'bulb1topic' value in module variables. Topic format is 'ShellyBulbDuo-'. The Device ID can be found by opening url 'http://shellyIpAddress', in Settings -> Device info."); RETURN(-1); END IF INDEXOF(RECEIVEDMSG.TOPIC, "shellies/" + bulb1topic + "/light/0/power") = 0 Ed := TODOUBLE(TOSTRING(RECEIVEDMSG.PAYLOAD)) / 1000.0; ELSEIF INDEXOF(RECEIVEDMSG.TOPIC, "shellies/" + bulb1topic + "/light/0/energy") = 0 To := TODOUBLE(TOSTRING(RECEIVEDMSG.PAYLOAD)) / 60000.0; END ``` Licht 1 Weißlicht Lesen und Schreiben Lampe 1 mit einstellbarem Weiß — Ein/Aus, Helligkeit 0-100 % und Farbtemperatur 3000-6500 K mit weichen Übergängen json Einheit: % / K json\_path Variable: `transitionTime` — Übergangszeit pro Lampe in Millisekunden (0-5000 ms), übernommen vom Importparameter TransitionTime Listener ```taphome IF(INDEXOF(bulb1topic, "ShellyBulbDuo-deviceid") = 0) ADDERROR("Set correct 'bulb1topic' value in module variables. Topic format is 'ShellyBulbDuo-'. The Device ID can be found by opening url 'http://shellyIpAddress', in Settings -> Device info."); RETURN(-1); END IF INDEXOF(RECEIVEDMSG.TOPIC, "shellies/" + bulb1topic + "/light/0/status") != 0 RETURN(0); END IF RECEIVEDMSG.PAYLOAD.LENGTH = 0 RETURN(0); END VAR ison := PARSEJSON(RECEIVEDMSG.PAYLOAD, "$.ison", 1); VAR bright := PARSEJSON(RECEIVEDMSG.PAYLOAD, "$.brightness"); IF ISNULL(ison) OR ISNULL(bright) RETURN(0); END Ct := PARSEJSON(RECEIVEDMSG.PAYLOAD, "$.temp", 1); IF ison Hb := bright / 100.0; St := isOn; ELSE Hb := 0; St := 0; END ``` Helligkeit schreiben ```taphome IF St > 0.5 VAR topic := "shellies/" + bulb1topic + "/light/0/set"; MQTTPUBLISH(topic, "{\"turn\": \"on\", \"transition\": " + transitionTime + ", \"brightness\": " + ROUND(Hb*100.0) + "}"); ELSE MQTTPUBLISH("shellies/" + bulb1topic + "/light/0/command", "off"); END ``` Farbtemperatur schreiben ```taphome IF ISNAN(Ct) RETURN(0); END VAR topic := "shellies/" + bulb1topic + "/light/0/set"; MQTTPUBLISH(topic, "{\"transition\": " + transitionTime + ", \"temp\":" + Ct + "}"); ``` Stromzähler 2 Stromzähler Nur lesen Aktuelle Leistung (kW) und kumulative Energie (kWh) von Lampe 2 — erfordert das Setzen von Settings → Device Model in der Shelly App, sonst bleiben beide Werte 0 numeric Einheit: kW / kWh Listener ```taphome ADDINFO("To enable power monitoring, open device settings in Shelly app or web browser and configure device model in Settings->Device Model"); IF(INDEXOF(bulb2topic, "ShellyBulbDuo-deviceid") = 0) ADDERROR("Set correct 'bulb2topic' value in module variables. Topic format is 'ShellyBulbDuo-'. The Device ID can be found by opening url 'http://shellyIpAddress', in Settings -> Device info."); RETURN(-1); END IF INDEXOF(RECEIVEDMSG.TOPIC, "shellies/" + bulb2topic + "/light/0/power") = 0 Ed := TODOUBLE(TOSTRING(RECEIVEDMSG.PAYLOAD)) / 1000.0; ELSEIF INDEXOF(RECEIVEDMSG.TOPIC, "shellies/" + bulb2topic + "/light/0/energy") = 0 To := TODOUBLE(TOSTRING(RECEIVEDMSG.PAYLOAD)) / 60000.0; END ``` Licht 2 Weißlicht Lesen und Schreiben Lampe 2 mit einstellbarem Weiß — Ein/Aus, Helligkeit 0-100 % und Farbtemperatur 3000-6500 K mit weichen Übergängen json Einheit: % / K json\_path Variable: `transitionTime` — Übergangszeit pro Lampe in Millisekunden (0-5000 ms), übernommen vom Importparameter TransitionTime Listener ```taphome IF(INDEXOF(bulb2topic, "ShellyBulbDuo-deviceid") = 0) ADDERROR("Set correct 'bulb2topic' value in module variables. Topic format is 'ShellyBulbDuo-'. The Device ID can be found by opening url 'http://shellyIpAddress', in Settings -> Device info."); RETURN(-1); END IF INDEXOF(RECEIVEDMSG.TOPIC, "shellies/" + bulb2topic + "/light/0/status") != 0 RETURN(0); END IF RECEIVEDMSG.PAYLOAD.LENGTH = 0 RETURN(0); END VAR ison := PARSEJSON(RECEIVEDMSG.PAYLOAD, "$.ison", 1); VAR bright := PARSEJSON(RECEIVEDMSG.PAYLOAD, "$.brightness"); IF ISNULL(ison) OR ISNULL(bright) RETURN(0); END Ct := PARSEJSON(RECEIVEDMSG.PAYLOAD, "$.temp", 1); IF ison Hb := bright / 100.0; St := isOn; ELSE Hb := 0; St := 0; END ``` Helligkeit schreiben ```taphome IF St > 0.5 VAR topic := "shellies/" + bulb2topic + "/light/0/set"; MQTTPUBLISH(topic, "{\"turn\": \"on\", \"transition\": " + transitionTime + ", \"brightness\": " + ROUND(Hb*100.0) + "}"); ELSE MQTTPUBLISH("shellies/" + bulb2topic + "/light/0/command", "off"); END ``` Farbtemperatur schreiben ```taphome IF ISNAN(Ct) RETURN(0); END VAR topic := "shellies/" + bulb2topic + "/light/0/set"; MQTTPUBLISH(topic, "{\"transition\": " + transitionTime + ", \"temp\":" + Ct + "}"); ``` Stromzähler 3 Stromzähler Nur lesen Aktuelle Leistung (kW) und kumulative Energie (kWh) von Lampe 3 — erfordert das Setzen von Settings → Device Model in der Shelly App, sonst bleiben beide Werte 0 numeric Einheit: kW / kWh Listener ```taphome ADDINFO("To enable power monitoring, open device settings in Shelly app or web browser and configure device model in Settings->Device Model"); IF(INDEXOF(bulb3topic, "ShellyBulbDuo-deviceid") = 0) ADDERROR("Set correct 'bulb3topic' value in module variables. Topic format is 'ShellyBulbDuo-'. The Device ID can be found by opening url 'http://shellyIpAddress', in Settings -> Device info."); RETURN(-1); END IF INDEXOF(RECEIVEDMSG.TOPIC, "shellies/" + bulb3topic + "/light/0/power") = 0 Ed := TODOUBLE(TOSTRING(RECEIVEDMSG.PAYLOAD)) / 1000.0; ELSEIF INDEXOF(RECEIVEDMSG.TOPIC, "shellies/" + bulb3topic + "/light/0/energy") = 0 To := TODOUBLE(TOSTRING(RECEIVEDMSG.PAYLOAD)) / 60000.0; END ``` Licht 3 Weißlicht Lesen und Schreiben Lampe 3 mit einstellbarem Weiß — Ein/Aus, Helligkeit 0-100 % und Farbtemperatur 3000-6500 K mit weichen Übergängen json Einheit: % / K json\_path Variable: `transitionTime` — Übergangszeit pro Lampe in Millisekunden (0-5000 ms), übernommen vom Importparameter TransitionTime Listener ```taphome IF(INDEXOF(bulb3topic, "ShellyBulbDuo-deviceid") = 0) ADDERROR("Set correct 'bulb3topic' value in module variables. Topic format is 'ShellyBulbDuo-'. The Device ID can be found by opening url 'http://shellyIpAddress', in Settings -> Device info."); RETURN(-1); END IF INDEXOF(RECEIVEDMSG.TOPIC, "shellies/" + bulb3topic + "/light/0/status") != 0 RETURN(0); END IF RECEIVEDMSG.PAYLOAD.LENGTH = 0 RETURN(0); END VAR ison := PARSEJSON(RECEIVEDMSG.PAYLOAD, "$.ison", 1); VAR bright := PARSEJSON(RECEIVEDMSG.PAYLOAD, "$.brightness"); IF ISNULL(ison) OR ISNULL(bright) RETURN(0); END Ct := PARSEJSON(RECEIVEDMSG.PAYLOAD, "$.temp", 1); IF ison Hb := bright / 100.0; St := isOn; ELSE Hb := 0; St := 0; END ``` Helligkeit schreiben ```taphome IF St > 0.5 VAR topic := "shellies/" + bulb3topic + "/light/0/set"; MQTTPUBLISH(topic, "{\"turn\": \"on\", \"transition\": " + transitionTime + ", \"brightness\": " + ROUND(Hb*100.0) + "}"); ELSE MQTTPUBLISH("shellies/" + bulb3topic + "/light/0/command", "off"); END ``` Farbtemperatur schreiben ```taphome IF ISNAN(Ct) RETURN(0); END VAR topic := "shellies/" + bulb3topic + "/light/0/set"; MQTTPUBLISH(topic, "{\"transition\": " + transitionTime + ", \"temp\":" + Ct + "}"); ``` Stromzähler 4 Stromzähler Nur lesen Aktuelle Leistung (kW) und kumulative Energie (kWh) von Lampe 4 — erfordert das Setzen von Settings → Device Model in der Shelly App, sonst bleiben beide Werte 0 numeric Einheit: kW / kWh Listener ```taphome ADDINFO("To enable power monitoring, open device settings in Shelly app or web browser and configure device model in Settings->Device Model"); IF(INDEXOF(bulb4topic, "ShellyBulbDuo-deviceid") = 0) ADDERROR("Set correct 'bulb4topic' value in module variables. Topic format is 'ShellyBulbDuo-'. The Device ID can be found by opening url 'http://shellyIpAddress', in Settings -> Device info."); RETURN(-1); END IF INDEXOF(RECEIVEDMSG.TOPIC, "shellies/" + bulb4topic + "/light/0/power") = 0 Ed := TODOUBLE(TOSTRING(RECEIVEDMSG.PAYLOAD)) / 1000.0; ELSEIF INDEXOF(RECEIVEDMSG.TOPIC, "shellies/" + bulb4topic + "/light/0/energy") = 0 To := TODOUBLE(TOSTRING(RECEIVEDMSG.PAYLOAD)) / 60000.0; END ``` Licht 4 Weißlicht Lesen und Schreiben Lampe 4 mit einstellbarem Weiß — Ein/Aus, Helligkeit 0-100 % und Farbtemperatur 3000-6500 K mit weichen Übergängen json Einheit: % / K json\_path Variable: `transitionTime` — Übergangszeit pro Lampe in Millisekunden (0-5000 ms), übernommen vom Importparameter TransitionTime Listener ```taphome IF(INDEXOF(bulb4topic, "ShellyBulbDuo-deviceid") = 0) ADDERROR("Set correct 'bulb4topic' value in module variables. Topic format is 'ShellyBulbDuo-'. The Device ID can be found by opening url 'http://shellyIpAddress', in Settings -> Device info."); RETURN(-1); END IF INDEXOF(RECEIVEDMSG.TOPIC, "shellies/" + bulb4topic + "/light/0/status") != 0 RETURN(0); END IF RECEIVEDMSG.PAYLOAD.LENGTH = 0 RETURN(0); END VAR ison := PARSEJSON(RECEIVEDMSG.PAYLOAD, "$.ison", 1); VAR bright := PARSEJSON(RECEIVEDMSG.PAYLOAD, "$.brightness"); IF ISNULL(ison) OR ISNULL(bright) RETURN(0); END Ct := PARSEJSON(RECEIVEDMSG.PAYLOAD, "$.temp", 1); IF ison Hb := bright / 100.0; St := isOn; ELSE Hb := 0; St := 0; END ``` Helligkeit schreiben ```taphome IF St > 0.5 VAR topic := "shellies/" + bulb4topic + "/light/0/set"; MQTTPUBLISH(topic, "{\"turn\": \"on\", \"transition\": " + transitionTime + ", \"brightness\": " + ROUND(Hb*100.0) + "}"); ELSE MQTTPUBLISH("shellies/" + bulb4topic + "/light/0/command", "off"); END ``` Farbtemperatur schreiben ```taphome IF ISNAN(Ct) RETURN(0); END VAR topic := "shellies/" + bulb4topic + "/light/0/set"; MQTTPUBLISH(topic, "{\"transition\": " + transitionTime + ", \"temp\":" + Ct + "}"); ``` Stromzähler 5 Stromzähler Nur lesen Aktuelle Leistung (kW) und kumulative Energie (kWh) von Lampe 5 — erfordert das Setzen von Settings → Device Model in der Shelly App, sonst bleiben beide Werte 0 numeric Einheit: kW / kWh Listener ```taphome ADDINFO("To enable power monitoring, open device settings in Shelly app or web browser and configure device model in Settings->Device Model"); IF(INDEXOF(bulb5topic, "ShellyBulbDuo-deviceid") = 0) ADDERROR("Set correct 'bulb5topic' value in module variables. Topic format is 'ShellyBulbDuo-'. The Device ID can be found by opening url 'http://shellyIpAddress', in Settings -> Device info."); RETURN(-1); END IF INDEXOF(RECEIVEDMSG.TOPIC, "shellies/" + bulb5topic + "/light/0/power") = 0 Ed := TODOUBLE(TOSTRING(RECEIVEDMSG.PAYLOAD)) / 1000.0; ELSEIF INDEXOF(RECEIVEDMSG.TOPIC, "shellies/" + bulb5topic + "/light/0/energy") = 0 To := TODOUBLE(TOSTRING(RECEIVEDMSG.PAYLOAD)) / 60000.0; END ``` Licht 5 Weißlicht Lesen und Schreiben Lampe 5 mit einstellbarem Weiß — Ein/Aus, Helligkeit 0-100 % und Farbtemperatur 3000-6500 K mit weichen Übergängen json Einheit: % / K json\_path Variable: `transitionTime` — Übergangszeit pro Lampe in Millisekunden (0-5000 ms), übernommen vom Importparameter TransitionTime Listener ```taphome IF(INDEXOF(bulb5topic, "ShellyBulbDuo-deviceid") = 0) ADDERROR("Set correct 'bulb5topic' value in module variables. Topic format is 'ShellyBulbDuo-'. The Device ID can be found by opening url 'http://shellyIpAddress', in Settings -> Device info."); RETURN(-1); END IF INDEXOF(RECEIVEDMSG.TOPIC, "shellies/" + bulb5topic + "/light/0/status") != 0 RETURN(0); END IF RECEIVEDMSG.PAYLOAD.LENGTH = 0 RETURN(0); END VAR ison := PARSEJSON(RECEIVEDMSG.PAYLOAD, "$.ison", 1); VAR bright := PARSEJSON(RECEIVEDMSG.PAYLOAD, "$.brightness"); IF ISNULL(ison) OR ISNULL(bright) RETURN(0); END Ct := PARSEJSON(RECEIVEDMSG.PAYLOAD, "$.temp", 1); IF ison Hb := bright / 100.0; St := isOn; ELSE Hb := 0; St := 0; END ``` Helligkeit schreiben ```taphome IF St > 0.5 VAR topic := "shellies/" + bulb5topic + "/light/0/set"; MQTTPUBLISH(topic, "{\"turn\": \"on\", \"transition\": " + transitionTime + ", \"brightness\": " + ROUND(Hb*100.0) + "}"); ELSE MQTTPUBLISH("shellies/" + bulb5topic + "/light/0/command", "off"); END ``` Farbtemperatur schreiben ```taphome IF ISNAN(Ct) RETURN(0); END VAR topic := "shellies/" + bulb5topic + "/light/0/set"; MQTTPUBLISH(topic, "{\"transition\": " + transitionTime + ", \"temp\":" + Ct + "}"); ``` **Verbindung:** Packet Parser → MQTT • Hostname: `ShellyBulbDuo-{MAC}.local` Mögliche Verbesserungen (7) - Connection Status (LWT) — Last Will and Testament — true on connect, false on disconnect. Could detect offline bulbs. - Full Status JSON — Complete /status as JSON. Could expose wifi\_sta.rssi, has\_update, uptime, source of last command. - Device Announce — Emitted on boot/announce — payload {id, model, mac, ip, fw\_ver, new\_fw}. Useful for auto-discovery. - White channel (0-100 %) — Separate 'white' parameter (0-100) on the set JSON; template only writes brightness/temp. - Timer (auto on/off) — Auto-off timer in seconds via set JSON. Not surfaced as TapHome capability. - Warm-white below 3000 K — TapHome XML clamps MinColorTemperature to 3000 K; the bulb hardware can go down to 2700 K (GU10). E27 marketed range starts at 3000 K — clamp matches E27 spec but loses 300 K of GU10 range. - MQTT broker authentication — Shelly device side supports MQTT username/password, but TapHome import parameters do not expose them. Workaround: open broker without auth on a trusted segment. ## 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` | | Transition time (ms) | `300` | ## 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 DUO — MQTT Bulb API [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen1/#shelly-duo-mqtt) 2026-04-25 - Shelly DUO — Product Datasheet [shellystore.co.uk](https://shellystore.co.uk/wp-content/uploads/2021/05/Duo-specs.pdf) 2026-04-25 [PDF](https://taphome.com/compatibility/devices/shelly-duo-mqtt/manufacturer/duo-specs.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/)