---
title: "Shelly Plus Plug S"
description: "Comutați sarcini până la 12 A, măsurați puterea (kW), energia (kWh), tensiunea, curentul și temperatura prin Gen2+ HTTP RPC. Inel LED RGB cu trei moduri."
url: "https://taphome.com/ro/compatibility/shelly-plus-plug-s/"
language: ro
lastmod: 2026-10-08
generator: hugo
ai:
  topics: ["http","smart-plug","electric-meter","wifi","gen2plus","rpc-api","mdns","power-metering","led-ring"]
  questions: ["Cum integrez Shelly Plus Plug S cu TapHome?","Ce măsoară șablonul TapHome pentru Shelly Plus Plug S?","Cum conectez Shelly Plus Plug S prin HTTP la TapHome?","Care sunt cele trei moduri ale inelului LED pe Shelly Plus Plug S?","Cum schimb culoarea inelului LED din TapHome?","De ce Shelly Plus Plug S afișează o putere zero?"]
---

# Shelly Plus Plug S

Comunicație: Packet Parser → HTTP

- [Baza de cunoștințe Shelly Plus Plug S](https://kb.shelly.cloud/knowledge-base/shelly-plus-plug-s)
- [Documentația API RPC Shelly Gen2+](https://shelly-api-docs.shelly.cloud/gen2/)

> 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 Plug S este o priză inteligentă Wi-Fi Gen2+ cu măsurarea integrată a puterii și un inel LED multicolor de semnalizare. Se introduce într-o priză standard CEE 7/3 (Type-F / Schuko) și poate comuta sarcini de până la 12 A / 2760 W la 230 V. TapHome comunică cu dispozitivul local, prin Wi-Fi, folosind API-ul JSON-RPC Gen2+ pe portul 80 — nu este necesară conexiunea la cloud.

Șablonul pune la dispoziție șase dispozitive TapHome pentru această priză: un întrerupător cu releu, un contor electric, un selector al modului de semnalizare LED, două selectoare de culoare LED (pentru stările releului pornit și oprit) și un dimmer pentru reglarea luminozității în modul de semnalizare a puterii.

## Configurare

### Împerecherea și configurarea rețelei

La prima pornire, dispozitivul intră în modul punct de acces, cu SSID-ul `ShellyPlusPlugS-XXXXXX` (LED-ul clipește albastru). Conectați-vă la acest SSID, deschideți `http://192.168.33.1/` și conectați priza la rețeaua Wi-Fi locală din interfața web. După ce priza se conectează la rețeaua locală, este accesibilă pe portul 80 la adresa IP atribuită în modul stație și prin mDNS la `shellyplusplugs-<MAC>.local`.

TapHome interoghează endpointurile RPC Gen2+ prin HTTP simplu — HTTPS este dezactivat implicit, iar autentificarea HTTP (`Shelly.SetAuth`) trebuie să rămână dezactivată pentru ca șablonul să funcționeze. Asigurați-vă că priza se află în aceeași rețea locală / VLAN ca TapHome Core.

La importul șablonului în TapHome, introduceți adresa IP a prizei în parametrul `IpAddress`. Se recomandă insistent o rezervare DHCP statică, pentru ca adresa să nu se schimbe între reporniri.

## Funcțiile dispozitivului

### Comanda releului

Releul este oferit ca dispozitiv de tip întrerupător. Starea sa se citește din `/rpc/Switch.GetStatus?id=0` (valoarea booleană `output`), iar releul se comandă prin `/rpc/Switch.Set?id=0&on=true|false`. Modulul păstrează întregul răspuns `Switch.GetStatus`, astfel încât releul, contorul și atributele de service folosesc împreună un singur apel HTTP la fiecare interogare.

### Măsurarea puterii și a energiei

Contorul integrat al componentei Switch oferă:

- **Putere instantanee** — `apower` în wați, convertită de șablon în kW (împărțire la 1000)
- **Energie cumulată** — `aenergy.total` în wați-oră, convertită în kWh (împărțire la 1000)

Alte trei valori sunt oferite ca atribute de service ale contorului:

| Atribut | Unitate | Câmp sursă |
|-----------|------|--------------|
| Curent | A | `current` |
| Tensiune | V | `voltage` |
| Temperatură | °C | `temperature.tC` |

Contorul este doar pentru citire și se actualizează la fiecare ciclu de interogare.

### Modul de semnalizare LED

Inelul LED multicolor este comandat de componenta RPC `PLUGS_UI`, specifică modelului Plus Plug S. TapHome oferă un selector de mod cu trei opțiuni valide — deși șablonul are zece poziții în listă, doar primele trei corespund unor moduri reale din firmware:

| Valoare | Comportament |
|-------|-----------|
| `off` | Inelul LED este dezactivat (stările de diagnosticare Wi-Fi / AP / firmware sunt afișate în continuare) |
| `switch` | Culoarea LED-ului reflectă starea releului — folosește culorile pentru OPRIT și PORNIT definite de utilizator |
| `power` | Culoarea LED-ului reflectă sarcina măsurată ca fracțiune din limita de putere configurată (gradient verde → galben → roșu) |

Trecerea de la un mod la altul este o modificare vizuală și nu necesită repornire.

### Culorile LED (modul Întrerupător)

Două dispozitive HSB independente vă permit să alegeți culoarea inelului LED pentru fiecare stare a releului:

- **Culoare LED (starea OPRIT)** — culoarea și luminozitatea afișate cât timp releul este oprit
- **Culoare LED (starea PORNIT)** — culoarea și luminozitatea afișate cât timp releul este pornit

Ambele corespund `leds.colors.switch:0.{off|on}.{rgb,brightness}` din configurația `PLUGS_UI`. Shelly stochează valorile RGB în procente (0–100 pe canal), nu 0–255, așa că șablonul înmulțește fiecare canal cu 2,55 la conversia între HSV și formatul nativ al dispozitivului. Această conversie este internă — în TapHome, dispozitivele se comportă ca orice alt selector de culoare HSB.

### Luminozitatea LED (modul Putere)

Când LED-ul este în modul `power`, culoarea este aleasă automat de firmware în funcție de sarcină. Doar luminozitatea poate fi configurată de utilizator, de aceea șablonul o oferă ca dimmer (`leds.colors.power.brightness`, 0–100 % convertit în nivelul de dimmer TapHome 0,0–1,0).

### Diagnosticarea și acțiunile modulului

Modulul HTTP oferă patru atribute de service, preluate din `/rpc/WiFi.GetStatus` și `/rpc/Sys.GetStatus`:

| Atribut | Sursă |
|-----------|--------|
| SSID Wi-Fi | `ssid` |
| Adresă IP | `sta_ip` |
| Puterea semnalului | `rssi` (dBm) |
| Adresă MAC | `mac` |

Sunt disponibile și două acțiuni de service:

- **Actualizare firmware** — pornește o actualizare OTA din canalul stabil (`/rpc/Shelly.Update?stage="stable"`). Firmware-ul instalează actualizarea doar dacă este disponibilă (`available_updates.stable` în `Sys.GetStatus`).
- **Repornire** — repornește dispozitivul (`/rpc/Shelly.Reboot`), util după modificarea configurației rețelei sau pentru eliminarea problemelor temporare.

> [!TIP]
> Dacă aveți nevoie doar de comanda pornit/oprit și de monitorizarea de bază a energiei, ignorați dispozitivele LED — sunt opționale. Releul și contorul funcționează independent de modul de semnalizare LED.

## Rezolvarea problemelor

### Dispozitivul nu răspunde

1. Verificați dacă priza este conectată la Wi-Fi — LED-ul nu trebuie să clipească și nici să lumineze continuu roșu
2. Încercați numele de gazdă mDNS `shellyplusplugs-<MAC>.local` în locul adresei IP — alocarea DHCP s-ar fi putut schimba
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 priza sunt în aceeași rețea locală / VLAN
5. Asigurați-vă că autentificarea HTTP este dezactivată în interfața web Shelly — șablonul nu acceptă autentificarea digest

### Puterea afișată este zero

1. Verificați dacă sarcina este într-adevăr conectată în priza Shelly, nu ocolește priza
2. Verificați dacă releul este pornit — contorul raportează 0 W când releul este deschis
3. Interogați direct `/rpc/Switch.GetStatus?id=0` în browser și verificați dacă `apower` este diferită de zero

### LED-ul nu se schimbă după schimbarea modului

1. LED-ul reflectă starea curentă doar în modurile `switch` și `power`; în modul `off` rămâne stins, cu excepția semnalizărilor de diagnosticare ale sistemului (mod AP, reconectare, OTA)
2. În modul `switch`, asigurați-vă că culorile pentru PORNIT și OPRIT nu sunt setate amândouă la negru / luminozitate 0 %
3. Semnalizările sistemului (albastru intermitent pentru modul AP, roșu pentru probleme Wi-Fi) au întotdeauna prioritate față de configurația LED a utilizatorului — dacă LED-ul clipește roșu, priza nu este conectată la rețeaua dvs. Wi-Fi

### Acțiunea de actualizare a firmware-ului nu se execută

1. Firmware-ul instalează actualizarea doar când `Sys.GetStatus` raportează `available_updates.stable` — dacă priza este deja actualizată, acțiunea nu are ce instala
2. Șablonul folosește doar canalul stabil; firmware-ul beta trebuie instalat din interfața web Shelly

## 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 Plug S Modul

Atribute de service

|                    |                                                                                                                                             |
|--------------------|---------------------------------------------------------------------------------------------------------------------------------------------|
| SSID Wi-Fi         |                                                                                                                                             |
| Adresă IP          |                                                                                                                                             |
| Puterea semnalului | Puterea semnalului Wi-Fi în dBm — valorile mai apropiate de 0 indică o conexiune mai puternică (de ex. −55 dBm este bun, −80 dBm este slab) |
| Adresă MAC         |                                                                                                                                             |

Acțiuni de service

|                      |                                                                                                                   |
|----------------------|-------------------------------------------------------------------------------------------------------------------|
| Actualizare firmware | Pornește o actualizare de firmware prin rețea (OTA) din canalul stabil Shelly                                     |
| Repornire            | Repornește dispozitivul — util după modificarea configurației rețelei sau pentru eliminarea problemelor temporare |

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

response := SENDHTTPREQUEST("/rpc/PLUGS_UI.GetConfig");
IF response.IsSuccess
    PLUGS_UI.GetConfig := 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")
```

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

```

Reboot

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

Întrerupător Comutator Citire și scriere

boolean

Valori / Stări: ON · OFF

Citirea stării comutatorului

```taphome
var x := (sendhttprequest("/rpc/Switch.GetStatus?id=0"));
var status := x.Content;
return(PARSEJSON(status, "$.output", true));
```

Scrierea stării comutatorului

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

Contor electric Contor electric Doar citire

Putere instantanee (kW) și energie cumulată (kWh) măsurate de contorul integrat, cu diagnosticarea curentului, tensiunii și temperaturii interne

numeric Unitate: kW / kWh

Atribute de service

|             |                                                                                         |
|-------------|-----------------------------------------------------------------------------------------|
| Curent      |                                                                                         |
| Tensiune    |                                                                                         |
| Temperatură | Temperatura internă a dispozitivului în °C — priza se oprește automat la supraîncălzire |

Citirea consumului total

```taphome
return(parsejson(parsejson(Switch.GetStatus,"aenergy"), "total")/1000);
```

Citirea cererii

```taphome
return(parsejson(Switch.GetStatus,"apower")/1000);
```

Citire (modul)

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

Atribute de service

${electric\_current} \[A]

```taphome
return(parsejson(Switch.GetStatus,"current"));
```

${electric\_voltage} \[V]

```taphome
return(parsejson(Switch.GetStatus,"voltage"));
```

${temperature} \[°C]

```taphome
return(parsejson(parsejson(Switch.GetStatus,"temperature"), "tC"));
```

Mod de semnalizare LED Comutator cu mai multe valori Citire și scriere

Comportamentul inelului LED — Oprit (dezactivat), Întrerupător (culoarea reflectă starea releului) sau Putere (culoarea reflectă sarcina: verde → galben → roșu)

string enum

Valori / Stări: ${xml\_off} · ${switch} · ${xml\_power}

Citirea stării comutatorului

```taphome
switch(parsejson(PLUGS_UI.GetConfig, "leds.mode"), "power", 2, "switch", 1, 0)
```

Scrierea stării comutatorului

```taphome
VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"mode\":\"" + switch(Mu, 2, "power", 1, "switch", "off") + "\"}}");

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

Culoare LED (starea OPRIT) Lumină HSB Citire și scriere

Culoarea RGB și luminozitatea inelului LED cât timp releul este oprit (folosite în modul de semnalizare Întrerupător)

HSB (hue, saturation, brightness) hsv-to-rgb

Citirea luminozității

```taphome
parsejson(PLUGS_UI.GetConfig, basePath + ".brightness") / 100
```

Scrierea luminozității

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"off\":{\"brightness\":" + Hb*100 + "}}}}}");

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

Citirea nuanței

```taphome
VAR HSVColor := RGBTOHSV(parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[0]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[1]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[2]") *2.55);

HSVColor.Hue
```

Scrierea nuanței

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"off\":{\"rgb\":[" + rgb.red/2.55 + "," + rgb.green/2.55 + "," + rgb.blue/2.55 + "],\"brightness\":" + Hb*100 + "}}}}}");

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

Citirea saturației

```taphome
VAR HSVColor := RGBTOHSV(parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[0]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[1]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[2]") *2.55);

HSVColor.Saturation
```

Scrierea saturației

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"off\":{\"rgb\":[" + rgb.red/2.55 + "," + rgb.green/2.55 + "," + rgb.blue/2.55 + "],\"brightness\":" + Hb*100 + "}}}}}");

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

Culoare LED (starea PORNIT) Lumină HSB Citire și scriere

Culoarea RGB și luminozitatea inelului LED cât timp releul este pornit (folosite în modul de semnalizare Întrerupător)

HSB (hue, saturation, brightness) hsv-to-rgb

Citirea luminozității

```taphome
parsejson(PLUGS_UI.GetConfig, basePath + ".brightness") / 100
```

Scrierea luminozității

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"on\":{\"brightness\":" + Hb*100 + "}}}}}");

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

Citirea nuanței

```taphome
VAR HSVColor := RGBTOHSV(parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[0]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[1]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[2]") *2.55);

HSVColor.Hue
```

Scrierea nuanței

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"on\":{\"rgb\":[" + rgb.red/2.55 + "," + rgb.green/2.55 + "," + rgb.blue/2.55 + "],\"brightness\":" + Hb*100 + "}}}}}");

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

Citirea saturației

```taphome
VAR HSVColor := RGBTOHSV(parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[0]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[1]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[2]") *2.55);

HSVColor.Saturation
```

Scrierea saturației

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"on\":{\"rgb\":[" + rgb.red/2.55 + "," + rgb.green/2.55 + "," + rgb.blue/2.55 + "],\"brightness\":" + Hb*100 + "}}}}}");

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

Luminozitate LED (modul Putere) Dimmer Citire și scriere

Luminozitatea inelului LED în modul de semnalizare Putere — culoarea este aleasă automat de firmware în funcție de sarcină

numeric

Citirea nivelului

```taphome
parsejson(PLUGS_UI.GetConfig, "leds.colors.power.brightness") / 100
```

Scrierea nivelului

```taphome
VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"power\":{\"brightness\":" + Le*100 + "}}}}");

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

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

Îmbunătățiri posibile (23)

- Power Factor — Power factor (0.0–1.0) reported in Switch.GetStatus response for metered devices
- Line Frequency — AC line frequency in Hz, available in Switch.GetStatus response
- Returned Energy — Returned/exported energy in Wh, for bi-directional metering scenarios
- Per-minute Energy History — Rolling three-minute energy buffer in mWh, useful for fine-grained load profiling
- Toggle Relay — Toggles the relay state without needing to know current state; not mapped as a TapHome service action
- Auto-off Timer — Optional toggle\_after parameter (seconds) on Switch.Set — relay auto-reverts after N seconds
- Overpower Protection — Configurable power limit (W); firmware turns the relay off when exceeded. Template does not expose a setter
- Over-voltage / Over-current Protection — Voltage and current safety thresholds configurable via Switch.SetConfig; not exposed by template
- Initial State After Power-up — Relay behaviour after power loss (off / on / restore\_last / match\_input); not exposed by template
- Reset Energy Counters — Resets aenergy / ret\_aenergy counters; not exposed by template
- Button Input Mode — Physical button behaviour (momentary / detached); device-internal, not exposed as a TapHome input
- LED Night Mode — Dims the LED ring during a configurable HH:MM window (wraps midnight); not mapped by template
- Local Scheduler — On-device cron-like scheduler for relay actions; no TapHome equivalent (TapHome uses its own schedules)
- Webhooks — Outbound HTTP webhooks on device events; not used by template (TapHome polls instead)
- mJS Scripts — Up to 10 on-device mJS scripts; out of scope for TapHome integration
- Shelly Cloud Connection — Cloud connection status and enable/disable toggle; not mapped by template (TapHome communicates locally)
- Bluetooth LE Configuration — BLE gateway enable/disable and observer mode; not exposed by template
- MQTT Transport Config — Inbound/outbound MQTT RPC transport config; template uses HTTP exclusively
- System Diagnostics — Uptime, RAM/FS utilisation, last reset reason — available in cached Sys.GetStatus but not surfaced as attributes
- Device Time — Device wall-clock (HH:MM) and unix epoch; not surfaced as attribute
- Beta Firmware Availability — Template warns on available\_updates.stable but ignores the beta channel
- Factory Reset — Restores factory defaults; not exposed by template (deliberately destructive)
- HTTP Authentication — Enables digest auth on the RPC endpoint; template assumes no-auth local access

## 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-29
- Shelly Gen2+ Switch Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Switch/) 2026-03-29
- Shelly Gen2+ System (Sys) Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Sys/) 2026-03-29
- Shelly Gen2+ WiFi Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/WiFi/) 2026-03-29
- Shelly Gen2+ MQTT Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Mqtt/) 2026-03-29
- Home Assistant Shelly Integration
  
  [www.home-assistant.io](https://www.home-assistant.io/integrations/shelly/) 2026-03-29
- Shelly Plus Plug S Knowledge Base — specs, wiring, LED indication
  
  [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-plus-plug-s) 2026-04-24
- Shelly Plus Plug S RPC API — PLUGS\_UI component (device-specific)
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/Devices/Gen2/ShellyPlusPlugS/) 2026-04-24

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

