---
title: "Shelly 3EM MQTT"
description: "Putere activă, tensiune, curent, factor de putere și energie bidirecțională pe fază, plus comanda contactorului prin MQTT. Șablon TapHome: Shelly 3EM Gen1."
url: "https://taphome.com/ro/compatibility/shelly-3em-gen1-mqtt/"
language: ro
lastmod: 2026-04-25
generator: hugo
ai:
  topics: ["mqtt","electric-meter","3-phase","wifi","energy-metering","bidirectional-metering","mdns"]
  questions: ["Cum integrez Shelly 3EM cu TapHome prin MQTT?","Ce măsoară pe fiecare fază șablonul TapHome Shelly 3EM MQTT?","Cum găsesc Device ID-ul Shelly 3EM pentru șablonul MQTT?","De ce prefixul de topic MQTT al Shelly 3EM este shellyem3- și nu shelly3em-?","Acceptă șablonul Shelly 3EM MQTT contorizarea bidirecțională pentru instalații solare?","Cum resetez din TapHome contoarele electrice ale fiecărei faze pe Shelly 3EM?"]
---

# Shelly 3EM MQTT

Comunicație: Packet Parser → MQTT

- [Pagina produsului Shelly 3EM](https://www.shelly.com/en/products/shop/shelly-3em)

> Adresa în rețea
> 
> Pentru brokerul MQTT integrat în TapHome este vorba de un singur broker, accesat din două locuri. Șablonul rulează direct în TapHome Core, de aceea în TapHome adresa brokerului este `127.0.0.1` (acest calculator). Dispozitivul rulează în altă parte a rețelei, de aceea în dispozitiv introduceți adresa IP a unității TapHome Core și atribuiți unității Core o rezervare IP în router — dacă adresa Core se schimbă, dispozitivul nu mai ajunge la broker.
> 
> [Pregătirea rețelei](https://taphome.com/ro/docs/setup/network-preparation/)

## Ghid de integrare

Shelly 3EM este un contor electric trifazat Wi-Fi din prima generație Shelly (Gen1). Măsoară independent, pe fiecare dintre cele trei faze, puterea activă, tensiunea, curentul, factorul de putere și energia cumulată totală, cu ajutorul celor trei clești CT cu miez divizat de 120 A incluși, și are un releu integrat de 10 A, folosit de obicei pentru acționarea bobinei unui contactor de putere extern. TapHome comunică cu dispozitivul prin MQTT — dispozitivul trimite măsurătorile fiecărei faze către un broker, iar modulul TapHome PacketParser se abonează la arborele de topicuri `shellies/#` și direcționează valorile către patru dispozitive subordonate (3 contoare electrice + 1 întrerupător pentru contactor).

Aceasta este **varianta MQTT** a șablonului Shelly 3EM. Este disponibilă și o variantă HTTP — alegeți MQTT atunci când folosiți deja un broker MQTT local, doriți actualizări trimise de dispozitiv în locul interogării periodice sau trebuie să partajați contorul cu mai mulți consumatori de date (TapHome plus un alt sistem). Rețineți că activarea MQTT în firmware-ul Gen1 **dezactivează Shelly Cloud** — cele două nu pot funcționa simultan.

## Configurare

### Activarea MQTT în Shelly 3EM

Deschideți interfața web Shelly 3EM (`http://{device-ip}` sau `http://shelly3em-{MAC}.local`) și configurați clientul MQTT:

1. Accesați **Internet & Security** → **Advanced - Developer Settings**
2. Bifați **Enable action execution via MQTT**
3. Completați **Server** cu `{MQTT broker IP address}:{port}` — de obicei `192.168.1.10:1883`
4. (Opțional) Setați **Username** și **Password** dacă brokerul necesită autentificare
5. Faceți clic pe **SAVE** — dispozitivul repornește și se conectează la broker

> [!WARNING]
> Dispozitivele Shelly Gen1 **nu** acceptă MQTT prin TLS. Comunicația dintre dispozitiv și broker se face necriptat, prin TCP simplu pe portul 1883. Numele de utilizator și parola se transmit în text simplu. Folosiți brokerul MQTT doar într-o rețea locală de încredere.

> [!NOTE]
> Activarea MQTT **dezactivează automat Shelly Cloud** în firmware-ul Gen1. Pentru a reveni, debifați opțiunea MQTT și reactivați Cloud în Internet & Security.

### Găsirea Device ID-ului

Șablonul TapHome se abonează la `shellies/shellyem3-{dID}/#`, unde `{dID}` este sufixul MAC al dispozitivului, folosit ca prefix de topic MQTT.

Pentru a-l găsi în interfața web Shelly 3EM:

1. Deschideți interfața web a dispozitivului în browser
2. Accesați **Settings** → **Device Info**
3. Copiați **primul șir Device ID** (NU valoarea din paranteze) — acesta este identic cu adresa MAC Wi-Fi (de ex. `DC4F227649A1`)

Alternativ, interogați `GET http://{device-ip}/settings` și citiți câmpul `mqtt.id`.

### Configurarea șablonului

După importul șablonului în TapHome, setați trei parametri de import:

| Parametru | Descriere | Exemplu |
|-----------|-----------|---------|
| **IpAddress** | Adresa IP a brokerului MQTT | `192.168.1.10` |
| **Port** | Portul brokerului MQTT | `1883` |
| **dID** | Device ID (sufixul MAC) al Shelly 3EM | `DC4F227649A1` |

Modulul se abonează apoi la `shellies/#` (QoS 0), iar scripturile de ascultare direcționează mesajele emeter ale fiecărei faze și mesajele releului către dispozitivele subordonate corespunzătoare. Perioada implicită de actualizare MQTT a dispozitivului este de 30 de secunde — o puteți reduce prin `GET http://{device-ip}/settings?mqtt_update_period=N` (setați `0` pentru publicare doar la schimbarea valorii).

> [!NOTE]
> Prefixul de topic MQTT folosit efectiv este `shellyem3-{MAC}`, în timp ce numele de gazdă mDNS al dispozitivului este `shelly3em-{MAC}.local` — Shelly folosește două forme diferite pentru același dispozitiv. Șablonul urmează prefixul de topic MQTT real (`shellyem3-`). Dacă mesajele MQTT nu sosesc, abonați-vă la `shellies/#` cu un client MQTT pentru a verifica prefixul folosit de firmware.

## Funcțiile dispozitivului

### Puterea activă și energia totală pe fiecare fază

Șablonul creează trei dispozitive de tip contor electric — câte unul pentru fiecare fază (cleștele CT 1 → faza A, cleștele 2 → faza B, cleștele 3 → faza C). Fiecare contor citește două valori:

- **Putere activă** — puterea instantanee din `shellies/shellyem3-{dID}/emeter/{i}/power` (W), împărțită la 1000 și memorată în kW
- **Energie totală consumată** — energia cumulată totală din `.../emeter/{i}/total` (Wh), împărțită la 1000 și memorată în kWh

Fiecare clește CT are un curent nominal de **120 A** și este neinvaziv (se prinde pe conductor, fără tăierea acestuia). Cei 3 clești CT incluși sunt marcați și calibrați individual — NU sunt interschimbabili între canale.

### Parametrii electrici pe fiecare fază

Fiecare contor electric oferă patru atribute de service pentru monitorizarea avansată:

- **Tensiune** — tensiunea RMS fază-neutru pe faza respectivă, în V (`.../emeter/{i}/voltage`)
- **Curent** — curentul RMS măsurat de cleștele CT corespunzător, în A (`.../emeter/{i}/current`)
- **Factor de putere** — raportul dintre puterea activă și cea aparentă, cu valori între −1,00 și 1,00 (`.../emeter/{i}/pf`)
- **Energie returnată** — energia cumulată totală returnată **în** rețea pe faza respectivă, în Wh (`.../emeter/{i}/total_returned`), utilă pentru instalațiile fotovoltaice / contorizarea bidirecțională

Combinația dintre `total` (energie consumată) și `total_returned` (energie exportată) pe fiecare fază face ca șablonul să fie potrivit pentru instalațiile solare / cu injecție în rețea.

### Resetarea contoarelor electrice

Fiecare fază are acțiunea de service **Resetare total**, care publică `reset_totals` pe `shellies/shellyem3-{dID}/emeter/{i}/command`. Aceasta aduce la zero ambele contoare, `total` și `total_returned`, ale fazei respective — util la reutilizarea contorului sau la începutul unei noi perioade de măsurare.

### Releul pentru contactor

Releul integrat de 10 A este disponibil ca dispozitiv de tip întrerupător. Starea se citește din `shellies/shellyem3-{dID}/relay/0` (`on` → 1, orice altă valoare → 0), iar releul se comandă prin publicarea `on` sau `off` pe `.../relay/0/command`. Releul are valorile nominale 10 A / 240 V AC și se conectează de obicei prin bornele `I` (intrare fază) și `O` (ieșire releu) pentru a acționa bobina unui contactor de putere extern la comutarea sarcinilor mai mari.

> [!TIP]
> Șablonul MQTT nu publică suma puterii pe cele 3 faze (`total_power` este disponibil la Gen1 doar prin HTTP). Dacă aveți nevoie de o singură valoare pentru puterea întregii locuințe, creați în TapHome un dispozitiv virtual care adună cele trei valori de putere pe fază.

## Rezolvarea problemelor

### Nu se primesc mesaje MQTT

1. Verificați dacă MQTT este activat în interfața web Shelly (**Internet & Security** → **Advanced - Developer Settings** → **Enable action execution via MQTT**) și dacă dispozitivul a repornit după salvare
2. Verificați dacă adresa IP și portul brokerului setate în dispozitiv corespund parametrilor de import `IpAddress`/`Port` din TapHome
3. Abonați-vă la `shellies/#` cu un client MQTT (de ex. MQTT Explorer, `mosquitto_sub`) și verificați dacă dispozitivul publică ceva — verificați dacă prefixul de topic real (`shellyem3-{dID}`) corespunde valorii `dID` introduse în TapHome
4. Asigurați-vă că brokerul MQTT funcționează și este accesibil atât din Shelly 3EM, cât și din TapHome Core
5. Dacă adresa IP a dispozitivului s-a schimbat recent, încercați să vă conectați la numele de gazdă mDNS `shelly3em-{MAC}.local` pentru a verifica dacă dispozitivul este accesibil în rețea

### Valorile energiei sunt zero sau neplauzibile

1. Verificați dacă fiecare clește CT este conectat la intrarea **corectă** — cleștele marcat `IA` trebuie conectat la bornele `IA-/IA+`, `IB` la `IB-/IB+`, `IC` la `IC-/IC+`. Cleștii sunt calibrați pentru fiecare canal și nu sunt interschimbabili.
2. Verificați dacă **săgeata de pe corpul cleștelui CT** indică sensul curentului (de la sursă spre sarcină). Un clește montat invers produce un factor de putere negativ și inversează clasificarea consum / energie returnată.
3. Verificați dacă intrările de tensiune `VA`, `VB`, `VC` sunt conectate la aceleași faze pe care le măsoară cleștii CT — o asociere greșită tensiune / curent produce valori greșite ale puterii și ale factorului de putere.
4. Dacă o singură fază indică zero, iar celelalte sunt corecte, înlocuiți cleștele CT al acelei faze cu unul despre care știți că funcționează, pentru a stabili dacă problema este la clește sau la circuit.

### MQTT nu poate fi activat — Cloud este în uz

În firmware-ul Gen1, MQTT și Shelly Cloud se exclud reciproc. Dacă caseta **Enable action execution via MQTT** este inactivă (gri), dezactivați mai întâi Shelly Cloud în **Internet & Security** → **Cloud**, apoi redeschideți setările MQTT.

### Istoricul Shelly Cloud a dispărut după activarea MQTT

Este un comportament normal — activarea MQTT dezactivează Cloud, inclusiv păstrarea istoricului pe 365 de zile. Dacă aveți nevoie atât de comanda MQTT în timp real în TapHome, cât și de un istoric pe termen lung, direcționați mesajele MQTT prin propriul broker și păstrați datele istorice în TapHome (sau într-un sistem separat de înregistrare).

> [!WARNING]
> Fiecare clește CT trebuie conectat întotdeauna la bornele Shelly 3EM **înainte** de a-l prinde în jurul unui conductor sub tensiune. Tensiunea indusă în înfășurarea secundară deschisă a unui transformator CT poate atinge niveluri periculoase și poate deteriora cleștele.

## Cum se instalează în TapHome

### Cerințe preliminare

- Dispozitiv Shelly conectat la Wi-Fi (2,4 GHz), de ex. prin aplicația Shelly sau prin punctul de acces propriu al dispozitivului
- Broker MQTT care rulează în rețeaua dvs. locală (de ex. Mosquitto, Home Assistant sau brokerul integrat TapHome)
- TapHome CCU în aceeași rețea cu brokerul

> [!WARNING]
> La dispozitivele **Gen1**, activarea MQTT **dezactivează Shelly Cloud**. Cele două nu pot funcționa simultan. La dispozitivele Gen2/Plus această limitare nu se aplică.

### Pasul 1 — Activați MQTT pe dispozitivul Shelly

#### Dispozitive Gen1 (Shelly 1, 1PM, 2.5, EM, 3EM, Plug S, RGBW2, Dimmer, TRV…)

1. Deschideți interfața web Shelly: `http://<device-ip>/`
2. Accesați **Internet & Security** → **Advanced — MQTT**
3. Activați **MQTT**
4. Setați **MQTT Server**: `<broker-ip>:<port>` (de ex. `192.168.1.10:1883`)
5. Opțional, setați **MQTT User** și **MQTT Password**, dacă brokerul dvs. necesită autentificare
6. Faceți clic pe **Save** — dispozitivul repornește și se conectează la broker

#### Dispozitive Gen2 / Plus (Shelly Plus 1, Plus 1PM, Plus 2PM, Plus Plug S, Plus H&T, Pro 3EM…)

1. Deschideți interfața web Shelly: `http://<device-ip>/`
2. Accesați **Settings** → **MQTT**
3. Activați **MQTT**
4. Setați **Server**: `<broker-ip>:<port>` (de ex. `192.168.1.10:1883`)
5. Câmpul **Client ID** este precompletat cu ID-ul dispozitivului (de ex. `shellyplus1pm-AABBCCDDEE`) — lăsați-l neschimbat, dacă nu aveți un motiv anume să îl modificați
6. Faceți clic pe **Save** și reporniți dispozitivul

La brokerul integrat TapHome, `<broker-ip>` este adresa IP a unității TapHome Core. Atribuiți unității Core o rezervare IP în router; altfel dispozitivul pierde brokerul atunci când routerul schimbă adresa → [Pregătirea rețelei](https://taphome.com/ro/docs/setup/network-preparation/).

> [!TIP]
> Pentru a verifica funcționarea MQTT, folosiți un client MQTT (de ex. MQTT Explorer) și abonați-vă la `shellies/#` (Gen1) sau `<device-id>/#` (Gen2). Ar trebui să vedeți mesajele de stare trimise de dispozitiv.

### Pasul 2 — Aflați Device ID / MQTT Client ID

Unele șabloane necesită parametrul **Device ID** sau **MQTT Client ID**. Acesta este identificatorul unic folosit în topicurile MQTT.

- **Gen1:** se găsește pe etichetă, ca adresă MAC (de ex. `AABBCCDDEE`). Device ID = `shelly<model>-<mac>`, de ex. `shelly1pm-AABBCCDDEE`
- **Gen2/Plus:** se găsește în interfața web Shelly, la **Settings** → **Device Info** → **Device ID**, sau pe eticheta dispozitivului

### Pasul 3 — Configurați dispozitivul în TapHome

1. În TapHome adăugați un nou modul **Packet Parser (MQTT)**
2. **IP Address:** pentru brokerul integrat TapHome `127.0.0.1` (unitatea de control se conectează la ea însăși, adresa nu se schimbă niciodată); pentru un broker extern, adresa sa IP (de ex. `192.168.1.10`)
3. **Port:** `1883` (implicit; pentru TLS folosiți `8883`)
4. **Device ID / MQTT Client ID:** introduceți valoarea de la pasul 2 (dacă șablonul o necesită)
5. Importați șablonul — TapHome se abonează automat la topicurile dispozitivului

## Dispozitive disponibile 4

Aceste dispozitive apar în TapHome după import.

Shelly 3EM MQTT Modul

Variabile personalizate

`dID` (string) Sufixul MAC al Shelly 3EM care formează prefixul de topic MQTT shellies/shellyem3-{dID}/... — se găsește în interfața web Shelly → Settings → Device Info (primul șir, NU valoarea din paranteze)

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)

Contor electric (faza 1) Contor electric Doar citire

Putere activă (kW) și energie cumulată totală (kWh) pe faza A — citite de la cleștele CT 1, cu conversie W→kW și Wh→kWh

numeric Unitate: kW / kWh

Atribute de service

|                   |                                                                                                                                  |
|-------------------|----------------------------------------------------------------------------------------------------------------------------------|
| Energie returnată | Energia cumulată totală returnată în rețea pe faza A (Wh) — utilă pentru instalațiile fotovoltaice / contorizarea bidirecțională |
| Tensiune          | Tensiunea RMS fază-neutru pe faza A (V)                                                                                          |
| Curent            | Curentul RMS măsurat de cleștele CT 1 (A)                                                                                        |
| Factor de putere  | Factorul de putere pe faza A — raportul dintre puterea activă și cea aparentă, valori între −1,00 și 1,00                        |

Acțiuni de service

|                |                                                                                      |
|----------------|--------------------------------------------------------------------------------------|
| Resetare total | Resetează la zero ambele contoare electrice, total și total\_returned, pentru faza A |

Citirea consumului total

```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");
```

Citirea cererii

```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");
```

Ascultător

```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
```

Atribute de service

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
```

Acțiuni de service

Reset total

```taphome
mqttpublish("shellies/shellyem3-"+dID+"/emeter/0/command", "reset_totals");
```

Contor electric (faza 2) Contor electric Doar citire

Putere activă (kW) și energie cumulată totală (kWh) pe faza B — citite de la cleștele CT 2, cu conversie W→kW și Wh→kWh

numeric Unitate: kW / kWh

Atribute de service

|                   |                                                                                                                                  |
|-------------------|----------------------------------------------------------------------------------------------------------------------------------|
| Energie returnată | Energia cumulată totală returnată în rețea pe faza B (Wh) — utilă pentru instalațiile fotovoltaice / contorizarea bidirecțională |
| Tensiune          | Tensiunea RMS fază-neutru pe faza B (V)                                                                                          |
| Curent            | Curentul RMS măsurat de cleștele CT 2 (A)                                                                                        |
| Factor de putere  | Factorul de putere pe faza B — raportul dintre puterea activă și cea aparentă, valori între −1,00 și 1,00                        |

Acțiuni de service

|                |                                                                                      |
|----------------|--------------------------------------------------------------------------------------|
| Resetare total | Resetează la zero ambele contoare electrice, total și total\_returned, pentru faza B |

Citirea consumului total

```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");
```

Citirea cererii

```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");
```

Ascultător

```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
```

Atribute de service

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
```

Acțiuni de service

Reset total

```taphome
mqttpublish("shellies/shellyem3-"+dID+"/emeter/1/command", "reset_totals");
```

Contor electric (faza 3) Contor electric Doar citire

Putere activă (kW) și energie cumulată totală (kWh) pe faza C — citite de la cleștele CT 3, cu conversie W→kW și Wh→kWh

numeric Unitate: kW / kWh

Atribute de service

|                   |                                                                                                                                  |
|-------------------|----------------------------------------------------------------------------------------------------------------------------------|
| Energie returnată | Energia cumulată totală returnată în rețea pe faza C (Wh) — utilă pentru instalațiile fotovoltaice / contorizarea bidirecțională |
| Tensiune          | Tensiunea RMS fază-neutru pe faza C (V)                                                                                          |
| Curent            | Curentul RMS măsurat de cleștele CT 3 (A)                                                                                        |
| Factor de putere  | Factorul de putere pe faza C — raportul dintre puterea activă și cea aparentă, valori între −1,00 și 1,00                        |

Acțiuni de service

|                |                                                                                      |
|----------------|--------------------------------------------------------------------------------------|
| Resetare total | Resetează la zero ambele contoare electrice, total și total\_returned, pentru faza C |

Citirea consumului total

```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");
```

Citirea cererii

```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");
```

Ascultător

```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
```

Atribute de service

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
```

Acțiuni de service

reset total

```taphome
mqttpublish("shellies/shellyem3-"+dID+"/emeter/2/command", "reset_totals");
```

Releu pentru contactor Comutator Citire și scriere

Releu integrat de 10 A — conectat de obicei prin bornele I/O pentru a acționa bobina unui contactor de putere extern

boolean

Valori / Stări: ON · OFF

Citirea stării comutatorului

```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");
```

Scrierea stării comutatorului

```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
```

Ascultător

```taphome
# Parse received bytes:
IF(RECEIVEDMSG.TOPIC = "shellies/shellyem3-"+dID+"/relay/0")
 St := switch(TOSTRING(RECEIVEDMSG.PAYLOAD),"on",1,0);
END
```

**Conexiune:** Packet Parser → MQTT • Nume gazdă: `shelly3em-{MAC}.local`

Îmbunătățiri posibile (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.

## Parametri de import

Introduceți aceste valori când importați XML-ul.

| Solicitat în aplicație | Implicit               |
|------------------------|------------------------|
| Mqtt Broker Adresă IP  | `192.168.0.1`          |
| Mqtt Broker port       | `1883`                 |
| Device ID              | Se introduce la import |

## Surse

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

Documentele producătorilor sunt © ale proprietarilor respectivi. Sunt furnizate așa cum au fost publicate de producător, doar ca referință.

## Documentație asociată

- [MQTT Integration](https://taphome.com/ro/compatibility/mqtt-guide/)
- [Packet Parser (HTTP, TCP, UDP, FTP, MQTT)](https://taphome.com/ro/docs/integration/packet-parser/)
- [Funcții Packet parser](https://taphome.com/ro/docs/script/packet-parser/)
- [Funcții de parsare](https://taphome.com/ro/docs/script/parsing-functions/)
- [MQTT Broker](https://taphome.com/ro/docs/integration/packet-parser/mqtt-broker/)
- [Scripturi listener](https://taphome.com/ro/docs/script/listener-scripts/)

