---
title: "Shelly Plus 2PM"
description: "Releu dublu cu măsurarea puterii sau comanda rulourilor/jaluzelelor prin HTTP RPC API. Integrare TapHome pentru Shelly Plus 2PM, cu schimbarea profilului."
url: "https://taphome.com/ro/compatibility/shelly-plus-2-pm/"
language: ro
lastmod: 2026-10-08
generator: hugo
ai:
  topics: ["http","electric-meter","wifi","relay","power-metering","cover","shutter","mdns","profile"]
  questions: ["Cum integrez Shelly Plus 2PM cu TapHome?","Care este diferența dintre profilul switch și profilul cover pe Shelly Plus 2PM?","Cum comand un rulou cu Shelly Plus 2PM și TapHome?","Cum trec între modul releu și modul cover pe Shelly Plus 2PM?","De ce șablonul Shelly Plus 2PM afișează o eroare de profil în TapHome?","Cum calibrez ruloul Shelly Plus 2PM pentru comanda poziției?","Ce informații de diagnosticare sunt disponibile pentru Shelly Plus 2PM în TapHome?"]
---

# Shelly Plus 2PM

Comunicație: Packet Parser → HTTP

- [Pagina produsului Shelly Plus 2PM](https://www.shelly.com/en/products/shop/shelly-plus-2pm)
- [Documentația API Shelly Plus 2PM](https://shelly-api-docs.shelly.cloud/gen2/Devices/Gen2/ShellyPlus2PM/)

> Adresa în rețea
> 
> TapHome comunică cu dispozitivul la adresa introdusă la import. Atribuiți dispozitivului o adresă fixă — o rezervare IP în router sau numele său mDNS, dacă îl acceptă —, altfel integrarea nu mai funcționează când routerul schimbă adresa.
> 
> [Pregătirea rețelei](https://taphome.com/ro/docs/setup/network-preparation/)

## Ghid de integrare

Shelly Plus 2PM este un releu Wi-Fi compact cu două canale și măsurarea integrată a puterii pe ambele canale. Se montează în spatele unui întrerupător de perete standard și poate comanda două circuite independente de până la 10 A fiecare (16 A în total la 230 V AC) sau un singur rulou motorizat. TapHome comunică cu dispozitivul prin HTTP, folosind API-ul RPC Gen2+ în rețeaua locală — nu este necesară conexiunea la cloud.

Dispozitivul are două profiluri de funcționare — **switch** și **cover** — care se selectează în interfața web Shelly sau prin acțiunea de service din TapHome. În profilul switch, ambele ieșiri de releu (O1 și O2) funcționează independent, cu monitorizarea puterii pe fiecare canal. În profilul cover, cele două ieșiri acționează un singur motor pentru rulouri, jaluzele sau draperii, cu comanda poziției și calibrare.

> [!NOTE]
> Shelly Plus 2PM nu se mai produce. Succesorul său, [Shelly 2PM Gen3](https://taphome.com/ro/compatibility/shelly-2pm-gen3/), oferă aceleași funcții cu două profiluri, un procesor mai performant (8 MB flash), până la 6 conexiuni HTTP simultane și posibilitatea de actualizare pentru Matter.

## Configurare

Shelly Plus 2PM se conectează prin Wi-Fi. La importul șablonului în TapHome, introduceți adresa IP a dispozitivului (valoarea implicită: `192.168.0.1`).

> [!WARNING]
> Pentru integrarea cu TapHome, autentificarea pe dispozitivul Shelly trebuie să fie **dezactivată**. TapHome nu acceptă HTTP Digest Auth, folosită de dispozitivele Gen2+. Deschideți interfața web Shelly (`http://{device-ip}`) → Settings → Authentication și asigurați-vă că este dezactivată.

> [!NOTE]
> Dacă pe dispozitivul Shelly este activat modul ECO, pot apărea erori de timeout ale comunicării din cauza intervalelor scurte de interogare folosite de șablon (2,5–5 secunde). Dacă întâmpinați probleme intermitente de conectivitate, dezactivați modul ECO în interfața web Shelly.

### Selectarea profilului

Shelly Plus 2PM funcționează la un moment dat într-unul dintre cele două profiluri. Profilul activ determină ce dispozitive TapHome funcționează:

- **Profilul switch** — activează ambele întrerupătoare cu releu (Întrerupător 1 și Întrerupător 2) și contoarele electrice ale fiecărui canal. Ruloul și contorul electric al ruloului nu vor răspunde.
- **Profilul cover** — activează ruloul și contorul său electric. Cele două întrerupătoare și contoarele lor electrice nu vor răspunde.

Profilul activ este afișat în TapHome ca atribut de service la nivel de modul („Profil”). Pentru a schimba profilul, folosiți acțiunea de service **Profil** la nivel de modul sau schimbați-l în interfața web Shelly. După schimbarea profilului, dispozitivul repornește și vor funcționa doar dispozitivele care corespund noului profil.

> [!TIP]
> Șablonul include toate cele șase dispozitive (2 întrerupătoare + 2 contoare electrice pentru întrerupătoare + 1 rulou + 1 contor electric pentru rulou), dar vor funcționa doar dispozitivele care corespund profilului activ. Este un comportament normal — dispozitivele pentru celălalt profil pur și simplu nu răspund.

### Calibrarea ruloului

În profilul cover, limitele de cursă ale motorului trebuie calibrate înainte ca comanda poziției să funcționeze. Până la finalizarea calibrării, `current_pos` returnează null, iar atributul de service „Calibrat” afișează `false`. Calibrarea se poate face în interfața web Shelly sau prin acțiunea de service **Calibrare** a ruloului în TapHome. În timpul calibrării, ruloul parcurge o secvență în mai mulți pași (deschidere completă → închidere completă → deschidere completă → închidere în pași → deschidere în pași) pentru a măsura distanțele de deplasare.

## Funcțiile dispozitivului

### Comanda releului (profilul switch)

Șablonul oferă două întrerupătoare cu releu independente. Fiecare întrerupător își citește starea din `/rpc/Switch.GetStatus?id={0,1}` (câmpul `output`, boolean) și comandă releul prin `/rpc/Switch.Set?id={0,1}&on=true|false`.

Fiecare întrerupător oferă șapte atribute de service:

- **Sursă** — sursa ultimei comenzi (http, UI, WS_in etc.)
- **Temperatură** — temperatura internă a dispozitivului în °C
- **Stare inițială** — comportamentul întrerupătorului la pornirea alimentării (off, on, restore_last sau match_input)
- **Mod intrare** — modul de conectare a intrării fizice (follow sau detached)
- **Limită de putere** — pragul maxim de putere în wați pentru protecția la depășirea puterii
- **Limită de tensiune** — pragul maxim de tensiune în volți
- **Limită de curent** — pragul maxim de curent în amperi

La fiecare întrerupător sunt disponibile două acțiuni de service:

- **Setare stare inițială** — configurează comportamentul releului după pornirea alimentării (off, on, restore_last, match_input)
- **Setare mod** — configurează modul de conectare a intrării fizice (follow, detached)

### Măsurarea puterii (profilul switch)

Fiecare canal al întrerupătorului are un contor electric dedicat, care citește două valori din `/rpc/Switch.GetStatus`:

- **Putere în timp real** — `apower`, raportată în wați și convertită de șablon în kW
- **Consum total** — `aenergy.total`, raportat în wați-oră și convertit de șablon în kWh

Fiecare contor electric oferă și trei atribute de service:

- **Tensiune** — tensiunea de alimentare în volți
- **Curent** — curentul sarcinii în amperi
- **Factor de putere** — factorul de putere al sarcinii

Contoarele sunt doar pentru citire — se actualizează automat la fiecare ciclu de interogare.

### Comanda ruloului (profilul cover)

Dispozitivul Rulou comandă un rulou, o draperie sau o copertină motorizată. Citește poziția din `/rpc/Cover.GetStatus?id=0` (câmpul `current_pos`, 0–100 %) și o setează prin `/rpc/Cover.GoToPosition?id=0&pos=N`.

Ruloul oferă 21 de atribute de service:

- **Stare** — sursa, starea (open/closed/opening/closing/stopped/calibrating), poziția curentă și cea țintă, timpul maxim de mișcare și momentul pornirii mișcării
- **Calibrat** — dacă este activată comanda poziției (`pos_control`)
- **Temperatură** — temperatura internă a dispozitivului în °C
- **Comportament la pornirea alimentării** — configurarea stării inițiale (open, closed, stopped)
- **Setările intrărilor** — modul intrării (single, dual, detached), inversarea intrărilor, inversarea direcțiilor
- **Limite de protecție** — limită de putere (W), limită de tensiune (V), limită de curent (A)
- **Reglarea motorului** — pragul de putere în repaus (0–50 W), perioada de confirmare a repausului (0,25–2 s)
- **Limite de mișcare** — timpul maxim de deschidere (0,1–300 s), timpul maxim de închidere (0,1–300 s)
- **Funcții de siguranță** — starea detectării obstacolelor, starea întrerupătorului de siguranță

La rulou sunt disponibile șase acțiuni de service:

- **Deschidere** — deschide complet ruloul
- **Închidere** — închide complet ruloul
- **Oprire** — oprește imediat mișcarea
- **Calibrare** — pornește procedura de calibrare pentru comanda poziției
- **Deplasare la poziție** — deplasează ruloul într-o anumită poziție (0–100 %)
- **Inversare direcții** — comută valoarea parametrului `invert_directions` și repornește dispozitivul

### Măsurarea puterii (profilul cover)

Ruloul are un contor electric dedicat, care citește din `/rpc/Cover.GetStatus`:

- **Putere în timp real** — `apower`, raportată în wați și convertită de șablon în kW
- **Consum total** — `aenergy.total`, raportat în wați-oră și convertit de șablon în kWh

Contorul electric al ruloului oferă și tensiunea, curentul și factorul de putere ca atribute de service.

### Diagnosticare de service

Șablonul oferă două atribute de service la nivel de modul:

- **MAC** — adresa MAC a dispozitivului din configurația sistemului
- **Profil** — profilul activ al dispozitivului (switch sau cover)

Scriptul de citire al modulului verifică și `restart_required` din `/rpc/Sys.GetStatus` și afișează o avertizare în TapHome dacă este necesară o repornire.

### Acțiuni de service

La nivelul modulului sunt disponibile două acțiuni de service:

- **Repornire** — repornește dispozitivul prin `/rpc/Shelly.Reboot`
- **Profil** — comută între profilurile de funcționare switch și cover prin `/rpc/Shelly.SetProfile`

### Funcții suplimentare

În răspunsurile RPC, Shelly Plus 2PM furnizează și frecvența rețelei (`freq`), valorile energiei pe minut (`aenergy.by_minute`), starea intrărilor fizice (`input:0`, `input:1`), puterea semnalului Wi-Fi (RSSI) și un endpoint de comutare (toggle) pentru întrerupător. Contoarele electrice se pot reseta prin `/rpc/Switch.ResetCounters` (profilul switch) sau `/rpc/Cover.ResetCounters` (profilul cover). În modul cover, poziția lamelelor/înclinarea pentru jaluzelele venețiene este disponibilă atunci când hardware-ul o permite. Aceste funcții pot fi adăugate într-o actualizare viitoare a șablonului.

## Rezolvarea problemelor

### Dispozitivul nu răspunde

1. Verificați dacă Shelly este conectat la Wi-Fi și are o adresă IP validă
2. Încercați să folosiți numele de gazdă mDNS (`shellyplus2pm-AABBCCDDEE.local`) în locul adresei IP — adresa IP se poate schimba după reînnoirea DHCP
3. Deschideți `http://{device-ip}/rpc/Shelly.GetDeviceInfo` în browser — dacă răspunde cu JSON, dispozitivul este accesibil
4. Verificați dacă TapHome Core și Shelly sunt în aceeași rețea / VLAN
5. Verificați dacă autentificarea este dezactivată pe dispozitivul Shelly

### Profil nepotrivit — dispozitivele nu răspund

Dacă unele dispozitive nu afișează valori, în timp ce altele funcționează corect:

1. Verificați ce profil este activ — atributul de service „Profil” la nivel de modul afișează modul curent
2. Treceți la profilul corect cu acțiunea de service **Profil** sau ignorați dispozitivele nefolosite
3. După schimbarea profilului, dispozitivul repornește automat — așteptați câteva secunde pentru reconectare

### Comanda poziției ruloului nu funcționează

1. Verificați dacă dispozitivul este în profilul cover — profilul switch nu oferă funcțiile pentru rulou
2. Rulați acțiunea de service **Calibrare** pe rulou — comanda poziției necesită finalizarea calibrării
3. Verificați dacă motorul este conectat corect la bornele O1 și O2
4. Interogați manual `/rpc/Cover.GetStatus?id=0` și verificați dacă `pos_control` este `true`

### Calibrarea ruloului eșuează

Calibrarea se întrerupe dacă:

- Ruloul nu ajunge în poziția finală în intervalul `maxtime_open` sau `maxtime_close`
- O funcție de siguranță (detectarea obstacolelor sau întrerupătorul de siguranță) se declanșează în timpul calibrării
- În timpul calibrării este trimisă o comandă externă de oprire
- Direcția motorului nu corespunde răspunsului așteptat
- Dispozitivul repornește în timpul calibrării

Verificați cablajul motorului, măriți `maxtime_open`/`maxtime_close` dacă motorul este lent și asigurați-vă că nu există obstacole.

### Puterea afișată este zero

1. Verificați dacă sarcina este conectată prin releul Shelly (nu ocolește releul)
2. Verificați dacă releul este pornit — contorul măsoară doar atunci când curentul trece prin releu
3. Interogați manual `/rpc/Switch.GetStatus?id=0` (profilul switch) sau `/rpc/Cover.GetStatus?id=0` (profilul cover) și verificați dacă `apower` returnează o valoare diferită de zero

> [!WARNING]
> Dispozitivele Shelly Gen2+ acceptă până la **6 conexiuni HTTP simultane**. Deși este o îmbunătățire față de Gen1 (2 conexiuni), evitați interogarea simultană din prea multe sisteme (TapHome, Home Assistant, scripturi proprii), pentru a nu epuiza conexiunile.

## Cum se instalează în TapHome

### Cerințe preliminare

- Dispozitiv Shelly instalat și pornit
- Rețea Wi-Fi locală (2,4 GHz)
- TapHome CCU în aceeași rețea

### Pasul 1 — Conectați dispozitivul Shelly la Wi-Fi

**Varianta A — aplicația Shelly (recomandat):**

1. Descărcați [aplicația Shelly](https://www.shelly.com/en/support/shelly-app) (iOS / Android)
2. Atingeți **+** → **Add Device** și urmați asistentul de împerechere prin Bluetooth
3. Introduceți datele de conectare la Wi-Fi când vi se solicită

**Varianta B — modul AP (fără aplicație):**

1. La prima pornire, dispozitivul creează un hotspot: `ShellyXXX-AABBCCDDEE`
2. Conectați telefonul/PC-ul la acest hotspot
3. Deschideți `http://192.168.33.1` → **Internet & Security** → **Wi-Fi Mode - Client**
4. Introduceți SSID-ul și parola → **Save**

> [!NOTE]
> Shelly acceptă doar rețele de **2,4 GHz**. Rețelele de 5 GHz nu vor apărea la scanare.

### Pasul 2 — Găsiți adresa dispozitivului

Dispozitivele Shelly Gen1 acceptă **mDNS** (Zeroconf). Puteți accesa dispozitivul folosind un nume de gazdă în locul adresei IP:

```
shelly<model>-<MAC>.local
```

De exemplu: `shelly1pm-AABBCCDDEE.local` (adresa MAC în hexazecimal cu majuscule, fără două puncte).

> [!TIP]
> **Recomandat: folosiți Scanner IP din TapHome.** Deschideți aplicația TapHome și folosiți **Scanner IP** (Setări → Rețea → Scanare). Scannerul descoperă dispozitivele din rețea și afișează atât adresa IP, cât și numele de gazdă mDNS. Pentru o conexiune mai fiabilă folosiți **numele de gazdă** în locul adresei IP — acesta rămâne același chiar dacă adresa IP a dispozitivului se schimbă după o repornire a routerului.

**Metode alternative** pentru aflarea adresei IP:

- **Aplicația Shelly:** detaliile dispozitivului → **Device info** → adresa IP
- **Interfața web Shelly:** conectați-vă la AP-ul dispozitivului înainte de configurarea Wi-Fi — adresa IP se afișează după salvare
- **Tabelul DHCP al routerului:** căutați un nume de gazdă de forma `shelly1pm-AABBCCDDEE`

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

1. În TapHome adăugați un nou modul **Packet Parser (HTTP)**
2. **Address:** introduceți numele de gazdă mDNS (de ex. `shelly1pm-AABBCCDDEE.local`) sau adresa IP de la pasul 2
3. **Port:** `80` (implicit, nu este necesară nicio modificare)
4. Importați șablonul — TapHome va interoga periodic `/status` pentru a citi starea dispozitivului

> [!NOTE]
> Autentificarea HTTP este dezactivată implicit pe dispozitivele Shelly. Dacă ați activat protecția prin autentificare, rețineți că TapHome nu acceptă momentan HTTP Basic Auth — pentru integrarea cu TapHome lăsați autentificarea dezactivată.

## Dispozitive disponibile 6

Aceste dispozitive apar în TapHome după import.

Shelly Plus 2PM Modul

Atribute de service

|        |                                                         |
|--------|---------------------------------------------------------|
| MAC    | Adresa MAC a dispozitivului din configurația sistemului |
| Profil | Profilul activ al dispozitivului — switch sau cover     |

Acțiuni de service

|           |                                                                                              |
|-----------|----------------------------------------------------------------------------------------------|
| Repornire | Repornește dispozitivul                                                                      |
| Profil    | Comută între profilurile de funcționare switch și cover — necesită repornirea dispozitivului |

Variabile personalizate

Citire (modul)

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Sys.GetConfig");
IF response.IsSuccess
  VAR content := response.Content;
  VAR responseHeaders := response.Headers;
  SysConfig := response.Content;
END;
 
response := SENDHTTPREQUEST("/rpc/Sys.GetStatus");
IF response.IsSuccess
  content := response.Content;
  responseHeaders := response.Headers;
  if(PARSEJSON(response.Content, "$.restart_required") = true, ADDERROR("Restart required"));
END
```

Atribute de service

MAC

```taphome
PARSEJSON(SysConfig, "$.device.mac");
```

Profile

```taphome
PARSEJSON(SysConfig, "$.device.profile");
```

Acțiuni de service

Reboot

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Shelly.Reboot");
IF response.IsSuccess
  VAR content := response.Content;
  VAR responseHeaders := response.Headers;
  Return("OK");
END;
```

Profile

Parametri: Profile

```taphome
var profile := SWITCH(pr, 1, "cover", "switch");
VAR response := SENDHTTPREQUEST("/rpc/Shelly.SetProfile?name=\""+profile+"\"");
IF response.IsSuccess
  VAR content := response.Content;
  VAR responseHeaders := response.Headers;
  Return("OK");
END;
```

Contor electric (rulou) Contor electric Doar citire

Măsurarea energiei în modul cover — putere instantanee (kW) și energie cumulată (kWh)

numeric Unitate: kW / kWh json\_path

Atribute de service

|                  |                                  |
|------------------|----------------------------------|
| Tensiune         | Tensiunea de alimentare în volți |
| Curent           | Curentul sarcinii în amperi      |
| Factor de putere | Factorul de putere al sarcinii   |

Citirea consumului total

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    adderror("Device profile is set to switch");
else
    return(PARSEJSON(CoverStatus, "$.aenergy.total") / 1000);
end
```

Citirea cererii

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    return(PARSEJSON(CoverStatus, "$.apower", true) / 1000);
end
```

Citire (modul)

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    var response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=" + Id);
    IF response.IsSuccess
        VAR content := response.Content;
        VAR responseHeaders := response.Headers;
        CoverStatus := response.Content;
    END
end
```

Atribute de service

Voltage \[V]

```taphome
PARSEJSON(CoverStatus, "$.voltage", true);
```

Current \[A]

```taphome
PARSEJSON(CoverStatus, "$.current", true);
```

Power Factor

```taphome
PARSEJSON(CoverStatus, "$.pf", true);
```

Contor electric (întrerupător 1) Contor electric Doar citire

Măsurarea energiei pentru canalul 1 al întrerupătorului — putere instantanee (kW) și energie cumulată (kWh)

numeric Unitate: kW / kWh json\_path

Atribute de service

|                  |                                  |
|------------------|----------------------------------|
| Tensiune         | Tensiunea de alimentare în volți |
| Curent           | Curentul sarcinii în amperi      |
| Factor de putere | Factorul de putere al sarcinii   |

Citirea consumului total

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    adderror("Device profile is set to cover");
else
    return(PARSEJSON(SwitchStatus, "$.aenergy.total", true) / 1000);
end
```

Citirea cererii

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    return(PARSEJSON(SwitchStatus, "$.apower", true) / 1000);
end
```

Citire (modul)

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    var response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + Id);
    IF response.IsSuccess
        VAR content := response.Content;
        VAR responseHeaders := response.Headers;
        SwitchStatus := response.Content;
    END
end
```

Atribute de service

Voltage \[V]

```taphome
PARSEJSON(SwitchStatus, "$.voltage", true);
```

Current \[A]

```taphome
PARSEJSON(SwitchStatus, "$.current", true);
```

Power Factor

```taphome
PARSEJSON(SwitchStatus, "$.pf", true);
```

Contor electric (întrerupător 2) Contor electric Doar citire

Măsurarea energiei pentru canalul 2 al întrerupătorului — putere instantanee (kW) și energie cumulată (kWh)

numeric Unitate: kW / kWh json\_path

Atribute de service

|                  |                                  |
|------------------|----------------------------------|
| Tensiune         | Tensiunea de alimentare în volți |
| Curent           | Curentul sarcinii în amperi      |
| Factor de putere | Factorul de putere al sarcinii   |

Citirea consumului total

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    adderror("Device profile is set to cover");
else
    return(PARSEJSON(SwitchStatus, "$.aenergy.total", true) / 1000);
end
```

Citirea cererii

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    return(PARSEJSON(SwitchStatus, "$.apower", true) / 1000);
end
```

Citire (modul)

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    var response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + Id);
    IF response.IsSuccess
        VAR content := response.Content;
        VAR responseHeaders := response.Headers;
        SwitchStatus := response.Content;
    END
end
```

Atribute de service

Voltage \[V]

```taphome
PARSEJSON(SwitchStatus, "$.voltage", true);
```

Current \[A]

```taphome
PARSEJSON(SwitchStatus, "$.current", true);
```

Power Factor

```taphome
PARSEJSON(SwitchStatus, "$.pf", true);
```

Rulou Glisare Citire și scriere

Comanda ruloului motorizat cu urmărirea poziției — comanda poziției necesită calibrare

numeric Unitate: % json\_path

Atribute de service

|                                               |                                                                                                     |
|-----------------------------------------------|-----------------------------------------------------------------------------------------------------|
| Sursă                                         | Sursa ultimei comenzi a ruloului                                                                    |
| Stare                                         | Starea curentă a ruloului — open, closed, opening, closing, stopped, calibrating                    |
| Poziție curentă                               | Poziția curentă a ruloului în procente (0–100), null dacă nu este calibrat                          |
| Poziție țintă                                 | Poziția țintă în timpul mișcării ruloului                                                           |
| Timp maxim de mișcare                         | Secunde până la oprirea automată în timpul mișcării                                                 |
| Momentul pornirii mișcării                    | Momentul în care a pornit mișcarea curentă                                                          |
| Calibrat                                      | Indică dacă este activată comanda poziției (true după o calibrare reușită)                          |
| Temperatură                                   | Temperatura internă a dispozitivului în grade Celsius                                               |
| Stare inițială                                | Comportamentul ruloului la pornirea alimentării — open, closed sau stopped                          |
| Mod intrare                                   | Modul de conectare a intrării fizice — single, dual sau detached                                    |
| Limită de putere                              | Pragul maxim de putere în wați pentru protecția la depășirea puterii                                |
| Limită de tensiune                            | Pragul maxim de tensiune în volți pentru protecția la supratensiune                                 |
| Limită de curent                              | Pragul maxim de curent în amperi pentru protecția la supracurent                                    |
| Prag de putere în repaus al motorului         | Pragul de putere sub care motorul este considerat în repaus (0–50 W)                                |
| Perioadă de confirmare a repausului motorului | Durata în care motorul trebuie să rămână sub pragul de repaus pentru confirmarea opririi (0,25–2 s) |
| Timp maxim de deschidere                      | Timpul maxim de deschidere înainte de oprirea automată (0,1–300 s)                                  |
| Timp maxim de închidere                       | Timpul maxim de închidere înainte de oprirea automată (0,1–300 s)                                   |
| Inversare intrări                             | Indică dacă alocarea intrărilor S1/S2 este inversată                                                |
| Inversare direcții                            | Indică dacă direcțiile de deschidere/închidere sunt inversate                                       |
| Detectarea obstacolelor                       | Indică dacă detectarea obstacolelor este activată                                                   |
| Întrerupător de siguranță                     | Indică dacă funcția întrerupătorului de siguranță este activată                                     |

Acțiuni de service

|                      |                                                                            |
|----------------------|----------------------------------------------------------------------------|
| Deschidere           | Deschide complet ruloul                                                    |
| Închidere            | Închide complet ruloul                                                     |
| Oprire               | Oprește imediat mișcarea ruloului                                          |
| Calibrare            | Pornește calibrarea ruloului — necesară pentru comanda poziției            |
| Deplasare la poziție | Deplasează ruloul într-o anumită poziție (0–100 %)                         |
| Inversare direcții   | Comută valoarea parametrului invert\_directions și repornește dispozitivul |

Citire (modul)

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    adderror("Device profile is set to switch");
else
    var response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=" + Id);
    IF response.IsSuccess
        VAR content := response.Content;
        VAR responseHeaders := response.Headers;
        CoverStatus := response.Content;
    END
    
    response := SENDHTTPREQUEST("/rpc/Cover.GetConfig?id=" + Id);
    IF response.IsSuccess
        content := response.Content;
        responseHeaders := response.Headers;
        CoverConfig := response.Content;
    END
end
```

Citirea nivelului jaluzelei

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    adderror("Device profile is set to switch");
else
    var response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=" + Id);
    IF response.IsSuccess
        CoverStatus := response.Content;
    END
    if PARSEJSON(CoverStatus, "$.pos_control", true) = true
        var pos := -1;
        var curpos := PARSEJSON(CoverStatus, "$.current_pos", true);
        if ISNULL(curpos)
            adderror("Device lost its position. Open or close the cover completely to enable back position control.");
            return(0);
        end
        var target := PARSEJSON(CoverStatus, "$.target_pos", true);
        if(ISNULL(target), pos := curpos, pos := target);
        if PARSEJSON(CoverConfig, "$.invert_directions", true)
            return(linear(pos, 0, 0, 100, 1));
        else
            return(linear(pos, 0, 1, 100, 0));
        end
    else
        adderror("Device is not calibrated");
    end
end
```

Scrierea nivelului jaluzelei

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    adderror("Device profile is set to switch");
else
    var pos := 0;
    if PARSEJSON(CoverConfig, "$.invert_directions", true)
        pos := linear(Bl, 0, 0, 1, 100);
    else
        pos := linear(Bl, 0, 100, 1, 0);
    end
    VAR response := SENDHTTPREQUEST("rpc/Cover.GoToPosition?id=" + Id + "&pos=" + pos);
    IF response.IsSuccess
      VAR content := response.Content;
      Return("OK");
    else
      return(parsejson(response.Content,"$.message"));
    END
end
```

Atribute de service

Source

```taphome
PARSEJSON(CoverStatus, "$.source", true);
```

State

```taphome
PARSEJSON(CoverStatus, "$.state", true);
```

Current Position

```taphome
PARSEJSON(CoverStatus, "$.current_pos", true);
```

Target Position

```taphome
PARSEJSON(CoverStatus, "$.target_pos", true);
```

Move Timeout

```taphome
PARSEJSON(CoverStatus, "$.move_timeout", true);
```

Move Started at

```taphome
PARSEJSON(CoverStatus, "$.move_started_at", true);
```

Calibrated

```taphome
PARSEJSON(CoverStatus, "$.pos_control", true);
```

Temperature \[°C]

```taphome
PARSEJSON(CoverStatus, "$.temperature.tC", true);
```

Initial State

```taphome
PARSEJSON(CoverConfig, "$.initial_state", true);
```

Input Mode

```taphome
PARSEJSON(CoverConfig, "$.in_mode", true);
```

Power Limit \[W]

```taphome
PARSEJSON(CoverConfig, "$.power_limit", true);
```

Voltage Limit \[V]

```taphome
PARSEJSON(CoverConfig, "$.voltage_limit", true);
```

Current Limit \[A]

```taphome
PARSEJSON(CoverConfig, "$.current_limit", true);
```

Motor Idle Power Threshold \[W]

```taphome
PARSEJSON(CoverConfig, "$.motor.idle_power_thr", true);
```

Motor Idle Confirm Period \[s]

```taphome
PARSEJSON(CoverConfig, "$.motor.idle_confirm_period", true);
```

Max Time Open \[s]

```taphome
PARSEJSON(CoverConfig, "$.maxtime_open", true);
```

Max Time Close \[s]

```taphome
PARSEJSON(CoverConfig, "$.maxtime_close", true);
```

Swap Inputs

```taphome
PARSEJSON(CoverConfig, "$.swap_inputs", true);
```

Invert Directions

```taphome
PARSEJSON(CoverConfig, "$.invert_directions", true);
```

Obstruction Detection

```taphome
PARSEJSON(CoverConfig, "$.obstruction_detection", true);
```

Safety Switch

```taphome
PARSEJSON(CoverConfig, "$.safety_switch", true);
```

Acțiuni de service

Open

```taphome
VAR response := SENDHTTPREQUEST("rpc/Cover.Open?id=" + Id );
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Close

```taphome
VAR response := SENDHTTPREQUEST("rpc/Cover.Close?id=" + Id );
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Stop

```taphome
VAR response := SENDHTTPREQUEST("rpc/Cover.Stop?id=" + Id );
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Calibrate

```taphome
VAR response := SENDHTTPREQUEST("rpc/Cover.Calibrate?id=" + Id );
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Go to Position

Parametri: Position (0–100 pos)

```taphome
VAR response := SENDHTTPREQUEST("rpc/Cover.GoToPosition?id=" + Id + "&pos=" + pos);
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Reverse directions

```taphome
var reverse := "false";
if(PARSEJSON(CoverConfig, "$.invert_directions"), reverse := "false", reverse := "true");
VAR response := SENDHTTPREQUEST("rpc/Cover.SetConfig?id=0&config={\"invert_directions\":" + reverse + "}");
IF response.IsSuccess
  SENDHTTPREQUEST("rpc/Shelly.Reboot");
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Întrerupător 1 Comutator Citire și scriere

Canalul 1 al ieșirii releului — comandă pornit/oprit, cu configurarea comportamentului la pornirea alimentării și a modului intrării

boolean json\_path

Valori / Stări: ON · OFF

Acțiuni de service

|                       |                                                                      |
|-----------------------|----------------------------------------------------------------------|
| Setare stare inițială | Configurează comportamentul întrerupătorului la pornirea alimentării |
| Setare mod            | Configurează modul de conectare a intrării fizice                    |

Citirea stării comutatorului

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    adderror("Device profile is set to cover");
else
    RETURN(PARSEJSON(SwitchStatus, "$.output", true));
end
```

Scrierea stării comutatorului

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    VAR response := SENDHTTPREQUEST("rpc/Switch.Set?id=" + Id + "&on=" + if(St,"true","false"));
    IF response.IsSuccess = false
      ADDERROR(response.StatusCode);
    END
end
```

Citire (modul)

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    var response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + Id);
    IF response.IsSuccess
        VAR content := response.Content;
        VAR responseHeaders := response.Headers;
        SwitchStatus := response.Content;
    END
    
    response := SENDHTTPREQUEST("/rpc/Switch.GetConfig?id=" + Id);
    IF response.IsSuccess
        content := response.Content;
        responseHeaders := response.Headers;
        SwitchConfig := response.Content;
    END
end
```

Atribute de service

Source

```taphome
PARSEJSON(SwitchStatus, "$.source", true);
```

Temprature \[°C]

```taphome
PARSEJSON(SwitchStatus, "$.temperature.tC", true);
```

Initial State

```taphome
PARSEJSON(SwitchConfig, "$.initial_state", true);
```

Input Mode

```taphome
PARSEJSON(SwitchConfig, "$.in_mode", true);
```

Power Limit \[W]

```taphome
PARSEJSON(SwitchConfig, "$.power_limit", true);
```

Voltage Limit \[V]

```taphome
PARSEJSON(SwitchConfig, "$.voltage_limit", true);
```

Current Limit \[A]

```taphome
PARSEJSON(SwitchConfig, "$.current_limit", true);
```

Acțiuni de service

Set Initial State

Parametri: Mode

```taphome
var mode := SWITCH(md, 1, "on", 2, "restore_last", 3, "match_input", "off");
VAR response := SENDHTTPREQUEST("rpc/Switch.SetConfig?id=" + Id +"&config={\"initial_state\":\""+mode+"\"}");
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Set Mode

Parametri: Mode

```taphome
var mode := SWITCH(md, 1, "detached", "follow");
VAR response := SENDHTTPREQUEST("rpc/Switch.SetConfig?id=" + Id +"&config={\"in_mode\":\""+mode+"\"}");
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Întrerupător 2 Comutator Citire și scriere

Canalul 2 al ieșirii releului — comandă pornit/oprit, cu configurarea comportamentului la pornirea alimentării și a modului intrării

boolean json\_path

Valori / Stări: ON · OFF

Acțiuni de service

|                       |                                                                      |
|-----------------------|----------------------------------------------------------------------|
| Setare stare inițială | Configurează comportamentul întrerupătorului la pornirea alimentării |
| Setare mod            | Configurează modul de conectare a intrării fizice                    |

Citirea stării comutatorului

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    adderror("Device profile is set to cover");
else
    RETURN(PARSEJSON(SwitchStatus, "$.output", true));
end
```

Scrierea stării comutatorului

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    VAR response := SENDHTTPREQUEST("rpc/Switch.Set?id=" + Id + "&on=" + if(St,"true","false"));
    IF response.IsSuccess = false
      ADDERROR(response.StatusCode);
    END
end
```

Citire (modul)

```taphome
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    var response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + Id);
    IF response.IsSuccess
        VAR content := response.Content;
        VAR responseHeaders := response.Headers;
        SwitchStatus := response.Content;
    END
    
    response := SENDHTTPREQUEST("/rpc/Switch.GetConfig?id=" + Id);
    IF response.IsSuccess
        content := response.Content;
        responseHeaders := response.Headers;
        SwitchConfig := response.Content;
    END
end
```

Atribute de service

Source

```taphome
PARSEJSON(SwitchStatus, "$.source", true);
```

Temprature \[°C]

```taphome
PARSEJSON(SwitchStatus, "$.temperature.tC", true);
```

Initial State

```taphome
PARSEJSON(SwitchConfig, "$.initial_state", true);
```

Input Mode

```taphome
PARSEJSON(SwitchConfig, "$.in_mode", true);
```

Power Limit \[W]

```taphome
PARSEJSON(SwitchConfig, "$.power_limit", true);
```

Voltage Limit \[V]

```taphome
PARSEJSON(SwitchConfig, "$.voltage_limit", true);
```

Current Limit \[A]

```taphome
PARSEJSON(SwitchConfig, "$.current_limit", true);
```

Acțiuni de service

Set Initial State

Parametri: Mode

```taphome
var mode := SWITCH(md, 1, "on", 2, "restore_last", 3, "match_input", "off");
VAR response := SENDHTTPREQUEST("rpc/Switch.SetConfig?id=" + Id +"&config={\"initial_state\":\""+mode+"\"}");
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

Set Mode

Parametri: Mode

```taphome
var mode := SWITCH(md, 1, "detached", "follow");
VAR response := SENDHTTPREQUEST("rpc/Switch.SetConfig?id=" + Id +"&config={\"in_mode\":\""+mode+"\"}");
IF response.IsSuccess
  VAR content := response.Content;
  Return("OK");
else
  return(parsejson(response.Content,"$.message"));
END;
```

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

Îmbunătățiri posibile (8)

- Frequency — Network frequency in Hz, available in both Switch and Cover status responses
- Energy per Minute — Last 3 minute energy values in Wh, available but not exposed as separate device
- Input 1 State — Physical input state (input:0), available in both profiles
- Input 2 State — Physical input state (input:1), available in both profiles
- Switch Toggle — Toggle switch without knowing current state — could be added as service action
- Reset Energy Counters — Resets energy measurement counters — could be added as service action
- Slat Position — Slat/tilt position for venetian blinds, if hardware supports it
- WiFi Signal Strength — RSSI in dBm, available via WiFi component

## Parametri de import

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

| Solicitat în aplicație | Implicit      |
|------------------------|---------------|
| Adresă IP              | `192.168.0.1` |

## Surse

- Shelly Gen2+ RPC API Reference
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/) 2026-03-27
- Switch Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Switch/) 2026-03-27
- System (Sys) Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Sys/) 2026-03-27
- WiFi Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Wifi/) 2026-03-27
- MQTT Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/MQTT/) 2026-03-27
- HA Shelly Integration (Gen2+)
  
  [www.home-assistant.io](https://www.home-assistant.io/integrations/shelly/) 2026-03-27
- Shelly Plus 2PM Knowledge Base
  
  [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-plus-2pm) 2026-03-29
- Cover Component API (Gen2+)
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Cover/) 2026-03-29
- Shelly Plus 2PM Device API Reference
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/Devices/Gen2/ShellyPlus2PM/) 2026-03-29

## Documentație asociată

- [Packet Parser Integration](https://taphome.com/ro/compatibility/packet-parser-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/)

