
Riscrivere la stessa automazione tante volte quanti sono i dispositivi in casa, cambiando solo un sensore o un tasto, diventa ripetitivo e poco efficiente. Qui ci vengono in soccorso i blueprint di Home Assistant: sono modelli di automazione in cui la logica si scrive una sola volta, e poi si scelgono solo i dispositivi o le entità.
Per esempio, prendo due casi che ho in casa. Il primo è l’automazione che aggiorna la temperatura delle valvole termostatiche da un sensore esterno: va ripetuta per ogni stanza. Il secondo è un telecomando Zigbee a 4 tasti, dove ogni tasto ha 3 pressioni diverse, e quindi ci ritroviamo con fino a 12 automazioni. Il codice è sempre lo stesso, quello che cambia sono solo le entità. Immagina poi di doverlo modificare un giorno: dovresti correggere ogni copia.
In questa guida vediamo come importare dei blueprint già pronti dalla community, come leggerli e capirli e, la parte più interessante, come crearne di nostri partendo da un’automazione che usiamo già.
Io poi uso i blueprint della community anche solo come ispirazione. Ogni tanto vado sul forum, cerco un’automazione e vedo se posso rendere più efficienti le mie, o crearne di nuove, con soluzioni che altri hanno già provato e, ovviamente, documentato.
Cos’è un blueprint Home Assistant e quando conviene
Il team di Home Assistant lo definisce così:
“I blueprint sono il modo più semplice per aggiungere automazioni, script o entità template al tuo Home Assistant. Qualcuno nella community ha già fatto il lavoro di scrivere la configurazione, e a te basta inserire i dettagli specifici per la tua casa, come quale sensore monitorare e quale luce controllare.”
Dalla documentazione ufficiale di Home Assistant sui blueprint, traduzione mia.
Quindi è un modello di automazione precompilato, in cui devo inserire solo piccole parti: molto spesso solo le entità che vogliamo usare e pochi altri campi stabiliti dall’autore, mentre tutta la logica è già stata scritta. Molto efficiente.
| Automazione duplicata | Script con campi | Blueprint | |
|---|---|---|---|
| Dove modifichi la logica | In ogni copia | In un punto | In un punto |
| Chi la avvia | Il trigger | Un’altra automazione, un pulsante o la voce | Il trigger, già incluso |
| Cosa compili | Niente, è già fissa | I campi alla chiamata | Gli ingressi, una volta per istanza |
| Quando conviene | Un solo caso | Azioni riusate da più automazioni | Stessa automazione, più dispositivi |
Dove modifichi la logica
Chi la avvia
Cosa compili
Quando conviene
Per esempio, uno dei miei primi dispositivi è stato un cubo Aqara, che ha decine di possibili trigger. Per il mio, il modello di prima generazione, c’è un blueprint che gestisce 35 azioni. Per il nuovo cubo T1 Pro, che non ho provato, c’è invece un blueprint che si appoggia a un sensore creato da Zigbee2MQTT per distinguere oltre 58 comandi diversi, più di 118 contando tutte le combinazioni.
Quindi conviene usare i blueprint quando ho una logica ripetitiva per tante possibili varianti di trigger e non voglio stare lì a riscrivere tutto da capo ogni volta. È un modello riutilizzabile per più dispositivi uguali, che hanno le stesse funzioni: gli stessi interruttori in stanze diverse, il cubo, o il telecomando Moes a 4 tasti.
Come importare un blueprint in Home Assistant
Passo dopo passo
Per importare un nuovo blueprint vado su Impostazioni (Settings), poi su Automazioni e scene (Automations & scenes) e infine sulla scheda Blueprint. In basso a destra clicco su Importa blueprint (Import blueprint) e si apre una finestra in cui inserisco il link al blueprint che avevo trovato prima. Clicco su Anteprima (Preview) e confermo con Importa blueprint. In alternativa posso cliccare sul link View blueprints on the community forums, così da trovare il modello che mi interessa. Molti blueprint sul forum hanno anche il pulsante Import Blueprint, che apre direttamente la finestra di importazione nel tuo Home Assistant.
Una volta importato, il blueprint si trova nella lista di quelli disponibili: basta aprirlo e seguire le istruzioni, che cambiano in base al progetto. Quando salvo, alla fine della configurazione, si crea un’automazione.
Di seguito importiamo un blueprint di esempio, preso veramente a caso dalla sezione Blueprints Exchange del forum: Notify Entering and/or Leaving Zone.
Apri Settings
- Apri Settings
- Entra in Automations & scenes
- Passa alla scheda Blueprints
- Clicca su Import blueprint
- Cerca un blueprint sul forum
- Scegli il blueprint
- Copia l'indirizzo della pagina
- Incolla l'indirizzo e clicca Preview
- Compila i campi e salva
Un caso reale: il blueprint della community per l’Aqara E1
Io uso poco i blueprint, ma uno che uso ormai da tempo (e funziona) è il blueprint di pavax per la valvola Aqara E1. È molto semplice: serve ad aggiornare la temperatura di riferimento della valvola da un sensore di temperatura esterno. Senza, la vicinanza della valvola al radiatore darebbe letture di temperatura falsate, troppo alte o troppo basse (ne parlo nella recensione dell’Aqara E1). Il modello è semplice: devo solo inserire il sensore esterno e la valvola target, e lasciare il terzo valore su external. Quando cambia la temperatura, per esempio da 20,3 a 20,4 gradi, la valvola si aggiorna automaticamente (il valore è evidenziato nella seconda immagine qui sotto).
Lo YAML dell’automazione creata dal blueprint è di poche righe:
description: ''
alias: Aqara TRV E1 External Temperature Control
use_blueprint:
path: pavax/z2m_aqara_trv_external_temperature.yaml
input:
external_temp_sensor: sensor.0x00158d008bbe7678_temperature
aqara_trv_device: 62f5202abc4ffd59026a27bbf6b8a58cDentro però c’è tutta la logica che il blueprint scrive al posto mio. La parte che conta è il primo if: se il sensore esterno diventa non disponibile, la valvola torna al sensore interno.
Mostra il blueprint di pavax visto dentro (60 righe)
mode: single
max_exceeded: silent
variables:
aqara_trv_device: 62f5202abc4ffd59026a27bbf6b8a58c
external_temp_sensor: sensor.0x00158d008bbe7678_temperature
external_temperature_input_name: external
triggers:
- trigger: state
entity_id: sensor.0x00158d008bbe7678_temperature
actions:
- variables:
aqara_trv_device_name: '{{ device_attr(aqara_trv_device, ''name'') }}'
aqara_trv_select_entity: >-
{% set device_entities = device_entities(aqara_trv_device) %} {{
expand(states['select'])
| selectattr('entity_id','in', device_entities)
| selectattr('attributes.options', 'contains', 'external')
| map(attribute='entity_id')
| first
}}
aqara_trv_number_entity: >-
{% set device_entities = device_entities(aqara_trv_device) %} {{
expand(states['number'])
| selectattr('entity_id','in', device_entities)
| selectattr('entity_id', 'contains', external_temperature_input_name)
| map(attribute='entity_id')
| first
}}
- if:
- condition: template
value_template: >-
{{ is_state(external_temp_sensor, "unavailable") or
is_state(external_temp_sensor, "unknown") }}
then:
- action: select.select_option
target:
entity_id: '{{aqara_trv_select_entity}}'
data:
option: internal
- action: system_log.write
data:
level: error
message: External temperature sensor unavailable
logger: Aqara TRV
- stop: External temperature sensor unavailable
- if:
- condition: template
value_template: '{{ not is_state(aqara_trv_select_entity, ''external'')}}'
then:
- action: select.select_option
target:
entity_id: '{{aqara_trv_select_entity}}'
data:
option: external
- delay:
hours: 0
minutes: 0
seconds: 10
milliseconds: 0
- action: number.set_value
data:
value: '{{ (states(external_temp_sensor)|float(0)|round(1)) }}'
target:
entity_id: '{{aqara_trv_number_entity}}'
alias: Aqara TRV E1 External Temperature Control
description: ''Altri esempi dalla community
Altri blueprint che ho usato in passato sono quello per il cubo Aqara, che ha molte azioni complesse e con il blueprint diventa tutto molto più facile, e quello per la pulsantiera Moes (la recensisco qui):
- per il cubo: Aqara Cube zigbee2mqtt (35 actions), di fapg;
- per il Moes: Zigbee2MQTT Moes 12 Scene Switch, di j-oconnell.
Questi sono solo due esempi, ma la community è davvero ampia e ci sono decine di modelli. Sicuramente troverai qualcosa che ti serve, anche solo come ispirazione, che è poi quello che faccio io quando sono bloccato su un’automazione.
Come è fatto un blueprint Home Assistant: ingressi, selettori e !input
Il nostro blueprint di esempio è quello per la calibrazione delle valvole termostatiche con un sensore esterno.
La prima volta che l’ho visto non ho capito bene cosa stessi guardando: la struttura è un po’ diversa da quella delle normali automazioni. Ha una sintassi a parte, ma non è difficile da imparare e, una volta capita, tutto diventa più facile. Ci sono due o tre concetti da chiarire e alcune chiavi da imparare, come input e selector, almeno per le automazioni più semplici.
Ecco il blueprint completo. Poi lo divido in blocchi, così si legge meglio.
Mostra il blueprint di calibrazione completo
blueprint:
name: Calibrazione valvola termostatica con sensore esterno
description: Invia la temperatura di un sensore esterno al campo "external temperature input" della valvola.
domain: automation
author: Massimo Di Vona
homeassistant:
min_version: 2024.10.0
input:
external_sensor:
name: Sensore di temperatura
description: Il sensore che misura la temperatura reale della stanza.
selector:
entity:
filter:
- domain: sensor
device_class: temperature
trv_input:
name: Ingresso temperatura esterna della valvola
description: L'entità number "external temperature input" della valvola.
selector:
entity:
filter:
- domain: number
variables:
sensor_entity: !input external_sensor
triggers:
- trigger: state
entity_id: !input external_sensor
not_to:
- unavailable
- unknown
conditions:
- condition: template
value_template: "{{ states(sensor_entity) | is_number }}"
actions:
- action: number.set_value
target:
entity_id: !input trv_input
data:
value: "{{ states(sensor_entity) | float(21.0) | round(1) }}"
mode: singleI metadati
All’inizio abbiamo il blocco con nome, descrizione, autore e versione minima di Home Assistant. Tutte cose molto semplici.
blueprint:
name: Calibrazione valvola termostatica con sensore esterno
description: Invia la temperatura di un sensore esterno al campo "external temperature input" della valvola.
domain: automation
author: Massimo Di Vona
homeassistant:
min_version: 2024.10.0Gli ingressi e i selettori
Abbiamo ora il blocco dei due ingressi (input), a cui ho dato il nome external_sensor e trv_input (li ho scelti io così). Per ognuno c’è un nome e una descrizione per il frontend, e poi la parte del selettore (selector), che apre il campo in cui scegliere la nostra entità (sensore, number e così via), filtrata nel nostro caso per sensor e number.
input:
external_sensor:
name: Sensore di temperatura
description: Il sensore che misura la temperatura reale della stanza.
selector:
entity:
filter:
- domain: sensor
device_class: temperature
trv_input:
name: Ingresso temperatura esterna della valvola
description: L'entità number "external temperature input" della valvola.
selector:
entity:
filter:
- domain: numberTrigger, condizione e azione
Poi ho inserito, come nelle automazioni, i classici tre passi: il trigger, la condizione e l’azione. Quando cambia lo stato di entity_id: !input external_sensor scatta l’automazione, e parte l’azione number.set_value sull’ingresso trv_input (che ho raccolto prima) con il valore del sensore: value: "{{ states(sensor_entity) | float(21.0) | round(1) }}".
triggers:
- trigger: state
entity_id: !input external_sensor
not_to:
- unavailable
- unknown
conditions:
- condition: template
value_template: "{{ states(sensor_entity) | is_number }}"
actions:
- action: number.set_value
target:
entity_id: !input trv_input
data:
value: "{{ states(sensor_entity) | float(21.0) | round(1) }}"Il tranello: !input dentro un template
Qui nel template, però, non possiamo usare direttamente !input external_sensor: l’automazione ci darebbe un errore. Ecco perché lo trasformiamo in una variabile con il blocco
variables:
sensor_entity: !input external_sensore nel template usiamo sensor_entity.
La regola:
!inputva usato solo dove sostituisce un valore intero; dentro{{ }}si usa una variabile che lo ha raccolto prima.
L’ultimo blocco che ho messo è una condizione, e vale la stessa regola di prima sull’uso della variabile al posto di !input:
conditions:
- condition: template
value_template: "{{ states(sensor_entity) | is_number }}"I selettori più usati
| Selettore | Cosa vede l’utente | Opzioni utili | Cosa restituisce | Dove lo usiamo |
|---|---|---|---|---|
entity | Un campo di ricerca che sceglie una o più entità | filter (con domain, device_class, integration), multiple | Un id entità, o una lista con multiple | Calibrazione: sensore e valvola; porta aperta: sensore e valvole |
number | Una casella numerica o uno slider | min, max, step, unit_of_measurement, mode (box o slider) | Un numero | Calibrazione: la correzione (offset); porta aperta: minuti di attesa |
text | Una riga di testo, o più righe con multiline | multiline, prefix, suffix, multiple | Una stringa | Pulsanti: nome dell’azione |
device | Un campo di ricerca che sceglie un dispositivo | filter (integration, manufacturer, model), multiple | Un id dispositivo | Pulsanti: telecomando |
target | Un campo per scegliere entità, dispositivi o aree | entity (con domain), device | Un target pronto per l’azione | Pulsanti: cosa accendere e spegnere |
action | La stessa sezione “azioni” dell’editor visivo | Nessuna | Una lista di azioni | Non qui: serve quando chi usa il blueprint sceglie cosa fare |
condition | La stessa sezione “condizioni” dell’editor visivo | Nessuna | Una lista di condizioni | Porta o finestra aperta: condizioni per riaccendere |
Selettore entity
filter (con domain, device_class, integration), multiplemultipleSelettore number
min, max, step, unit_of_measurement, mode (box o slider)Selettore text
multilinemultiline, prefix, suffix, multipleSelettore device
filter (integration, manufacturer, model), multipleSelettore target
entity (con domain), deviceSelettore action
Selettore condition
L’elenco completo, con tutte le opzioni, è nella documentazione dei selettori.
Valori predefiniti e opzioni avanzate
Aggiungo al codice (non originale) un offset, per spiegarti i valori predefiniti (default) e una sezione avanzata. Il codice diventa così:
Mostra il blueprint di calibrazione con l’offset
blueprint:
name: Calibrazione valvola termostatica con sensore esterno
description: Invia la temperatura di un sensore esterno al campo "external temperature input" della valvola.
domain: automation
author: Massimo Di Vona
homeassistant:
min_version: 2024.10.0
input:
external_sensor:
name: Sensore di temperatura
description: Il sensore che misura la temperatura reale della stanza.
selector:
entity:
filter:
- domain: sensor
device_class: temperature
trv_input:
name: Ingresso temperatura esterna della valvola
description: L'entità number "external temperature input" della valvola.
selector:
entity:
filter:
- domain: number
advanced:
name: Opzioni avanzate
icon: mdi:cog
collapsed: true
input:
offset:
name: Correzione
description: Valore sommato alla temperatura del sensore. Lascia 0 se il sensore è preciso.
default: 0
selector:
number:
min: -5
max: 5
step: 0.1
unit_of_measurement: "°C"
mode: box
variables:
sensor_entity: !input external_sensor
offset_value: !input offset
triggers:
- trigger: state
entity_id: !input external_sensor
not_to:
- unavailable
- unknown
conditions:
- condition: template
value_template: "{{ states(sensor_entity) | is_number }}"
actions:
- action: number.set_value
target:
entity_id: !input trv_input
data:
value: "{{ (states(sensor_entity) | float(21.0) + offset_value) | round(1) }}"
mode: singleLa sezione advanced serve se voglio inserire un offset, cioè una correzione, alla temperatura del sensore esterno. Qui ho usato l’opzione collapsed: come vedi, è una sezione comprimibile che contiene opzioni che posso usare oppure no. Per questo va specificato un valore predefinito, nel mio caso 0. Come input abbiamo messo un selettore numerico con limiti da -5 a +5 e passo 0,1.
advanced:
name: Opzioni avanzate
icon: mdi:cog
collapsed: true
input:
offset:
name: Correzione
description: Valore sommato alla temperatura del sensore. Lascia 0 se il sensore è preciso.
default: 0
selector:
number:
min: -5
max: 5
step: 0.1
unit_of_measurement: "°C"
mode: boxQuindi, ricapitolando in breve:
- il blueprint funziona già così: l’offset non serve a farlo funzionare;
- un ingresso facoltativo ha un valore predefinito: zero lascia tutto invariato;
- le opzioni che quasi nessuno tocca si raccolgono in una sezione chiusa, per non allungare il modulo;
- ogni ingresso di una sezione chiusa deve avere un default, nel nostro caso 0;
- un ingresso numerico ha il suo selettore, con limiti e unità di misura.
Dove salvare un blueprint creato da te
I blueprint creati da noi vanno salvati in un file YAML dentro la cartella blueprints/automation della configurazione, in una sottocartella a scelta. Io, collegato via SSH, ho messo i miei in homeassistant/blueprints/automation/wearesmart/, per esempio pulsante-zigbee2mqtt-accendi.yaml.
Blueprint per i pulsanti Zigbee2MQTT: un tasto che accende e spegne
In questo altro esempio ho costruito un blueprint in cui scegli il dispositivo, che può essere un pulsante Moes, Aqara o Tuya collegato con Zigbee2MQTT. Il filtro integration: mqtt l’ho messo io: mostra solo i dispositivi che arrivano da MQTT, cioè quelli di Zigbee2MQTT, e si può tranquillamente togliere. Poi scelgo il pulsante e il target, e il blueprint accende o spegne le luci di riferimento.
blueprint:
name: "Pulsante Zigbee2MQTT: accendi e spegni"
description: Alterna lo stato di luci o prese quando premi il tasto scelto.
domain: automation
author: Massimo Di Vona
homeassistant:
min_version: 2024.10.0
input:
remote_device:
name: Telecomando
selector:
device:
filter:
- integration: mqtt
action_name:
name: Pulsante e tipo di pressione
description: Per esempio 1_single (Moes) o single_left (Aqara).
selector:
text:
target_entities:
name: Cosa accendere e spegnere
selector:
target:
entity:
- domain:
- light
- switch
triggers:
- trigger: device
domain: mqtt
device_id: !input remote_device
type: action
subtype: !input action_name
actions:
- action: homeassistant.toggle
target: !input target_entities
mode: singleQuesto esempio ci serve per far vedere che possiamo usare il target come selettore, con dei domini,
target_entities:
name: Cosa accendere e spegnere
selector:
target:
entity:
- domain:
- light
- switche che non dobbiamo inserire l’azione: il toggle, cioè accendi e spegni, è già implicito nel blueprint.
actions:
- action: homeassistant.toggle
target: !input target_entitiesOvviamente questo è un esempio di costruzione banale.
Come si trova il nome del tasto
Il mio Moes a 4 tasti in Zigbee2MQTT compare come TS0044, un modello Tuya venduto anche con il marchio Moes: lo vedi nella scheda About del dispositivo, alla voce Zigbee Model.
Con il modello, il nome dei tasti lo troviamo nella pagina ufficiale di Zigbee2MQTT del TS0044: 4 tasti per 3 pressioni (single, double e hold), cioè le 12 azioni da 1_single a 4_hold. Lo stesso vale per Aqara, sempre nelle pagine di riferimento, che sono ben documentate.
Nota: con i dispositivi collegati via Zigbee2MQTT, come i pulsanti Moes, un’azione (per esempio
1_single, cioè il primo tasto premuto una volta) viene rilevata da Home Assistant solo dopo che il tasto è stato premuto almeno una volta; altrimenti non viene riconosciuta né letta. Ne parlo anche nella guida sulle azioni dei pulsanti che non compaiono.
Un’istanza per tasto
Questo blueprint crea un’automazione per ogni tasto del Moes o del dispositivo: un’azione, un’istanza.
Ovviamente, se non funziona, possiamo seguire le tracce e fare i controlli, come descritto nell’articolo sulle automazioni che non funzionano.
Il limite, detto apertamente
Voglio ripetere ancora una volta che l’esempio riportato sopra è a scopo didattico. Il blueprint crea un’automazione per ogni azione e forse non è il modo migliore, né il più efficiente, di usare i blueprint: esistono blueprint, come quello della community per il Moes a 4 tasti, che racchiudono in sé tutti i tasti in un’unica automazione. Nel mio la logica è sempre fissa (accendi e spegni): è molto utile per le luci, ma forse meno per scenari complessi.
Dal blueprint della community alla mia automazione: la valvola Sonoff
Come dicevo, non uso tanto i blueprint intesi come modelli già precompilati, anche se ne ammetto l’utilità e l’efficienza. Preferisco confezionarmi le automazioni da solo, adattandole al mio contesto specifico. Una cosa che faccio sicuramente, però, è partire da un blueprint (per spunto, per necessità o per superare degli ostacoli) e poi ricavarmi la mia automazione.
Il punto di partenza
L’automazione della calibrazione della valvola Sonoff è molto semplice. Sono partito da questo blueprint di photomoose (photomoose/sonoff-trvzb-external-temperature-sensor-calibration.yaml), in cui devi inserire solo due campi: il sensore esterno e la valvola target. L’azione finale è una sola: number.set_value con la temperatura del sensore.
Mostra il blueprint di photomoose
blueprint:
domain: automation
name: Sonoff TRVZB External Temperature Sensor Calibration
description: "..." # descrizione lunga, qui abbreviata
input:
external_temperature_sensor:
name: External Temperature Sensor
description: The entity of the external temperature sensor device that represents
the temperature value.
selector:
entity:
filter:
- domain:
- sensor
device_class:
- temperature
multiple: false
reorder: false
trv_external_temperature_input:
name: Sonoff TRVZB(s)
description: The entity of the Sonoff TRVZB device that represents the external
temperature value.
selector:
entity:
multiple: true
filter:
- domain:
- number
device_class:
- temperature
reorder: false
source_url: https://community.home-assistant.io/t/sonoff-trvzb-external-temperature-sensor-calibration/856444
triggers:
- trigger: state
entity_id: !input external_temperature_sensor
variables:
external_temperature_sensor: !input external_temperature_sensor
actions:
- action: number.set_value
metadata: {}
data:
value: '{{ states(external_temperature_sensor) | float }}'
entity_id: !input trv_external_temperature_input
mode: singleLa mia automazione
E sono arrivato a questa:
alias: Calibrazione Valvola Termostatica Sonoff
description: Invia la temperatura del sensore esterno alla valvola termostatica
triggers:
- trigger: state
entity_id: sensor.0x84ba20fffed47cfc_temperature
not_to:
- unavailable
- unknown
conditions:
- condition: template
value_template: '{{ states(''sensor.0x84ba20fffed47cfc_temperature'') | is_number }}'
actions:
- action: number.set_value
target:
entity_id: number.0x3c2ef5fffebad64b_external_temperature_input
data:
value: >-
{{ states('sensor.0x84ba20fffed47cfc_temperature') | float(21.0) |
round(1) }}
mode: singleHo aggiunto alcune condizioni per i sensori non disponibili e un controllo numerico; il resto l’ho preso dal blueprint.
Da questa automazione è nato il blueprint di calibrazione che abbiamo smontato nel capitolo “Come è fatto un blueprint”. Sulla E1 uso il blueprint di pavax, sulla Sonoff la mia automazione perché, in tutta onestà, il blueprint per la Sonoff mi dava problemi quando i sensori diventavano indisponibili: ecco il perché delle due condizioni aggiunte di cui parlavo sopra. Con l’Aqara, invece, non ho mai avuto nessun tipo di problema, perché il blueprint stesso predispone il passaggio al sensore interno quando quello esterno è non disponibile.
Se vuoi approfondire, ne parlo nella calibrazione con sensore esterno, nella recensione della Sonoff TRVZB e nel confronto tra Sonoff TRVZB e Aqara E1.
Piccola nota: ovviamente questo è un caso limite, e molto semplice. Ci sono blueprint molto più complessi.
Nel prossimo capitolo proviamo a fare il percorso contrario: creare un nostro blueprint partendo da un’automazione, quella della finestra aperta.
Dalla mia automazione al blueprint: porta o finestra aperta
Ora voglio costruire un blueprint partendo da una nostra automazione: quella che spegne il riscaldamento se ci sono porte o finestre aperte, partendo da questo tipo di sensori.
L’automazione di partenza
Non ho ancora un sensore sulle finestre, quindi l’automazione l’ho creata e provata sul sensore del portone, che è quello che ho davvero in casa. Usiamo door.opened e door.closed per far scattare l’automazione: se il portone rimane aperto per più di un minuto, spegne le valvole. Poi attende la chiusura del varco (portone o finestra che sia) e riaccende il riscaldamento.
Ovviamente sono state aggiunte alcune condizioni per rendere solida l’automazione. Per esempio, se il riscaldamento non era acceso, l’automazione non parte, e alla chiusura riaccende solo le valvole che aveva spento lei. Serve a evitare che, ogni volta che si chiude una finestra, il riscaldamento si riaccenda anche se prima era spento.
La nostra automazione è la seguente:
alias: Portone aperto, spegni il riscaldamento
description: Spegne le valvole accese quando il portone resta aperto per più di un minuto e riaccende solo quelle quando si chiude
mode: single
max_exceeded: silent
triggers:
- trigger: door.opened
target:
entity_id: binary_sensor.0xa4c138dccb4cb231_contact
options:
behavior: each
for: '00:01:00'
conditions:
- condition: climate.is_on
target:
entity_id:
- climate.0x3c2ef5fffebad64b
- climate.aqara_termostato
options:
behavior: any
for: '00:00:00'
actions:
- variables:
valvole_accese: >-
{{ ['climate.0x3c2ef5fffebad64b', 'climate.aqara_termostato']
| reject('is_state', 'off') | list }}
- action: climate.turn_off
target:
entity_id: '{{ valvole_accese }}'
- wait_for_trigger:
- trigger: door.closed
target:
entity_id: binary_sensor.0xa4c138dccb4cb231_contact
options:
behavior: each
for: '00:00:00'
- action: climate.set_hvac_mode
target:
entity_id: '{{ valvole_accese }}'
data:
hvac_mode: heatAttenzione: se Home Assistant si riavvia mentre l’automazione è in funzione (cioè dopo che è scattato il trigger del portone aperto), al riavvio non riaccende i termosifoni, perché si perde l’attesa del trigger di chiusura.
Cosa diventa ingresso e cosa resta fisso
| Parte dell’automazione | Nel blueprint | Perché |
|---|---|---|
| Sensore del portone | Ingresso: sensore di apertura (porta, finestra o generico) | Ognuno ha il suo sensore |
| Le due valvole | Ingresso: una o più valvole | Cambiano da casa a casa |
| Un minuto di attesa | Ingresso: minuti di attesa, predefinito 1 | Per una finestra può servire un tempo diverso |
| Spegni, aspetta la chiusura, riaccendi solo quelle spente | Fisso | È la logica, uguale per tutti |
| La mia programmazione | Ingresso facoltativo: condizioni per riaccendere | Ognuno gestisce il riscaldamento a modo suo |
Sensore del portone
Le due valvole
Un minuto di attesa
Spegni, aspetta, riaccendi
La mia programmazione
Il blueprint
Nel blueprint uso il classico trigger di stato al posto di door.opened, così funziona con qualsiasi sensore di apertura: porta, finestra o generico. La logica resta quella dell’automazione: la variabile valvole_accese ricorda quali valvole erano accese, e alla chiusura riaccende solo quelle, dopo aver controllato le condizioni facoltative.
Mostra il blueprint porta o finestra aperta
blueprint:
name: Porta o finestra aperta, spegni le valvole
description: Spegne le valvole accese quando una porta o una finestra resta aperta e riaccende solo quelle quando si chiude.
domain: automation
author: Massimo Di Vona
homeassistant:
min_version: 2024.10.0
input:
window_sensor:
name: Sensore di apertura
description: Il sensore della porta o della finestra.
selector:
entity:
filter:
- domain: binary_sensor
device_class:
- window
- door
- opening
valves:
name: Valvole termostatiche
description: Una o più valvole da spegnere.
selector:
entity:
multiple: true
filter:
- domain: climate
open_minutes:
name: Minuti di attesa
description: Per quanti minuti deve restare aperta prima di spegnere le valvole.
default: 1
selector:
number:
min: 0
max: 30
step: 1
unit_of_measurement: min
mode: slider
restore_conditions:
name: Condizioni per riaccendere
description: Facoltative. Per esempio, riaccendi solo se la programmazione del riscaldamento è attiva.
default: []
selector:
condition:
variables:
valves_list: !input valves
triggers:
- trigger: state
entity_id: !input window_sensor
to: "on"
for:
minutes: !input open_minutes
conditions:
- condition: template
value_template: "{{ valves_list | reject('is_state', 'off') | list | count > 0 }}"
actions:
- variables:
valvole_accese: "{{ valves_list | reject('is_state', 'off') | list }}"
- action: climate.turn_off
target:
entity_id: "{{ valvole_accese }}"
- wait_for_trigger:
- trigger: state
entity_id: !input window_sensor
to: "off"
- condition: and
conditions: !input restore_conditions
- action: climate.set_hvac_mode
target:
entity_id: "{{ valvole_accese }}"
data:
hvac_mode: heat
mode: single
max_exceeded: silentAdattalo al tuo impianto
Riconosco anche che ognuno gestisce il riscaldamento in modo specifico, ecco perché dicevo di adattare poi i blueprint alle proprie necessità. Io, per esempio, aggiungo questa condizione subito prima dell’ultima azione:
- condition: state
entity_id: schedule.programma_riscaldamento
state: "on"Così, alla chiusura, il riscaldamento si riaccende solo se è ancora programmato (valore on). Nel blueprint è proprio il campo “Condizioni per riaccendere”.
Non serve invece una condizione sull’automazione della mia programmazione settimanale: quando la spengo in primavera le valvole sono già spente, quindi questa automazione non parte.
Blueprint o script: quando uso uno e quando l’altro
Ovviamente i blueprint sono molto vicini agli script e si potrebbero confondere. Sono simili, ma hanno scopi diversi. Il blueprint serve a non dover riscrivere la logica per ogni dispositivo: lo usiamo, inseriamo i dati (le entità coinvolte) e si crea un’automazione. Gli script servono a scrivere sequenze di azioni riutilizzabili da più automazioni. I blueprint sono delle scorciatoie, se mi passate il termine; gli script, invece, non hanno un trigger loro: partono quando li chiama un’automazione, un pulsante o la voce, e ricevono i campi ogni volta. Ne parlo nel capitolo su quando usare uno script, e la documentazione ufficiale ha una pagina su quale strumento usare.
Errori comuni con i blueprint
Ovviamente nella costruzione dei blueprint si incorre in errori, ma si possono individuare seguendo le tracce delle automazioni, come spiego nel mio articolo sulle automazioni che non partono.
- Ingressi usati nei template. È l’errore più comune: un
!inputdentro{{ }}invece di una variabile. Rivedi il paragrafo sul tranello di !input. - Entità sostituite. Fai attenzione quando sostituisci o cambi dispositivi ed entità: a volte scriviamo automazioni da molto tempo e, nel frattempo, abbiamo sostituito delle entità, ma non nell’automazione. È un caso molto frequente.
- Nome dell’azione sbagliato. Il nome del tasto (per esempio
1_single) va scritto esattamente come lo invia il dispositivo. Verifica sempre le azioni negli strumenti di Home Assistant e provale prima. - File modificato a mano. Se modifichi a mano il file di un blueprint, ricarica le automazioni: le modifiche passano a tutte le automazioni create da quel blueprint.
Il consiglio, comunque, quando si crea un blueprint, è di partire da un’automazione esistente e poi ricavare da lì il blueprint, sostituendo le entità con degli ingressi e, dove servono dentro i template, con delle variabili.
Da dove partire
Quindi esplora il forum della community: sicuramente troverai blueprint che fanno per te, o che ti possono ispirare a creare automazioni migliori. Parti da un blueprint già fatto e poi cerca di migliorarlo e adattarlo alle tue specifiche necessità. Io faccio così: ho un problema, devo creare un’automazione e la scrivo, ma poi cerco anche tra i blueprint se qualcuno l’ha già fatta e, se sì, se l’ha fatta meglio. A quel punto prendo le parti e gli spunti che mi servono (e che a me erano sfuggiti) per aggiornarla e renderla migliore.
Se stai iniziando, ti possono servire anche Home Assistant: cos’è e come funziona, la guida alle automazioni senza codice, quella sugli script di Home Assistant e come installare Zigbee2MQTT.











