---
title: "Shelly 2PM Gen3"
description: "Releu cu două canale, cu măsurarea puterii sau comanda rulourilor/jaluzelelor prin HTTP RPC API. Shelly 2PM Gen3 în TapHome, cu schimbarea profilului."
url: "https://taphome.com/ro/compatibility/shelly-2pm-gen3/"
language: ro
lastmod: 2026-03-29
generator: hugo
ai:
  topics: ["http","electric-meter","wifi","relay","power-metering","cover","blind","mdns","profile"]
  questions: ["Cum integrez Shelly 2PM Gen3 cu TapHome?","Care este diferența dintre profilul switch și profilul cover la Shelly 2PM Gen3?","Cum comand o jaluzea motorizată cu Shelly 2PM Gen3 și TapHome?","Cum comut între modul releu și modul cover la Shelly 2PM Gen3?","De ce șablonul Shelly 2PM Gen3 afișează o eroare de profil în TapHome?","Cum calibrez ruloul Shelly 2PM Gen3 pentru comanda poziției?"]
---

# Shelly 2PM Gen3

Comunicație: Packet Parser → HTTP

- [Pagina produsului Shelly 2PM Gen3](https://www.shelly.com/en/products/shop/shelly-2-pm-gen3)

> 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 2PM Gen3 este un modul releu Wi-Fi compact cu două canale și măsurarea integrată a puterii. 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/o singură jaluzea motorizată. TapHome comunică cu dispozitivul prin HTTP, folosind API-ul JSON-RPC 2.0 Gen2+/Gen3, î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, suport pentru înclinarea lamelelor și calibrare.

Spre deosebire de Shelly 1PM Gen3, care comandă un singur circuit, 2PM Gen3 oferă comandă pe două canale sau suport pentru rulouri motorizate. Ambele folosesc aceeași platformă Gen3 cu procesor ESP (8 MB flash), până la 6 conexiuni HTTP simultane și posibilitatea de actualizare pentru Matter.

## Configurare

Shelly 2PM Gen3 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+/Gen3. 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–3 secunde). Dacă întâmpinați probleme intermitente de conectivitate, dezactivați modul ECO în interfața web Shelly.

### Selectarea profilului

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

- **Profilul switch** — activează ambele întrerupătoare cu releu (Întrerupător 1 și Întrerupător 2), cu monitorizarea independentă a puterii. Dispozitivele rulou și jaluzea vor afișa o eroare de profil.
- **Profilul cover** — activează dispozitivele rulou și jaluzea (jaluzea venețiană cu înclinarea lamelelor). Dispozitivele de tip întrerupător vor afișa o eroare de profil.

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

> [!TIP]
> Șablonul include toate cele patru tipuri de dispozitive (2 întrerupătoare + rulou + jaluzea), dar vor funcționa doar dispozitivele care corespund profilului activ. Dispozitivele pentru celălalt profil afișează un mesaj de eroare, de exemplu „Profile is not set to switch” sau „Profile is not set to cover” — este un comportament normal, nu o defecțiune.

### 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, șablonul afișează eroarea „Calibration is required”. Calibrarea se poate face în interfața web Shelly sau prin acțiunea de service **Pornire calibrare automată** din TapHome. În timpul calibrării, ruloul se deschide complet și se închide complet pentru a măsura distanțele de deplasare.

## Funcțiile dispozitivului

### Comanda releelor (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ă și atribute de service pentru monitorizarea fiecărui canal:

- **Temperatură** — temperatura internă a dispozitivului în °C (`temperature.tC`)
- **Consum de energie** — energia cumulată în Wh (`aenergy.total`)
- **Putere consumată** — puterea în timp real în W (`apower`)
- **Tensiune electrică** — tensiunea de alimentare în V (`voltage`)
- **Curent electric** — curentul sarcinii în A (`current`)
- **Frecvență** — frecvența rețelei AC în Hz (`freq`)
- **Factor de putere** — valoarea factorului de putere (`pf`)

Întrerupătoarele se actualizează la fiecare 2,5 secunde.

### 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âmpurile `current_pos` și `target_pos`, 0–100) și o scrie prin `/rpc/Cover.GoToPosition?id=0&pos=N`. Șablonul inversează scala poziției, astfel încât în TapHome 0 = complet deschis și 100 = complet închis.

Ruloul oferă atribute de service:

- **Temperatură** — temperatura internă a dispozitivului în °C
- **Consum de energie** — energia cumulată a motorului în Wh
- **Putere consumată** — puterea motorului în timp real în W
- **Tensiune electrică** — tensiunea de alimentare în V
- **Curent electric** — curentul motorului în A

Acțiunea de service **Pornire calibrare automată** permite pornirea calibrării ruloului direct din TapHome.

### Comanda jaluzelei (profilul cover)

Dispozitivul jaluzea completează funcțiile ruloului cu comanda înclinării lamelelor pentru jaluzelele venețiene. Pe lângă poziție, citește și scrie poziția lamelelor (`slat_pos`) prin `/rpc/Cover.GoToPosition?id=0&pos=N&slat_pos=M`. Ambele scale, a poziției și a înclinării, sunt inversate (în TapHome 0 = deschis, 100 = închis).

Jaluzeaua oferă aceleași atribute de service ca ruloul și, în plus:

- **Lamele** — arată dacă comanda lamelelor este activată sau dezactivată (din `Cover.GetConfig → $.slat.enable`)
- **Timp de deschidere a lamelelor** — durata configurată de deschidere a lamelelor, în secunde
- **Timp de închidere a lamelelor** — durata configurată de închidere a lamelelor, în secunde

> [!NOTE]
> **Problemă cunoscută a șablonului:** atributul de service „Timp de închidere a lamelelor” citește din configurația Cover `$.slat.open_time` în loc de `$.slat.close_time`. Ambele atribute, „Timp de deschidere a lamelelor” și „Timp de închidere a lamelelor”, afișează în prezent aceeași valoare (timpul de deschidere). Problema va fi corectată într-o revizie viitoare a șablonului.

Pe dispozitivul jaluzea sunt disponibile două acțiuni de service:

- **Pornire calibrare automată** — pornește calibrarea poziției ruloului
- **Setare lamele** — activează comanda lamelelor și configurează timpii de deschidere/închidere (0,1–5 secunde fiecare) prin `/rpc/Cover.SetConfig`

> [!WARNING]
> Comanda înclinării lamelelor trebuie activată înainte ca dispozitivul jaluzea să poată comanda înclinarea. Dacă dispozitivul nu furnizează poziția lamelelor, jaluzeaua afișează eroarea „Slat position must be enabled for blinds”. Folosiți acțiunea de service **Setare lamele** pentru a o activa și a seta duratele de deschidere/închidere.

### Diagnosticare de service

Șablonul oferă la nivelul modulului atribute de service pentru monitorizarea dispozitivului:

- **Wi-Fi** — numele SSID al rețelei conectate
- **Adresă IP** — adresa IP curentă a dispozitivului în rețeaua Wi-Fi
- **Puterea semnalului** — Wi-Fi RSSI în dB
- **MAC** — adresa MAC a dispozitivului
- **Profil** — profilul activ al dispozitivului (switch sau cover)

Scriptul de citire al modulului verifică și actualizările de firmware disponibile și necesitatea unei reporniri, pe care le afișează ca avertizări în interfața TapHome.

### Acțiuni de service

La nivelul modulului sunt disponibile trei acțiuni de service:

- **Actualizare firmware** — pornește actualizarea firmware-ului la ultima versiune stabilă prin `/rpc/Shelly.Update`
- **Repornire** — declanșează repornirea dispozitivului prin `/rpc/Shelly.Reboot`
- **Setare profil** — comută între modurile de funcționare cover și switch prin `/rpc/Shelly.SetProfile`

### Funcții suplimentare

În răspunsurile RPC, Shelly 2PM Gen3 furnizează și starea intrărilor fizice (`input:0`, `input:1`), contoarele energiei returnate/exportate, timpul de funcționare al dispozitivului, utilizarea RAM și ora dispozitivului. Un temporizator de oprire automată este disponibil prin parametrul `toggle_after`, protecția la depășirea puterii se poate configura prin `Switch.SetConfig → power_limit`, iar contoarele electrice se pot reseta prin `/rpc/Switch.ResetCounters`. În modul cover sunt disponibile comenzi directe de deschidere/închidere/oprire și starea de mișcare a ruloului (open/opening/closed/closing/stopped/calibrating). 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 (`shelly2pmg3-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

### Erori de nepotrivire a profilului

Dacă un dispozitiv afișează „Profile is not set to switch” sau „Profile is not set to cover”:

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

### Poziția 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 **Pornire calibrare automată** — comanda poziției necesită o calibrare finalizată
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`

### Înclinarea jaluzelei nu răspunde

1. Verificați dacă comanda lamelelor este activată — verificați atributul de service „Lamele” (ar trebui să afișeze „Enabled”)
2. Dacă este dezactivată, folosiți acțiunea de service **Setare lamele** pentru a o activa și a configura timpii de deschidere/închidere
3. Verificați dacă motorul jaluzelei permite înclinarea — rulourile fără înclinare ignoră comenzile pentru lamele

### Avertizare de supratemperatură

Shelly 2PM Gen3 are protecție termică internă. Dacă temperatura dispozitivului depășește limitele de siguranță, valoarea `temperature` din atributele de service ale dispozitivului va crește. Asigurați o ventilație adecvată în jurul dispozitivului, mai ales la comutarea continuă a sarcinilor mari. Curentul maxim de comutare este de 10 A pe canal, cu 16 A în total (18 A vârf).

> [!WARNING]
> Dispozitivele Shelly Gen2+/Gen3 acceptă până la **6 conexiuni HTTP simultane**. Deși este o îmbunătățire semnificativă față de Gen1 (2 conexiuni), evitați interogarea simultană din prea multe sisteme (TapHome, Home Assistant, scripturi proprii), pentru a nu epuiza conexiunile. Șablonul Shelly 2PM Gen3 folosește până la 4 endpointuri simultane per ciclu de interogare, ceea ce lasă o rezervă limitată pentru conexiuni suplimentare.

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

Aceste dispozitive apar în TapHome după import.

Shelly 2PM Gen3 Modul

Atribute de service

|                    |                                                                                             |
|--------------------|---------------------------------------------------------------------------------------------|
| Wi-Fi              |                                                                                             |
| Adresă IP          |                                                                                             |
| Puterea semnalului |                                                                                             |
| MAC                |                                                                                             |
| Profil             | Profilul activ al dispozitivului — switch (releu dublu) sau cover (jaluzea/rulou motorizat) |

Acțiuni de service

|                      |                                                                                                             |
|----------------------|-------------------------------------------------------------------------------------------------------------|
| Actualizare firmware |                                                                                                             |
| Repornire            |                                                                                                             |
| Setare profil        | Comutare între modurile de funcționare cover și switch — dispozitivul repornește după schimbarea profilului |

Variabile personalizate

Citire (modul)

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Sys.GetStatus");
IF response.IsSuccess
    Sys.GetStatus := response.Content;
END

response := SENDHTTPREQUEST("/rpc/Sys.GetConfig");
IF response.IsSuccess
    Sys.GetConfig := response.Content;
END

response := SENDHTTPREQUEST("/rpc/WiFi.GetStatus");
IF response.IsSuccess
    WiFi.GetStatus := response.Content;
END

if ! ISNULL(parsejson(Sys.GetStatus, "available_updates.stable", true))
    addwarning("New firmware update is available");
end

if parsejson(Sys.GetStatus, "restart_required", true)
    addwarning("Restart required");
end
```

Atribute de service

Wifi

```taphome
PARSEJSON(WiFi.GetStatus, "ssid")
```

${ipAddress}

```taphome
PARSEJSON(WiFi.GetStatus, "sta_ip")
```

${xml\_signal\_strength} \[dB]

```taphome
PARSEJSON(WiFi.GetStatus, "rssi")
```

MAC

```taphome
PARSEJSON(Sys.GetStatus, "mac")
```

Profile

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

Acțiuni de service

${xml\_update\_fw}

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Shelly.Update?stage=\"stable\"");
IF response.IsSuccess
    return("OK");
else
    return("Error");
END

```

${restart}

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Shelly.Reboot");
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

Set Profile

Parametri: Profile

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Shelly.SetProfile?name=\"" + 
switch(prof,
0, "cover",
1, "switch",
"")
+ "\"");
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

Întrerupător 1 Comutator Citire și scriere

Ieșirea de releu 1 cu monitorizarea puterii pe canal — necesită profilul switch

boolean

Valori / Stări: ON · OFF

Citirea stării comutatorului

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + ID);
IF response.IsSuccess
    Switch.GetStatus := response.Content;  
END
return(PARSEJSON(Switch.GetStatus, "$.output", true));
```

Scrierea stării comutatorului

```taphome
VAR response := SENDHTTPREQUEST("rpc/Switch.Set?id=" + ID + "&on=" + if(St,"true","false"));
IF response.IsSuccess = false
  ADDERROR(response.StatusCode);
END
```

Citire (modul)

```taphome
if PARSEJSON(Sys.GetConfig, "$.device.profile") != "switch"
	adderror("Profile is not set to switch (" + PARSEJSON(Sys.GetConfig, "$.device.profile") + ")");
end

VAR response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + ID);
IF response.IsSuccess
    Switch.GetStatus := response.Content;  
END

response := SENDHTTPREQUEST("/rpc/Switch.GetConfig?id=" + ID);
IF response.IsSuccess
    Switch.GetConfig := response.Content;
END

if ! ISNULL(parsejson(Switch.GetStatus, "errors", true))
    adderror("Error: " + parsejson(Switch.GetStatus, "errors"));
end
```

Atribute de service

${device\_variable\_realtemperature} \[°C]

```taphome
parsejson(Switch.GetStatus, "$.temperature.tC", true)
```

${device\_variable\_electricityconsumption} \[Wh]

```taphome
parsejson(Switch.GetStatus, "$.aenergy.total", true)
```

${device\_variable\_electricitydemand} \[W]

```taphome
parsejson(Switch.GetStatus, "$.apower", true)
```

${valueLogType\_ElectricVoltage} \[V]

```taphome
parsejson(Switch.GetStatus, "$.voltage", true)
```

${valueLogType\_ElectricCurrent} \[A]

```taphome
parsejson(Switch.GetStatus, "$.current", true)
```

${frequency} \[Hz]

```taphome
parsejson(Switch.GetStatus, "$.freq", true)
```

Power Factor

```taphome
parsejson(Switch.GetStatus, "$.pf", true)
```

Întrerupător 2 Comutator Citire și scriere

Ieșirea de releu 2 cu monitorizarea puterii pe canal — necesită profilul switch

boolean

Valori / Stări: ON · OFF

Citirea stării comutatorului

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + ID);
IF response.IsSuccess
    Switch.GetStatus := response.Content;  
END
return(PARSEJSON(Switch.GetStatus, "$.output", true));
```

Scrierea stării comutatorului

```taphome
VAR response := SENDHTTPREQUEST("rpc/Switch.Set?id=" + ID + "&on=" + if(St,"true","false"));
IF response.IsSuccess = false
  ADDERROR(response.StatusCode);
END
```

Citire (modul)

```taphome
if PARSEJSON(Sys.GetConfig, "$.device.profile") != "switch"
	adderror("Profile is not set to switch (" + PARSEJSON(Sys.GetConfig, "$.device.profile") + ")");
end

VAR response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=" + ID);
IF response.IsSuccess
    Switch.GetStatus := response.Content;  
END

response := SENDHTTPREQUEST("/rpc/Switch.GetConfig?id=" + ID);
IF response.IsSuccess
    Switch.GetConfig := response.Content;
END

if ! ISNULL(parsejson(Switch.GetStatus, "errors", true))
    adderror("Error: " + parsejson(Switch.GetStatus, "errors"));
end
```

Atribute de service

${device\_variable\_realtemperature} \[°C]

```taphome
parsejson(Switch.GetStatus, "$.temperature.tC", true)
```

${device\_variable\_electricityconsumption} \[Wh]

```taphome
parsejson(Switch.GetStatus, "$.aenergy.total", true)
```

${device\_variable\_electricitydemand} \[W]

```taphome
parsejson(Switch.GetStatus, "$.apower", true)
```

${valueLogType\_ElectricVoltage} \[V]

```taphome
parsejson(Switch.GetStatus, "$.voltage", true)
```

${valueLogType\_ElectricCurrent} \[A]

```taphome
parsejson(Switch.GetStatus, "$.current", true)
```

${frequency} \[Hz]

```taphome
parsejson(Switch.GetStatus, "$.freq", true)
```

Power Factor

```taphome
parsejson(Switch.GetStatus, "$.pf", true)
```

Rulou Glisare Citire și scriere

Rulou sau draperie motorizată cu comanda poziției — necesită profilul cover și calibrare

numeric Unitate: %

Atribute de service

|                    |
|--------------------|
| Temperatură        |
| Consum de energie  |
| Putere consumată   |
| Tensiune electrică |
| Curent electric    |

Acțiuni de service

|                            |
|----------------------------|
| Pornire calibrare automată |

Citire (modul)

```taphome
if PARSEJSON(Sys.GetConfig, "$.device.profile") != "cover"
	adderror("Profile is not set to cover (" + PARSEJSON(Sys.GetConfig, "$.device.profile") + ")");
end

VAR response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=" + ID);
IF response.IsSuccess
    Cover.GetStatus := response.Content;  
END

response := SENDHTTPREQUEST("/rpc/Cover.GetConfig?id=" + ID);
IF response.IsSuccess
    Cover.GetConfig := response.Content;
END

if ! parsejson(Cover.GetStatus, "$.pos_control", true)
    #adderror("${presence_calibration_required}");
    adderror("Calibration is required");
end

if ! ISNULL(parsejson(Cover.GetStatus, "errors", true))
    adderror("Error: " + parsejson(Cover.GetStatus, "errors"));
end
```

Citirea nivelului jaluzelei

```taphome
var pos := PARSEJSON(Cover.GetStatus, "$.current_pos", true);
if ! isnull(PARSEJSON(Cover.GetStatus, "$.target_pos", true))
	pos := PARSEJSON(Cover.GetStatus, "$.target_pos", true);
end

return(linear(pos,0,1,100,0));
```

Scrierea nivelului jaluzelei

```taphome
VAR response := SENDHTTPREQUEST("rpc/Cover.GoToPosition?id=" + ID + "&pos=" + round(linear(Bl,0,100,1,0)));
IF response.IsSuccess = false
  ADDERROR(response.StatusCode);
END

response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=" + ID);
IF response.IsSuccess
    Cover.GetStatus := response.Content;  
END
```

Atribute de service

${device\_variable\_realtemperature} \[°C]

```taphome
parsejson(Cover.GetStatus, "$.temperature.tC", true)
```

${device\_variable\_electricityconsumption} \[Wh]

```taphome
parsejson(Cover.GetStatus, "$.aenergy.total", true)
```

${device\_variable\_electricitydemand} \[W]

```taphome
parsejson(Cover.GetStatus, "$.apower", true)
```

${valueLogType\_ElectricVoltage} \[V]

```taphome
parsejson(Cover.GetStatus, "$.voltage", true)
```

${valueLogType\_ElectricCurrent} \[A]

```taphome
parsejson(Cover.GetStatus, "$.current", true)
```

Acțiuni de service

${start\_automatic\_calibration}

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Cover.Calibrate?id=" + ID);
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

Jaluzea Jaluzea Citire și scriere

Jaluzea venețiană cu comanda poziției și a înclinării lamelelor — necesită profilul cover, calibrare și comanda lamelelor activată

numeric Unitate: %

Atribute de service

|                                |                                                                                     |
|--------------------------------|-------------------------------------------------------------------------------------|
| Temperatură                    |                                                                                     |
| Consum de energie              |                                                                                     |
| Putere consumată               |                                                                                     |
| Tensiune electrică             |                                                                                     |
| Curent electric                |                                                                                     |
| Lamele                         | Indică dacă comanda înclinării lamelelor este activată în configurația Shelly Cover |
| Timp de deschidere a lamelelor |                                                                                     |
| Timp de închidere a lamelelor  |                                                                                     |

Acțiuni de service

|                            |                                                                                                          |
|----------------------------|----------------------------------------------------------------------------------------------------------|
| Pornire calibrare automată |                                                                                                          |
| Setare lamele              | Activează comanda lamelelor și configurează duratele de deschidere/închidere a lamelelor (0,1–5 secunde) |

Citire (modul)

```taphome
if PARSEJSON(Sys.GetConfig, "$.device.profile") != "cover"
	adderror("Profile is not set to cover (" + PARSEJSON(Sys.GetConfig, "$.device.profile") + ")");
end

VAR response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=" + ID);
IF response.IsSuccess
    Cover.GetStatus := response.Content;  
END

response := SENDHTTPREQUEST("/rpc/Cover.GetConfig?id=" + ID);
IF response.IsSuccess
    Cover.GetConfig := response.Content;
END

if ! parsejson(Cover.GetStatus, "$.pos_control", true)
    #adderror("${presence_calibration_required}");
    adderror("Calibration is required");
end

if ! ISNULL(parsejson(Cover.GetStatus, "errors", true))
    adderror("Error: " + parsejson(Cover.GetStatus, "errors"));
end
```

Citirea nivelului jaluzelei

```taphome
var pos := PARSEJSON(Cover.GetStatus, "$.current_pos", true);
var target := PARSEJSON(Cover.GetStatus, "$.target_pos", true);
var slatPos := PARSEJSON(Cover.GetStatus, "$.slat_pos", true);

BlSend := 0;
if BsSend = 0 and (Bs = 0 or Bs = 1) 
	if (!isnull(target))
		DeltaPos := 0;
		return(linear(target,0,1,100,0));
	else
		return(linear(pos - DeltaPos,0,1,100,0));	
	end
end

return(Bl);
```

Scrierea nivelului jaluzelei

```taphome
var pos := PARSEJSON(Cover.GetStatus, "$.current_pos", true);
var target := PARSEJSON(Cover.GetStatus, "$.target_pos", true);
var slatPos := PARSEJSON(Cover.GetStatus, "$.slat_pos", true);

VAR response := SENDHTTPREQUEST("rpc/Cover.GoToPosition?id=0&pos=" + round(linear(Bl,0,100,1,0)));
BlSend := 1;
IF response.IsSuccess = false
  ADDERROR(response.StatusCode);
END

#response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=0");
#IF response.IsSuccess
#    Cover.GetStatus := response.Content;  
#END
```

Citirea înclinării jaluzelei

```taphome
var pos := PARSEJSON(Cover.GetStatus, "$.current_pos", true);
var slatPos := PARSEJSON(Cover.GetStatus, "$.slat_pos", true);
var state := PARSEJSON(Cover.GetStatus, "$.state", true);
var date := NOW();

if ISNULL(slatPos)
    adderror("Slat position must be enabled for blinds");
    return(NaN);
end

if state = "closing" or state = "opening"
	BsSend := 1;
	return(Bs);
end

if BsSend > 1
	BsSend := 1;
	return(Bs);
else
	if BsSend = 1
		BsSend := 0;
		DeltaPos := pos - round(linear(Bl,0,100,1,0));	
	end
	return(linear(slatPos,0,1,100,0));
end
```

Scrierea înclinării jaluzelei

```taphome
var date := NOW();
var pos := PARSEJSON(Cover.GetStatus, "$.current_pos", true);

if BlSend = 0
	VAR response := SENDHTTPREQUEST("rpc/Cover.GoToPosition?id=0&pos=" + pos + "&slat_pos=" + round(linear(Bs,0,100,1,0)));
	BsSend := date.UNIXTIME;
	IF response.IsSuccess = false
	  ADDERROR(response.StatusCode);
	END
end

#response := SENDHTTPREQUEST("/rpc/Cover.GetStatus?id=0");
#IF response.IsSuccess
#    Cover.GetStatus := response.Content;  
#END
```

Atribute de service

${device\_variable\_realtemperature} \[°C]

```taphome
parsejson(Cover.GetStatus, "$.temperature.tC", true)
```

${device\_variable\_electricityconsumption} \[Wh]

```taphome
parsejson(Cover.GetStatus, "$.aenergy.total", true)
```

${device\_variable\_electricitydemand} \[W]

```taphome
parsejson(Cover.GetStatus, "$.apower", true)
```

${valueLogType\_ElectricVoltage} \[V]

```taphome
parsejson(Cover.GetStatus, "$.voltage", true)
```

${valueLogType\_ElectricCurrent} \[A]

```taphome
parsejson(Cover.GetStatus, "$.current", true)
```

Slat

```taphome
if(parsejson(Cover.GetConfig, "$.slat.enable", true), "Enabled", "Disabled")
```

Slat open time \[s]

```taphome
parsejson(Cover.GetConfig, "$.slat.open_time ", true)
```

Slat close time \[s]

```taphome
parsejson(Cover.GetConfig, "$.slat.open_time ", true)
```

Acțiuni de service

${start\_automatic\_calibration}

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Cover.Calibrate?id=" + ID);
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

Set Slat

Parametri: Open time \[s] (0.1–5 ot), Close time \[s] (0.1–5 ct)

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Cover.SetConfig?id=" + ID + 
	"&config={\"slat\":{\"enable\":true, \"open_time\": " + ot +", \"close_time\": " + ct +"}}");
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

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

Îmbunătățiri posibile (11)

- Input 1 State — Physical switch/button input 1 state, available via /rpc/Input.GetStatus?id=0
- Input 2 State — Physical switch/button input 2 state, available via /rpc/Input.GetStatus?id=1
- Returned Energy — Returned/exported energy in Wh, for bi-directional metering scenarios
- Uptime — Seconds since last reboot, available in Sys.GetStatus response
- RAM Usage — Total and free RAM in bytes, available in Sys.GetStatus response
- Device Time — Current device time in HH:MM format, available in Sys.GetStatus response
- Auto-off Timer — Auto-reset timer in seconds via toggle\_after parameter, could be added as switch parameter
- Reset Energy Counters — Resets energy measurement counters (aenergy, ret\_aenergy) for both channels
- Overpower Protection — Configurable power limit threshold in Watts, relay turns off when exceeded
- Cover State — Cover movement state (open/opening/closed/closing/stopped/calibrating), available in Cover.GetStatus
- Cover Open/Close/Stop Commands — Direct open/close/stop commands without position parameter; template uses GoToPosition instead

## 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+/Gen3 RPC API Reference
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/) 2026-03-27
- Shelly Gen2+ Switch Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Switch/) 2026-03-27
- Shelly Gen2+ System (Sys) Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Sys/) 2026-03-27
- Shelly Gen2+ WiFi Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/WiFi/) 2026-03-27
- Home Assistant Shelly Integration
  
  [www.home-assistant.io](https://www.home-assistant.io/integrations/shelly/) 2026-03-27
- Shelly 2PM Gen3 Knowledge Base
  
  [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-2pm-gen3) 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/)

