TutorialBlueprint

Blueprint Home Assistant: come si usano, come sono fatti e come crearne uno tuo

Foto di Massimo Di Vona

Massimo Di Vona

16 novembre 2026

Tablet con la finestra Import a blueprint di Home Assistant e la scritta Blueprint Home Assistant, come si usano e come si creano

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.

Dove modifichi la logica

BlueprintIn un punto
Script con campiIn un punto
Automazione duplicataIn ogni copia

Chi la avvia

BlueprintIl trigger, già incluso
Script con campiUn’altra automazione, un pulsante o la voce
Automazione duplicataIl trigger

Cosa compili

BlueprintGli ingressi, una volta per istanza
Script con campiI campi alla chiamata
Automazione duplicataNiente, è già fissa

Quando conviene

BlueprintStessa automazione, più dispositivi
Script con campiAzioni riusate da più automazioni
Automazione duplicataUn solo caso

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.

Passo passo1 / 9

Apri Settings

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).

Il blueprint di pavax: sensore esterno, valvola e nome dell'ingresso
La valvola riceve la temperatura misurata dal sensore esterno

Lo YAML dell’automazione creata dal blueprint è di poche righe:

YAMLAutomazione creata dal blueprint di pavax
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: 62f5202abc4ffd59026a27bbf6b8a58c

Dentro 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)
YAMLBlueprint di pavax, versione espansa
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):

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.

Il modulo che compare a chi usa il blueprint: due campi da compilare

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
YAMLBlueprint di calibrazione della valvola
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: single

I metadati

All’inizio abbiamo il blocco con nome, descrizione, autore e versione minima di Home Assistant. Tutte cose molto semplici.

YAMLMetadati del blueprint
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

Gli 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.

YAMLIngressi e selettori
  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

Trigger, 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) }}".

YAMLTrigger, condizione e azione
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

YAMLL'ingresso diventa una variabile
variables:
  sensor_entity: !input external_sensor

e nel template usiamo sensor_entity.

La regola: !input va 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:

YAMLLa condizione usa la variabile
conditions:
- condition: template
  value_template: "{{ states(sensor_entity) | is_number }}"

I selettori più usati

Selettore entity

Cosa vede l’utenteUn campo di ricerca che sceglie una o più entità
Opzioni utilifilter (con domain, device_class, integration), multiple
Cosa restituisceUn id entità, o una lista con multiple
Dove lo usiamoCalibrazione: sensore e valvola; porta aperta: sensore e valvole

Selettore number

Cosa vede l’utenteUna casella numerica o uno slider
Opzioni utilimin, max, step, unit_of_measurement, mode (box o slider)
Cosa restituisceUn numero
Dove lo usiamoCalibrazione: la correzione (offset); porta aperta: minuti di attesa

Selettore text

Cosa vede l’utenteUna riga di testo, o più righe con multiline
Opzioni utilimultiline, prefix, suffix, multiple
Cosa restituisceUna stringa
Dove lo usiamoPulsanti: nome dell’azione

Selettore device

Cosa vede l’utenteUn campo di ricerca che sceglie un dispositivo
Opzioni utilifilter (integration, manufacturer, model), multiple
Cosa restituisceUn id dispositivo
Dove lo usiamoPulsanti: telecomando

Selettore target

Cosa vede l’utenteUn campo per scegliere entità, dispositivi o aree
Opzioni utilientity (con domain), device
Cosa restituisceUn target pronto per l’azione
Dove lo usiamoPulsanti: cosa accendere e spegnere

Selettore action

Cosa vede l’utenteLa stessa sezione “azioni” dell’editor visivo
Opzioni utiliNessuna
Cosa restituisceUna lista di azioni
Dove lo usiamoNon qui: serve quando chi usa il blueprint sceglie cosa fare

Selettore condition

Cosa vede l’utenteLa stessa sezione “condizioni” dell’editor visivo
Opzioni utiliNessuna
Cosa restituisceUna lista di condizioni
Dove lo usiamoPorta o finestra aperta: condizioni per riaccendere

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
YAMLBlueprint di calibrazione con le opzioni avanzate
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: single

La 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.

La sezione Opzioni avanzate, aperta, con il campo Correzione
YAMLLa sezione avanzata con l'offset
    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

Quindi, 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.

I miei blueprint nella sottocartella wearesmart

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.

YAMLBlueprint pulsante Zigbee2MQTT: accendi e spegni
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: single
Il blueprint compilato: il Moes della cucina, il tasto 3_single e il gruppo di luci

Questo esempio ci serve per far vedere che possiamo usare il target come selettore, con dei domini,

YAMLIl selettore target
    target_entities:
      name: Cosa accendere e spegnere
      selector:
        target:
          entity:
            - domain:
                - light
                - switch

e che non dobbiamo inserire l’azione: il toggle, cioè accendi e spegni, è già implicito nel blueprint.

YAMLL'azione fissa
actions:
- action: homeassistant.toggle
  target: !input target_entities

Ovviamente 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.

Il mio Moes in Zigbee2MQTT: il modello da cercare è TS0044

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
YAMLBlueprint di photomoose per la Sonoff TRVZB
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: single

La mia automazione

E sono arrivato a questa:

YAMLCalibrazione della valvola Sonoff
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: single

Ho 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:

YAMLPortone aperto, spegni il riscaldamento
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: heat
L'automazione del portone, un passaggio alla volta

Attenzione: 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

Sensore del portone

Nel blueprintIngresso: sensore di apertura (porta, finestra o generico)
PerchéOgnuno ha il suo sensore

Le due valvole

Nel blueprintIngresso: una o più valvole
PerchéCambiano da casa a casa

Un minuto di attesa

Nel blueprintIngresso: minuti di attesa, predefinito 1
PerchéPer una finestra può servire un tempo diverso

Spegni, aspetta, riaccendi

Nel blueprintFisso
PerchéÈ la logica, uguale per tutti

La mia programmazione

Nel blueprintIngresso facoltativo: condizioni per riaccendere
PerchéOgnuno gestisce il riscaldamento a modo suo

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
YAMLBlueprint porta o finestra aperta, spegni le valvole
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: silent
Il blueprint porta o finestra aperta, un passaggio alla volta

Adattalo 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:

YAMLRiaccendi solo se il riscaldamento è programmato
- 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 !input dentro {{ }} 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.

Foto di Massimo Di Vona

Massimo Di Vona

Esperto di Smart Home e domotica, fondatore di WeAreSmart.it.

Massimo si occupa di tendenze tecnologiche da oltre un decennio, con un'attenzione particolare alle automazioni domestiche e alla smart home, ambiti che ha approfondito in particolare con Home Assistant. Si interessa anche di intelligenza artificiale e delle sue applicazioni nella tecnologia consumer.

BlueprintAutomazioniYAMLZigbee2MQTTValvole termostaticheHome AssistantDomotica