TapHome

Shelly Plus 2PM

Packet Parser → HTTP
Inviato da
Ultimo aggiornamento: 03. 2026
Shelly Plus 2PM

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.

Lo Shelly Plus 2PM è stato dismesso. Il suo successore, lo 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).

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.

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.

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
  • Calibrazione — 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

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

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

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

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

Shelly Plus 2PM Modulo
Attributi di servizio
MACIndirizzo MAC del dispositivo dalla configurazione di sistema
ProfiloProfilo dispositivo attivo — switch o cover
Azioni di servizio
RiavvioRiavvia il dispositivo
ProfiloPassa tra i profili operativi switch e cover — richiede riavvio del dispositivo
Variabili personalizzate

Shelly Plus 2 PM

Lettura (modulo)
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
PARSEJSON(SysConfig, "$.device.mac");
Profile
PARSEJSON(SysConfig, "$.device.profile");
Azioni di servizio
Reboot
VAR response := SENDHTTPREQUEST("/rpc/Shelly.Reboot");
IF response.IsSuccess
  VAR content := response.Content;
  VAR responseHeaders := response.Headers;
  Return("OK");
END;
Profile
Parametri: Profile
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
TensioneTensione di alimentazione in Volt
CorrenteCorrente di carico in Ampere
Fattore di potenzaFattore di potenza del carico

Misuratore di potenza (Tapparella)

Lettura consumo totale
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    adderror("Device profile is set to switch");
else
    return(PARSEJSON(CoverStatus, "$.aenergy.total") / 1000);
end
Lettura domanda
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    return(PARSEJSON(CoverStatus, "$.apower", true) / 1000);
end
Lettura (modulo)
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]
PARSEJSON(CoverStatus, "$.voltage", true);
Current [A]
PARSEJSON(CoverStatus, "$.current", true);
Power Factor
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
TensioneTensione di alimentazione in Volt
CorrenteCorrente di carico in Ampere
Fattore di potenzaFattore di potenza del carico

Misuratore di potenza (Interruttore 1)

Lettura consumo totale
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    adderror("Device profile is set to cover");
else
    return(PARSEJSON(SwitchStatus, "$.aenergy.total", true) / 1000);
end
Lettura domanda
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    return(PARSEJSON(SwitchStatus, "$.apower", true) / 1000);
end
Lettura (modulo)
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]
PARSEJSON(SwitchStatus, "$.voltage", true);
Current [A]
PARSEJSON(SwitchStatus, "$.current", true);
Power Factor
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
TensioneTensione di alimentazione in Volt
CorrenteCorrente di carico in Ampere
Fattore di potenzaFattore di potenza del carico

Misuratore di potenza (Interruttore 2)

Lettura consumo totale
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    adderror("Device profile is set to cover");
else
    return(PARSEJSON(SwitchStatus, "$.aenergy.total", true) / 1000);
end
Lettura domanda
if PARSEJSON(SysConfig, "$.device.profile") = "switch"
    return(PARSEJSON(SwitchStatus, "$.apower", true) / 1000);
end
Lettura (modulo)
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]
PARSEJSON(SwitchStatus, "$.voltage", true);
Current [A]
PARSEJSON(SwitchStatus, "$.current", true);
Power Factor
PARSEJSON(SwitchStatus, "$.pf", true);
Tapparella Cursore

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

numeric Unità: % json_path
Attributi di servizio
SorgenteSorgente dell'ultimo comando tapparella
StatoStato attuale tapparella — open, closed, opening, closing, stopped, calibrating
Posizione attualePosizione attuale tapparella in percentuale (0–100), null se non calibrata
Posizione targetPosizione target durante il movimento della tapparella
Timeout movimentoSecondi fino all'arresto automatico durante il movimento
Movimento iniziato alleTimestamp di inizio del movimento corrente
CalibratoSe il controllo posizione è abilitato (true dopo calibrazione riuscita)
TemperaturaTemperatura interna del dispositivo in Celsius
Stato inizialeComportamento tapparella all'accensione — open, closed o stopped
Modalità ingressoModalità cablaggio ingresso fisico — single, dual o detached
Limite di potenzaSoglia massima di potenza in Watt per protezione da sovraccarico
Limite di tensioneSoglia massima di tensione in Volt per protezione da sovratensione
Limite di correnteSoglia massima di corrente in Ampere per protezione da sovracorrente
Soglia potenza inattività motoreSoglia di potenza sotto la quale il motore è considerato inattivo (0–50 W)
Periodo conferma inattività motoreDurata in cui il motore deve rimanere sotto la soglia di inattività per confermare l'arresto (0,25–2 s)
Tempo massimo aperturaTempo massimo di apertura prima dell'arresto automatico (0,1–300 s)
Tempo massimo chiusuraTempo massimo di chiusura prima dell'arresto automatico (0,1–300 s)
Scambia ingressiSe l'assegnazione degli ingressi S1/S2 è scambiata
Inverti direzioniSe le direzioni apertura/chiusura sono invertite
Rilevamento ostacoliSe il rilevamento ostacoli è abilitato
Interruttore di sicurezzaSe la funzione interruttore di sicurezza è abilitata
Azioni di servizio
ApriApre completamente la tapparella
ChiudiChiude completamente la tapparella
StopArresta immediatamente il movimento della tapparella
CalibrareAvvia la calibrazione della tapparella — necessaria per il controllo posizione
Vai alla posizioneMuove la tapparella in una posizione specifica (0–100 %)
Inverti direzioniCommuta la configurazione invert_directions e riavvia il dispositivo

Tapparella

Lettura (modulo)
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
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
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
PARSEJSON(CoverStatus, "$.source", true);
State
PARSEJSON(CoverStatus, "$.state", true);
Current Position
PARSEJSON(CoverStatus, "$.current_pos", true);
Target Position
PARSEJSON(CoverStatus, "$.target_pos", true);
Move Timeout
PARSEJSON(CoverStatus, "$.move_timeout", true);
Move Started at
PARSEJSON(CoverStatus, "$.move_started_at", true);
Calibrated
PARSEJSON(CoverStatus, "$.pos_control", true);
Temperature [°C]
PARSEJSON(CoverStatus, "$.temperature.tC", true);
Initial State
PARSEJSON(CoverConfig, "$.initial_state", true);
Input Mode
PARSEJSON(CoverConfig, "$.in_mode", true);
Power Limit [W]
PARSEJSON(CoverConfig, "$.power_limit", true);
Voltage Limit [V]
PARSEJSON(CoverConfig, "$.voltage_limit", true);
Current Limit [A]
PARSEJSON(CoverConfig, "$.current_limit", true);
Motor Idle Power Threshold [W]
PARSEJSON(CoverConfig, "$.motor.idle_power_thr", true);
Motor Idle Confirm Period [s]
PARSEJSON(CoverConfig, "$.motor.idle_confirm_period", true);
Max Time Open [s]
PARSEJSON(CoverConfig, "$.maxtime_open", true);
Max Time Close [s]
PARSEJSON(CoverConfig, "$.maxtime_close", true);
Swap Inputs
PARSEJSON(CoverConfig, "$.swap_inputs", true);
Invert Directions
PARSEJSON(CoverConfig, "$.invert_directions", true);
Obstruction Detection
PARSEJSON(CoverConfig, "$.obstruction_detection", true);
Safety Switch
PARSEJSON(CoverConfig, "$.safety_switch", true);
Azioni di servizio
Open
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
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
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
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)
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
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

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 inizialeConfigura il comportamento dell'interruttore all'accensione
Imposta modalitàConfigura la modalità cablaggio dell'ingresso fisico

Interruttore 1

Lettura stato interruttore
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    adderror("Device profile is set to cover");
else
    RETURN(PARSEJSON(SwitchStatus, "$.output", true));
end
Scrittura stato interruttore
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)
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
PARSEJSON(SwitchStatus, "$.source", true);
Temprature [°C]
PARSEJSON(SwitchStatus, "$.temperature.tC", true);
Initial State
PARSEJSON(SwitchConfig, "$.initial_state", true);
Input Mode
PARSEJSON(SwitchConfig, "$.in_mode", true);
Power Limit [W]
PARSEJSON(SwitchConfig, "$.power_limit", true);
Voltage Limit [V]
PARSEJSON(SwitchConfig, "$.voltage_limit", true);
Current Limit [A]
PARSEJSON(SwitchConfig, "$.current_limit", true);
Azioni di servizio
Set Initial State
Parametri: Mode
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
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

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 inizialeConfigura il comportamento dell'interruttore all'accensione
Imposta modalitàConfigura la modalità cablaggio dell'ingresso fisico

Interruttore 2

Lettura stato interruttore
if PARSEJSON(SysConfig, "$.device.profile") = "cover"
    adderror("Device profile is set to cover");
else
    RETURN(PARSEJSON(SwitchStatus, "$.output", true));
end
Scrittura stato interruttore
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)
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
PARSEJSON(SwitchStatus, "$.source", true);
Temprature [°C]
PARSEJSON(SwitchStatus, "$.temperature.tC", true);
Initial State
PARSEJSON(SwitchConfig, "$.initial_state", true);
Input Mode
PARSEJSON(SwitchConfig, "$.in_mode", true);
Power Limit [W]
PARSEJSON(SwitchConfig, "$.power_limit", true);
Voltage Limit [V]
PARSEJSON(SwitchConfig, "$.voltage_limit", true);
Current Limit [A]
PARSEJSON(SwitchConfig, "$.current_limit", true);
Azioni di servizio
Set Initial State
Parametri: Mode
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
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
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

Fonti