Home Assistant - Primi passi con le automazioni

Mi è capitato spesso di leggere nei commenti degli articoli o dei video dedicati alle Smart Home, di utenti che sottolineano il fatto che la domotica non è accendere una luce dal proprio smartphone o avere il controllo remoto della macchinetta del caffè o cose simili. Il fatto che i dispositivi smart siano connessi in effetti e solo il presupposto per poter realizzare la "vera" domotica.

In molti infatti dimenticano che, quella che noi chiamiamo Domotica, ossia l'Home Automation, altro non è che la casa automatica.

Ogni automazione atta a migliorare la qualità della vita nella casa è Domotica.

Dall'automazione più semplice (apriamo la porta d'ingresso e un sensore porta finestra fa accendere una luce di cortesia) a quelle più complesse (un energy meter misura costantemente la produzione del nostro impianto fotovoltaico e nello stesso tempo i consumi della nostra abitazione e decide autonomamente se accendere o spegnere determinati elettrodomestici in base ad una priorità pre-impostata dall'utente).

Tutto ciò semplifica la gestione del proprio appartamento e, perché no, ci può far risparmiare denaro, ad esempio evitando di lasciare luci accese quando non siamo in casa, o abbassando la temperatura del riscaldamento quando non necessaria o magari evitando di irrigare il nostro giardino se il meteo prevede pioggia.

Come avrete intuito oggi inizieremo a muovere i primi passi nel mondo delle automazioni di Home Assistant. Non basterebbero 10 guide per affrontare tutte le possibilità che questo software offre, tuttavia il mio intento è quello di farvi capire in primis il concetto delle automazioni e in seguito farvi vedere delle automazioni di test, parleremo di automazioni semplici e, nel corso del tempo, affronteremo automazioni più complesse.

Questo argomento è forse il più difficile da trattare, perciò la guida sarà prolissa. Il mio consiglio è quello di rileggerla più volte per assimilare bene il concetto.

Home Assistant fornisce due possibilità:

creare automazioni dall'interfaccia grafica, troverete il menù automazioni in configurazioni

... oppure creare automazioni scrivendo direttamente del codice.

anche se più complesso, il mio consiglio è di usare il codice, questo perché concettualmente credo che il miglior modo di imparare le cose è capirne il funzionamento.

Non mancherò comunque di farvi vedere alcuni esempi su interfaccia grafica più avanti nel corso del tempo.

Dunque prima di tutto è bene capire la mappa concettuale delle automazioni.

Ogni automazione è composta da 3 fasi:

• L'evento scatenante, denominato Trigger
• Un'eventuale condizione perché l'automazione si avvii denominata appunto Condition
• ed infine l'azione che questa automazione dovrà compiere chiamata appunto Action

Per quanto importante in un'automazione base la condition non è obbligatoria, si possono creare ad esempio automazioni dirette.

La mappa concettuale di questa automazione è quindi la seguente.

Un esempio potrebbe essere questo:

all'accensione di uno Switch X (trigger) si dovrà accendere un altro switch Y (action). Ecco il codice.

  - alias: accensione di y se accendi x
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

Se avessi avuto bisogno di mettere all'interno dell'automazione una condizione in quel caso la mappa concettuale si sarebbe trasformata in questo:

Nel caso, ad esempio, che lo switch.yyyy si debba accendere all'accensione dello Switch.xxxx, ma solo se lo switch.zzzz è spento, dovremmo aggiungere una condizione.

Il codice si trasformerebbe in questo.

  - alias: accensione di y se accendi x
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
      - condition: state
        entity_id: switch.zzzz
        state: 'off'
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

Come avrete notato in entrambe le automazioni è presente la voce initial_state: true, questa voce si inserisce per far si che al riavvio di Home Assistant le automazioni siano abilitate. Diversamente le automazioni partiranno in stato off all'avvio di Home Assistant e, anche se il trigger venisse soddisfatto l'automazione non partirebbe. Praticamente in questo caso l'automazione c'è ma è spenta.

I trigger possono essere di varie tipologie, quello che abbiamo visto sopra è un trigger di tipo State.

• Trigger ID
• Trigger variables
• Event trigger
• Home Assistant trigger
• MQTT trigger
• Numeric state trigger
• State trigger
• Sun trigger
• Tag trigger
• Template trigger
• Time trigger
• Time pattern trigger
• Webhook trigger
• Zone trigger
• Geolocation trigger
• Device triggers

Questi sono tutti quelli disponibili, con il tempo magari per qualche progetto ne vedremo alcuni, per il momento vi rimando ai collegamenti ufficiali.

Il trigger può essere popolato anche da due o più eventi scatenanti, ad esempio:

  - alias: accensione di y se accendi x o f
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
      - platform: state
        entity_id: switch.ffff
        to: 'on'
    condition:
      - condition: state
        entity_id: switch.zzzz
        state: 'off'
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

In questo caso qualsiasi evento trigger attiverà l'automazione. Quindi, nel caso specifico, se lo switch.xxxx o lo switch.ffff si accenderà, farà accendere anche lo switch.yyyy. Ovviamente dovrà essere soddisfatta la condizione che lo switch.zzzz sia spento.

Passiamo ad occuparci delle condizioni e qui le variabili sono molteplici quindi ve le mostrerò nel dettaglio.

Le condizioni logiche (Logical Condition) sono le prime che affronteremo.

Tutte le condizioni possono essere molteplici o singole, come abbiamo visto nell'esempio fatto poco fa.

In quel caso l'automazione sarà eseguita se, come unica condizione, lo stato dello switch.zzzz è off.

Si possono aggiungere più condizioni e tali condizioni possono essere identificate con AND oppure OR. Nel caso di più condizioni presenti con AND tutte le condizioni dovranno essere rispettate affinché l'automazione possa procedere.

Se utilizziamo più condizioni ma inseriamo OR allora basterà che anche solo una delle condizioni sia soddisfatta per far si che l'automazione venga eseguita. Guardiamo degli esempi inizieremo con l'esempio di AND

ESEMPIO CON AND:

  - alias: accensione di y se accendi x  e z e a sono su off
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
       alias: "entrambe le condizioni"
       condition: and
       conditions:
         - condition: state
           entity_id: switch.zzzz
           state: 'off'
         - condition: state
           entity_id: switch.aaaa
           state: 'off'
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

In questo caso specifico  quando lo switch.xxxx si accenderà e, sia lo switch.zzzz che lo switch.aaaa saranno in stato di off, allora si accenderà anche lo switch.yyyy

Dato che è possibile combinare le condizioni and e or, nel caso che nell'automazione non sia presente un mix di condizioni and e or contemporaneamente, l'automazione suddetta si potrà semplificare cosi:

  - alias: accensione di y se accendi x e z e a sono su off
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
       - condition: state
         entity_id: switch.zzzz
         state: 'off'
       - condition: state
         entity_id: switch.aaaa
         state: 'off'
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

Le due automazioni sopra otterranno lo stesso risultato, in quel caso l'AND è implicito.

ESEMPIO CON OR:

  - alias: accensione di y se accendi x e o z o a sono su off
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
       condition: or
       conditions:
         - condition: state
           entity_id: switch.zzzz
           state: 'off'
         - condition: state
           entity_id: switch.aaaa
           state: 'off'
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

In questo caso specifico, quando lo switch.xxxx si accenderà e o lo switch.zzzz o lo switch.aaaa (ma si attiverà anche se entrambi sono su off) saranno in stato di off, allora si accenderà anche lo switch.yyyy

In questo caso basterà che perlomeno una delle condizioni sia verificata affinché l'automazione venga eseguita.

Come vi anticipavo prima è possibile anche combinare le condizioni and e or. Vediamo un esempio.

ESEMPIO CON AND COMBINATO CON OR:

  - alias: un nome a caso
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
       condition: and
       conditions:
         - condition: state
           entity_id: switch.zzzz
           state: 'off'
         - condition: or
             - condition: state
               entity_id: switch.aaaa
               state: 'off'
             - condition: state
               entity_id: switch.bbbb
               state: 'off'
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

 In questo caso all'accensione dello switch.xxx,x se lo switch.zzzz è sullo stato di off e uno dei 2 switch tra switch.aaaa e switch.bbbb (ma anche nel caso che lo fossero tutti e due) è sullo stato di off, allora l'automazione verrebbe eseguita accendendo switch.yyyy

Esiste poi una condizione chiamata not condition che sinceramente utilizzo poco, comunque ve la mostro.

ESEMPIO CON NOT CONDITION:

  - alias: un nome a scelta
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
       condition: not
       conditions:
         - condition: state
           entity_id: switch.zzzz
           state: 'off'
         - condition: state
           entity_id: switch.aaaa
           state: 'off'
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

In questo caso nessuna delle condizioni deve essere soddisfatta perché l'automazione proceda e quindi all'accensione di switch.xxxx si accenda anche switch.yyyy

E con questo è tutto per quanto riguarda le condizioni logiche.

Esistono poi le CONDIZIONI DI STATO NUMERICO 

L'esempio più semplice che posso portarvi è quelli di un sensore di temperatura che nel nostro caso denomineremo sensor.temperatura.

vediamo quindi un esempio:

  - alias: un nome a scelta
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
      condition: numeric_state
      entity_id: sensor.temperatura
      above: 18
      below: 22
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

In questo caso lo switch.xxxx alla sua attivazione accenderà lo switch.yyyy se il sensor.temperatura si trova sopra i 18 ma sotto i 22 gradi.

È anche possibile testare la condizione su più entità contemporaneamente. La condizione passerà se tutte le entità soddisfano le soglie.

  - alias: un nome a scelta
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
      condition: numeric_state
      entity_id:
        - sensor.temperatura
        - sensor.temperatura_camera
      above: 20
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

In questo caso lo switch.xxxx, accendendosi, attiverà lo switch.yyyy solo se i due sensori sensor.temperatura e sensor.temperatura_camera sono sopra i 20 gradi.

In alternativa, la condizione può essere verificata rispetto a un attributo di stato. La condizione passerà se il valore dell'attributo dell'entità corrisponde alle soglie. Mi viene in mente un termostato ad esempio che per definizione rileva più parametri. 

  - alias: un nome a scelta
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
      condition: numeric_state
      entity_id: climate.termostato_cucina
      attribute: temperature
      above: 17
      below: 25
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

In questo caso andremo a prelevare l'attributo temperature dal termostato e lo switch.xxxx accenderà lo switch.yyyy alla sua accensione solo se l'attributo temperature del termostato è sopra i 17 gradi ma sotto i 25.

 Abbiamo poi le STATE CONDITION vediamo subito un primo esempio:

  - alias: un nome a scelta
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
      condition: state
      entity_id: switch.hhhh
      state: "on"
      for:
        hours: 1
        minutes: 10
        seconds: 5
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

In questo caso questa automazione ha poco senso ma serve solo per farvi capire il concetto.

In pratica si sviluppa cosi: quando lo switch.xxxx si accende, se lo switch.hhhh è acceso da 1 ora 10 minuti e 5 secondi, allora accende lo switch.yyyy

È anche possibile testare la condizione su più entità contemporaneamente. La condizione passerà se tutte le entità corrispondono allo stato.

  - alias: un nome a scelta
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
      condition: state
      entity_id:
        - switch.hhhh
        - switch.oooo
      state: "on"
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

In questo esempio all'accensione dello switch.xxxx, se lo switch.hhhh e lo switch.oooo saranno sullo stato on, allora si accenderà lo switch.yyyy

È anche possibile aggiungere una condizione che dice che se un elemento è in uno o più stati, allora l'automazione verrà portata a termine, questa condizione non è possibile utilizzare ad esempio uno switch in quanto per definizione ha solo 2 stati: on e off. Nell'esempio sottostante metteremo nella condizione un allarme che ha varie possibilità tra i suoi stati. 

Il pannello allarme ancora non lo abbiamo affrontato nelle nostre guide, sicuramente lo vedremo più avanti, per il momento vi basti sapere che ha più stati tra cui armed_away (allarmato fuori casa) armed_home (allarmato con persone presenti in casa) e disarmed (in realtà possiede altri stati ma per il momento prenderemo come esempio questi 3).

  - alias: un nome a scelta
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
      condition: state
      entity_id: alarm_control_panel.gigi
      state:
        - armed_away
        - armed_home
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

In questo caso all'accensione dello switch.xxxx, se la condizione del pannello allarme è in uno dei due stati quindi armed_away o armed_home allora si accenderà lo switch.yyyy

L'automazione non si sarebbe avviata se il pannello allarme fosse stato ad esempio in stato disarmed.

È possibile mettere anche più entità nella condizione precedente ed entrambe devono quindi rispettare uno dei due stati, ad esempio:

  - alias: un nome a scelta
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
      condition: state
      entity_id:
        - alarm_control_panel.gigi
        - alarm_control_panel_garage
      state:
        - armed_away
        - armed_home
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

In alternativa, la condizione può essere verificata rispetto a un attributo di stato. La condizione passerà se l'attributo corrisponde allo stato specificato.

  - alias: un nome a scelta
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
      condition: state
      entity_id: light.sala
      attribute: effect_list
      state: RGB
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy

In questa automazione, quando lo switch.xxxx passerà ad on e light.sala sarà sull'attributo rgb, allora si accenderà lo switch.yyyy

Non abbiamo ancora affrontato le entità light, lo faremo presto.

L'importante per il momento è che sia chiaro il concetto.

Adesso parliamo delle TEMPLATE CONDITION, prestate molta attenzione perché forse questa è la parte più difficile delle automazioni. 

Nell'esempio utilizzerò uno shelly button integrato con mqtt per accendere uno switch. Se vi siete persi l'articolo su come integrarlo vi rinfresco la memoria QUI

In sintesi il button di Shelly (come i button di altri marchi) ha più possibilità di pressione.

S = singola pressione

SS= doppia pressione

SSS= tripla pressione 

L= pressione prolungata.

 Di seguito tre automazioni, il trigger è sempre la pressione del medesimo pulsante ma la condizione va a richiamare un template che va ad identificare la tipologia di pressione.

  - alias: pulsante1 breve
    initial_state: true
    trigger:
      - platform: mqtt
        topic: shellies/shellybutton1-xxxx/input_event/0
    condition:
      - condition: template
        value_template: '{{ (trigger.payload_json[''event''] ==''S'' ) }}'
    action:
      - service: switch.toggle
        entity_id: switch.3

  - alias: pulsante2 breve
    initial_state: true
    trigger:
      - platform: mqtt
        topic: shellies/shellybutton1-xxxx/input_event/0
    condition:
      - condition: template
        value_template: '{{ (trigger.payload_json[''event''] ==''SS'' ) }}'
    action:
      - service: switch.toggle
        entity_id: switch.2

  - alias: pulsante lungo
    initial_state: true
    trigger:
      - platform: mqtt
        topic: shellies/shellybutton1-xxxx/input_event/0
    condition:
      - condition: template
        value_template: '{{ (trigger.payload_json[''event''] ==''L'' ) }}'
    action:
      - service: switch.toggle
        entity_id: switch.3

Ogni tipologia di pressione in questo caso permetterà 3 switch diversi.

Facciamo degli ulteriori esempi prendendo a campione la batteria di un telefono integrato in HA (anche questo lo vedremo più avanti nel corso di queste videoguide, anche in questo caso cercate di assimilare più che altro il concetto).

conditions: "{{ (state_attr('device_tracker.iphone', 'battery_level')|int) > 50 }}"

In questa condizione si prende come riferimento l'attributo battery_level che dovrà essere superiore a 50.

Si può usare anche in un elenco di condizioni cosi come abbiamo visto nelle tipologie di condizioni precedentemente

conditions:
  - "{{ (state_attr('device_tracker.iphone', 'battery_level')|int) > 50 }}"
  - condition: state
    entity_id: alarm_control_panel.home
    state: armed_away
  - "{{ is_state('device_tracker.iphone', 'away') }}"

Può essere utilizzata ovunque in Home Assistant dove sono accettate le condizioni AND OR oppure NOT

condition:
  condition: or
  conditions:
    - "{{ is_state('device_tracker.iphone', 'away') }}"
    - condition: numeric_state
      entity_id: "sensor.temperature"
      below: 20

In questa condizione ad esempio vediamo un template sullo stato di un device tracker (gli smartphone possono essere sfruttati come dispositivi di tracciamento, in futuro lo vedremo) e un sensore di temperatura che invece ha un below quindi un valore ben definito.

La condizione dovrà soddisfare la prima, la seconda o entrambe le condizioni per andare avanti nell'esecuzione dell'automazione.

È anche supportato repeat nell'azione while (che sta per mentre) o until (che indica fino a) oppure ci sarà la possibilità del choose ovvero la scelta di una condizione.

 Abbiamo anche le CONDITION TIME

La condizione temporale si può verificare se siamo dopo un'ora specificata oppure prima di un'ora specificata o se siamo in un determinato giorno della settimana

condition:
  alias: "Time 15~02"
  condition: time
  # At least one of the following is required.
  after: "15:00:00"
  before: "02:00:00"
  weekday:
    - mon
    - wed
    - fri

I valori validi per weekday sono mon, tue, wed, thu, fri, sat, sun. Si noti che se before viene utilizzata solo la chiave, la condizione sarà vera da mezzanotte fino all'ora specificata. Se after viene utilizzata solo la chiave, la condizione sarà vera dall'ora specificata fino a mezzanotte. Le finestre delle condizioni temporali possono estendersi oltre la soglia della mezzanotte se vengono utilizzati entrambi i tasti after e before nell'esempio sopra, la finestra delle condizioni va dalle 15:00 alle 2:00.

Ultime, ma non per importanza, sono le Zone Condition

Le condizioni della zona verificano se un'entità si trova in una determinata zona. Affinché l'automazione delle zone funzioni, è necessario aver configurato una piattaforma di localizzazione del dispositivo che supporti la segnalazione delle coordinate GPS. Quindi le vedremo quando tratteremo i dispositivi di tracking.

Adesso passiamo finalmente alle ACTION l'ultima parte delle automazioni.

Con le azioni andiamo a determinare cosa l'automazione dovrà fare una volta che il trigger sia scattato e che le condizioni siano tutte soddisfatte.

Quindi andranno a richiamare un servizio o una scena come ad esempio quella di accendere uno switch.

Come abbiamo visto nella prima automazione di esempio i servizi che si possono lanciare sono tutti i servizi che sono presenti negli strumenti dello sviluppatore alla voce appunto servizi.

Si potranno usare anche 1 o 2 o più azioni richiamando più servizi. 

Tali azioni potranno essere compiute contemporaneamente oppure si potrà ritardare lo svolgimento dell'azione seguente con un delay:

  - alias: nome a caso
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
      - condition: state
        entity_id: switch.zzzz
        state: 'off'
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy
      - delay: 00:05
      - service: switch.turn_on
        entity_id: switch.wwwww

In questo esempio passeranno 5 secondi prima che lo switch.wwww si accenda dopo l'accensione dello switch.yyyy

Il delay potrà essere indicato anche in maniera diversa come negli esempi sottostanti:

  - alias: nome a caso
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
      - condition: state
        entity_id: switch.zzzz
        state: 'off'
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy
      - delay:
          minutes: 10
      - service: switch.turn_on
        entity_id: switch.wwwww



  - alias: nome a caso
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
      - condition: state
        entity_id: switch.zzzz
        state: 'off'
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy
      - delay:
          seconds: 10
      - service: switch.turn_on
        entity_id: switch.wwwww


  - alias: nome a caso
    initial_state: true
    trigger:
      - platform: state
        entity_id: switch.xxxx
        to: 'on'
    condition:
      - condition: state
        entity_id: switch.zzzz
        state: 'off'
    action:
      - service: switch.turn_on
        entity_id: switch.yyyy
      - delay:
          milliseconds: 10
      - service: switch.turn_on
        entity_id: switch.wwwww

andando ad intervenire fino ai milliseconds di delay.

Le azioni possono essere popolate anche da delle condizioni che permettano di scegliere quale azione svolgere in base a dei parametri oppure eventualmente da dei template come abbiamo visto prima per le condizioni.

vediamo un esempio:

- alias: nome a caso
  trigger:
    - platform: state
      entity_id: sensor.office_occupancy
      to: "on"
  action:
    - service: ligt.turn_on
      entity_id: light.aaaa
    - condition: or
      conditions:
        - condition: numeric_state
          entity_id: sun.sun
          attribute: elevation
          below: 4
        - condition: state
          entity_id: sensor.office_illuminance
          below: 10
    - service: switch.turn_on
      target:
        entity_id: switch.tttt

In questo caso l'azione accenderà la light.aaaa

Poi guarderà se le condizioni del sesnsore sun.sun (sensore che determina il livello nel sole, ne parleremo più avanti nelle prossime guide) abbia il suo attributo elevation sotto 4 oppure se il sensore di luminosità sia sotto 10 e successivamente accenderà switch.tttt .

Potrebbe interrompere le automazione se le condizioni non sono soddisfatte e quindi fare solo la parte precedente all'OR della action.

 Vi lascio adesso al video di fine articolo, che questa volta è stato sicuramente più lungo del normale, hehehehehe.