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
- Le tipologie di installazione
- Gli elementi principali
- Il primo impatto
- I componenti aggiuntivi
- La struttura dei file
- La scelta di gestione
- La sicurezza ed il cloud
- I backup
- Il file “secrets.yaml”
- Il file “configuration.yaml”
- Il file “customize.yaml”
- HACS
- I packages
- AppDaemon
- Gli assistenti esterni
- Le integrazioni
- L’interfaccia grafica
- Conclusione
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: PuTTY, WinSCP, Cyberduck, Transmit);
- 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.
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.
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”.
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 packagesTutti 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:
- Input Boolean: Un semplice interruttore ON/OFF (documentazione ufficiale);
- Input Number: Uno selettore a scorrimento per definire un valore numerico (documentazione ufficiale);
- Input Select: Un elenco a discesa per selezionare una specifica voce tra quelle impostate (documentazione ufficiale);
- Input Datetime: Per definire un valore di data e ora (documentazione ufficiale);
- Input Text: Un campo di testo per un valore a scelta (documentazione ufficiale).
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:
---
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:
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.
20 commenti
Ciao,
ho installato HA su synology nas con docker ma non riesco a vedere i componenti aggiuntivi. Ho attivato la modalità avanzata ma nulla.
Com’è possibile? Grazie mille
Ciao Vito. Mi chiamo Fabio (premetto da subito la mia poca capacita ed esperienza in questo settore e in genere su tutta linformatica ….😢…però diciamo qualcosa riesco a capire …) Premesso questo anche io voglio complimentarmi per il tuo articolo , se prima girando sul web poco e niente avevo capito considerando la grande confusione che avevo accumulato, dopo aver letto il tuo articolo tutto ( diciamo una buona parte forse è meglio… ) mi è risultato decisamente piu chiaro ….. Oltre la tua indiscutibile preparazione tecnica, voglio manifestare i miei complimenti sulla logica estremamente comprensibile anche da chi poco o niente ne sà ( cioè io…!..) con cui hai spiegato e motivato le scelte tecniche che hai fatto…… ancora complimenti…👍👍👍.. Ora però verrà la prte piu difficile , quella che dovrò, appena possibile, replicare la tua configurazione sul mio HA… spero qualora ne abbia bisogno , potro chiederti sostegno….. (io al tuo posto risponderei di NO… onde evitare l’inizio di una vero e proprio interrogatorio per spiegarmi gli infiniti errori che adro a fare ….😢😢… sto scherzando … cmq complimenti ancore … bel pezzo ….
Ciao, se ti serve qualche consiglio c’è telegram. Comunque sono cambiate un pó di cose da questo articolo alla versione odierna.. ma bene o male un 85% è ancora così
Ciao, ottimo tutorial.
Sto cercando di organizzare al meglio il mio progetto con home assistant ed ho scelto di usare i Packages. Ho quindi creato la cartella ‘Packages’ all’interno della cartella ‘config’. Ho riempito la cartella con i file yaml dei vari pacchetti (tutti i nomi in minuscolo). Ho poi aggiunto al file ‘configuration.yaml’ la seguente chiave:
homeassistant:
packages: !include_dir_named packages
Ho riavviato il sistema ma non funziona nulla. Non sono stato capace di attivare i Packages.
Dove sbaglio??
Grazie
Quello che hai fatto è corretto, salvo errori nel compilare il file configuration, il problema forse è da verificare nei tuoi vari packages.. magari vi è qualcosa che turba l’installazione.
Ehilà, complimenti per l’articolo! Dopo lo metterò in pratica. L’ho letto dal Cell sul letto perché ho mal di schiena dovuto ad un lavoro che mi hanno fatto fare in reparto sollevando 16 kg contro i miei 39 di peso corporeo. Ho sempre il problema di duck DNS che non riesco a configurare
Prova nabu casa, non te ne pentirai.
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?
ciao, questo approccio è ancora attualissimo, al massimo va eseguito qualche adattamento se qualcosa è variato con delle breaking changes.
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.
Grazie mille 🙂
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
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!
Aggiungo che volendo puoi testare tutto su macchina virtuale tipo virtual box!
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
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.
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
GRAZIE 🙂
Ottimo tutorial !
Grazie!