---
title: "Shelly Plus Plug S"
description: "Shelly Plus Plug S via HTTP locale in TapHome: commuta carichi fino a 2760 W, misura potenza ed energia e imposta colori e modalità dell'anello LED."
url: "https://taphome.com/it/compatibility/shelly-plus-plug-s/"
language: it
lastmod: 2026-10-08
generator: hugo
ai:
  topics: ["http","smart-plug","electric-meter","wifi","gen2plus","rpc-api","mdns","power-metering","led-ring"]
  questions: ["Come integrare Shelly Plus Plug S con TapHome?","Cosa misura il template TapHome per Shelly Plus Plug S?","Come collegare Shelly Plus Plug S via HTTP a TapHome?","Quali sono le tre modalità dell'anello LED su Shelly Plus Plug S?","Come cambiare il colore dell'anello LED da TapHome?","Perché Shelly Plus Plug S mostra letture di potenza a zero?"]
---

# Shelly Plus Plug S

Comunicazione: Packet Parser → HTTP

- [Shelly Plus Plug S – knowledge base](https://kb.shelly.cloud/knowledge-base/shelly-plus-plug-s)
- [Documentazione Shelly Gen2+ RPC API](https://shelly-api-docs.shelly.cloud/gen2/)

> Indirizzo di rete
> 
> TapHome raggiunge il dispositivo all'indirizzo inserito durante l'importazione. Assegna al dispositivo un indirizzo fisso — una prenotazione IP nel router, oppure il suo nome mDNS se lo supporta —, altrimenti l'integrazione smette di funzionare quando il router cambia l'indirizzo.
> 
> [Preparazione della rete](https://taphome.com/it/docs/setup/network-preparation/)

## Guida all'integrazione

Shelly Plus Plug S è una presa smart Wi-Fi Gen2+ con misura di energia integrata e anello LED multicolore. Si inserisce in una normale presa CEE 7/3 (Type-F / Schuko) e può commutare carichi fino a 12 A / 2760 W a 230 V. TapHome comunica con il dispositivo localmente via Wi-Fi utilizzando l'API JSON-RPC Gen2+ sulla porta 80 — non è richiesta alcuna connessione cloud.

Il template espone la presa come sei dispositivi TapHome: un interruttore a relè, un contatore elettrico, un selettore di modalità di indicazione LED, due selettori di colore LED (per gli stati relè ON e OFF) e un dimmer di luminosità per la modalità di indicazione di potenza.

## Configurazione

### Associazione e configurazione di rete

All'accensione iniziale il dispositivo entra in modalità access point con SSID `ShellyPlusPlugS-XXXXXX` (LED lampeggia in blu). Connettiti a questo SSID, apri `http://192.168.33.1/` e seleziona la tua rete Wi-Fi domestica dall'interfaccia web. Dopo l'accesso alla LAN, la presa è raggiungibile sulla porta 80 al suo indirizzo IP di stazione e via mDNS all'indirizzo `shellyplusplugs-<MAC>.local`.

TapHome interroga gli endpoint RPC Gen2+ su HTTP non cifrato — HTTPS è disabilitato per impostazione predefinita e l'autenticazione HTTP (`Shelly.SetAuth`) deve rimanere disabilitata affinché il template funzioni. Assicurati che la presa si trovi sulla stessa LAN / VLAN del TapHome Core.

Durante l'importazione del template in TapHome, fornisci l'indirizzo IP della presa come parametro `IpAddress`. Si consiglia vivamente di configurare una prenotazione DHCP statica in modo che l'indirizzo non cambi tra i riavvii.

## Capacità del dispositivo

### Controllo relè

Il relè è esposto come dispositivo interruttore. Il suo stato viene letto da `/rpc/Switch.GetStatus?id=0` (booleano `output`) e controllato via `/rpc/Switch.Set?id=0&on=true|false`. Il modulo memorizza in cache l'intera risposta di `Switch.GetStatus`, così il relè, il contatore e gli attributi di servizio condividono una singola chiamata HTTP per polling.

### Misura di potenza ed energia

Il contatore integrato nel componente Switch fornisce:

- **Potenza istantanea** — `apower` in watt, convertita in kW dal template (divisa per 1000)
- **Energia cumulativa** — `aenergy.total` in wattora, convertita in kWh (divisa per 1000)

Altre tre letture sono esposte come attributi di servizio sul contatore:

| Attributo | Unità | Campo sorgente |
|-----------|-------|----------------|
| Corrente | A | `current` |
| Tensione | V | `voltage` |
| Temperatura | °C | `temperature.tC` |

Il contatore è di sola lettura e si aggiorna ad ogni ciclo di polling.

### Modalità di indicazione LED

L'anello LED multicolore è controllato dal componente RPC `PLUGS_UI` specifico di Plus Plug S. TapHome espone un selettore di modalità con tre opzioni valide — nonostante il template elenchi dieci slot enum, solo i primi tre corrispondono a modalità firmware reali:

| Valore | Comportamento |
|--------|---------------|
| `off` | Anello LED disabilitato (gli stati diagnostici Wi-Fi / AP / firmware vengono comunque mostrati) |
| `switch` | Il colore del LED riflette lo stato del relè — utilizza i colori OFF e ON definiti dall'utente |
| `power` | Il colore del LED riflette il carico misurato come frazione del limite di potenza configurato (gradiente verde → giallo → rosso) |

La commutazione tra modalità è un cambiamento estetico e non richiede un riavvio.

### Colori LED (modalità switch)

Due dispositivi HSB indipendenti permettono di scegliere il colore dell'anello LED per ogni stato del relè:

- **Colore LED (stato OFF)** — colore e luminosità quando il relè è spento
- **Colore LED (stato ON)** — colore e luminosità quando il relè è acceso

Entrambi vengono mappati su `leds.colors.switch:0.{off|on}.{rgb,brightness}` nella configurazione `PLUGS_UI`. Shelly memorizza i valori RGB in percentuale (0–100 per canale), non 0–255, quindi il template moltiplica ogni canale per 2,55 durante la conversione tra HSV e il formato nativo del dispositivo. La conversione è interna — da TapHome i dispositivi si comportano come qualsiasi altro selettore di colore HSB.

### Luminosità LED (modalità power)

Quando il LED è in modalità `power`, il colore viene scelto automaticamente dal firmware in base al carico. Solo la luminosità è configurabile dall'utente, quindi il template la espone come dimmer (`leds.colors.power.brightness`, 0–100 % scalato su un livello dimmer TapHome 0,0–1,0).

### Diagnostica e azioni del modulo

Il modulo HTTP espone quattro attributi di servizio analizzati da `/rpc/WiFi.GetStatus` e `/rpc/Sys.GetStatus`:

| Attributo | Sorgente |
|-----------|----------|
| SSID Wi-Fi | `ssid` |
| Indirizzo IP | `sta_ip` |
| Intensità del segnale | `rssi` (dBm) |
| Indirizzo MAC | `mac` |

Sono disponibili anche due azioni di servizio:

- **Aggiornamento firmware** — avvia un aggiornamento OTA dal canale stabile (`/rpc/Shelly.Update?stage="stable"`). Il firmware installa un aggiornamento solo se disponibile (`available_updates.stable` in `Sys.GetStatus`).
- **Riavvio** — riavvia il dispositivo (`/rpc/Shelly.Reboot`), utile dopo modifiche alla configurazione di rete o per risolvere problemi transitori.

> [!TIP]
> Se serve solo il controllo on/off e il monitoraggio energetico di base, ignora i dispositivi LED — sono opzionali. Il relè e il contatore funzionano indipendentemente dalla modalità di indicazione LED.

## Risoluzione dei problemi

### Il dispositivo non risponde

1. Verifica che la presa sia connessa al Wi-Fi — il LED non dovrebbe lampeggiare né rimanere rosso fisso
2. Prova il nome host mDNS `shellyplusplugs-<MAC>.local` al posto dell'indirizzo IP — il lease DHCP potrebbe essere cambiato
3. Apri `http://{ip-dispositivo}/rpc/Shelly.GetDeviceInfo` nel browser; se risponde con JSON, il dispositivo è raggiungibile
4. Conferma che TapHome Core e la presa si trovino sulla stessa LAN / VLAN
5. Assicurati che l'autenticazione HTTP sia disabilitata nell'interfaccia web Shelly — il template non supporta l'autenticazione digest

### Le letture di potenza mostrano zero

1. Verifica che un carico sia effettivamente collegato alla Shelly e non bypassato
2. Controlla che il relè sia acceso — il contatore riporta 0 W quando il relè è aperto
3. Interroga direttamente `/rpc/Switch.GetStatus?id=0` nel browser e verifica che `apower` sia diverso da zero

### Il LED non cambia dopo il cambio di modalità

1. Il LED riflette lo stato runtime solo nelle modalità `switch` e `power`; in modalità `off` rimane scuro tranne per i pattern di diagnostica di sistema (modalità AP, riconnessione, OTA)
2. In modalità `switch` assicurati che i colori ON e OFF non siano entrambi impostati su nero / 0 % luminosità
3. Le indicazioni di sistema (lampeggio blu in modalità AP, rosso per problemi Wi-Fi) sovrascrivono sempre la configurazione utente del LED — se il LED lampeggia in rosso, la presa non è nella tua rete Wi-Fi

### L'azione di aggiornamento firmware non si avvia

1. Il firmware installa l'aggiornamento solo quando `Sys.GetStatus` segnala `available_updates.stable` — se la presa è già aggiornata, l'azione non ha nulla da installare
2. Il template mira solo al canale stabile; il firmware beta deve essere installato dall'interfaccia web Shelly

## Come installare in TapHome

### Prerequisiti

- Dispositivo Shelly installato e acceso
- Rete Wi-Fi locale (2,4 GHz)
- TapHome CCU sulla stessa rete

### Passaggio 1 — Collegare Shelly al Wi-Fi

**Opzione A — App Shelly (consigliata):**

1. Scarica l'[app Shelly](https://www.shelly.com/en/support/shelly-app) (iOS / Android)
2. Tocca **+** → **Add Device** e segui la procedura guidata di associazione Bluetooth
3. Inserisci le credenziali Wi-Fi quando richiesto

**Opzione B — Modalità AP (senza app):**

1. Al primo avvio il dispositivo crea un hotspot: `ShellyXXX-AABBCCDDEE`
2. Collega il tuo telefono/PC a questo hotspot
3. Apri `http://192.168.33.1` → **Internet & Security** → **Wi-Fi Mode - Client**
4. Inserisci SSID e password → **Save**

> [!NOTE]
> Shelly supporta solo reti a **2,4 GHz**. Le reti a 5 GHz non appariranno nella scansione.

### Passaggio 2 — Trovare l'indirizzo IP

Dopo la connessione al Wi-Fi, trova l'indirizzo IP assegnato tramite uno di questi metodi:

- **App Shelly:** Dettaglio dispositivo → **Device info** → Indirizzo IP
- **Interfaccia web Shelly:** Connettiti all'AP del dispositivo prima della configurazione Wi-Fi — l'IP viene mostrato dopo il salvataggio
- **Tabella DHCP del router:** Cerca un hostname come `shelly1pm-AABBCCDDEE`
- **mDNS:** Esegui il ping di `shelly<model>-<mac>.local` (es. `shelly1pm-AABBCCDDEE.local`) dalla stessa rete

> [!TIP]
> Assegna un **IP statico** (prenotazione DHCP) nel tuo router per il dispositivo Shelly per evitare che l'indirizzo cambi dopo un riavvio del router.

### Passaggio 3 — Configurazione in TapHome

1. In TapHome, aggiungi un nuovo modulo **Packet Parser (HTTP)**
2. **IP Address:** inserisci l'IP dal passaggio 2 (es. `192.168.1.50`)
3. **Port:** `80` (predefinito, nessuna modifica necessaria)
4. Importa il template — TapHome interrogherà periodicamente `/status` per leggere lo stato del dispositivo

> [!NOTE]
> L'autenticazione HTTP è disabilitata per impostazione predefinita sui dispositivi Shelly. Se hai abilitato la protezione con accesso, TapHome attualmente non supporta HTTP Basic Auth — mantieni l'autenticazione disabilitata per l'integrazione con TapHome.

## Dispositivi disponibili 6

Questi dispositivi compaiono in TapHome dopo l'importazione.

Shelly Plus Plug S Modulo

Attributi di servizio

|                       |                                                                                                                                   |
|-----------------------|-----------------------------------------------------------------------------------------------------------------------------------|
| SSID Wi-Fi            |                                                                                                                                   |
| Indirizzo IP          |                                                                                                                                   |
| Intensità del segnale | Intensità del segnale Wi-Fi in dBm — valori più vicini a 0 indicano una connessione più forte (es. −55 dBm buona, −80 dBm debole) |
| Indirizzo MAC         |                                                                                                                                   |

Azioni di servizio

|                        |                                                                                                               |
|------------------------|---------------------------------------------------------------------------------------------------------------|
| Aggiornamento firmware | Avvia un aggiornamento firmware over-the-air dal canale stabile Shelly                                        |
| Riavvio                | Riavvia il dispositivo — utile dopo modifiche alla configurazione di rete o per risolvere problemi transitori |

Variabili personalizzate

Lettura (modulo)

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

Attributi di servizio

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

Azioni di servizio

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

Interruttore Interruttore Lettura e scrittura

boolean

Valori / Stati: ON · OFF

Lettura stato interruttore

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

Scrittura stato interruttore

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

Contatore elettrico Contatore elettrico Solo lettura

Potenza istantanea (kW) ed energia cumulativa (kWh) misurate dal contatore integrato, con diagnostica di corrente, tensione e temperatura interna

numeric Unità: kW / kWh

Attributi di servizio

|             |                                                                                                            |
|-------------|------------------------------------------------------------------------------------------------------------|
| Corrente    |                                                                                                            |
| Tensione    |                                                                                                            |
| Temperatura | Temperatura interna del dispositivo in °C — la presa si spegne automaticamente in caso di surriscaldamento |

Lettura consumo totale

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

Lettura domanda

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

Lettura (modulo)

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

Attributi di servizio

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

Modalità indicazione LED Interruttore multivalore Lettura e scrittura

Comportamento dell'anello LED — Off (disabilitato), Switch (il colore riflette lo stato del relè) o Power (il colore riflette il carico come verde → giallo → rosso)

string enum

Valori / Stati: ${xml\_off} · ${switch} · ${xml\_power}

Lettura stato interruttore

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

Scrittura stato interruttore

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

Colore LED (stato OFF) Luce HSB Lettura e scrittura

Colore RGB e luminosità dell'anello LED quando il relè è spento (usato in modalità Switch)

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

Lettura luminosità

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

Scrittura luminosità

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

Lettura tonalità

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

Scrittura tonalità

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

Lettura saturazione

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

Scrittura saturazione

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

Colore LED (stato ON) Luce HSB Lettura e scrittura

Colore RGB e luminosità dell'anello LED quando il relè è acceso (usato in modalità Switch)

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

Lettura luminosità

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

Scrittura luminosità

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

Lettura tonalità

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

Scrittura tonalità

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

Lettura saturazione

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

Scrittura saturazione

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

Luminosità LED (modalità Power) Dimmer Lettura e scrittura

Luminosità dell'anello LED in modalità Power — il colore è scelto automaticamente dal firmware in base al carico

numeric

Lettura livello

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

Scrittura livello

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

**Connessione:** Packet Parser → HTTP • Hostname: `shellyplusplugs-{MAC}.local`

Possibili miglioramenti (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 di importazione

Inserisci questi valori quando importi l'XML.

| Richiesto nell'app | Predefinito   |
|--------------------|---------------|
| Indirizzo IP       | `192.168.0.1` |

## Fonti

- 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

## Documentazione correlata

- [Integrazione Packet Parser](https://taphome.com/it/compatibility/packet-parser-guide/)
- [Packet Parser (HTTP, TCP, UDP, FTP, MQTT)](https://taphome.com/it/docs/integration/packet-parser/)
- [Funzioni Packet parser](https://taphome.com/it/docs/script/packet-parser/)
- [Funzioni di parsing](https://taphome.com/it/docs/script/parsing-functions/)