community italiana di domotica personale
 
Integrare Shelly Pro 4PM a Home Assistant via MQTT

Integrare Shelly Pro 4PM a Home Assistant via MQTT

Scopi della guida:
  • Integrare l’attuatore Shelly Pro 4PM all’HUB di domotica personale Home Assistant
  • Livello di difficoltà: medio/bassa
  • Categoria d’integrazione: Local Push
Concetti affrontati:
  • Configurazione software
Componenti software utilizzate:
  • Home Assistant
  • Componente Home Assistant “MQTT” e varie piattaforme figlie di tale componente
Prerequisiti:
  • Home Assistant configurato e funzionante
  • Componente/i Shelly da integrare già configurato/i in Wi-Fi
Dispositivi fisici utilizzati:
GUIDA INDICATA A UTENTI CON ISTALLAZIONE:
Ambienti Home Assistant HassOS-Supervised-Core
NOTE E DISCLAIMER
  • qualsiasi eventuale modifica agli impianti domestici dev'essere progettata e realizzata SOLO da personale qualificato;
  • qualsiasi modifica non prevista attuata in proprio è a propria responsabilità personale nonché a proprio rischio e pericolo (i contenuti della presenta pagina hanno infatti puro scopo didattico) e fa decadere garanzia, omologazioni e certificazioni di qualità; dei dispositivi interessati;
  • tutte le tecniche descritte si intendono applicate a software e firmware aggiornati alle ultime versioni disponibili;
  • gli articoli di inDomus sono totalmente indipendenti e non sponsorizzati. Se mai questo cambiasse, verrà segnalato chiaramente sulle pagine oggetto di sponsorizzazione;
  • questa pagina è materialmente scritta e manutenuta da più individui: non ci si aspetti né si pretenda un supporto personale. In caso di difficoltà, chiedere supporto alla community sul nostro forum o sulla nostra chat;
  • se hai bisogno di orientarti, c'è la mappa.
Revisione guida: 1.0

Shelly Pro 4PM - Home Assistant

Abstract

Uno dei grandi vantaggi della linea Shelly (rispetto per esempio alla diretta rivale, la ITEAD Sonoff, o altre analoghe) è quella di installare sui propri componenti di firmware in grado di offrire supporto allo standard MQTT.

MQTT (Message Queue Telemetry Transport) è uno standard particolarmente apprezzato in domotica personale per prestazioni e semplicità; la sua adozione consente di integrare con estrema facilità (e nel modo preferibile, il Local Push) qualunque componente che lo utilizzi con i più svariati ambienti operativi quali, in domotica, gli HUB personali.

Home Assistant è uno degli HUB personali con i quali è più semplice far dialogare i componenti Shelly sfruttando il protocollo MQTT: in questa guida vedremo come predisporre le funzionalità dello Shelly Pro 4PM e come configurare Home Assistant affinché lo integri in tutte le sue possibili funzioni.

N.b. La metodologia MQTT qui descritta rimane tra quelle più comprovatamente sicure, efficienti. In assoluto, però, si consiglia l’utilizzo della piattaforma di integrazione inclusa nativamente su Home Assistant, in quanto ormai più che rodata, affidabile e, tutto sommato, più semplice da attuare. Inoltre, essa rende inutile la presenza di un broker MQTT il quale, va da sé, rappresenta un single-point-of-failure in più nella catena d’integrazione.

Assunti

Shelly Pro 4PMPer l’implementazione della presente guida è necessario che sulla propria rete sia presente un broker MQTT; in primis però è importante capire come MQTT funzioni: per far questo, è importante la lettura di questa scheda scritta appositamente per capire il ruolo del broker MQTT all’interno della propria rete – a prescindere dai componenti che supportino MQTT presenti nel proprio ambiente.

Per dotarsi di  un broker e per attivare le funzioni client MQTT su Home Assistant si rimanda a questa guida.

Si assume inoltre che lo/gli Shelly in questione siano già stati configurati fornendogli accesso alla propria rete Wi-Fi, cosa che può essere fatta sia tramite l’app Shelly Cloud (per Android e iOS)  sia attraverso l’access point da essi fornito a fronte di un reset alle impostazioni di fabbrica.

Si parte

Modalità LAN e MQTT

La prima cosa da fare è connettere il nostro Shelly al broker MQTT presente sulla nostra rete (must-have indicato negli assunti). Per farlo è necessario attivare la modalità LAN disponibile sul firmware dell’unità, fornire le coordinate del broker (e gli eventuali username e password di autenticazione).

Per effettuare la configurazione è necessario utilizzare un qualsiasi browser tramite il quale collegarsi all’interfaccia web offerta dall’attuatore. Non è possibile effettuare questa configurazione tramite app mobile, e il perché è semplice: alcune impostazioni (tipo questa) sull’app semplicemente non figurano.

Avremo dunque bisogno dell’indirizzo IP a cui collegarci: lo si potrà trovare facilmente tramite l’interfaccia web del proprio modem/router oppure con un qualsiasi tool di scansione reti (eg. Fing). Se l’IP assegnato sarà (per esempio) il 192.168.1.100, l’interfaccia web alla quale collegarsi sarà disponibile all’indirizzo http://192.168.1.100.

Una volta connessi apparirà un’interfaccia piuttosto semplice.

Entrare poi nella sezione “Network – MQTT“.
La schermata che segue consente di inserire il “nome” dello Shelly, indirizzo (e porta) del proprio broker MQTT nonchè le relative credenziali d’accesso:

Shelly Pro 4PM - Configurazione MQTT

Per quanto riguarda l’indirizzo e porta del server, esso deve essere espresso in termini di IP:PORTA (eg. 192.168.1.1:1883). La porta standard del broker MQTT è 1883 (a meno che non l’abbiate modificata).

La scelta del nome è personale; si tratta di un passaggio cardine rispetto alla configurazione che effettueremo, successivamente, su Home Assistant.

Una volta completata la configurazione, cliccare su “SAVE“.

N.b. Attivare MQTT – quindi la cosiddetta modalità “LAN” di fatto disconnette il componente dal cloud Shelly, il che non consentirà più di controllare l’unità via app (da remoto, perché localmente continuerà a funzionare). Tale comportamento è più normale: il controllo remoto sarà garantito attraverso Home Assistant e non più dall’app Shelly Cloud.

Modalità d’uso dello Shelly

Prima di passare a Home Assistant, alcune considerazioni lato Shelly sono doverose.

Lo Shelly Pro 4PM è un attuatore da quadro elettrico su barra DIN ed è in grado di gestire quattro canali a 16A per un totale di 40A (complessivi, massimi). Per ogni canale, Shelly Pro 4PM prevede un misuratore indipendente di assorbimento istantaneo (potenza) espresso in Watt (con precisione al decimo di unità) e di energia (consumo nel tempo) espresso in kWh.

Trattandosi di un attuatore a quattro canali singli, esso viene tipicamente utilizzato per controllare punti luce, prese elettriche o comunque un carichi generici: va da sé che l’integrazione da realizzare sia principalmente questa, ovvero quella di dotarsi di “Switch” per attivare/disattivare i quattro interruttori indipendenti. Teoricamente Shelly Pro 4PM si potrebbe anche utilizzare per controllare due diverse tapparelle elettriche, ma questo è un mestiere al quale è dedicato il fratello Shelly Pro Dual Cover PM, pertanto in questa guida non ci concentreremo su questo possibile aspetto.

Nei paragrafi che seguono scopriremo come integrare via MQTT queste funzionalità.

Home Assistant

Vediamo ora come provvedere all’integrazione dell’attuatore in termini di interruttori indipendenti nonché dei sensori di diversa natura sopra descritti.

Relè

L’obiettivo dell’integrazione è quella di dotarsi, presso Home Assistant, di quattro “Switch” il quale non solo agiscano sullo Shelly in modo da poter attivarne i vari relè, ma anche da visualizzarne lo stato operativo aggiornato in caso di variazione effettuata tramite i pulsanti presenti sul display touch dell’unità.

Allo scopo utilizzeremo la piattaforma “MQTT Switch“.

L’implementazione è semplice. Sarà infatti sufficiente inserire in configurazione (personalizzandola, come spiegato a seguire) il seguente blocco (integrando eventuali switch già presenti):

mqtt:
  switch:
    - name: "Switch 1"
      unique_id: "NOME_SHELLY_Switch_1"
      icon: mdi:lightbulb
      state_topic: "NOME_SHELLY/status/switch:0"
      value_template: {{ value_json.output }}
      command_topic: "NOME_SHELLY/rpc"
      payload_on: '{"id": 2,"src":"user_1","method":"Switch.Set","params": {"id":0,"on":true}}'
      payload_off: '{"id": 2,"src":"user_1","method":"Switch.Set","params": {"id":0,"on":false}}'
      state_on: true
      state_off: false
      optimistic: false
      availability_topic: "NOME_SHELLY/online"
      payload_available: "true"
      payload_not_available: "false"
      qos: 1
      retain: false

    - name: "Switch 2"
      unique_id: "NOME_SHELLY_Switch_2"
      icon: mdi:lightbulb
      state_topic: "NOME_SHELLY/status/switch:1"
      value_template: {{ value_json.output }}
      command_topic: "NOME_SHELLY/rpc"
      payload_on: '{"id": 2,"src":"user_1","method":"Switch.Set","params": {"id":0,"on":true}}'
      payload_off: '{"id": 2,"src":"user_1","method":"Switch.Set","params": {"id":0,"on":false}}'
      state_on: true
      state_off: false
      optimistic: false
      availability_topic: "NOME_SHELLY/online"
      payload_available: "true"
      payload_not_available: "false"
      qos: 1
      retain: false

    - name: "Switch 3"
      unique_id: "NOME_SHELLY_Switch_3"
      icon: mdi:lightbulb
      state_topic: "NOME_SHELLY/status/switch:2"
      value_template: {{ value_json.output }}
      command_topic: "NOME_SHELLY/rpc"
      payload_on: '{"id": 2,"src":"user_1","method":"Switch.Set","params": {"id":0,"on":true}}'
      payload_off: '{"id": 2,"src":"user_1","method":"Switch.Set","params": {"id":0,"on":false}}'
      state_on: true
      state_off: false
      optimistic: false
      availability_topic: "NOME_SHELLY/online"
      payload_available: "true"
      payload_not_available: "false"
      qos: 1
      retain: false

    - name: "Switch 4"
      unique_id: "NOME_SHELLY_Switch_4"
      icon: mdi:lightbulb
      state_topic: "NOME_SHELLY/status/switch:3"
      value_template: {{ value_json.output }}
      command_topic: "NOME_SHELLY/rpc"
      payload_on: '{"id": 2,"src":"user_1","method":"Switch.Set","params": {"id":0,"on":true}}'
      payload_off: '{"id": 2,"src":"user_1","method":"Switch.Set","params": {"id":0,"on":false}}'
      state_on: true
      state_off: false
      optimistic: false
      availability_topic: "NOME_SHELLY/online"
      payload_available: "true"
      payload_not_available: "false"
      qos: 1
      retain: false 

Il valore NOME_SHELLY è ovviamente da personalizzare: tale nome viene impostato nella fase di configurazione MQTT già effettuata precedentemente. Ovviamente il tutto è personalizzabile, inclusi (in primis) i nomi dei due interruttori (campo “name“), o per esempio l’icona (campo “icon“) usando il solito materialicondesign.com per la scelta dell’icona appropriata (in questo caso, una lampadina).

QoS, come spesso capita, è impostato a 1 per una maggiore certezza dell’esecuzione dei comandi.

Sensori

Occupiamoci ora di integrare la sensoristica.

Potenza istantanea

In primis, utilissimi i sensori che rilevano la potenza assorbita istantaneamente dai quattro canali, nel momento in cui i relativi interruttori sono su “ON”.

mqtt:
  sensor:
    - name: "Potenza Switch 1"
      unique_id: "NOME_SHELLY_Potenza_Switch_1"
      state_topic: "NOME_SHELLY/status/switch:0"
      value_template: {{ value_json.apower|float(default=0)|round(2) }}
      unit_of_measurement: "W"
      device_class: power
 
    - name: "Potenza Switch 2"
      unique_id: "NOME_SHELLY_Potenza_Switch_2"
      state_topic: "NOME_SHELLY/status/switch:1"
      value_template: {{ value_json.apower|float(default=0)|round(2) }}
      unit_of_measurement: "W"
      device_class: power

    - name: "Potenza Switch 3"
      unique_id: "NOME_SHELLY_Potenza_Switch_3"
      state_topic: "NOME_SHELLY/status/switch:2"
      value_template: {{ value_json.apower|float(default=0)|round(2) }}
      unit_of_measurement: "W"
      device_class: power

    - name: "Potenza Switch 4"
      unique_id: "NOME_SHELLY_Potenza_Switch_4"
      state_topic: "NOME_SHELLY/status/switch:3"
      value_template: {{ value_json.apower|float(default=0)|round(2) }}
      unit_of_measurement: "W"
      device_class: power

Anche in questo caso, la stringa NOME_SHELLY è da personalizzare in funzione del nome attribuito allo Shelly.

Tale configurazione genera quattro nuovi sensori:

  • sensor.potenza_switch_1
  • sensor.potenza_switch_2
  • sensor.potenza_switch_3
  • sensor.potenza_switch_4

i quali rappresenteranno le letture, istantanee, di potenza.

Energia consumata

Lo stesso dicasi per quanto concerne l’energia consumata. 

mqtt:
  sensor:
    - name: "Energia Switch 1"
      unique_id: "NOME_SHELLY_Energia_Switch_1"
      state_topic: "NOME_SHELLY/status/switch:0"
      value_template: {{ value_json.aenergy.total|float(default=0)|round(2) }}
      unit_of_measurement: "Wh"
      state_class: total_increasing
      device_class: energy

    - name: "Energia Switch 2"
      unique_id: "NOME_SHELLY_Energia_Switch_2"
      state_topic: "NOME_SHELLY/status/switch:1"
      value_template: {{ value_json.aenergy.total|float(default=0)|round(2) }}
      unit_of_measurement: "Wh"
      state_class: total_increasing
      device_class: energy

    - name: "Energia Switch 3"
      unique_id: "NOME_SHELLY_Energia_Switch_3"
      state_topic: "NOME_SHELLY/status/switch:2"
      value_template: {{ value_json.aenergy.total|float(default=0)|round(2) }}
      unit_of_measurement: "Wh"
      state_class: total_increasing
      device_class: energy

    - name: "Energia Switch 4"
      unique_id: "NOME_SHELLY_Energia_Switch_4"
      state_topic: "NOME_SHELLY/status/switch:3"
      value_template: {{ value_json.aenergy.total|float(default=0)|round(2) }}
      unit_of_measurement: "Wh"
      state_class: total_increasing
      device_class: energy 

Anche in questo caso, la stringa NOME_SHELLY è da personalizzare in funzione del nome attribuito allo Shelly.

Tale configurazione genera quattro nuovi sensori:

  • sensor.energia_switch_1
  • sensor.energia_switch_2
  • sensor.energia_switch_3
  • sensor.energia_switch_4

i quali rappresenteranno le letture di energia consumata, crescente, espressa in “Wh”.

N.b. I sensori sopra realizzati sono purtroppo espressi in Watt/ore, anziché nella tipica unità di misura “kWh”. Si suggerisce pertanto di NON attuare la configurazione di cui sopra e piuttosto realizzare da sé i sensori di energia espressi in kWh sfruttando i sensori di potenza realizzati in precedenza e la guida specifica.
Vetrina - Offerte del giorno

Voltaggio e amperaggio

Utile, anche se secondario, possedere dei sensori di voltaggio e amperaggio per i singoli canali.

mqtt:
  sensor:
    - name: "Voltaggio Switch 1"
      unique_id: "NOME_SHELLY_Voltaggio_Switch_1"
      state_topic: "NOME_SHELLY/status/switch:0"
      value_template: {{ value_json.voltage|float(default=0)|round(2) }}
      unit_of_measurement: "V"
      state_class: measurement
      device_class: voltage

    - name: "Voltaggio Switch 2"
      unique_id: "NOME_SHELLY_Voltaggio_Switch_2"
      state_topic: "NOME_SHELLY/status/switch:1"
      value_template: {{ value_json.voltage|float(default=0)|round(2) }}
      unit_of_measurement: "V"
      state_class: measurement
      device_class: voltage

    - name: "Voltaggio Switch 3"
      unique_id: "NOME_SHELLY_Voltaggio_Switch_3"
      state_topic: "NOME_SHELLY/status/switch:2"
      value_template: {{ value_json.voltage|float(default=0)|round(2) }}
      unit_of_measurement: "V"
      state_class: measurement
      device_class: voltage

    - name: "Voltaggio Switch 4"
      unique_id: "NOME_SHELLY_Voltaggio_Switch_4"
      state_topic: "NOME_SHELLY/status/switch:3"
      value_template: {{ value_json.voltage|float(default=0)|round(2) }}
      unit_of_measurement: "V"
      state_class: measurement
      device_class: voltage 

Anche in questo caso, la stringa NOME_SHELLY è da personalizzare in funzione del nome attribuito allo Shelly.

Tale configurazione genera quattro nuovi sensori:

  • sensor.voltaggio_switch_1
  • sensor.voltaggio_switch_2
  • sensor.voltaggio_switch_3
  • sensor.voltaggio_switch_4

Quanto all’amperaggio, è sufficiente realizzare in proprio un sensore template il quale si calcoli tramire la divisione di potenza e voltaggio (grazie ai sensori sin qui realizzati).

Stato

Utile inoltre disporre di un sensore binario che indichi lo stato dell’unità (se sia connessa alla rete o meno):

binary_sensor:
  - platform: rest
    resource: http://IP_DELLO_SHELLY/rpc
    name: "Satus Shelly Pro 4PM"
    value_template: "{{ value_json.result.wifi.status|trim != 'disconnected' }}"
    payload: '{"id":1, "src":"status_connect", "method":"Shelly.GetStatus"}'
    method: POST
    device_class: connectivity 
    scan_interval: 300

In questo caso la stringa IP_DELLO_SHELLY è da personalizzare in funzione dell’IP (fisso, a questo punto) attribuito allo Shelly.

Deatching

Lo Shelly Pro 4PM consente di collegarvi quattro diversi pulsanti/interruttori meccanici (contatti S1/S2/S3/S4) al fine di controllare direttamente i quattro canali.

Shelly Pro 4PM - Connessioni
lo schema di connessione, come da manuale.

Configurando però l’attuatore in modalità “detached” (interfaccia menu: “Channel Settings”) è possibile “sganciarli”, per l’appunto”, dal controllo dei canali e usarli in domotica per altri scopi. In pratica, è possibile utilizzare pulsanti murali collegati allo Shelly Pro 4PM in modalità “detached” per innescare automazioni diverse su Home Assistant.

Gli stati che possono essere intercettati (e usati) sono:

  • single_push (singola pressione del pulsante murale);
  • double_push (doppia pressione del pulsante murale);
  • long_push (pressione prolungata del pulsante murale).

L’automazione per gestirli tutti e 12 (tre stati x quattro canali) è la seguente:

automation:
  - alias: "Gestione Detached Shelly"
    trigger:
      - platform: mqtt
        id: "single_push"
        topic: "NOME_SHELLY/events/rpc"
        value_template: "{{ value_json.params.events[0].event }}"
        payload: "single_push"
      - platform: mqtt
        id: "single_push"
        topic: "NOME_SHELLY/events/rpc"
        value_template: "{{ value_json.params.events[0].event }}"
        payload: "double_push"
      - platform: mqtt
        id: "single_push"
        topic: "NOME_SHELLY/events/rpc"
        value_template: "{{ value_json.params.events[0].event }}"
        payload: "long_push"
    condition: []
    action:
      - choose:
          - conditions:
              - condition: trigger
                id: "single_push"
              - choose:
                  - conditions:
                      - condition: template
                        value_template: >
                          {% set value_json = trigger.payload | from_json %}
                          {{ value_json.params.events[0].component == 'input:0'  }}
                        sequence:
                          # Quel che deve fare l'automazione per il pulsante 1 premuto una volta
                      - condition: template
                        value_template: >
                          {% set value_json = trigger.payload | from_json %}
                          {{ value_json.params.events[0].component == 'input:1' }}
                        sequence:
                          # Quel che deve fare l'automazione per il pulsante 2 premuto una volta
                      - condition: template
                        value_template: >
                          {% set value_json = trigger.payload | from_json %}
                          {{ value_json.params.events[0].component == 'input:2' }}
                        sequence:
                          # Quel che deve fare l'automazione per il pulsante 3 premuto una volta
                      - condition: template
                        value_template: >
                          {% set value_json = trigger.payload | from_json %}
                          {{ value_json.params.events[0].component == 'input:3' }}
                        sequence:
                          # Quel che deve fare l'automazione per il pulsante 4 premuto una volta
              - condition: trigger
                id: "double_push"
              - choose:
                  - conditions:
                      - condition: template
                        value_template: >
                          {% set value_json = trigger.payload | from_json %}
                          {{ value_json.params.events[0].component == 'input:0' }}
                        sequence:
                          # Quel che deve fare l'automazione per il pulsante 1 premuto due volte
                      - condition: template
                        value_template: >
                          {% set value_json = trigger.payload | from_json %}
                          {{ value_json.params.events[0].component == 'input:1' }}
                        sequence:
                          # Quel che deve fare l'automazione per il pulsante 2 premuto due volte
                      - condition: template
                        value_template: >
                          {% set value_json = trigger.payload | from_json %}
                          {{ value_json.params.events[0].component == 'input:2' }}
                        sequence:
                          # Quel che deve fare l'automazione per il pulsante 3 premuto due volte
                      - condition: template
                        value_template: >
                          {% set value_json = trigger.payload | from_json %}
                          {{ value_json.params.events[0].component == 'input:3' }}
                        sequence:
                          # Quel che deve fare l'automazione per il pulsante 4 premuto due volte
              - condition: trigger
                id: "long_push"
              - choose:
                  - conditions:
                      - condition: template
                        value_template: >
                          {% set value_json = trigger.payload | from_json %}
                          {{ value_json.params.events[0].component == 'input:0' }}
                        sequence:
                          # Quel che deve fare l'automazione per il pulsante 1 premuto a lungo
                      - condition: template
                        value_template: >
                          {% set value_json = trigger.payload | from_json %}
                          {{ value_json.params.events[0].component == 'input:1' }}
                        sequence:
                          # Quel che deve fare l'automazione per il pulsante 2 premuto a lungo
                      - condition: template
                        value_template: >
                          {% set value_json = trigger.payload | from_json %}
                          {{ value_json.params.events[0].component == 'input:2' }}
                        sequence:
                          # Quel che deve fare l'automazione per il pulsante 3 premuto a lungo
                      - condition: template
                        value_template: >
                          {% set value_json = trigger.payload | from_json %}
                          {{ value_json.params.events[0].component == 'input:3' }}
                        sequence:
                          # Quel che deve fare l'automazione per il pulsante 4 premuto a lungo 

Anche in questo caso, la stringa NOME_SHELLY è da personalizzare in funzione del nome attribuito allo Shelly.

Naturalmente, le 12 diverse azioni (indicata in verde) andranno personalizzate a proprio piacimento.

Censimento iniziale di stato

All’avvio, Home Assistant non conosce lo stato dello/degli Shelly; per far in modo che tali stati vengano raccolti immediatamente, aggiungere la seguente automazione all’elenco di quelle esistenti:

automation:
- alias: MQTT Announce
  trigger:
  - event: start
    platform: homeassistant
  condition: []
  action:
  - service: mqtt.publish
    data:
      payload: update
      topic: shellies/command

Pubblicando il topic “shellies/command“, tutti gli Shelly presenti sulla rete connessi al broker MQTT risponderanno fornendo il proprio stato.


⚠️ Se di Home Assistant ne sai poco ma sei interessato a capirne di più, ti suggeriamo di partire da qui.

Questa pagina è redatta, manutenuta e aggiornata dallo staff di inDomus, un gruppo di persone molto diverse tra loro che trovi, per domande e supporto, sul forum e sulla chat del sito. Alcuni link sono taggati in qualità di affiliati Amazon e riceviamo un compenso dagli acquisti idonei, utile al sostenimento del sito, ma le nostre recensioni sono tutte indipendenti e non sponsorizzate. Se ti sei perso, a tua disposizione c'è la mappa.