---
title: "Shelly Plus 2PM"
description: "Shelly Plus 2PM via HTTP RPC API locale: due relè con misura di potenza o una tapparella con posizione e calibrazione. Profilo switch o cover."
url: "https://taphome.com/it/compatibility/shelly-plus-2-pm/"
language: it
lastmod: 2026-10-08
generator: hugo
ai:
  topics: ["http","electric-meter","wifi","relay","power-metering","cover","shutter","mdns","profile"]
  questions: ["Come integrare Shelly Plus 2PM con TapHome?","Qual è la differenza tra profilo switch e cover su Shelly Plus 2PM?","Come controllare una tapparella con Shelly Plus 2PM e TapHome?","Come passare tra modalità relè e copertura su Shelly Plus 2PM?","Perché il template Shelly Plus 2PM mostra un errore di profilo in TapHome?","Come calibrare la copertura Shelly Plus 2PM per il controllo posizione?","Quali diagnostiche sono disponibili per Shelly Plus 2PM in TapHome?"]
---

# Shelly Plus 2PM

Comunicazione: Packet Parser → HTTP

- [Shelly Plus 2PM pagina prodotto](https://www.shelly.com/en/products/shop/shelly-plus-2pm)
- [Shelly Plus 2PM documentazione API](https://shelly-api-docs.shelly.cloud/gen2/Devices/Gen2/ShellyPlus2PM/)

> 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

Lo Shelly Plus 2PM è un relè Wi-Fi compatto a due canali con misurazione della potenza integrata su entrambi i canali. Si installa dietro un interruttore a parete standard e può controllare due circuiti indipendenti, ciascuno fino a 10 A (16 A totali a 230 V AC), o azionare una singola tapparella motorizzata. TapHome comunica con il dispositivo tramite HTTP usando l'API RPC Gen2+ sulla rete locale — non è richiesta alcuna connessione cloud.

Il dispositivo supporta due profili operativi — **switch** e **cover** — selezionabili tramite l'interfaccia web Shelly o l'azione di servizio TapHome. Nel profilo switch, entrambe le uscite relè (O1 e O2) operano indipendentemente con monitoraggio della potenza per canale. Nel profilo cover, le due uscite azionano un singolo motore per tapparelle, veneziane o tende, con controllo della posizione e calibrazione.

> [!NOTE]
> Lo Shelly Plus 2PM è stato dismesso. Il suo successore, lo [Shelly 2PM Gen3](https://taphome.com/it/compatibility/shelly-2pm-gen3/), offre la stessa funzionalità a doppio profilo con processore migliorato (8 MB flash), fino a 6 connessioni HTTP simultanee e aggiornabilità a Matter.

## Configurazione

Lo Shelly Plus 2PM si connette tramite Wi-Fi. Durante l'importazione del template TapHome, inserire l'indirizzo IP del dispositivo (segnaposto predefinito `192.168.0.1`).

> [!WARNING]
> L'autenticazione deve essere **disabilitata** sul dispositivo Shelly per l'integrazione con TapHome. TapHome non supporta l'HTTP Digest Auth utilizzata dai dispositivi Gen2+. Aprire l'interfaccia web Shelly (`http://{ip-dispositivo}`) → Settings → Authentication e assicurarsi che sia disattivata.

> [!NOTE]
> Se la modalità ECO è abilitata sul dispositivo Shelly, può causare timeout di comunicazione a causa degli intervalli di polling rapidi del template (2,5–5 secondi). Disabilitare la modalità ECO nell'interfaccia web Shelly se si verificano problemi di connettività intermittente.

### Selezione del profilo

Lo Shelly Plus 2PM opera in uno dei due profili alla volta. Il profilo attivo determina quali dispositivi TapHome sono funzionali:

- **Profilo switch** — abilita entrambi i relè (Switch 1 e Switch 2) e i rispettivi contatori di energia per canale. Il dispositivo tapparella e il contatore energia tapparella non risponderanno.
- **Profilo cover** — abilita il dispositivo tapparella e il suo contatore di energia. I due dispositivi interruttore e i loro contatori di energia non risponderanno.

Il profilo attivo è visibile come attributo di servizio a livello di modulo ("Profile") in TapHome. Per cambiare il profilo, utilizzare l'azione di servizio **Profile** a livello di modulo oppure cambiarlo nell'interfaccia web Shelly. Dopo il cambio profilo, il dispositivo si riavvia e solo i dispositivi corrispondenti al nuovo profilo funzioneranno.

> [!TIP]
> Il template include tutti e sei i dispositivi (2 interruttori + 2 contatori energia interruttori + 1 tapparella + 1 contatore energia tapparella), ma solo i dispositivi corrispondenti al profilo attivo funzioneranno. Questo è il comportamento previsto — i dispositivi sul profilo sbagliato semplicemente non rispondono.

### Calibrazione della copertura

Quando si utilizza il profilo cover, i limiti di corsa del motore devono essere calibrati prima che il controllo della posizione funzioni. Fino al completamento della calibrazione, `current_pos` restituisce null e l'attributo di servizio "Calibrated" mostra `false`. Calibrare tramite l'interfaccia web Shelly o attivando l'azione di servizio **Calibrate** sul dispositivo Shutter in TapHome. Durante la calibrazione, la copertura esegue una sequenza a più fasi (apertura completa → chiusura completa → apertura completa → chiusura a passi → apertura a passi) per misurare le distanze di corsa.

## Funzionalità del dispositivo

### Controllo relè (profilo switch)

Il template espone due interruttori relè indipendenti. Ogni interruttore legge il proprio stato da `/rpc/Switch.GetStatus?id={0,1}` (campo `output`, boolean) e controlla il relè tramite `/rpc/Switch.Set?id={0,1}&on=true|false`.

Ogni interruttore espone sette attributi di servizio:

- **Source** — sorgente dell'ultimo comando (http, UI, WS_in, ecc.)
- **Temperature** — temperatura interna del dispositivo in °C
- **Initial State** — comportamento dell'interruttore all'accensione (off, on, restore_last o match_input)
- **Input Mode** — modalità di cablaggio dell'ingresso fisico (follow o detached)
- **Power Limit** — soglia di potenza massima in watt per la protezione da sovraccarico
- **Voltage Limit** — soglia di tensione massima in volt
- **Current Limit** — soglia di corrente massima in ampere

Due azioni di servizio sono disponibili per ogni interruttore:

- **Set Initial State** — configura il comportamento del relè dopo l'accensione (off, on, restore_last, match_input)
- **Set Mode** — configura la modalità di cablaggio dell'ingresso fisico (follow, detached)

### Misurazione della potenza (profilo switch)

Ogni canale dell'interruttore ha un contatore di energia dedicato che legge due valori da `/rpc/Switch.GetStatus`:

- **Potenza istantanea** — `apower` in watt, convertita in kW dal template
- **Consumo totale** — `aenergy.total` in wattora, convertito in kWh dal template

Ogni contatore di energia espone anche tre attributi di servizio:

- **Voltage** — tensione di alimentazione in volt
- **Current** — corrente di carico in ampere
- **Power Factor** — fattore di potenza del carico

I contatori sono di sola lettura — si aggiornano automaticamente con ogni ciclo di polling.

### Controllo tapparella (profilo cover)

Il dispositivo tapparella controlla una tapparella motorizzata, una tenda o un'avvolgibile. Legge la posizione da `/rpc/Cover.GetStatus?id=0` (campo `current_pos`, 0–100%) e scrive tramite `/rpc/Cover.GoToPosition?id=0&pos=N`.

Il dispositivo tapparella espone 21 attributi di servizio:

- **Stato** — sorgente, stato (open/closed/opening/closing/stopped/calibrating), posizione attuale e target, timeout movimento e ora di avvio
- **Calibrato** — se il controllo posizione è abilitato (`pos_control`)
- **Temperatura** — temperatura interna del dispositivo in °C
- **Comportamento all'accensione** — configurazione stato iniziale (open, closed, stopped)
- **Impostazioni ingresso** — modalità ingresso (single, dual, detached), scambio ingressi, inversione direzioni
- **Limiti di protezione** — limite potenza (W), limite tensione (V), limite corrente (A)
- **Regolazione motore** — soglia potenza a riposo (0–50 W), periodo conferma riposo (0,25–2 s)
- **Limiti di movimento** — tempo massimo apertura (0,1–300 s), tempo massimo chiusura (0,1–300 s)
- **Funzioni di sicurezza** — stato rilevamento ostacoli, stato interruttore di sicurezza

Sei azioni di servizio sono disponibili per la tapparella:

- **Open** — apre completamente la copertura
- **Close** — chiude completamente la copertura
- **Stop** — arresta il movimento immediatamente
- **Calibrate** — avvia la procedura di calibrazione per il controllo posizione
- **Go to Position** — muove la copertura a una posizione specifica (0–100%)
- **Reverse directions** — commuta la configurazione `invert_directions` e riavvia il dispositivo

### Misurazione della potenza (profilo cover)

La tapparella ha un contatore di energia dedicato che legge da `/rpc/Cover.GetStatus`:

- **Potenza istantanea** — `apower` in watt, convertita in kW dal template
- **Consumo totale** — `aenergy.total` in wattora, convertito in kWh dal template

Il contatore di energia della tapparella espone anche tensione, corrente e fattore di potenza come attributi di servizio.

### Diagnostica di servizio

Il template espone due attributi di servizio a livello di modulo:

- **MAC** — indirizzo MAC del dispositivo dalla configurazione di sistema
- **Profile** — profilo dispositivo attualmente attivo (switch o cover)

Lo script di lettura del modulo controlla anche `restart_required` da `/rpc/Sys.GetStatus` e mostra un avviso in TapHome se è in attesa un riavvio.

### Azioni di servizio

Due azioni di servizio sono disponibili a livello di modulo:

- **Reboot** — attiva un riavvio del dispositivo tramite `/rpc/Shelly.Reboot`
- **Profile** — commuta tra i profili operativi switch e cover tramite `/rpc/Shelly.SetProfile`

### Funzionalità aggiuntive

Lo Shelly Plus 2PM espone anche frequenza di rete (`freq`), valori di energia al minuto (`aenergy.by_minute`), stati degli ingressi fisici (`input:0`, `input:1`), potenza del segnale Wi-Fi (RSSI) e un endpoint toggle dell'interruttore nelle sue risposte RPC. I contatori di energia possono essere azzerati tramite `/rpc/Switch.ResetCounters` (profilo switch) o `/rpc/Cover.ResetCounters` (profilo cover). In modalità cover, la posizione lamelle/inclinazione per veneziane è disponibile quando l'hardware la supporta. Queste funzionalità potranno essere aggiunte in un futuro aggiornamento del template.

## Risoluzione dei problemi

### Il dispositivo non risponde

1. Verificare che lo Shelly sia connesso al Wi-Fi e abbia un indirizzo IP valido
2. Provare a utilizzare l'hostname mDNS (`shellyplus2pm-AABBCCDDEE.local`) invece dell'indirizzo IP — l'IP potrebbe essere cambiato dopo un rinnovo DHCP
3. Aprire `http://{ip-dispositivo}/rpc/Shelly.GetDeviceInfo` nel browser — se risponde con JSON, il dispositivo è raggiungibile
4. Verificare che TapHome Core e Shelly siano sulla stessa rete / VLAN
5. Assicurarsi che l'autenticazione sia disabilitata sul dispositivo Shelly

### Discrepanza profilo — dispositivi non rispondono

Se alcuni dispositivi non mostrano letture mentre altri funzionano correttamente:

1. Controllare quale profilo è attualmente attivo — l'attributo di servizio "Profile" a livello di modulo mostra la modalità corrente
2. Passare al profilo corretto utilizzando l'azione di servizio **Profile** oppure ignorare i dispositivi non utilizzati
3. Dopo il cambio profilo, il dispositivo si riavvia automaticamente — attendere qualche secondo per la riconnessione

### La posizione della copertura non funziona

1. Verificare che il dispositivo sia in profilo cover — il profilo switch non espone le funzionalità di copertura
2. Eseguire l'azione di servizio **Calibrate** sul dispositivo Shutter — il controllo posizione richiede calibrazione completata
3. Controllare che il motore sia collegato correttamente ai morsetti O1 e O2
4. Interrogare manualmente `/rpc/Cover.GetStatus?id=0` e verificare che `pos_control` sia `true`

### La calibrazione della copertura fallisce

La calibrazione si interrompe se:

- La copertura non raggiunge la posizione finale entro `maxtime_open` o `maxtime_close`
- Una funzione di sicurezza (rilevamento ostacoli o interruttore di sicurezza) viene attivata durante la calibrazione
- Un comando di arresto esterno viene inviato durante la calibrazione
- La direzione del motore non corrisponde al feedback atteso
- Il dispositivo si riavvia durante la calibrazione

Controllare il cablaggio del motore, aumentare `maxtime_open`/`maxtime_close` se il motore è lento e assicurarsi che non siano presenti ostacoli.

### Le letture di potenza mostrano zero

1. Confermare che il carico sia collegato attraverso il relè Shelly (non bypassato)
2. Verificare che il relè sia acceso — il contatore misura solo quando la corrente scorre attraverso il relè
3. Interrogare manualmente `/rpc/Switch.GetStatus?id=0` (profilo switch) o `/rpc/Cover.GetStatus?id=0` (profilo cover) e verificare che `apower` restituisca un valore diverso da zero

> [!WARNING]
> I dispositivi Shelly Gen2+ supportano fino a **6 connessioni HTTP simultanee**. Sebbene sia un miglioramento rispetto a Gen1 (2 connessioni), evitare il polling simultaneo da troppi sistemi (TapHome, Home Assistant, script personalizzati) per prevenire l'esaurimento delle connessioni.

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

Attributi di servizio

|         |                                                               |
|---------|---------------------------------------------------------------|
| MAC     | Indirizzo MAC del dispositivo dalla configurazione di sistema |
| Profilo | Profilo dispositivo attivo — switch o cover                   |

Azioni di servizio

|         |                                                                                 |
|---------|---------------------------------------------------------------------------------|
| Riavvio | Riavvia il dispositivo                                                          |
| Profilo | Passa tra i profili operativi switch e cover — richiede riavvio del dispositivo |

Variabili personalizzate

Lettura (modulo)

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

Attributi di servizio

MAC

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

Profile

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

Azioni di servizio

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

Misuratore di potenza (Tapparella) Contatore elettrico Solo lettura

Misurazione energia in modalità cover — potenza istantanea (kW) ed energia cumulativa (kWh)

numeric Unità: kW / kWh json\_path

Attributi di servizio

|                    |                                   |
|--------------------|-----------------------------------|
| Tensione           | Tensione di alimentazione in Volt |
| Corrente           | Corrente di carico in Ampere      |
| Fattore di potenza | Fattore di potenza del carico     |

Lettura consumo totale

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

Lettura domanda

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

Lettura (modulo)

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

Attributi di servizio

Voltage \[V]

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

Current \[A]

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

Power Factor

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

Misuratore di potenza (Interruttore 1) Contatore elettrico Solo lettura

Misurazione energia per il canale interruttore 1 — potenza istantanea (kW) ed energia cumulativa (kWh)

numeric Unità: kW / kWh json\_path

Attributi di servizio

|                    |                                   |
|--------------------|-----------------------------------|
| Tensione           | Tensione di alimentazione in Volt |
| Corrente           | Corrente di carico in Ampere      |
| Fattore di potenza | Fattore di potenza del carico     |

Lettura consumo totale

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

Lettura domanda

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

Lettura (modulo)

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

Attributi di servizio

Voltage \[V]

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

Current \[A]

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

Power Factor

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

Misuratore di potenza (Interruttore 2) Contatore elettrico Solo lettura

Misurazione energia per il canale interruttore 2 — potenza istantanea (kW) ed energia cumulativa (kWh)

numeric Unità: kW / kWh json\_path

Attributi di servizio

|                    |                                   |
|--------------------|-----------------------------------|
| Tensione           | Tensione di alimentazione in Volt |
| Corrente           | Corrente di carico in Ampere      |
| Fattore di potenza | Fattore di potenza del carico     |

Lettura consumo totale

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

Lettura domanda

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

Lettura (modulo)

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

Attributi di servizio

Voltage \[V]

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

Current \[A]

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

Power Factor

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

Tapparella Cursore Lettura e scrittura

Controllo tapparella motorizzata con tracciamento posizione — richiede calibrazione per il controllo posizione

numeric Unità: % json\_path

Attributi di servizio

|                                    |                                                                                                         |
|------------------------------------|---------------------------------------------------------------------------------------------------------|
| Sorgente                           | Sorgente dell'ultimo comando tapparella                                                                 |
| Stato                              | Stato attuale tapparella — open, closed, opening, closing, stopped, calibrating                         |
| Posizione attuale                  | Posizione attuale tapparella in percentuale (0–100), null se non calibrata                              |
| Posizione target                   | Posizione target durante il movimento della tapparella                                                  |
| Timeout movimento                  | Secondi fino all'arresto automatico durante il movimento                                                |
| Movimento iniziato alle            | Timestamp di inizio del movimento corrente                                                              |
| Calibrato                          | Se il controllo posizione è abilitato (true dopo calibrazione riuscita)                                 |
| Temperatura                        | Temperatura interna del dispositivo in Celsius                                                          |
| Stato iniziale                     | Comportamento tapparella all'accensione — open, closed o stopped                                        |
| Modalità ingresso                  | Modalità cablaggio ingresso fisico — single, dual o detached                                            |
| Limite di potenza                  | Soglia massima di potenza in Watt per protezione da sovraccarico                                        |
| Limite di tensione                 | Soglia massima di tensione in Volt per protezione da sovratensione                                      |
| Limite di corrente                 | Soglia massima di corrente in Ampere per protezione da sovracorrente                                    |
| Soglia potenza inattività motore   | Soglia di potenza sotto la quale il motore è considerato inattivo (0–50 W)                              |
| Periodo conferma inattività motore | Durata in cui il motore deve rimanere sotto la soglia di inattività per confermare l'arresto (0,25–2 s) |
| Tempo massimo apertura             | Tempo massimo di apertura prima dell'arresto automatico (0,1–300 s)                                     |
| Tempo massimo chiusura             | Tempo massimo di chiusura prima dell'arresto automatico (0,1–300 s)                                     |
| Scambia ingressi                   | Se l'assegnazione degli ingressi S1/S2 è scambiata                                                      |
| Inverti direzioni                  | Se le direzioni apertura/chiusura sono invertite                                                        |
| Rilevamento ostacoli               | Se il rilevamento ostacoli è abilitato                                                                  |
| Interruttore di sicurezza          | Se la funzione interruttore di sicurezza è abilitata                                                    |

Azioni di servizio

|                    |                                                                                |
|--------------------|--------------------------------------------------------------------------------|
| Apri               | Apre completamente la tapparella                                               |
| Chiudi             | Chiude completamente la tapparella                                             |
| Stop               | Arresta immediatamente il movimento della tapparella                           |
| Calibrare          | Avvia la calibrazione della tapparella — necessaria per il controllo posizione |
| Vai alla posizione | Muove la tapparella in una posizione specifica (0–100 %)                       |
| Inverti direzioni  | Commuta la configurazione invert\_directions e riavvia il dispositivo          |

Lettura (modulo)

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

Lettura livello tapparella

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

Scrittura livello tapparella

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

Attributi di servizio

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

Azioni di servizio

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

Interruttore 1 Interruttore Lettura e scrittura

Uscita relè canale 1 — controllo on/off con configurazione comportamento all'accensione e modalità ingresso

boolean json\_path

Valori / Stati: ON · OFF

Azioni di servizio

|                        |                                                             |
|------------------------|-------------------------------------------------------------|
| Imposta stato iniziale | Configura il comportamento dell'interruttore all'accensione |
| Imposta modalità       | Configura la modalità cablaggio dell'ingresso fisico        |

Lettura stato interruttore

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

Scrittura stato interruttore

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

Lettura (modulo)

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

Attributi di servizio

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

Azioni di servizio

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

Interruttore 2 Interruttore Lettura e scrittura

Uscita relè canale 2 — controllo on/off con configurazione comportamento all'accensione e modalità ingresso

boolean json\_path

Valori / Stati: ON · OFF

Azioni di servizio

|                        |                                                             |
|------------------------|-------------------------------------------------------------|
| Imposta stato iniziale | Configura il comportamento dell'interruttore all'accensione |
| Imposta modalità       | Configura la modalità cablaggio dell'ingresso fisico        |

Lettura stato interruttore

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

Scrittura stato interruttore

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

Lettura (modulo)

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

Attributi di servizio

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

Azioni di servizio

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

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

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

Inserisci questi valori quando importi l'XML.

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

## Fonti

- 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

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