--- title: "Shelly EM MQTT" description: "Contatore monofase Shelly EM collegato a TapHome tramite MQTT. Consumo energetico per canale (kWh), monitoraggio tensione e controllo relè contattore." url: "https://taphome.com/it/compatibility/shelly-em-mqtt/" language: it lastmod: 2026-10-08 generator: hugo ai: topics: ["mqtt","electric-meter","wifi","energy-metering","contactor-control","ct-clamp"] questions: ["Come integrare Shelly EM con TapHome tramite MQTT?","Cosa misura il template Shelly EM MQTT in TapHome?","Come trovare il Device ID dello Shelly EM per MQTT?","Posso controllare il relè contattore dello Shelly EM da TapHome tramite MQTT?","Perché il mio Shelly EM non invia dati energetici tramite MQTT?","Il template Shelly EM MQTT supporta letture di potenza istantanea?"] --- # Shelly EM MQTT Comunicazione: Packet Parser → MQTT - [Pagina prodotto Shelly EM](https://www.shelly.com/en/products/shop/shelly-em) > Indirizzo di rete > > Con il broker MQTT integrato in TapHome, inserisci `127.0.0.1` come indirizzo del broker in TapHome. Nel dispositivo inserisci l’indirizzo IP del TapHome Core e assegna al Core una prenotazione IP nel router. > > [Preparazione della rete](https://taphome.com/it/docs/setup/network-preparation/) ## Guida all'integrazione Lo Shelly EM è un contatore di energia monofase con due canali di misurazione indipendenti e un'uscita relè da 2A per il controllo del contattore. Ogni canale si collega a un trasformatore di corrente esterno (pinza CT) -- disponibile nelle varianti 50A e 120A -- consentendo il monitoraggio non invasivo di due circuiti separati contemporaneamente. Questo template si collega al dispositivo tramite un broker MQTT nella rete locale. Non è necessaria una connessione cloud. Il template espone tre dispositivi: due contatori elettrici (uno per canale CT) che tracciano il consumo energetico cumulativo e un interruttore per il relè contattore. ## Configurazione ### Device ID Lo Shelly EM utilizza un Device ID nel formato `shellyem-XXXXXX`, dove `XXXXXX` sono gli ultimi 6 caratteri dell'indirizzo MAC in formato esadecimale (es. `shellyem-B929CC`). Durante l'importazione del template, inserisci solo la parte esadecimale (es. `B929CC`) nel parametro **Device ID**. Il Device ID si trova: - Nell'interfaccia web Shelly: **Settings** > **Device Info** - Tramite API: `GET http:///settings` -- campo `mqtt.id` > [!TIP] > Questo dispositivo supporta la **scoperta mDNS**. Puoi usare l'hostname `shellyem-{MAC}.local` invece dell'indirizzo IP quando configuri il broker MQTT. Sostituisci `{MAC}` con la stessa parte esadecimale del Device ID (es. `shellyem-B929CC.local`). L'uso dell'hostname previene problemi di connettività quando l'indirizzo IP del dispositivo cambia. ### Configurazione MQTT Prima di importare il template, abilita MQTT sullo Shelly EM: 1. Apri l'interfaccia web Shelly su `http://` 2. Vai su **Internet & Security** > **Advanced — Developer Settings** 3. Spunta **Enable action execution via MQTT** 4. Nel campo **Server**, inserisci l'indirizzo del broker MQTT nel formato `broker-ip:1883` 5. Premi **SAVE** > [!WARNING] > Sui dispositivi Shelly Gen1, abilitare MQTT **disabilita Shelly Cloud**. Le due funzioni non possono funzionare contemporaneamente. ### Configurazione template Dopo l'importazione del template in TapHome: 1. Imposta **MQTT Broker IP** sull'indirizzo del tuo broker MQTT 2. Imposta **MQTT Broker Port** (predefinito `1883`) 3. Imposta **Device ID** sulla parte esadecimale del Device ID dello Shelly EM (es. `B929CC`) Il modulo si iscrive a `shellies/#` e gli script listener su ogni dispositivo filtrano i messaggi in base al Device ID configurato. ## Funzionalità del dispositivo ### Misurazione energetica (per canale) Ogni canale è esposto come dispositivo Contatore elettrico indipendente in TapHome. Lo script listener si iscrive a due topic MQTT per canale: | Topic | Unità | Descrizione | |-------|-------|-------------| | `emeter/{i}/energy` | watt-minuti | Energia cumulativa dall'ultimo riavvio -- divisa per 60 000 per convertire in kWh | | `emeter/{i}/total` | Wh | Energia totale consumata persistente -- sopravvive ai riavvii | Il template memorizza entrambi i valori: `Ed` (energia dal topic watt-minuti, convertita in kWh) e `To` (consumo totale in Wh dal topic persistente). > [!TIP] > Il topic `energy` si azzera al riavvio del dispositivo. Per il tracciamento persistente dell'energia, il template legge anche il topic `total` che sopravvive ai riavvii. Ogni canale espone anche un attributo di servizio **Tensione**, che legge la tensione di rete RMS dal topic MQTT `emeter/{i}/voltage`. > [!NOTE] > Gli script `readtotalconsumption` e `readdemand` sono boilerplate commentato del template -- tutti i dati energetici arrivano tramite il listener MQTT. Ciò significa che il template **non fornisce** letture di potenza istantanea (W). Vengono tracciati solo l'energia cumulativa (kWh) e il consumo totale (Wh). La potenza attiva istantanea è disponibile tramite il topic MQTT `emeter/{i}/power`, ma questo template non vi si iscrive. ### Relè contattore L'uscita relè è esposta come interruttore in TapHome. Il relè è dimensionato per **2A / 230 VAC** -- è progettato solo per il controllo del contattore, non per la commutazione diretta del carico. - **Lettura:** si iscrive a `shellies/shellyem-{id}/relay/0` -- payload `on` corrisponde a acceso, `off` a spento - **Scrittura:** pubblica `on` o `off` su `shellies/shellyem-{id}/relay/0/command` > [!WARNING] > Il relè è dimensionato per soli 2A. Per carichi superiori a questo limite, usa sempre un contattore esterno. Il collegamento diretto di carichi ad alta potenza danneggia il relè. ## Risoluzione dei problemi ### Nessun dato energetico 1. Verifica che MQTT sia abilitato nell'interfaccia web Shelly (Internet & Security > Advanced — Developer Settings) 2. Controlla che l'indirizzo e la porta del broker MQTT siano corretti sia nelle impostazioni del dispositivo Shelly che del modulo TapHome 3. Verifica che la variabile personalizzata **Device ID** corrisponda esattamente al Device ID dello Shelly (es. `B929CC`) 4. Usando un client MQTT (es. MQTT Explorer), iscriviti a `shellies/#` e verifica che il dispositivo pubblichi i topic `emeter/0/energy` e `emeter/1/energy` ### Dati da un solo canale 1. Verifica che la pinza CT sia collegata al jack da 3,5 mm corretto (canale 0 o canale 1) 2. Controlla che corrente scorra nel conduttore monitorato -- la pinza CT deve circondare un singolo conduttore, non l'intero cavo 3. Iscriviti separatamente ai topic `shellies/shellyem-{id}/emeter/0/#` e `shellies/shellyem-{id}/emeter/1/#` e verifica che entrambi i canali pubblichino dati ### Il relè non risponde 1. Controlla che lo Shelly EM sia alimentato e connesso al broker MQTT 2. Pubblica manualmente `on` o `off` su `shellies/shellyem-{id}/relay/0/command` tramite un client MQTT per testare il funzionamento del relè indipendentemente da TapHome 3. Verifica il cablaggio corretto dell'uscita relè (controlla le etichette dei morsetti sul dispositivo) > [!WARNING] > I dispositivi Shelly Gen1 **non supportano** MQTT su TLS. La comunicazione tra il dispositivo e il broker MQTT non è crittografata (plain MQTT, porta 1883). Assicurati che il broker MQTT sia su una rete locale affidabile. ## Come installare in TapHome ### Prerequisiti - Dispositivo Shelly connesso al Wi-Fi (2,4 GHz), ad es. tramite l'app Shelly o l'access point del dispositivo stesso - Broker MQTT attivo sulla rete locale (es. Mosquitto, Home Assistant o il broker integrato di TapHome) - TapHome CCU sulla stessa rete del broker > [!WARNING] > Sui dispositivi **Gen1**, l'attivazione di MQTT **disabilita Shelly Cloud**. Entrambi non possono funzionare contemporaneamente. Sui dispositivi Gen2/Plus questa limitazione non si applica. ### Passaggio 1 — Abilitare MQTT sul dispositivo Shelly #### Dispositivi Gen1 (Shelly 1, 1PM, 2.5, EM, 3EM, Plug S, RGBW2, Dimmer, TRV…) 1. Apri l'interfaccia web Shelly: `http:///` 2. Vai su **Internet & Security** → **Advanced — MQTT** 3. Abilita **MQTT** 4. Imposta **MQTT Server**: `:` (es. `192.168.1.10:1883`) 5. Opzionalmente imposta **MQTT User** e **MQTT Password** se il broker richiede l'autenticazione 6. Clicca su **Save** — il dispositivo si riavvierà e si connetterà al broker #### Dispositivi Gen2 / Plus (Shelly Plus 1, Plus 1PM, Plus 2PM, Plus Plug S, Plus H&T, Pro 3EM…) 1. Apri l'interfaccia web Shelly: `http:///` 2. Vai su **Settings** → **MQTT** 3. Abilita **MQTT** 4. Imposta **Server**: `:` (es. `192.168.1.10:1883`) 5. Il **Client ID** è precompilato con l'ID del dispositivo (es. `shellyplus1pm-AABBCCDDEE`) — lascialo così a meno che tu non abbia un motivo specifico per cambiarlo 6. Clicca su **Save** e riavvia il dispositivo Con il broker integrato di TapHome, `` è l'indirizzo IP del TapHome Core. Assegna al Core una prenotazione IP nel router, altrimenti il dispositivo perde il broker quando il router cambia l'indirizzo → [Preparazione della rete](https://taphome.com/it/docs/setup/network-preparation/). > [!TIP] > Per verificare che MQTT funzioni, usa un client MQTT (es. MQTT Explorer) e sottoscrivi `shellies/#` (Gen1) o `/#` (Gen2). Dovresti vedere i messaggi di stato dal dispositivo. ### Passaggio 2 — Trovare il Device ID / MQTT Client ID Alcuni template richiedono un parametro **Device ID** o **MQTT Client ID**. Questo è l'identificatore univoco utilizzato nei topic MQTT. - **Gen1:** si trova sull'etichetta come indirizzo MAC (es. `AABBCCDDEE`). Device ID = `shelly-`, es. `shelly1pm-AABBCCDDEE` - **Gen2/Plus:** si trova nell'interfaccia web Shelly sotto **Settings** → **Device Info** → **Device ID**, oppure sull'etichetta del dispositivo ### Passaggio 3 — Configurazione in TapHome 1. In TapHome, aggiungi un nuovo modulo **Packet Parser (MQTT)** 2. **IP Address:** `127.0.0.1` per il broker integrato di TapHome (l'unità di controllo si connette a sé stessa, l'indirizzo non cambia mai); per un broker esterno il suo indirizzo IP (es. `192.168.1.10`) 3. **Port:** `1883` (predefinito; usa `8883` per TLS) 4. **Device ID / MQTT Client ID:** inserisci il valore dal passaggio 2 (se richiesto dal template) 5. Importa il template — TapHome si sottoscriverà automaticamente ai topic del dispositivo ## Dispositivi disponibili 3 Questi dispositivi compaiono in TapHome dopo l'importazione. Shelly EM MQTT Modulo Variabili personalizzate `deviceID` (string) Device ID MQTT dello Shelly EM — formato 'shellyem-DEVICEID' dove DEVICEID sono gli ultimi 6 caratteri esadecimali dell'indirizzo MAC (es. B929CC) Open http://shellyIpAddress → Settings → Device Info → copy Device ID Contatore elettrico - Canale 1 Contatore elettrico Solo lettura Consumo energetico sulla pinza CT canale 1 -- energia cumulativa (kWh) e consumo totale (Wh) numeric Unità: kWh Attributi di servizio | | | |----------|-----------------------------------------------------------------| | Tensione | Tensione RMS sul canale 1 letta dal topic MQTT emeter/0/voltage | Lettura consumo totale ```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"); ``` Lettura domanda ```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 VAR whatEd := "shellies/shellyem-"+deviceID+"/emeter/0/energy"; VAR whatTo := "shellies/shellyem-"+deviceID+"/emeter/0/total"; IF (whatEd = RECEIVEDMSG.TOPIC) Ed := todouble(TOSTRING(RECEIVEDMSG.PAYLOAD))/60000; END IF (whatTo = RECEIVEDMSG.TOPIC) To := todouble(TOSTRING(RECEIVEDMSG.PAYLOAD)); END ``` Attributi di servizio Voltage \[V] ```taphome if parsejson(response, "Topic") = "shellies/shellyem-"+deviceID+"/emeter/0/voltage" return(todouble(parsejson(response, "Payload"))); end ``` Contatore elettrico - Canale 2 Contatore elettrico Solo lettura Consumo energetico sulla pinza CT canale 2 -- energia cumulativa (kWh) e consumo totale (Wh) numeric Unità: kWh Attributi di servizio | | | |----------|-----------------------------------------------------------------| | Tensione | Tensione RMS sul canale 2 letta dal topic MQTT emeter/1/voltage | Lettura consumo totale ```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"); ``` Lettura domanda ```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 VAR whatEd := "shellies/shellyem-"+deviceID+"/emeter/1/energy"; VAR whatTo := "shellies/shellyem-"+deviceID+"/emeter/1/total"; IF (whatEd = RECEIVEDMSG.TOPIC) Ed := todouble(TOSTRING(RECEIVEDMSG.PAYLOAD))/60000; END IF (whatTo = RECEIVEDMSG.TOPIC) To := todouble(TOSTRING(RECEIVEDMSG.PAYLOAD)); END ``` Attributi di servizio voltage \[V] ```taphome if parsejson(response, "Topic") = "shellies/shellyem-"+deviceID+"/emeter/1/voltage" return(parsejson(response, "Payload")); end ``` Relè contattore Interruttore Lettura e scrittura Uscita relè 2A per controllo contattore -- legge lo stato relay/0 e pubblica comandi on/off boolean Valori / Stati: ON · OFF Lettura stato interruttore ```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"); ``` Scrittura stato interruttore ```taphome MQTTPUBLISH("shellies/shellyem-" + deviceID + "/relay/0/command",if(St = 1, "on","off")); # Simple HTTP Request: # 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 VAR whatSt := "shellies/shellyem-"+deviceID+"/relay/0"; IF (whatSt = RECEIVEDMSG.TOPIC) IF (TOSTRING(RECEIVEDMSG.PAYLOAD) = "on") St := 1; ELSE St := 0; END END ``` **Connessione:** Packet Parser → MQTT • Hostname: `shellyem-{MAC}.local` Possibili miglioramenti (5) - Active Power — Instantaneous active power in W per channel. Available via MQTT but template listener scripts do not subscribe to it — readdemand is commented-out boilerplate. - Reactive Power — Instantaneous reactive power in VAR per channel. Available via MQTT topic. - Total Energy Returned — Total energy returned to grid in Wh per channel. Useful for solar/bidirectional setups. - Connection Status — LWT topic — true on connect, false on disconnect. Could detect device offline state. - Reset Energy Data — Payload 'reset\_data' resets all accumulated energy counters on both channels. ## Parametri di importazione Inserisci questi valori quando importi l'XML. | Richiesto nell'app | Predefinito | |--------------------------|------------------------------| | Mqtt Broker Indirizzo IP | `192.168.0.1` | | Mqtt Broker port | `1883` | | Device ID | Da inserire all'importazione | ## Fonti - 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 EM — API Endpoints & MQTT Topics [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen1/#shelly-em) 2026-03-29 - Shelly EM — Product Specifications [robomaterial.com](https://robomaterial.com/product/shelly-em-single-phase-energy-meter-with-contactor-control/) 2026-03-29 ## Documentazione correlata - [MQTT Integration](https://taphome.com/it/compatibility/mqtt-guide/) - [Packet Parser (HTTP, TCP, UDP, FTP, MQTT)](https://taphome.com/it/docs/integration/packet-parser/) - [Funzioni Packet parser](https://taphome.com/it/docs/script/packet-parser/) - [Funzioni di parsing](https://taphome.com/it/docs/script/parsing-functions/) - [Broker MQTT](https://taphome.com/it/docs/integration/packet-parser/mqtt-broker/) - [Script listener](https://taphome.com/it/docs/script/listener-scripts/)