--- title: "Shelly Pro 4PM" description: "Shelly Pro 4PM via HTTP locale in TapHome: quattro relè da 16 A su guida DIN con potenza ed energia per canale. Serve solo l'indirizzo IP." url: "https://taphome.com/it/compatibility/shelly-4-pro/" language: it lastmod: 2026-03-29 generator: hugo ai: topics: ["http","electric-meter","wifi","relay","power-metering","din-rail","4-channel","mdns","ethernet"] questions: ["Come integrare Shelly Pro 4PM con TapHome?","Cosa misura il template Shelly Pro 4PM in TapHome?","Come collegare Shelly Pro 4PM tramite HTTP a TapHome?","Perché Shelly Pro 4PM mostra letture di potenza a zero?","TapHome può leggere lo stato del relè su Shelly Pro 4PM?","Come impostare il limite di protezione potenza su Shelly Pro 4PM da TapHome?","Qual è la differenza tra Shelly Pro 4PM V1 e V2?","Perché gli interruttori relè su Shelly Pro 4PM sono solo in scrittura?"] --- # Shelly Pro 4PM Comunicazione: Packet Parser → HTTP - [Shelly Pro 4PM pagina prodotto](https://www.shelly.com/en/products/shop/shelly-pro-4pm) - [Shelly Pro 4PM documentazione API](https://shelly-api-docs.shelly.cloud/gen2/Devices/Gen2/ShellyPro4PM) - [Shelly Pro 4PM knowledge base](https://kb.shelly.cloud/knowledge-base/shelly-pro-4pm) > 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 Pro 4PM è un relè smart a 4 canali per montaggio su guida DIN con misurazione della potenza integrata per canale. Ciascuna delle quattro uscite indipendenti può commutare fino a 16 A (totale 40 A), rendendolo adatto al controllo di circuiti di illuminazione, apparecchi o carichi del quadro elettrico con monitoraggio energetico individuale per canale. TapHome comunica con il dispositivo via HTTP sulla rete locale — non è richiesta alcuna connessione cloud. Il template utilizza un approccio API misto: endpoint RPC Gen2+ (`/rpc/Switch.GetStatus?id=N`) per la lettura delle misurazioni energetiche, ed endpoint Gen1 (`/relay/N?turn=on|off`) per il controllo dei relè. Entrambe le generazioni API sono supportate dal Pro 4PM per compatibilità retroattiva. Il dispositivo si connette tramite WiFi o Ethernet (RJ45) e dispone di un display LCD a colori da 1,8 pollici per il monitoraggio locale dello stato. ## Configurazione Lo Shelly Pro 4PM si connette tramite WiFi o Ethernet. Durante l'importazione del template TapHome, inserisci 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. Apri l'interfaccia web Shelly (`http://{ip-dispositivo}`) → Settings → Authentication e assicurati che sia disattivata. > [!WARNING] > Il cavo LAN deve essere collegato o scollegato solo quando il dispositivo è **spento**. L'inserimento a caldo del cavo Ethernet può causare problemi. > [!NOTE] > Se la modalità ECO è abilitata sul dispositivo Shelly, può causare timeout di comunicazione a causa degli intervalli di polling rapidi utilizzati dal template (2,5–15 secondi). Disabilita la modalità ECO nell'interfaccia web Shelly se riscontri problemi di connettività intermittenti. ## Funzionalità del dispositivo ### Misurazione dell'energia Il template espone quattro dispositivi contatore di energia indipendenti, uno per canale. Ogni contatore legge da `/rpc/Switch.GetStatus?id=N` (dove N è 0–3): - **Potenza in tempo reale** — `apower` in watt, convertita in kW dal template - **Consumo totale** — `aenergy.total` in wattora, convertito in kWh dal template Il canale 1 effettua il polling ogni 2,5 secondi per un feedback più rapido. I canali 2–4 effettuano il polling ogni 15 secondi. I contatori sono di sola lettura — si aggiornano automaticamente ad ogni ciclo di polling. ### Controllo relè Il template espone quattro dispositivi interruttore relè, uno per canale. Ogni relè è controllato tramite l'endpoint Gen1 `/relay/N?turn=on|off` (dove N è 0–3). > [!NOTE] > Gli interruttori relè sono **di sola scrittura** — il template non legge lo stato del relè dal dispositivo. Lo stato attuale del relè può essere dedotto dal contatore di energia corrispondente: se il canale riporta un consumo diverso da zero, il relè è acceso. Un futuro aggiornamento del template potrebbe aggiungere il feedback dello stato del relè utilizzando il campo Gen2+ `/rpc/Switch.GetStatus?id=N` → `output`. ### Sensore di potenza Un dispositivo sensore di potenza autonomo espone la potenza attiva grezza in watt per il canale 1 (letta da `/rpc/Switch.GetStatus?id=0` → `apower`). A differenza del contatore di energia che converte in kW, questo sensore riporta il valore in watt senza conversione, utile per automazioni che necessitano di precisione a livello di watt. ### Diagnostica di servizio Il template espone 13 attributi di servizio per il monitoraggio del dispositivo: - **Informazioni dispositivo** — hostname, indirizzo MAC, ora del dispositivo, uptime, utilizzo RAM - **Protezione termica** — temperatura interna (°C), stato temperatura (Normal / High / Very High), flag sovratemperatura - **Connettività** — cloud abilitato/connesso, MQTT connesso, aggiornamento firmware disponibile - **Protezione potenza** — limite massimo di potenza attuale (letto da `/settings`) ### Azioni di servizio Sono disponibili tre azioni di servizio: - **Imposta protezione potenza** — imposta il limite massimo di potenza (1–3500 W). Il relè si spegne automaticamente se il consumo supera questo valore. - **Abilita cloud** — abilita o disabilita la connettività Shelly Cloud - **Riavvio** — avvia un riavvio del dispositivo ### Funzionalità aggiuntive Lo Shelly Pro 4PM espone anche tensione, corrente, fattore di potenza, frequenza e temperatura interna per canale nella sua risposta `/rpc/Switch.GetStatus`. Stati degli ingressi fisici interruttore/pulsante (S1–S4), stato Ethernet, WiFi RSSI e controllo relè nativo Gen2+ con timer di spegnimento automatico sono disponibili tramite l'API RPC. 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 WiFi o Ethernet e abbia un indirizzo IP valido 2. Prova a utilizzare l'hostname mDNS (`shellypro4pm-AABBCCDDEE.local`) invece dell'indirizzo IP — l'IP potrebbe essere cambiato dopo un rinnovo DHCP 3. Apri `http://{ip-dispositivo}/rpc/Shelly.GetDeviceInfo` nel browser — se risponde con JSON, il dispositivo è raggiungibile 4. Verifica che TapHome Core e Shelly siano sulla stessa rete / VLAN 5. Assicurati che l'autenticazione sia disabilitata sul dispositivo Shelly ### Le letture di potenza mostrano zero 1. Conferma che il carico sia collegato attraverso l'uscita relè Shelly (O1–O4), non bypassato 2. Verifica che il relè sia acceso — il contatore misura solo quando la corrente scorre attraverso il relè 3. Interroga manualmente `/rpc/Switch.GetStatus?id=0` e verifica che `apower` restituisca un valore diverso da zero 4. Verifica l'ID canale corretto (id=0 per Uscita 1, id=1 per Uscita 2, ecc.) ### Stato relè sconosciuto Gli interruttori relè in questo template sono di sola scrittura — inviano comandi on/off ma non leggono lo stato del relè. Per verificare lo stato effettivo del relè: 1. Controlla il contatore di energia corrispondente — potenza diversa da zero significa che il relè è acceso 2. Osserva gli indicatori LED dei relè sul pannello frontale del dispositivo 3. Testa manualmente tramite browser: `http://{ip-dispositivo}/relay/0` restituisce lo stato attuale del relè in JSON ### Avviso sovratemperatura Lo Shelly Pro 4PM dispone di protezione termica interna. Se la temperatura del dispositivo supera i limiti di sicurezza, `temperature_status` cambia in "High" o "Very High" e `overtemperature` diventa `true`. Assicura una ventilazione adeguata nel quadro elettrico, specialmente quando si commutano carichi elevati su più canali contemporaneamente. ### Hardware V1 vs V2 Entrambe le versioni utilizzano lo stesso firmware e API. La V2 (SPSW-104PE16EU) ha connettori migliorati — cinque morsetti a vite individuali invece di quattro blocchi a 2 morsetti — e migliore isolamento elettrico LAN. Non sono necessarie modifiche al template tra le versioni. > [!WARNING] > I dispositivi Shelly Gen2 supportano fino a **6 connessioni HTTP simultanee**. Il template Shelly Pro 4PM utilizza fino a 5 endpoint simultanei per ciclo di polling (4 contatori energia + stato modulo), lasciando margine limitato. Evita il polling simultaneo da troppi sistemi. ## 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-.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 9 Questi dispositivi compaiono in TapHome dopo l'importazione. Shelly Pro 4PM Modulo Azioni di servizio | | | |----------------------------|---------------------------------------------------------------------------------------------------------------------| | Imposta protezione potenza | Imposta limite massimo di potenza (1–3500 W) — il relè si spegne automaticamente se il consumo supera questo valore | | Abilita cloud | Abilita o disabilita la connettività Shelly Cloud | | Riavvio | Avvia un riavvio del dispositivo | Variabili personalizzate | | |-------------------------| | `StatusJson` (string) | | `SettingsJson` (string) | | `status` (string) = 0 | Lettura (modulo) ```taphome VAR response := SENDHTTPREQUEST("/status", "GET"); StatusJson := response.Content; ``` Azioni di servizio Set power protection Parametri: Maximum power (1–3500 Watts) ```taphome VAR response := SENDHTTPREQUEST("settings?max_power=" + Watts); VAR contentJson := response.Content; VAR limitSet := PARSEJSON(contentJson, "max_power"); "Power limit set to " + limitSet + "W" ``` Enable cloud Parametri: Enable (Enable / Disable) ```taphome VAR response := SENDHTTPREQUEST("/settings/cloud?enabled=" + enable); VAR contentJson := response.Content; VAR wasEnabled := PARSEJSON(contentJson, "enabled"); IF(wasEnabled, "Cloud enabled", "Cloud disabled"); ``` Reboot ```taphome VAR response := SENDHTTPREQUEST("/reboot"); VAR contentJson := response.Content; VAR wasRebooted := PARSEJSON(contentJson, "ok"); IF(wasRebooted, "Reboot successful", "Error"); ``` Contatore energia canale 1 Contatore elettrico Solo lettura Misurazione potenza ed energia per canale per uscita 1 — potenza istantanea (kW) ed energia cumulativa (kWh) numeric Unità: W / kWh Lettura consumo totale ```taphome return(parsejson(parsejson(status,"aenergy"), "total")/1000); ``` Lettura domanda ```taphome return(parsejson(status,"apower")/1000); ``` Lettura (modulo) ```taphome var x := (sendhttprequest("/rpc/Switch.GetStatus?id=0")); status := x.Content; ``` Contatore energia canale 2 Contatore elettrico Solo lettura Misurazione potenza ed energia per canale per uscita 2 — potenza istantanea (kW) ed energia cumulativa (kWh) numeric Unità: W / kWh Lettura consumo totale ```taphome return(parsejson(parsejson(status,"aenergy"), "total")/1000); ``` Lettura domanda ```taphome return(parsejson(status,"apower")/1000); ``` Lettura (modulo) ```taphome var x := (sendhttprequest("/rpc/Switch.GetStatus?id=1")); status := x.Content; ``` Contatore energia canale 3 Contatore elettrico Solo lettura Misurazione potenza ed energia per canale per uscita 3 — potenza istantanea (kW) ed energia cumulativa (kWh) numeric Unità: W / kWh Lettura consumo totale ```taphome return(parsejson(parsejson(status,"aenergy"), "total")/1000); ``` Lettura domanda ```taphome return(parsejson(status,"apower")/1000); ``` Lettura (modulo) ```taphome var x := (sendhttprequest("/rpc/Switch.GetStatus?id=2")); status := x.Content; ``` Contatore energia canale 4 Contatore elettrico Solo lettura Misurazione potenza ed energia per canale per uscita 4 — potenza istantanea (kW) ed energia cumulativa (kWh) numeric Unità: W / kWh Lettura consumo totale ```taphome return(parsejson(parsejson(status,"aenergy"), "total")/1000); ``` Lettura domanda ```taphome return(parsejson(status,"apower")/1000); ``` Lettura (modulo) ```taphome var x := (sendhttprequest("/rpc/Switch.GetStatus?id=3")); status := x.Content; ``` Relè canale 2 Interruttore Lettura e scrittura Controllo relè solo scrittura per uscita 2 — stato non leggibile, desumere dal contatore energia boolean Valori / Stati: ON · OFF Scrittura stato interruttore ```taphome VAR path := "relay/1?turn=" + SWITCH(St, 0, "off", 1, "on","off"); SENDHTTPREQUEST(path); ``` Relè canale 1 Interruttore Lettura e scrittura Controllo relè solo scrittura per uscita 1 — stato non leggibile, desumere dal contatore energia boolean Valori / Stati: ON · OFF Scrittura stato interruttore ```taphome VAR path := "relay/0?turn=" + SWITCH(St, 0, "off", 1, "on","off"); SENDHTTPREQUEST(path); ``` Sensore potenza canale 1 Variabile Solo lettura Potenza attiva grezza in watt per canale 1 — valore sensore autonomo senza conversione kW numeric Unità: W Lettura ```taphome return(parsejson(status,"apower")); ``` Lettura (modulo) ```taphome var x := (sendhttprequest("/rpc/Switch.GetStatus?id=0")); status := x.Content; ``` Relè canale 3 Interruttore Lettura e scrittura Controllo relè solo scrittura per uscita 3 — stato non leggibile, desumere dal contatore energia boolean Valori / Stati: ON · OFF Scrittura stato interruttore ```taphome VAR path := "relay/2?turn=" + SWITCH(St, 0, "off", 1, "on","off"); SENDHTTPREQUEST(path); ``` Relè canale 4 Interruttore Lettura e scrittura Controllo relè solo scrittura per uscita 4 — stato non leggibile, desumere dal contatore energia boolean Valori / Stati: ON · OFF Scrittura stato interruttore ```taphome VAR path := "relay/3?turn=" + SWITCH(St, 0, "off", 1, "on","off"); SENDHTTPREQUEST(path); ``` **Connessione:** Packet Parser → HTTP • Hostname: `ShellyPro4PM-{MAC}.local` Possibili miglioramenti (10) - Relay State Read — Switches have no readswitchstate script — relay state is not read back. Gen2+ /rpc/Switch.GetStatus?id=N provides output (boolean) for state feedback. - Voltage — Per-channel line voltage in V, available in /rpc/Switch.GetStatus response - Current — Per-channel load current in A, available in /rpc/Switch.GetStatus response - Power Factor — Per-channel power factor, available in /rpc/Switch.GetStatus response - Frequency — Network frequency in Hz, available in /rpc/Switch.GetStatus response - Per-Channel Temperature — Internal temperature in °C per switch component, available in /rpc/Switch.GetStatus response - Input States (S1-S4) — 4 physical switch/button inputs, available via /rpc/Input.GetStatus?id=0..3 - Gen2+ Relay Control — Native Gen2+ relay control with toggle\_after timer support. Template uses Gen1 /relay/N instead. - WiFi Status (SSID, IP, RSSI) — WiFi status including signal strength, available via Gen2+ RPC - Ethernet Status — Pro 4PM has RJ45 LAN port; Ethernet status (IP, link) available via /rpc/Ethernet.GetStatus ## Parametri di importazione Inserisci questi valori quando importi l'XML. | Richiesto nell'app | Predefinito | |--------------------|---------------| | Indirizzo IP | `192.168.0.1` | ## Fonti - Shelly Gen2+/Gen3 RPC API Reference [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/) 2026-03-29 - Shelly Gen2+ Switch Component API [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Switch/) 2026-03-29 - Shelly Gen2+ System (Sys) Component API [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Sys/) 2026-03-29 - Shelly Gen2+ WiFi Component API [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/WiFi/) 2026-03-29 - Home Assistant Shelly Integration [www.home-assistant.io](https://www.home-assistant.io/integrations/shelly/) 2026-03-29 - Shelly Pro 4PM Knowledge Base [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-pro-4pm) 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/)