---
title: "Shelly 2PM Gen3"
description: "Relè a due canali con misurazione potenza o controllo tapparella/veneziana motorizzata via HTTP RPC API. Integrazione TapHome per Shelly 2PM Gen3."
url: "https://taphome.com/it/compatibility/shelly-2pm-gen3/"
language: it
lastmod: 2026-03-29
generator: hugo
ai:
  topics: ["http","electric-meter","wifi","relay","power-metering","cover","blind","mdns","profile"]
  questions: ["Come integrare lo Shelly 2PM Gen3 con TapHome?","Qual è la differenza tra il profilo switch e cover sullo Shelly 2PM Gen3?","Come controllare una veneziana motorizzata con Shelly 2PM Gen3 e TapHome?","Come passare dalla modalità relè a tapparella sullo Shelly 2PM Gen3?","Perché il template Shelly 2PM Gen3 mostra un errore di profilo in TapHome?","Come calibrare la tapparella Shelly 2PM Gen3 per il controllo posizione?"]
---

# Shelly 2PM Gen3

Comunicazione: Packet Parser → HTTP

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

> 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 2PM Gen3 è un modulo relè Wi-Fi compatto a due canali con misurazione della potenza integrata. Si adatta dietro un interruttore a parete standard e può controllare due circuiti indipendenti fino a 10 A ciascuno (16 A totali a 230 V AC) o un'unica tapparella/veneziana motorizzata. TapHome comunica con il dispositivo via HTTP utilizzando l'API Gen2+/Gen3 JSON-RPC 2.0 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) funzionano indipendentemente con misurazione della potenza per canale. Nel profilo cover, le due uscite pilotano un singolo motore per tapparelle, veneziane o tende, con controllo posizione, supporto lamelle e calibrazione.

A differenza dello Shelly 1PM Gen3, che controlla un singolo circuito, il 2PM Gen3 offre controllo a due canali o supporto tapparelle motorizzate. Entrambi condividono la stessa piattaforma Gen3 con processore ESP (8 MB flash), fino a 6 connessioni HTTP simultanee e aggiornabilità Matter.

## Configurazione

Lo Shelly 2PM Gen3 si connette tramite Wi-Fi. Durante l'importazione del template in TapHome, inserisci l'indirizzo IP del dispositivo (placeholder predefinito `192.168.0.1`).

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

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

### Selezione del profilo

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

- **Profilo switch** — attiva entrambi gli interruttori relè (Interruttore 1 e Interruttore 2) con misurazione della potenza indipendente. I dispositivi tapparella e veneziana mostreranno un errore di profilo.
- **Profilo cover** — attiva la tapparella e la veneziana. I dispositivi interruttore mostreranno un errore di profilo.

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

> [!TIP]
> Il template include tutti e quattro i tipi di dispositivo (2 interruttori + tapparella + veneziana), ma funzioneranno solo i dispositivi corrispondenti al profilo attivo. I dispositivi nel profilo sbagliato mostrano un messaggio di errore come "Profile is not set to switch" o "Profile is not set to cover" — questo è un comportamento previsto, non un malfunzionamento.

### Calibrazione tapparella

Quando si usa il profilo cover, i limiti di corsa del motore devono essere calibrati prima che il controllo posizione funzioni. Fino al completamento della calibrazione, il template mostrerà l'errore "Calibration is required". Calibra tramite l'interfaccia web Shelly o avviando l'azione di servizio **Avvia calibrazione automatica** in TapHome. Durante la calibrazione, la tapparella si apre e si chiude completamente per misurare le distanze di corsa.

## Funzionalità del dispositivo

### Controllo relè (profilo switch)

Il template espone due interruttori relè indipendenti. Ogni interruttore legge il suo 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 anche attributi di servizio per il monitoraggio per canale:

- **Temperatura** — temperatura interna del dispositivo in °C (`temperature.tC`)
- **Consumo energetico** — energia cumulativa in Wh (`aenergy.total`)
- **Potenza assorbita** — potenza istantanea in W (`apower`)
- **Tensione elettrica** — tensione di alimentazione in V (`voltage`)
- **Corrente elettrica** — corrente di carico in A (`current`)
- **Frequenza** — frequenza della rete AC in Hz (`freq`)
- **Fattore di potenza** — valore del fattore di potenza (`pf`)

Gli interruttori si aggiornano ogni 2,5 secondi.

### Controllo tapparella (profilo cover)

Il dispositivo tapparella controlla una tapparella motorizzata, tenda o tenda da sole. Legge la posizione da `/rpc/Cover.GetStatus?id=0` (campi `current_pos` e `target_pos`, 0–100) e scrive tramite `/rpc/Cover.GoToPosition?id=0&pos=N`. Il template inverte la scala di posizione in modo che 0 = completamente aperta e 100 = completamente chiusa in TapHome.

La tapparella espone attributi di servizio:

- **Temperatura** — temperatura interna del dispositivo in °C
- **Consumo energetico** — energia cumulativa del motore in Wh
- **Potenza assorbita** — potenza istantanea del motore in W
- **Tensione elettrica** — tensione di alimentazione in V
- **Corrente elettrica** — corrente del motore in A

L'azione di servizio **Avvia calibrazione automatica** è disponibile per avviare la calibrazione direttamente da TapHome.

### Controllo veneziana (profilo cover)

Il dispositivo veneziana estende la tapparella con il controllo inclinazione lamelle per veneziane orizzontali. Oltre alla posizione, legge e scrive la posizione delle lamelle (`slat_pos`) tramite `/rpc/Cover.GoToPosition?id=0&pos=N&slat_pos=M`. Sia la scala di posizione che quella di inclinazione sono invertite (0 = aperta, 100 = chiusa in TapHome).

La veneziana espone gli stessi attributi di servizio della tapparella, più:

- **Lamella** — mostra se il controllo lamelle è abilitato o disabilitato (da `Cover.GetConfig → $.slat.enable`)
- **Tempo apertura lamella** — durata configurata di apertura lamelle in secondi
- **Tempo chiusura lamella** — durata configurata di chiusura lamelle in secondi

> [!NOTE]
> **Problema noto del template:** L'attributo di servizio "Slat close time" legge `$.slat.open_time` invece di `$.slat.close_time` dalla configurazione Cover. Entrambi gli attributi del tempo lamelle mostrano attualmente lo stesso valore (il tempo di apertura). Questo sarà corretto in una revisione futura del template.

Due azioni di servizio sono disponibili sul dispositivo veneziana:

- **Avvia calibrazione automatica** — avvia la calibrazione della posizione della tapparella
- **Imposta lamella** — abilita il controllo lamelle e configura le durate di apertura/chiusura (0,1–5 secondi ciascuna) tramite `/rpc/Cover.SetConfig`

> [!WARNING]
> Il controllo lamelle deve essere abilitato prima che il dispositivo veneziana possa controllare l'inclinazione. Se la posizione delle lamelle non è disponibile dal dispositivo, la veneziana mostrerà l'errore "Slat position must be enabled for blinds". Usa l'azione di servizio **Imposta lamella** per abilitarlo e impostare le durate di apertura/chiusura.

### Diagnostica di servizio

Il template espone attributi di servizio a livello modulo per il monitoraggio del dispositivo:

- **WiFi** — nome della rete SSID connessa
- **Indirizzo IP** — IP attuale della stazione
- **Potenza del segnale** — WiFi RSSI in dB
- **MAC** — indirizzo MAC del dispositivo
- **Profilo** — profilo dispositivo attualmente attivo (switch o cover)

Lo script di lettura del modulo verifica anche la disponibilità di aggiornamenti firmware e requisiti di riavvio in sospeso, mostrandoli come avvisi nell'interfaccia TapHome.

### Azioni di servizio

Tre azioni di servizio sono disponibili a livello modulo:

- **Aggiornamento firmware** — avvia l'aggiornamento firmware all'ultima versione stabile tramite `/rpc/Shelly.Update`
- **Riavvio** — avvia il riavvio del dispositivo tramite `/rpc/Shelly.Reboot`
- **Imposta profilo** — passa tra le modalità operative cover e switch tramite `/rpc/Shelly.SetProfile`

### Funzionalità aggiuntive

Lo Shelly 2PM Gen3 espone anche gli stati degli ingressi fisici (`input:0`, `input:1`), contatori di energia restituita/esportata, uptime, utilizzo RAM e ora del dispositivo nelle sue risposte RPC. Un timer auto-off è disponibile tramite il parametro `toggle_after`, la protezione da sovraccarico può essere configurata tramite `Switch.SetConfig → power_limit` e i contatori energia possono essere resettati tramite `/rpc/Switch.ResetCounters`. In modalità cover, sono disponibili comandi diretti di apertura/chiusura/stop e lo stato di movimento della tapparella (open/opening/closed/closing/stopped/calibrating). Queste funzionalità potranno essere aggiunte in un futuro aggiornamento del template.

## Risoluzione dei problemi

### Il dispositivo non risponde

1. Verifica che lo Shelly sia connesso al Wi-Fi e abbia un indirizzo IP valido
2. Prova a usare l'hostname mDNS (`shelly2pmg3-AABBCCDDEE.local`) invece dell'indirizzo IP — l'IP potrebbe essere cambiato dopo un rinnovo DHCP
3. Apri `http://{device-ip}/rpc/Shelly.GetDeviceInfo` nel browser — se risponde con JSON, il dispositivo è raggiungibile
4. Verifica che TapHome Core e Shelly siano nella stessa rete / VLAN
5. Conferma che l'autenticazione è disattivata sul dispositivo Shelly

### Errori di mancata corrispondenza profilo

Se un dispositivo mostra "Profile is not set to switch" o "Profile is not set to cover":

1. Verifica quale profilo è attualmente attivo — l'attributo di servizio "Profilo" a livello modulo mostra la modalità corrente
2. Passa al profilo corretto usando l'azione di servizio **Imposta profilo**, o rimuovi i dispositivi non utilizzati da TapHome
3. Dopo il cambio profilo, il dispositivo si riavvia automaticamente — attendi qualche secondo per la riconnessione

### Il controllo posizione tapparella non funziona

1. Verifica che il dispositivo sia nel profilo cover — il profilo switch non espone la funzionalità tapparella
2. Esegui l'azione di servizio **Avvia calibrazione automatica** — il controllo posizione richiede la calibrazione completata
3. Verifica che il motore sia collegato correttamente ai morsetti O1 e O2
4. Interroga `/rpc/Cover.GetStatus?id=0` manualmente e verifica che `pos_control` sia `true`

### L'inclinazione della veneziana non risponde

1. Conferma che il controllo lamelle è abilitato — verifica l'attributo di servizio "Lamella" (dovrebbe mostrare "Enabled")
2. Se disabilitato, usa l'azione di servizio **Imposta lamella** per abilitarlo e configurare i tempi di apertura/chiusura
3. Verifica che il motore della veneziana supporti l'operazione di inclinazione — tapparelle senza inclinazione ignorano i comandi lamelle

### Avviso di sovratemperatura

Lo Shelly 2PM Gen3 ha una protezione termica interna. Se la temperatura del dispositivo supera i limiti di sicurezza, il valore `temperature` negli attributi di servizio del dispositivo aumenterà. Assicura una ventilazione adeguata attorno al dispositivo, specialmente quando si commutano carichi elevati. La corrente massima di commutazione è 10 A per canale con un totale di 16 A (18 A di picco).

> [!WARNING]
> I dispositivi Shelly Gen2+/Gen3 supportano fino a **6 connessioni HTTP simultanee**. Sebbene questo sia un miglioramento significativo rispetto a Gen1 (2 connessioni), evita il polling da troppi sistemi contemporaneamente (TapHome, Home Assistant, script personalizzati) per prevenire l'esaurimento delle connessioni. Il template Shelly 2PM Gen3 utilizza fino a 4 endpoint simultanei per ciclo di polling, lasciando margine limitato per connessioni aggiuntive.

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

Questi dispositivi compaiono in TapHome dopo l'importazione.

Shelly 2PM Gen3 Modulo

Attributi di servizio

|                     |                                                                                              |
|---------------------|----------------------------------------------------------------------------------------------|
| WiFi                |                                                                                              |
| Indirizzo IP        |                                                                                              |
| Potenza del segnale |                                                                                              |
| MAC                 |                                                                                              |
| Profilo             | Profilo dispositivo attivo — switch (doppio relè) o cover (tapparella/veneziana motorizzata) |

Azioni di servizio

|                        |                                                                                                   |
|------------------------|---------------------------------------------------------------------------------------------------|
| Aggiornamento firmware |                                                                                                   |
| Riavvio                |                                                                                                   |
| Imposta profilo        | Passa tra le modalità operative cover e switch — il dispositivo si riavvia dopo il cambio profilo |

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

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

Profile

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

Azioni di servizio

${xml\_update\_fw}

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

```

${restart}

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

Set Profile

Parametri: Profile

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

Interruttore 1 Interruttore Lettura e scrittura

Uscita relè 1 con monitoraggio potenza per canale — richiede profilo switch

boolean

Valori / Stati: ON · OFF

Lettura stato interruttore

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

Scrittura stato interruttore

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

Lettura (modulo)

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

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

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

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

Attributi di servizio

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

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

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

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

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

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

${valueLogType\_ElectricVoltage} \[V]

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

${valueLogType\_ElectricCurrent} \[A]

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

${frequency} \[Hz]

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

Power Factor

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

Interruttore 2 Interruttore Lettura e scrittura

Uscita relè 2 con monitoraggio potenza per canale — richiede profilo switch

boolean

Valori / Stati: ON · OFF

Lettura stato interruttore

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

Scrittura stato interruttore

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

Lettura (modulo)

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

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

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

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

Attributi di servizio

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

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

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

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

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

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

${valueLogType\_ElectricVoltage} \[V]

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

${valueLogType\_ElectricCurrent} \[A]

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

${frequency} \[Hz]

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

Power Factor

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

Tapparella Cursore Lettura e scrittura

Tapparella o tenda motorizzata con controllo posizione — richiede profilo cover e calibrazione

numeric Unità: %

Attributi di servizio

|                    |
|--------------------|
| Temperatura        |
| Consumo energetico |
| Potenza assorbita  |
| Tensione elettrica |
| Corrente elettrica |

Azioni di servizio

|                               |
|-------------------------------|
| Avvia calibrazione automatica |

Lettura (modulo)

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

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

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

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

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

Lettura livello tapparella

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

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

Scrittura livello tapparella

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

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

Attributi di servizio

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

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

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

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

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

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

${valueLogType\_ElectricVoltage} \[V]

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

${valueLogType\_ElectricCurrent} \[A]

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

Azioni di servizio

${start\_automatic\_calibration}

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

Veneziana Tapparella Lettura e scrittura

Veneziana con controllo posizione e inclinazione lamelle — richiede profilo cover, calibrazione e lamelle abilitate

numeric Unità: %

Attributi di servizio

|                        |                                                                                    |
|------------------------|------------------------------------------------------------------------------------|
| Temperatura            |                                                                                    |
| Consumo energetico     |                                                                                    |
| Potenza assorbita      |                                                                                    |
| Tensione elettrica     |                                                                                    |
| Corrente elettrica     |                                                                                    |
| Lamella                | Se il controllo inclinazione lamelle è abilitato nella configurazione Shelly Cover |
| Tempo apertura lamella |                                                                                    |
| Tempo chiusura lamella |                                                                                    |

Azioni di servizio

|                               |                                                                                         |
|-------------------------------|-----------------------------------------------------------------------------------------|
| Avvia calibrazione automatica |                                                                                         |
| Imposta lamella               | Abilita il controllo lamelle e configura le durate di apertura/chiusura (0,1–5 secondi) |

Lettura (modulo)

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

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

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

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

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

Lettura livello tapparella

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

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

return(Bl);
```

Scrittura livello tapparella

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

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

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

Lettura inclinazione tapparella

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

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

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

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

Scrittura inclinazione tapparella

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

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

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

Attributi di servizio

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

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

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

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

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

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

${valueLogType\_ElectricVoltage} \[V]

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

${valueLogType\_ElectricCurrent} \[A]

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

Slat

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

Slat open time \[s]

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

Slat close time \[s]

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

Azioni di servizio

${start\_automatic\_calibration}

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

Set Slat

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

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

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

Possibili miglioramenti (11)

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

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

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