Home Assistant: Costruiamo le fondamenta

Autore: Vito
4.402 visite
Home Assistant Fondamenta – Featured Image

Home Assistant negli anni è diventato sempre più “user friendly” offrendo una configurazione predefinita adeguata a buona parte dell’utenza alle prime armi ma che, a mio parere, presenta diverse carenze non permettendo una capillare configurazione sulla base delle esigenze personali.

Il dubbio che ho visto più spesso sollevare a chi intraprende il suo viaggio nell’utilizzo di questa piattaforma è su come gestire la struttura delle proprie configurazioni, in particolare è spesso sconosciuto l’utilizzo dei “pacakges” ed in rete non ho avuto modo di trovare un manuale di inizializzazione completo e dettagliato.

In questo articolo cercherò di raccogliere tutta la mia esperienza per guidare alla configurazione delle fondamenta della propria installazione spiegando le varie tipologie in cui questa può essere eseguita all’interno del proprio Home Assistant Supervised appena installato.

Attenzione: L’articolo sì basa sulla versione “2021.3.4” di Home Assistant. Alcune voci e configurazioni potrebbero variare nel tempo con gli aggiornamenti.

Sommario

Materiale necessario

Prima di partire con la configurazione scarichiamo questo pacchetto contenente il materiale che vedremo nei vari passaggi:

Le tipologie di installazione

Esistono svariate tipologie di installazione di Home Assistant sinteticamente divisibili in “Core”, “Supervised” e “HassOS”.

Tutte le metodologie e funzionalità delle varie versioni sono indicate nella documentazione ufficiale, ma noi ci concentreremo sulla variante “Suprevised” autonoma o a bordo di “HassOS” indistintamente dall’hardware sul quale viene eseguita.

Quello che differenzia Home Assistant Supervised dalle altre installazioni è la presenza del “Supervisor”, un componente essenziale per la serenità dell’utente e che gestirà le operazioni di supervisione di Home Assistant aggiungendo la possibilità di sfruttarlo al meglio con componenti aggiuntivi, backup e tanto altro.

Gli elementi principali

All’interno di questo articolo vedremo nominare più volte gli elementi che comporranno la nostra configurazione.

Ogni elemento fa parte di una “matrisoka” ben strutturata che ha preso forma nel tempo. Di seguito i principali elementi che ci troveremo a gestire:

  • Integrazione: Un modulo configurabile che può equivalere ad una piattaforma cloud o un dispositivo/HUB (Esempio: Philips HUE). Tutte le integrazioni ufficialmente disponibili sono verificabili qui ed ogni integrazione può contenere multipli dispositivi o entità;
  • Area:  Un’area virtuale che può contenere multipli dispositivi (Esempio: Ingresso, Cucina, Soggiorno);
  • Dispositivo: Un dispositivo fisico o virtuale che può contenere multiple entità (Esempio: Lavatrice, Robot aspirapolvere, Smartphone);
  • Dominio: La categoria che definisce l’entità (Esempio: Light, Switch o Sensor);
  • Entità: Un oggetto finale di controllo o analisi (Esempio: Lampadina, Interruttore o Sensore di movimento);
  • Attributi: Un valore contenuto all’interno di un’entità (Esempio: Consumo di un interruttore che funge da presa);
  • Card: Una scheda gestibile dall’interfaccia grafica che può contenere entità (Esempio: La scheda “Sole” al primo accesso).

Il primo impatto

Terminata l’installazione la prima operazione da eseguire è accedere all’interfaccia della nostra installazione recuperando l’indirizzo IP del dispositivo ospitante Home Assistant (porta 8123) e creando il proprio utente amministratore. 

Quello che apparirà successivamente al processo guidato di configurazione sarà una schermata con le informazioni essenziali e qualche card predefinita dell’interfaccia utente lovelace. L’errore più comune che un utente appena approdato possa fare è la corsa all’integrazione e configurazione, questa porterebbe solo alla generazione di tante entità ed integrazioni da gestire prima di aver compreso e strutturato adeguatamente la propria installazione.

Il mio consiglio è di fermarsi un attimo, evitando anche l’integrazione dei dispositivi automaticamente rilevati, e di seguire i successivi passaggi.

Un’operazione che consiglio e ritengo essenziale è l’impostazione di un indirizzo IP fisso e di un hostname univoco eseguibile tramite la sezione “Sistema” del “Supervisor”, evitando l’eventualità in cui il nostro router assegni un’indirizzo IP differente facendo sembrare inaccessibile l’interfaccia.

I componenti aggiuntivi

Il primo passo a carico dell’utente è l’installazione dei componenti aggiuntivi utili alla configurazione e gestione della propria installazione.

Lo scopo dei “componenti aggiuntivi” non è altro che quello di eseguire dei sotto-sistemi definibili “Container” che sfruttano la logica di Docker per espandere il sistema senza intaccarlo direttamente e favorendo una maggiore sicurezza. Ognuno di questi sotto-sistemi interagisce direttamente con il “Supervisor” dal quale è possibile avviarli, fermarli o gestirne la configurazione.

Diversi di questi componenti più complessi non appariranno senza attivare la “modalità avanzata” disponibile all’interno della pagina utente:

Accedere quindi alla sezione “Supervisor” e recarsi nella sezione “Negozio dei componenti aggiuntivi”. 

In questa sezione è possibile aggiungere anche sorgenti esterne chiamate “Repository” tramite il menù disponibile in alto a destra .

Un componente che consiglio ad ogni nuovo utente è “Home Assistant Google Drive Backup” con il quale è possibile salvare automaticamente i backup su un account Google Drive. Aggiungere alle repository:

https://github.com/sabeechen/hassio-google-drive-backup

Gli altri componenti che consiglio sono quelli visibili nella seguente immagine:

Ognuno di questi componenti presenta al suo interno diverse configurazioni da eseguire, ma vediamo prima lo scopo di ognuno di questi:

  • AppDaemon 4: Un ambiente di esecuzione di contenuti python utile per ampliare le funzionalità ed eseguire funzioni non gestibili direttamente;
  • File editor: Uno strumento indispensabile per gestire la configurazione;
  • Home Assistant Google Drive Backup: Salvataggio automatico dei backup su Google Drive;
  • Log Viewer: Un visualizzatore di LOG;
  • Mosquitto broker: Un Broker MQTT utilissimo per integrare svariati tipologie di dispositivi;
  • SSH & Web Terminal: Un server SSH utile per eseguire comandi ed accedere ai file tramite client SSH/SFTP (Esempio: PuTTYWinSCPCyberduckTransmit);
  • Samba share: Accesso ai file di configurazione tramite protocollo SMB.

Le configurazioni dei componenti sono puramente a discrezione dell’utente, ma a grandi linee consiglio di abilitare tutte le voci all’interno della sezione “Informazioni” per poi spostarsi nella sezione “Configurazione” e personalizzare i dettagli d’esecuzione del componente.

Non mi soffermo sulla configurazione di ogni singolo componente dato che eseguendo una ricerca in rete troverete adeguata documentazione per capire come personalizzarli al meglio.

Consiglio di utilizzare password complesse contenenti maiuscole, minuscole, numeri e simboli per incrementare la sicurezza ed evitare che il controllo interno rilevi una password poco sicura bloccando l’esecuzione del componente incriminato.

In caso di password poco sicura appariranno delle notifiche come le seguenti:

Come indicato nella documentazione ufficiale per identificare le password poco sicure viene sfruttato il servizio Have I Been Pwned (HIBP).

La struttura dei file

Accedendo alla cartella “config” tramite il “File editor” è possibile comprendere la struttura dei file e delle cartelle relativi alla configurazione del sistema.

Bisogna sempre tenere a mente che nell’elenco proposto diversi elementi sono nascosti (opzione modificabile dalle configurazioni del componente aggiuntivo) per evitare che l’utente inesperto modifichi elementi necessari al corretto funzionamento del sistema. Tra questi è presente la cartella “.storage” che al suo interno include tutte le configurazioni del sistema, comprese quelle eseguite da interfaccia grafica.

Fondamentali sono il file “configuration.yaml”, che vedremo più avanti, il quale dirigerà la nostra configurazione ed il database “home-assistant_v2.db”, gestito dal componente “Recorder”, nel quale verranno archiviati tutti i dati storici relativi alle entità per analizzarne le variazioni nel tempo.

La scelta di gestione

Arrivati a questo punto è molto importante capire come sì vuole procedere, se preferire una gestione per lo più Grafica o Testuale.

Analizziamo la differenze:

  • Grafica: Risulta il metodo predefinito e permette all’utente di personalizzare diversi aspetti del proprio ambiente direttamente dal pannello delle impostazioni con il compromesso che tutte le configurazioni saranno salvate automaticamente nei propri archivi senza permettere una personalizzazione avanzata e capillare. Questo comporta anche che in caso di danneggiamento di questi file, oppure nel caso si volesse partire da una nuova installazione pulita, molte delle configurazioni eseguite vadano perse. Questa modalità è definibile anche Storage;
  • Testuale: Risulta più affidabile nel tempo e permette una maggiore personalizzazione con la possibilità di sfruttare variabili di sicurezza (Secrets) e fornisce all’utente maggiore controllo sulla propria configurazione permettendo anche di condividerla o replicarla su altre installazioni, ma al contempo richiede maggiore impegno nella gestione e comprensione della documentazione ufficiale. Questa modalità è definibile anche YAML.
Nei seguenti passaggi verrà preferita la tipologia “Testuale” ma verrà chiaramente indicato dove questa può essere ignorata a favore di quella “Grafica”.

La sicurezza ed il cloud

Buona parte delle installazioni di Home Assistant viene esposta verso l’esterno per consentire l’utilizzo remoto dal proprio dispositivo mobile o dai vari assistenti vocali.

Esposta l’installazione non è più trascurabile la sicurezza, quindi cerchiamo di capire come rendere sicuro l’accesso.

Oltre una buona password di almeno 8 caratteri comprensiva di lettere maiuscole, minuscole, numeri e simboli è consigliato abilitare l’autenticazione a due fattori tramite l’utilizzo di un codice TOTP attivabile tramite la propria pagina utente. Questa password temporanea ed univoca verrà richiesta durante ogni nuova fase di accesso per evitare che un malintenzionato possa accedere con il nostro account nel caso venisse in possesso della password.

Per configurare questo servizio consiglio l’utilizzo dell’applicazione “Authy” disponibile per le principali piattaforme, compatibile con tantissimi servizi e con un sistema di backup automatico integrato. Nella fase di configurazione verrà richiesto di inquadrare un codice QR e di riportare il codice temporaneo visibile all’interno dell’applicazione.

Una buona abitudine è verificare i dispositivi all’interno della sezione Token di aggiornamento, e nel caso vi fossero dei dispositivi ambigui potrebbe essere consigliato bloccare temporaneamente l’accesso dall’esterno e cambiare la password.

Per l’accesso remoto è indubbiamente necessaria una connessione di tipo “HTTPS.

Ci sono svariati modi per ottenere un accesso di questo genere, ma quello che mi sento di consigliare a chiunque sia alle prime armi è il servizio integrato “Nabu Casa” attivabile dalle impostazioni nella sezione “Home Assistant Cloud“.

Questo servizio, dopo il mese di prova, ha un costo mensile di 5$ (circa 4,20€) ed offre:

  • Telecomando: Accesso remoto ad Home Assistant da App Mobile e da Browser tramite HTTPS con controllo di vulnerabilità della piattaforma;
  • Sintesi vocale: Un servizio di Text-to-Speech (TTS) integrato disponibile in svariate lingue, compreso l’italiano;
  • Alexa: Skill di controllo tramite il servizio Amazon Alexa con configurazione selettiva dell’esposizione delle entità;
  • Google Assistant: Supporto all’integrazione in Google Home con configurazione selettiva dell’esposizione delle entità;
  • Webhooks: Possibilità di interagire con Home Assistant dall’esterno tramite l’invio di comandi di tipo Webhook;
  • Supporto al progetto: Questo servizio nasce principalmente per supportare chi lavora al progetto Home Assistant permettendone la continuità e lo sviluppo.
Data la natura Open Source ogni singolo elemento sopra indicato può essere integrato in svariati modi, ma questo implica per ognuno di essi una gestione e delle complicazioni non adatte ai nuovi arrivati. Consiglio quindi di provare la versione di prova e valutarne la qualità, poi decidere se proseguire su un’altra strada seguendo i tanti tutorial disponibili in rete per integrare le singole funzionalità.

I backup

D’ora in poi le modifiche che faremo potrebbero, in caso di errore, rendere inaccessibile il sistema. Per evitare di perdere tutto il lavoro svolto è consigliato eseguire ad ogni passaggio un backup chiamato “snapshot” o “istantanea”.

Accediamo quindi al “Supervisor”,  spostiamoci nella sezione “Istantanee” e creiamo un backup di partenza assicurandoci di aver correttamente configurato il componente aggiuntivo “Home Assistant Google Drive Backup“.

Il file "secrets.yaml"

Prima di procedere con qualsiasi configurazione è giusto spendere qualche parola sul file secrets.yaml.

Questo file è un “contenitore” di variabili di ogni genere (username, password, coordinate ecc…) sfruttabili dall’intero sistema senza doverle ripetere molteplici volte all’interno delle singole configurazioni, ma soprattutto senza il rischio di esporle a occhi indiscreti durante la condivisione di file.

Ogni variabile è richiamabile indicando il valore “!secret <variabile>”. Di seguito possiamo vedere un esempio di come strutturare il file.

Ovviamente è necessario compilare ogni variabile con i valori desiderati, quindi utilizzando l’IP di accesso alla propria installazione di Home Assistant, i dati di accesso al Broker MQTT, posizione geografica della propria installazione ecc… Alcuni di questi valori saranno più chiari proseguendo.

# Secrets

# Home Assistant
home_assistant_latitude: '41.91611'
home_assistant_longitude: '12.49212'
home_assistant_elevation: '57'
home_assistant_time_zone: 'Europe/Rome'
home_assistant_internal_url: 'http://192.168.0.220:8123/'
home_assistant_external_url: 'https://a1b2c3d4f5g6h7i8j9k10l11m12.ui.nabu.casa/'
# -------------------------------------------------------------------------------------------------------------------
# Recorder
recorder_purge_keep_days: '2'
recorder_purge_empty_days: '0'
# -------------------------------------------------------------------------------------------------------------------
# AppDaemon
appdaemon_latitude: 41.91611
appdaemon_longitude: 12.49212
appdaemon_elevation: 57
appdaemon_time_zone: Europe/Rome
# -------------------------------------------------------------------------------------------------------------------
# Panels
panels_appdaemon_url: 'http://192.168.0.220:5050/'
# -------------------------------------------------------------------------------------------------------------------
# HomeKit
homekit_home_assistant_bridge_1_port: '8095'
# -------------------------------------------------------------------------------------------------------------------
# HACS
hacs_token: 'a1b2c3d4f5g6h7i8j9k10l11m12n13o14p15q16r17s18'
# -------------------------------------------------------------------------------------------------------------------
# Updater
updater_version_home_assistant_stable: 'https://version.home-assistant.io/stable.json'
updater_version_home_assistant_beta: 'https://version.home-assistant.io/beta.json'
updater_version_home_assistant_alpha: 'https://version.home-assistant.io/dev.json'
# -------------------------------------------------------------------------------------------------------------------
# Notifications
pushover_user_key: 'a1b2c3d4f5g6h7i8j9k10l11m12n13o14p15q16r17s18'
pushover_home_assistant_api_key: 'a1b2c3d4f5g6h7i8j9k10l11m12n13o14p15q16r17s18'
# -------------------------------------------------------------------------------------------------------------------
# MQTT
mqtt_host: '192.168.0.220'
mqtt_port: '1883'
mqtt_client_id: 'HOMEASSISTANT'
mqtt_username: 'Vito'
mqtt_password: 'topolino1234'
# -------------------------------------------------------------------------------------------------------------------
 

Il file "configuration.yaml"

Il file configuration.yaml è il punto di partenza di tutta la nostra configurazione.

In buona parte delle guide disponibili in rete e nella documentazione ufficiale sì può leggere spesso di questo file nel quale viene indicato di aggiungere del codice. Questo, dal mio punto di vista, è il consiglio peggiore che sì possa dare a chi muove i primi passi poiché non permette di predisporre il sistema all’inevitabile ampliamento della configurazione.

Altro “errore” commesso dagli sviluppatori nel tentativo di semplificare la configurazione è stata l’introduzione del componente “Default Config” (Ovvero la chiave default_config:) che abilita diversi componenti essenziali ma che non permette una selettiva personalizzazione sulla base delle proprie esigenze.

Questo file non deve diventare il nostro “cestino” di configurazioni contenendo ogni elemento che viene proposto di aggiungerci, ma piuttosto il “direttore” di tutta la configurazione.

Prima di procedere modificando il file tramite il “File editor”, creiamo all’interno della della cartella “config”:

  • Una cartella: packages
  • Una cartella: themes
  • Un file: customize.yaml

Come visibile nella seconda immagine sottostante comporre il file “configuration.yaml” con la configurazione fornita e riavviare Home Assistant.

Attenzione: Ogni configurazione testuale eseguita richiede obbligatoriamente un riavvio del sistema oppure un ri-caricamento dell’apposito dominio.

# Configuration

# Home Assistant
homeassistant:
  # Base
  name: 'Home Assistant'
  unit_system: metric
  latitude: !secret home_assistant_latitude
  longitude: !secret home_assistant_longitude
  elevation: !secret home_assistant_elevation
  time_zone: !secret home_assistant_time_zone
  # -------------------------------------------------------------------------------------------------------------------
  # URL
  internal_url: !secret home_assistant_internal_url
  external_url: !secret home_assistant_external_url
  # -------------------------------------------------------------------------------------------------------------------
  # Customize
  customize: !include customize.yaml
  # -------------------------------------------------------------------------------------------------------------------
  # Packages
  packages: !include_dir_named packages
  # -------------------------------------------------------------------------------------------------------------------
  # External Directories
  allowlist_external_dirs:
    - /config
    - /media
  # -------------------------------------------------------------------------------------------------------------------

# Frontend
frontend:
  # Themes
  themes: !include_dir_merge_named themes
  # -------------------------------------------------------------------------------------------------------------------

# Automations
automation: !include automations.yaml
# -------------------------------------------------------------------------------------------------------------------

# Scripts
script: !include scripts.yaml
# -------------------------------------------------------------------------------------------------------------------

# Scenes
scene: !include scenes.yaml
# -------------------------------------------------------------------------------------------------------------------

# Groups
group: !include groups.yaml
# -------------------------------------------------------------------------------------------------------------------
 

La configurazione sopra indicata rappresenta la modalità di tipo “testuale”, ma solo alcuni dei valori impostati impediranno la configurazione grafica come quelli della sezione “# Base” o “# URL”. Se si vuole continuare ad utilizzare la modalità “grafica” rimuovere questi valori dalla propria configurazione.

Ogni valore viene recuperato dal file “secrets.yaml” o include file e cartelle presenti all’interno della cartella “config”.

Come visibile dalle due immagini sottostanti il sistema ci avviserà quando una configurazione non è più modificabile tramite l’interfaccia grafica.

Eseguendo queste modifiche viene eliminato il componente “Default Config” e di conseguenza temporaneamente diversi moduli precedentemente presenti non saranno più disponibili (sì può notare dalla riduzione degli elementi nella barra laterale), ma non preoccupiamoci.

D’ora in poi più nulla sarà da aggiungere all’interno di questo file escluse eventuali altre inclusioni ed i valori configurabili come indicato nella documentazione ufficiale relativa alle basic information.

Il file "customize.yaml"

Mentre il file configuration.yaml dirige la struttura della configurazione, il file customize.yaml dirigerà la personalizzazione.

Esattamente come per la configurazione è possibile procedere nella modalità “grafica” o “testuale”.

Per eseguire una personalizzazione grafica semplicemente entrare nelle proprietà dell’entità e modificarne i valori, mentre per definire la personalizzazione tramite il file seguire le linee guida visibili nella seconda immagine. Ogni chiave configurabile è indicata all’interno della documentazione ufficiale.

Eventuali immagini definite tramite la chiave “entity_picture” possono essere archiviate nella cartella “www” posizionata all’interno della cartella principale “config”. Questa cartella viene identificata anche come “local” dalla configurazione.

Ogni icona con prefisso “mdi:” deriva dalla collezione Material Design Icons.

# Customize

# Persons
person.vito:
  friendly_name: 'Vito'
  icon: mdi:human-male
  entity_picture: '/local/pictures/person_vito.png'
# -------------------------------------------------------------------------------------------------------------------
# Updater
# Binary Senrors
# Generico
binary_sensor.updater:
  friendly_name: 'Aggiornamenti Disponibili'
# -------------------------------------------------------------------------------------------------------------------
 

HACS

Prima di procedere con la gestione dei packages è necessario introdurre HACS.

HACS è uno store (Home Assistant Community Store) di componenti non ufficiali che permettono l’espansione delle funzionalità base di Home Assistant fornendo: Integrazioni, Temi, Card ed altri componenti aggiuntivi (ad esempio moduli per AppDaemon).

Questi componenti non sono soggetti al controllo qualitativo di Home Assistant, ma è da tener presente che lo sviluppatore di HACS collabora con gli sviluppatori dietro al progetto Nabu Casa, di fatto rendendo HACS nulla di screditato da parte del progetto ufficiale. Bisogna sempre considerare che componenti non ottimizzati o aggiornati potrebbero rendere instabile ed insicura la propria installazione.

Esattamente come per le altre integrazioni vi sono vari metodi per l’installazione di HACS, noi come da premessa procederemo con la variante “testuale”, ma nulla vieta di gestire l’installazione in variante “grafica”.

Spiegando in maniera semplice le operazioni da eseguire, in entrambi i casi sarà necessario creare una cartella “custom_components” all’interno del percorso “config” nel quale inserire il pacchetto di HACS, prima però creare un proprio account e token GitHub. Nel caso della variante testuale sarà necessario indicare il token all’interno del file secrets.yaml.
 
Possiamo scaricare il pacchetto contenente l’integrazione HACS qui, estrarre i file ed inserire quelli all’interno della cartella “custom_components”, tramite Samba share” o “SSH & Web Terminal” nella cartella precedentemente creata.
 

I packages

I packages ci permettono di suddividere la nostra configurazione in multipli file ed evitare di avere tutto il contenuto nel “configuration.yaml” o suddiviso in file rispecchianti un singolo dominio. Vi sono diverse modalità di gestione come indicato nella documentazione ufficiale.

Nel nostro caso questa viene gestita dalla precedente chiave di configurazione:

  # Packages
  packages: !include_dir_named packages

Tutti i packages dovranno essere inseriti nell’omonima cartella con estensione “.yaml” (vengono accettati file solo nominati in minuscolo) e possono essere creati o caricati tramite il file editor, oppure sfruttando i componenti aggiuntivi precedentemente configurati come “Samba share” e “SSH & Web Terminal“.

Un esempio sono i packages visibili nell’immagine sottostante, recuperabili dal pacchetto scaricabile nel capitolo Materiale necessario.

Analizziamo cosa comprende ogni file fornito:

  • base_modules.yaml: Abilita tutti i moduli essenziali al funzionamento del sistema, presenti nella “Default Config” rimossa, più altri moduli utili;
  • cloud.yaml: Abilita il servizio cloud “Nabu Casa” e permette la configurazione (testuale) degli elementi da esporre su Amazon Alexa e Google Assistant;
  • fake_items.yaml: Crea delle entità fittizie di prova generate tramite la piattaforma Template (è possibile rimuoverlo quando non più necessario);
  • hacs.yaml: Abilita l’integrazione HACS (rimuovere questo file se non sì vuole utilizzare HACS o lo sì vuole configurare in variante “grafica”);
  • homekit.yaml: Abilita il servizio HomeKit di Apple e permette la configurazione (testuale) degli elementi da esporre;
  • mqtt.yaml: Predispone l’utilizzo del servizio MQTT collegandosi al Broker MQTT precedentemente configurato;
  • notifications.yaml: Predispone l’utilizzo di notifiche sfruttando Pushover come indicato in questo articolo;
  • panels.yaml: Aggiunge alla barra laterale dei “Pannelli” per i componenti aggiuntivi che non supportano di base questa possibilità;
  • recorder.yaml: Configura il componente “Recorder” che permette l’archiviazione dei dati nel database;
  • system.yaml: Aggiunge sensori e notifiche utili all’analisi dello stato del sistema come: Carico, Processore, RAM;
  • system_log.yaml: Abilita il salvataggio dei LOG di sistema ed aggiunge dei contatori di analisi;
  • test.yaml: Essenzialmente un file vuoto dove poter eseguire delle prove;
  • text_to_speech.yaml: Abilita i servizi Text-to-Speech (TTS) sfruttando Google Translate;
  • time_astronomy.yaml: Aggiunge tutti i sensori utili per comprendere il “Tempo” come orario e data più altri sensori come: Sole, Luna, Giorno Lavorativo;
  • updater.yaml: Aggiunge sensori sulla versione e aggiornamenti del sistema.

Ogni package che si crea può essere strutturato a piacimento, ma vediamo come sono strutturati i packages forniti per comprendere il mio metodo:

Personalmente cerco sempre di dividere tutto in “Sezioni” sfruttando dei separatori come:

# -------------------------------------------------------------------------------------------------------------------

Il simbolo “#” davanti ogni voce la rende un commento non funzionale.

La prima parte che dichiaro sono le “Piattaforme”, ovvero delle chiavi che sì collegano direttamente alle integrazioni e possono essere definite sia tramite interfaccia grafica (Impostazioni) che in modalità testuale. Ci sono piattaforme che supportano solo la modalità “grafica” mentre altre solo la modalità “testuale” (alcune le supportano entrambe). 

Possiamo identificare le varie piattaforme o integrazioni disponibili dalla documentazione ufficiale (o tramite la documentazione del componente su HACS se installate tramite questo).

Subito dopo le piattaforme, definisco gli elementi di “input”, ovvero tutti gli oggetti gestibili tramite interfaccia utente che permettono di interagire con il nostro codice configurandone le condizioni ed i parametri di esecuzione. Ecco alcuni esempi di input:

Nell’esempio in oggetto sono presenti 3 “Input Boolean”, ovvero 3 “interruttori” per attivare svariate funzioni gerarchicamente.

A seguire definisco i vari sensori che andranno a gestire le funzioni del package. I sensori “Template” sono degli elementi di natura generica rispecchianti il dominio definito che possono assumere valori, attributi, icone e tutto ciò che prevede il tipo di entità tramite una programmazione specifica dell’utente.

Per finire definisco le automazioni e gli script che sfrutteranno gli elementi creati per eseguire automaticamente azioni o per innescare l’esecuzione manuale tramite l’interfaccia grafica.

Nell’esempio l’automazione invierà una notifica all’avvio del sistema se gli specifici “Input” sono abilitati e lo script eseguirà il riavvio di Home Assistant se eseguito da interfaccia grafica.

Per configurare un sistema di notifiche è possibile seguire questo articolo oppure cercare una guida in rete relativa al sistema di notifiche che sì predilige.

Dove necessario indicare i valori all’interno del file secrets.yaml, visto in precedenza, ed al termine del caricamento è fondamentale eseguire un riavvio. Se i package verranno correttamente caricati possiamo notare alcune nuove voci apparire nella barra laterale.

AppDaemon

Richiede una piccola configurazione anche il componente aggiuntivo AppDaemon che come anticipato è un sotto-sistema per gestire script ed automazioni esterne integrabili in Home Assistant.

Vi è la possibilità di gestire le sue impostazioni tramite il file secrets.yaml. Accedendo alla cartella “appdaemon” all’interno di “config” modificare il file “appdaemon.yaml” come segue:

Home Assistant Fondamenta - appdaemon.yaml
---
secrets: /config/secrets.yaml
appdaemon:
  latitude: !secret appdaemon_latitude
  longitude: !secret appdaemon_longitude
  elevation: !secret appdaemon_elevation
  time_zone: !secret appdaemon_time_zone
  plugins:
    HASS:
      type: hass
http:
  url: http://127.0.0.1:5050
admin:
api:
hadashboard:

Gli assistenti esterni

Sfruttando il package “Fake Items” che genera un sensore ed una lampadina fittizia ho pre-configurato i file “cloud.yaml” e “homekit.yaml” per esporre in variante “testuale” le nostre entità verso i servizi cloud Amazon Alexa e Google Assistant precedentemente configurati, e creando un Bridge HomeKit integrabile nei dispositivi Apple. Per configurare il Bridge è necessario avviare l’applicazione “Casa” ed inquadrare il codice QR mostrato all’interno delle notifiche di Home Assistant.

Per capire come configurare i vari servizi:

Ognuna di queste integrazioni è gestibile anche in variante “grafica” dalle impostazioni, tramite il pannello Home Assistant Cloud per definire l’esposizione delle entità oppure tramite le integrazioni per creare un Bridge HomeKit. Il mio consiglio è di evitare la variante grafica per questa tipologia di servizi poiché quella testuale offre maggiore controllo degli elementi permettendo anche la personalizzazione di diversi aspetti funzionali.

Dopo un riavvio di Home Assistant è possibile verificare l’esposizione degli elementi.

Amazon Alexa:

Apple HomeKit:

Le integrazioni

Arrivati a questo punto è possibile finalmente integrare i dispositivi compatibili.

Accedere alla sezione “Integrazioni” tramite le impostazioni e seguire la procedura guidata che ognuna di esse propone.

Le varie integrazioni precedentemente impostate in variante “testuale” appariranno in alcuni casi già configurate mentre altre potrebbero richiedere un completamento manuale, se una di queste non è di nostro interesse è possibile ignorarla tramite l’apposito pulsante.

Ogni integrazione creerà svariati dispositivi ed entità in base alla sua natura e potrà essere rinominata.

Per integrare dispositivi ZigBee, uno dei principali standard wireless nella Smart Home, consiglio la lettura di questo articolo che spiega come orientarsi.

L'interfaccia grafica

L’interfaccia grafica lovelace può essere anch’essa gestita in variante “grafica” o “testuale”.

Personalmente prediligo la modalità “grafica”, ma se sì vuole comprendere la struttura vi consiglio la lettura di questo articolo che introduce alle varie modalità e come creare una interfaccia personalizzata.

Modificando la plancia ci verrà chiesto se prendere il controllo e svuotarla, quindi confermiamo e creiamo una nuova sezione vuota:

Aggiungiamo delle card “entità” da riempire con gli elementi precedentemente integrati tramite i packages. E’ possibile verificare gli elementi non ancora utilizzati all’interno dell’interfaccia utente tramite l’apposita sezione.

Ogni elemento che possiamo vedere nella seconda immagine è stato personalizzato tramite il file “customize.yaml” per essere graficamente coerente con la card. Troverete il file già compilato all’interno del pacchetto scaricabile nel capitolo Materiale necessario.

Conclusione

Spero tramite questa guida di aver spiegato chiaramente ed in maniera esaustiva come costruire le fondamenta della propria installazione per permettere di sfruttare al meglio questa piattaforma.

Se ti è stato utile, perché non...
Mi offri un caffè?

Post correlati

13 commenti

Maurizio Brilli 7 Agosto 2021 - 21:01

Temo che questo approccio non sia compatibile con la versione Home Assistant Operating System. Dopo l’aggiornamento del SO e del Core (da Supervisor), la configurazione è tornata quella di prima. Hai riscontri di questo?

Rispondi
Vito 7 Agosto 2021 - 22:12

ciao, questo approccio è ancora attualissimo, al massimo va eseguito qualche adattamento se qualcosa è variato con delle breaking changes.

Rispondi
Superbaldo 16 Maggio 2021 - 12:03

Complimenti Vito,
veramente molto interessante, sto iniziando l’avventura di costruirmi una nuova casa, ho già fatto in passato alcune automazioni con MyHome Bticino, Sonoff e altro, ma Home Assistant è un’altro pianeta, da qualche mese ho un raspberry con Hassio installato dove faccio delle prove (con notevoli difficoltà), la tua guida che ho appena scoperto è una manna piovuta dal cielo e sto cercando di imparare perchè mi piacerebbe nella casa nuova implementare questo sistema domotico.
Intanto grazie, caffè sicuramente offerto.

Rispondi
Vito 16 Maggio 2021 - 12:04

Grazie mille 🙂

Rispondi
Cristian 19 Aprile 2021 - 14:20

ciao Vito,
leggendo la tua guida mi è venuta voglia di iniziare a domotizzare qualcosa.
Ho un “vecchio” rp2, per iniziare a “giocarci” dove trovo l’immagine “Home Assistant Supervised” ? Vedo che esiste solo per il 3 e il 4
grazie in anticipo
Cristian

Rispondi
Vito 19 Aprile 2021 - 14:24

Ciao, rp2 non è consigliato. Puoi comunque provare installando raspbian con docker e HA supervised oppure vedere se c’è da qualche parte un’immagine un pó imboscata, ma se non è presente sul sito ufficiale dubito esista!

Rispondi
Vito 19 Aprile 2021 - 15:33

Aggiungo che volendo puoi testare tutto su macchina virtuale tipo virtual box!

Rispondi
Marco Merlino 11 Aprile 2021 - 11:44

Grazie per tutte le informazioni date in questo articolo !
Una domanda: che installazione consigli avendo un portatile a disposizione da dedicare totalmente a HA ?
Grazie

Rispondi
Vito 11 Aprile 2021 - 11:57

Ciao, se hai abbastanza hardware (4 thread almeno e 4-8 gb di ram) ti consiglio di provare Proxmox ed eseguirlo in VM. Ovviamente più VM vuoi fare più ti servono risorse. Alternativa è docker ma è meno pratico.

Rispondi
Mimmo 28 Marzo 2021 - 09:36

una start guide cosi esaustiva e completa all in one, per chi vuol affacciarsi nel mondo della home domotica relativa ad Home Assistant, finora non l’ho mai trovata; Grazie Vito per avermi schiarito vari aspetti e complimenti vivissimi per il tutorial

Rispondi
Vito 28 Marzo 2021 - 12:13

GRAZIE 🙂

Rispondi
Eugenio Valente 21 Marzo 2021 - 16:00

Ottimo tutorial !

Rispondi
Vito 21 Marzo 2021 - 18:57

Grazie!

Rispondi

Lascia un commento

* Utilizzando questo modulo accetti la memorizzazione e la gestione dei tuoi dati da questo sito web.