Home Assistant - file yaml, packages e integrazione Shelly con MQTT

Eccoci tornati ad un altro appuntamento con le Guide di Home Assistant.

Dopo essersi occupati dei componenti aggiuntivi, andiamo ad approfondire diversi aspetti della configurazione.

Parleremo di sintassi, ma anche di come separare la configurazione in vari file distinti. Concluderemo la guida con la creazione di alcuni switch e alcuni sensori tramite protocollo MQTT.

Abbiamo parlato più volte del (ormai famoso) file configuration.yaml, questo file è il file di configurazione principale di Home Assistant.

All'interno si potrebbe scrivere tutta la configurazione di Home Assistant mediante il componente file editor.

Abbiamo parlato di File editor nelle guide precedenti perciò, a chi se lo fosse perso, consiglio di guardare l'apposito capitolo. QUI  troverete tutti gli articoli relativi a questa nuova serie riguardante Home Assistant.

Come vi dicevo Il file Configuration.yaml è il file di configurazione principale, l'ultima volta lo avevamo usato per inserire le stringhe relative a Duckdns e lo avevamo lasciato in questo stato.

Come dicevo in precedenza è possibile scrivere nel file configuration.yaml tutta la configurazione di Home Assistant, ma è consigliabile dividere le configurazioni per categoria come mostreremo tra poco.

Per dividere la configurazione ci sono due modalità, l'una non esclude l'altra e oggi le vedremo entrambe.

Il modo più diretto per separare la configurazione ce lo troviamo di default davanti agli occhi la prima volta che apriamo il file.

Infatti come notate alcune voci vanno a richiamare un file esterno.

Inizialmente ci sono solo 4 voci che richiamano un file esterno: group, automation, script e scene.

Questo sta ad indicare che queste voci verranno gestite tramite altri file yaml esterni alla configurazione ma che verranno dichiarati nel file configuration.yaml. Questi file sono nel menù a tendina di file editor e li potrete trovare cliccando il simbolo della cartella (cerchiato in alto a sinistra nella foto).

Con questa stessa metodologia potrete aggiungere altri componenti da far gestire ai file esterni.

Aggiungete quindi quelli che vedete in foto.

Adesso che avete aggiunto switch, light, media_player, cover, climate, sensor e binary_sensor dovrete creare i relativi file proprio dove sono posizionati gli altri che erano di default preconfigurati in configuration.yaml

Quindi cliccate sull'icona della cartella, quella che avete visto prima nella foto evidenziata. Cliccate quindi sul simbolo per aggiungere dei file.

Dovrete creare diversi file.

switch.yaml, light.yaml, media_player.yaml, covers.yaml, climate.yaml, sensor.yaml e binary_sensor.yaml

Alla fine il risultato dovrebbe essere una cosa del genere.

Adesso che la vostra configurazione è divisa, ogni volta che dovrete inserire un componente, non dovrete più farlo in configuration.yaml ma dovrete farlo nel relativo file yaml. Più avanti inseriremo ad esempio degli switch e li inseriremo in switch.yaml.

Tuttavia prima di dedicarci alla configurazione voglio spiegarvi un altro concetto per separare la configurazione. 

I Packages.

Cosa sono?

Lo dice la parola stessa, dei pacchetti. All'interno di questi pacchetti si potrà inserire più elementi ad esempio sensori, switch e tutto quello che ci viene in mente, questo ci servirà magari ad identificare tutti gli elementi che comporranno un progetto. Questi passaggi li farò vedere bene nel video a fine articolo dove è più facile spiegare di cosa si tratta.

Tuttavia prima di lasciarvi al video vi farò vedere come abilitare i packages

Aprite nuovamente il file configuration.yaml

Dopo aver aggiunto i vari file yaml esterni la situazione che adesso vi si presenterà è questa.

dovrete aggiungere le stringhe che vedete in questa foto

queste stringhe serviranno a far capire ad Home Assistant che dovrà andare a cercare i package in una cartella esterna alla configurazione che a breve andremo a creare.

Ovviamente salvate il file configuration.yaml e recatevi nel menù laterale di file editor proprio dove prima avete aggiunto i file yaml aggiuntivi.

Dovrete creare una cartella chiamandola appunto packages

Questa volta dovrete premere il pulsante a forma di cartella per crearne una nuova e nominarla appunto come vi ho indicato sopra.

Il risultato sarà appunto questo.

Successivamente dovrete premere Configurazioni e impostazioni.

Verificate la configurazione e, se tutto è ok, riavviate Home Assistant per far applicare i cambiamenti.

Al riavvio dentro la cartella package potrete creare infiniti file yaml con all'interno vari elementi come vi farò vedere bene nel video.

 Adesso che abbiamo abilitato i package e abbiamo anche utilizzato vari file yaml esterni al file configuration.yaml ci avvaleremo di uno Shelly 2.5 e la sua integrazione MQTT per fare una prova.

Prima di procedere vi consiglio di leggere questo nostro vecchio articolo per rendervi conto di cosa parliamo.

https://www.vincenzocaputo.com/guide/come-usare-lo-shelly-25-per-gestire-due-punti-luce-247

Home Assistant da un po' di tempo supporta gli Shelly nativamente senza obbligatoriamente usare MQTT, tuttavia lo scopo di questa guida è farvi vedere un po' di sintassi e capire dove inserire i vari elementi, quindi ci avvarremo del protocollo MQTT per far comunicare lo Shelly con Home Assistant.

Abbiamo già visto in una guida di questa saga come abilitare MQTT, chi se lo fosse perso consiglio un ripasso nella sezione Guide di Home Assistant che potrete trovare QUI.

Una volta compilati i parametri della configurazione MQTT sulla web page dello Shelly (la procedura la potrete vedere nell'articolo che vi ho linkato sopra) sarete pronti per farlo comunicare con Home Assistant. Anche in questo caso ho comunque fatto un Recap nel video allegato a questo articolo.

Ho scelto questo dispositivo perché ha la possibilità di gestire due canali (di conseguenza creare 2 switch su Home Assistant)

Ma possiede anche la lettura dei consumi di entrambi i canali e l'ho ritenuto il device adatto per una prova di configurazione, proprio perché oltre ai 2 switch si possono ricavare anche due sensori.

Per quanto riguarda i 2 sensori e i 2 switch ricavati si potrà scegliere se inserirli relativamente in switch.yaml e in sensor.yaml oppure creare un package dove inserire tutto all'interno e magari chiamarlo direttamente shelly.yaml.

Configurazione all'interno dei file YAML

Ad inizio articolo vi ho fatto separare la configurazione, andiamo quindi ad utilizzare il file chiamato switch.yaml, al suo interno inseriremo i due switch relativi ai due canali dello Shelly

In questo caso non sarà necessario inserire la parola 

switch:

ad inizio della configurazione grazie alla inclusione che vi ho fatto inserire in configuration.yaml  

All'interno dei vari file yaml esterni si dovrà inserire solo i vari elementi.

Nello specifico la sintassi sarà la seguente:

  - platform: mqtt
    name: "canale1"
    state_topic: "shellies/shellyswitch25-xxxxxx/relay/0"
    command_topic: "shellies/shellyswitch25-xxxxxx/relay/0/command"
    qos: 0
    payload_on: "on"
    payload_off: "off"
    optimistic: false
    retain: false

  - platform: mqtt
    name: "canale2"
    state_topic: "shellies/shellyswitch25-xxxxx/relay/1"
    command_topic: "shellies/shellyswitch25-xxxxx/relay/1/command"
    qos: 0
    payload_on: "on"
    payload_off: "off"
    optimistic: false
    retain: false

 dove le xxxxx dopo shellyswitch25- saranno sostituite dal codice che troverete sulla pagina web di configurazione mqtt  dello shelly.

(Se non avete ben chiaro non vi preoccupate in quanto sul video lo spiego in maniera ottimale)

Salvate il file controllate la configurazione e, se è ok, riavviate Home Assistant.

Al riavvio vi troverete gli switch perfettamente funzionanti che risponderanno con lo stato anche se premerete gli interruttori/pulsanti o deviatori collegati allo Shelly stesso.

Adesso non vi rimane che configurare i due sensori per il consumo.

In questo caso vi dovrete recare in sensor.yaml e anche questa volta dovrete inserire solo la configurazione senza scrivere sensor: all'interno del file sensor.yaml proprio perché lo avete specificato in configuration.yaml così come per gli switch e tutti i file esterni creati ad inizio guida.

Una volta dentro sensor.yaml la sintassi per creare i due sensori è la seguente:

  - platform: mqtt
    name: "canale1"
    state_topic: "shellies/shellyswitch25-xxxxxx/relay/0"
    command_topic: "shellies/shellyswitch25-xxxxxx/relay/0/command"
    qos: 0
    payload_on: "on"
    payload_off: "off"
    optimistic: false
    retain: false

  - platform: mqtt
    name: "canale2"
    state_topic: "shellies/shellyswitch25-xxxxx/relay/1"
    command_topic: "shellies/shellyswitch25-xxxxx/relay/1/command"
    qos: 0
    payload_on: "on"
    payload_off: "off"
    optimistic: false
    retain: false

 Anche in questo caso le xxxxx andranno sostituite con quello che avete trovato nella web page dello Shelly.

una volta salvato il file e riavviato Home Assistant (non prima di aver controllato la configurazione), vi troverete i due sensori che monitorano i watt delle due uscite.

Configurazione dentro i PACKAGES  

Se invece preferite utilizzare i packages, anziché scrivere sul file switch.yaml e sensor.yaml, aprite la cartella packages.

andate a creare un file con l'icona in alto 

chiamatelo come volete con estensione .yaml

ad esempio shelly.yaml

Dentro questo file potrete inserire ciò che volete, in questo caso però dovrete identificare cosa andate ad inserire proprio perché all'interno si potranno mischiare configurazioni diverse, nel caso specifico la configurazione per questo packages sarà la seguente.

#########################################################################
################################switch shelly2,5#########################
#########################################################################
switch:
  - platform: mqtt
    name: "canale1"
    state_topic: "shellies/shellyswitch25-E0980695A249/relay/0"
    command_topic: "shellies/shellyswitch25-E0980695A249/relay/0/command"
    qos: 0
    payload_on: "on"
    payload_off: "off"
    optimistic: false
    retain: false

  - platform: mqtt
    name: "canale2"
    state_topic: "shellies/shellyswitch25-E0980695A249/relay/1"
    command_topic: "shellies/shellyswitch25-E0980695A249/relay/1/command"
    qos: 0
    payload_on: "on"
    payload_off: "off"
    optimistic: false
    retain: false
#########################################################################
################################sensori shelly2,5########################
#########################################################################
sensor:
  - platform: mqtt
    name: "Canale1"
    state_topic: "shellies/shellyswitch25-E0980695A249/relay/0/power"
    payload_available: "true"
    payload_not_available: "false"
    unit_of_measurement: "Watt"

  - platform: mqtt
    name: "Canale2"
    state_topic: "shellies/shellyswitch25-E0980695A249/relay/1/power"
    payload_available: "true"
    payload_not_available: "false"
    unit_of_measurement: "Watt"

Come notate ad inizio delle relative configurazioni è stato inserito

switch: e sensor:

I package e i file esterni possono convivere tranquillamente tuttavia, se inserite uno switch o un sensore nel package, sarà inutile inserirlo anche nei vari file esterni .yaml quindi scegliete l'uno o l'altro.

Salvate e riavviate e noterete che i vostri sensori e switch saranno presenti in Home Assistant.

Vi lascio al video che sicuramente chiarirà meglio il tutto.