---
title: "Shelly Plug S"
description: "Monitorizați consumul de energie, comandați releul și citiți temperatura dispozitivului prin MQTT. Șablon TapHome pentru priza inteligentă Shelly Plug S."
url: "https://taphome.com/ro/compatibility/shelly-plug-s-mqtt/"
language: ro
lastmod: 2026-03-31
generator: hugo
ai:
  topics: ["mqtt","smart-plug","wifi","energy-monitoring","relay-control"]
  questions: ["Cum integrez Shelly Plug S cu TapHome prin MQTT?","Ce măsoară șablonul TapHome pentru Shelly Plug S?","Cum găsesc Device ID-ul MQTT al Shelly Plug S?","De ce Shelly Plug S nu raportează datele de putere?","Cum comand releul Shelly Plug S din TapHome?","Raportează șablonul Shelly Plug S consumul de energie în kWh?"]
---

# Shelly Plug S

Comunicație: Packet Parser → MQTT

- [Pagina produsului Shelly Plug S](https://www.shelly.com/en/products/shop/shelly-plug-s)

> 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 Plug S este o priză inteligentă Wi-Fi compactă, cu monitorizarea integrată a energiei, cu valori nominale de 12 A / 2500 W. TapHome comunică cu dispozitivul prin MQTT — priza se conectează la un broker și publică starea releului, puterea consumată, contorul electric și temperatura internă.

Șablonul oferă două dispozitive: un contor electric pentru monitorizarea energiei și un întrerupător pentru comanda releului. Un atribut de service la nivel de modul raportează temperatura internă a dispozitivului.

## Configurare

### Device ID

Fiecare Shelly Plug S are un Device ID MQTT unic în formatul `shellyplug-s-<MAC6>`, unde `<MAC6>` reprezintă ultimele 6 caractere ale adresei MAC, în hexazecimal cu litere mici (de ex. `shellyplug-s-112233`).

Device ID-ul se găsește:

- În interfața web Shelly: **Settings** → **Device Info** → **Device ID** (folosiți primul șir de caractere, nu cel din paranteze)
- Prin API: `GET http://<device-ip>/settings` → câmpul `mqtt.id`

### Activarea MQTT

Pentru a activa MQTT pe Shelly Plug S:

1. Deschideți interfața web a dispozitivului în browser (accesați adresa IP a dispozitivului)
2. Mergeți la **Internet and Security** → **Advanced - Developer Settings**
3. Bifați **„Enable action execution via MQTT”**
4. Completați câmpul **„Server”** cu `{MQTT broker IP}:{port}` (portul implicit `1883`)
5. Apăsați **SAVE**

### Configurarea șablonului

După importul șablonului în TapHome:

1. Deschideți modulul **Shelly Plug S MQTT**
2. Setați **MQTT Broker IP** și **Port** (implicit `1883`)
3. Setați variabila personalizată **deviceID** la Device ID-ul prizei Shelly Plug S (de ex. `112233` — doar ultimele 6 caractere hexazecimale ale adresei MAC)

Modulul se abonează la `shellies/#`, iar scripturile de ascultare filtrează mesajele după prefixul de Device ID configurat `shellyplug-s-{deviceID}`.

## Funcțiile dispozitivului

### Monitorizarea energiei

Contorul electric citește două valori din priză:

- **Consum total** — energia cumulată din topicul `relay/0/energy`. Dispozitivul raportează energia în wați-minut; șablonul o convertește în kWh prin împărțire la 60000.
- **Putere instantanee** — puterea consumată în acest moment, din topicul `relay/0/power`. Dispozitivul raportează puterea în wați; șablonul o convertește în kW prin împărțire la 1000.

Ambele valori se actualizează conform intervalului de raportare MQTT (implicit 30 de secunde, configurabil în interfața web Shelly prin `mqtt_update_period`).

> [!TIP]
> Contorul electric se resetează la repornirea dispozitivului. Pentru o evidență permanentă a energiei, folosiți înregistrarea integrată a energiei în TapHome, care stochează valorile cumulate independent de contorul dispozitivului.

### Comanda releului

Întrerupătorul comandă releul prizei:

- **Citirea stării** — ascultă topicul `shellies/shellyplug-s-{deviceID}/relay/0` și transformă `on` → 1, `off` → 0
- **Scrierea stării** — publică `on` sau `off` pe `shellies/shellyplug-s-{deviceID}/relay/0/command`

Releul suportă o sarcină de până la 2500 W / 12 A.

### Monitorizarea temperaturii

Un atribut de service la nivel de modul raportează temperatura internă a dispozitivului în °C, citită din topicul `shellies/shellyplug-s-{deviceID}/temperature`. Este temperatura electronicii prizei, nu temperatura ambiantă din cameră.

### Funcții suplimentare

Shelly Plug S publică și starea online/offline prin topicul MQTT LWT, alerte de supratemperatură (când dispozitivul depășește temperatura de funcționare sigură), o clasificare ușor de citit a stării temperaturii (Normal/High/Very High) și evenimentele butonului (apăsare simplă, apăsare lungă, apăsare dublă). Aceste funcții pot fi adăugate într-o actualizare viitoare a șablonului.

## Rezolvarea problemelor

### Priza nu raportează date

1. Verificați dacă Shelly Plug S este conectată la Wi-Fi și dacă MQTT este activat în setările dispozitivului (**Internet and Security** → **Advanced - Developer Settings**)
2. Verificați dacă variabila personalizată **deviceID** corespunde exact Device ID-ului (de ex. `112233`)
3. Folosiți un client MQTT (de ex. MQTT Explorer) pentru a vă abona la `shellies/#` și verificați dacă priza publică mesaje

### Puterea afișată este zero

1. Verificați dacă este conectată o sarcină și dacă releul este pornit
2. Verificați topicul `relay/0/power` cu un client MQTT — valoarea trebuie să fie diferită de zero atunci când sarcina consumă energie
3. Verificați dacă contorul electric afișează valori în TapHome — consumul total în kWh, puterea în kW

### Releul nu răspunde la comenzi

1. Verificați dacă MQTT este activat și dacă adresa brokerului este corectă în interfața web Shelly
2. Verificați dacă TapHome poate accesa brokerul MQTT (adresa IP și portul corecte în setările modulului)
3. Testați publicând `on` sau `off` pe `shellies/shellyplug-s-{deviceID}/relay/0/command` cu un client MQTT

> [!WARNING]
> Dispozitivele Shelly Gen1 **nu** acceptă MQTT prin TLS. Comunicația dintre priză și brokerul MQTT nu este criptată (MQTT simplu, portul 1883). Asigurați-vă că brokerul MQTT se află într-o rețea locală de încredere.

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

Aceste dispozitive apar în TapHome după import.

Shelly Plug S MQTT Modul

Atribute de service

|             |                                                                           |
|-------------|---------------------------------------------------------------------------|
| Temperatură | Temperatura internă a dispozitivului — nu temperatura ambiantă din cameră |

Variabile personalizate

|                     |                                                                                                                                                                        |
|---------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `deviceID` (string) | Device ID-ul MQTT al Shelly Plug S — ultimele 6 caractere ale adresei MAC, în hexazecimal cu litere mici (se găsește în interfața web Shelly → Settings → Device Info) |

Ascultător

```taphome
VAR whatT := "shellies/shellyplug-s-"+deviceID+"/temperature";
IF (whatT = RECEIVEDMSG.TOPIC)
 temperatureC := TOSTRING(RECEIVEDMSG.PAYLOAD);
END
```

Atribute de service

Temperature \[°C ]

```taphome
temperatureC
```

Contor electric Contor electric Doar citire

Măsurarea puterii consumate și a energiei — putere instantanee (kW) și energie cumulată (kWh)

numeric Unitate: kWh (total), kW (demand) energy: Watt-minutes /60000 = kWh; demand: Watts /1000 = kW

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
VAR whatTo := "shellies/shellyplug-s-"+deviceID+"/relay/0/energy";
IF (whatTo = RECEIVEDMSG.TOPIC)
 To := TODOUBLE(TOSTRING(RECEIVEDMSG.PAYLOAD))/60000;
END
VAR whatEd := "shellies/shellyplug-s-"+deviceID+"/relay/0/power";
IF (whatEd = RECEIVEDMSG.TOPIC)
 Ed := TODOUBLE(TOSTRING(RECEIVEDMSG.PAYLOAD))/1000;
END
```

Întrerupător Comutator Citire și scriere

string on→1, off→0 (read); 1→on, 0→off (write)

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/shellyplug-s-"+deviceID+ "/relay/0/command",if(St = 1, "on","off"));
# 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






#MQTTPUBLISH(topic + "/relay/0/command",if());
```

Ascultător

```taphome
VAR whatSt := "shellies/shellyplug-s-"+deviceID+"/relay/0";
IF (whatSt = RECEIVEDMSG.TOPIC)
 IF (TOSTRING(RECEIVEDMSG.PAYLOAD) = "on")
  St := 1;
 ELSE
  St := 0;
 END
END
```

**Conexiune:** Packet Parser → MQTT

Îmbunătățiri posibile (6)

- Connection Status — LWT topic — true on connect, false on disconnect. Could detect offline device.
- Overtemperature Alert — 1 = overheated, 0 = normal. Could trigger safety alarm when device exceeds safe operating temperature.
- Temperature Status — String: Normal, High, or Very High. Human-readable temperature classification.
- Button Input State — 0 or 1 — physical button state on the device.
- Button Input Event — JSON payload with event type (S=short, L=long, SS=double, SSS=triple) and event counter.
- Overpower State — Relay topic can report 'overpower' payload when load exceeds rating. Not parsed in listener script.

## 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 Plug S — Device-Specific MQTT API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen1/#shelly-plug-plugs-mqtt) 2026-03-31

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

