Home Assistant: Gestione NFC con focus sulla sicurezza

Eseguire rapidamente delle azioni dall’esterno della propria abitazione, in auto o in qualsiasi situazione in cui non è possibile utilizzare un radiocomando connesso al proprio impianto, un comando vocale oppure dove può essere fastidioso avviare l’applicativo di gestione sul proprio smartphone solo per eseguire un’azione, può generare dubbi su quale alternativa usare e soprattutto su come gestirne la sicurezza.

In questo caso può aiutarci la recente introduzione dell’NFC all’interno dell’applicazione per smartphone di Home Assistant.

Gli elementi

Per permettere l’esecuzione di comandi tramite l’NFC (Near Field Communication) è necessario possedere dei tag NFC ed uno smartphone abilitato alla loro lettura e scrittura, oppure un lettore esterno come indicato nella documentazione ufficiale. In questo articolo ci concentreremo sull’utilizzo tramite smartphone poiché a mio parere risulta essere il metodo più pratico e fruibile da buona parte dell’utenza.

I tag NFC hanno solitamente un costo molto basso e sfruttano, a grandi linee, la stessa tecnologia presente all’interno di molte carte per pagamenti o dei sistemi di pagamento tramite smartphone.

Per acquistare i prodotti specifici mostrati in questo articolo:

Tag colorati: Amazon
Tag neri: Amazon
Tag bianchi: Amazon

Consiglio l’utilizzo dei tag bianchi e neri in situazioni in cui sì vuole mimetizzare il tag su superfici del medesimo colore, ovviamente cercando in rete sono presenti tag NFC di ogni forma, dimensione e colore.

Le entità che sfrutteremo per innescare le automazioni sono:

2 sensori binari:
- binary_sensor.alarm_status (opzionale – consigliato per la sicurezza e sostituibile a piacere);
- binary_sensor.presence_home_status (opzionale – consigliato per la sicurezza e creabile come indicato in questo articolo);
2 script:
- script.system_restart_home_assistant (necessario – disponibile nel package “system.yaml” di questo articolo)
- script.alarm_disarming (necessario – sostituibile a piacere)
1 switch:
- switch.luce_esterna (opzionale – sostituibile a piacere)
1 notify:
- notify.pushover_home_assistant (opzionale – consigliato per la sicurezza e sostituibile a piacere o creabile come indicato in questo articolo)

Di seguito possiamo vedere come si presentano i tag NFC sopra indicati:

Materiale necessario

Per eseguire questa automazione è necessario aver strutturato il proprio sistema per la gestione dei packages come indicato in questo articolo.

Una volta predisposto il sistema, scarichiamo questo pacchetto contenente il materiale che utilizzeremo nei vari passaggi:

La logica e la sicurezza

Come anticipato, questo progetto è incentrato sullo sfruttare l’NFC nel modo più sicuro possibile.

Questa premessa non vuol far intendere che il sistema risulti inviolabile, ma piuttosto che rispetto ad altre soluzioni (seguendo tutti i consigli) risulterà molto difficile aggirare i suoi controlli.

I motivi per cui lo considero sicuro sono i seguenti:

I tag NFC:
- Sono passivi e privi di alimentazione e possono essere posizionati ovunque senza nessuna modifica agli impianti;
- Possono avere un identificatore generato in maniera del tutto casuale e che non contiene alcuna informazione sulla sua funzione;
- Possono essere riscritti velocemente ed in qualsiasi momento si voglia rendendo facile la sostituzione di un identificatore eventualmente compromesso;
- Se adesivi possono essere nascosti in punti strategici (come da foto), acquistabili di colore simile alla superficie finale mimetizzandosi oppure essere oggetti di vario genere passando inosservati;

Il sistema di gestione NFC richiede che:
- Sullo smartphone sia stata installata l’applicazione ufficiale di Home Assistant, che sia stato eseguito l’accesso alla propria installazione e che il telefono risulti sbloccato (è consigliato attivare il riconoscimento biometrico o con codice);
- Lo smartphone venga riconosciuto tramite un ID univoco;
- Il tag NFC venga riconosciuto tramite un identificatore univoco;
- Sia attiva la specifica sezione di esecuzione;
- Sia attivo lo smartphone di esecuzione;
- L’utente che esegue l’azione sia nella zona di esecuzione (opzionale);
- L’antifurto sia attivo durante l’esecuzione (opzionale) evitando che un tag NFC posizionato all’esterno dell’abitazione possa essere innescato quando sì è all’interno di essa con ovviamente l’antifurto o una zona di esso disinserita.

Quindi come sì può immaginare eludere tutte queste condizioni senza che un eventuale malintenzionato conosca nei dettagli com’è configurato e gestito il nostro sistema risulta alquanto remoto.

Un tag NFC nella parte interna o posteriore è realizzato come nella seconda immagine, mentre nella prima possiamo vedere come è possibile nasconderne uno sul retro di una placca a muro per scatenare azioni appoggiando lo smartphone su questa senza che nulla sia visibile all’esterno, ad esempio dietro la placca del campanello fuori dal proprio ingresso.

Creazione di un tag NFC

Tramite l’applicazione ufficiale di Home Assistant disponibile per iOS ed Android, con un telefono abilitato alla lettura e scrittura dei tag NFC, è possibile accedere all’apposita sezione di configurazione e leggere un tag già realizzato (ad esempio per clonarlo) oppure scriverne uno nuovo.

Nel caso se ne stia scrivendo un nuovo è consigliato creare un identificatore casuale (come raccomando dall’applicazione stessa), in modo che questo non abbia nessun riferimento all’operazione che eseguirà. Avvicinare quindi il tag al retro del dispositivo ed annotarsi l’identificatore generato, che sfrutteremo più avanti.

Attenzione: Le impostazioni necessarie e le schermate possono variare in base al dispositivo e sistema operativo utilizzato. Nel caso di iPhone il supporto ai tag NFC è disponibile dai dispositivi dell’annata dell’iPhone X dove consiglio l’utilizzo di applicazioni come NFC Reader, dato che la lettura in background è disponibile solo dal modello successivo in poi.

Alla prima scansione i tag, definiti etichette, appariranno nell’omonima sezione all’interno delle impostazioni. Possono essere rinominati con una descrizione a piacere o che ne identifica la funzione oltre a poter generare un codice QR che se inquadrato eseguirà la funzione simulando la scansione del tag.

La gestione

Importato il package e riavviato Home Assistant, per ottenere un risultato simile all’immagine seguente è possibile aggiungere le card disponibili nella sezione “L’interfaccia utente“.

Analizziamo cosa fa ogni singola funzione indicata.

Sezione Gestione NFC:

Gestione NFC: Permette di disabilitare ogni funzione inibendo le esecuzioni;
- Avvisi: Se abilitato ci verranno notificate tutte le esecuzioni (opzionale). Se non sì possiede un sistema di notifiche lasciare disabilitata questa opzione.
Comandi Generici: Se abilitato permette l’esecuzione di comandi di tipo generico, ad esempio: Riavvio del sistema, Accensione di una luce, Spegnimento TV ecc…;
- Valutazione Allarme: Se abilitata eseguirà le azioni solo quando il sensore binario di allarme impostato sarà attivo (opzionale e che può equivalere ad una specifica zona come ad esempio “sensori interni”). Lo scopo è di eseguire le azioni solo quando l’allarme o zona sono inseriti indicando la nostra assenza in casa e non permettendo l’esecuzione di azioni tramite tag NFC esterni all’abitazione quando invece siamo in casa. Se non sì è impostato il sensore lasciare disabilitata questa opzione;
- Valutazione Presenza: Se abilitata eseguirà le azioni solo se la specifica persona che sta eseguendo l’azione sarà presente all’interno della zona configurata nelle valutazioni del sensore di presenza (opzionale), nell’esempio in esame all’interno del raggio della zona “Casa”. Se non sì è impostato il sensore lasciare disabilitata questa opzione.
Comandi Sicurezza: Se abilitato permette l’esecuzione di comandi di sicurezza, ad esempio: Disinserimento Allarme, Apertura Serratura, Apertura Cancello ecc…;
- Valutazione Allarme: Se abilitata eseguirà le azioni solo quando il sensore binario di allarme impostato sarà attivo (opzionale e che può equivalere ad una specifica zona come ad esempio “sensori interni”). Lo scopo è di eseguire le azioni solo quando l’allarme o zona sono inseriti indicando la nostra assenza in casa e non permettendo l’esecuzione di azioni tramite tag NFC esterni all’abitazione quando invece siamo in casa. Se non sì è impostato il sensore lasciare disabilitata questa opzione;
- Valutazione Presenza: Se abilitata eseguirà le azioni solo se la specifica persona che sta eseguendo l’azione sarà presente all’interno della zona configurata nelle valutazioni del sensore di presenza (opzionale), nell’esempio in esame all’interno del raggio della zona “Casa”. Se non sì è impostato il sensore lasciare disabilitata questa opzione.

Sezione Dispositivi NFC:

Smartphone 1: Se abilitato permette l’esecuzione dal dispositivo “Smartphone 1”. Nel caso in cui il dispositivo venisse perso o sì volesse temporaneamente inibirlo (esempio dispositivo di un parente o ospite) disattivare l’opzione;
Smartphone 2: Se abilitato permette l’esecuzione dal dispositivo “Smartphone 2”. Nel caso in cui il dispositivo venisse perso o sì volesse temporaneamente inibirlo (esempio dispositivo di un parente o ospite) disattivare l’opzione;

Sezione Sensori:

Stato Inserimento Allarme: Viene analizzato per eseguire la valutazione allarme. Come mostrato più avanti indicare all’interno del codice il proprio sensore binario originale o costruirne il template di analisi. Il sensore binario originale può equivalere ad una singola zona del proprio allarme come ad esempio “sensori interni”, oppure allo stato generale di inserimento.
Stato Presenza In Casa: Gestisce la valutazione presenza, creabile seguendo le indicazioni di questo articolo.

Preparazione

Compreso il funzionamento della gestione, la prima operazione da eseguire è dichiarare nel file secrets.yaml le seguenti chiavi:

# NFC
# Dispositivi
nfc_smartphone_1_device_id: 'X1234567-1234-ABCD-EFGH-IJKLMNOPQRST'
nfc_smartphone_2_device_id: 'Y1234567-1234-ABCD-EFGH-IJKLMNOPQRST'
# Tag
nfc_tag_id_1: 'xabcdefg-ijkl-mnop-1234-567891011123'
nfc_tag_id_2: 'yabcdefg-ijkl-mnop-1234-567891011123'
# -------------------------------------------------------------------------------------------------------------------

I valori delle chiavi sopra indicate, che definiscono i dispositivi ed i tag NFC abilitati all’esecuzione, possono essere recuperati tramite gli “Strumenti per sviluppatori” accessibili dalla la barra laterale.

Spostarsi nella sezione “Eventi” ed iniziare ad ascoltare l’evento “tag_scanned“, quindi eseguire la lettura del tag NFC interessato tramite ad esempio il dispositivo “Smartphone 1”.

Come visibile nell’immagine sottostante è possibile visionare tutti i dettagli della scansione compresi il “tag_id” ed il “device_id”.

Il tag_id equivale all’identificatore precedentemente scritto (annotato ed anche visibile in “Etichette”), mentre il device_id equivale all’ID univoco dello smartphone.

Attenzione: Ogni volta che l’applicazione verrà ripristinata e riconnessa alla propria installazione di Home Assistant, il device_id andrà aggiornato. Se sì desidera gestire più tag o più dispositivi aggiungere altrettanti chiavi nel file secrets.yaml.

Dopo aver predisposto il sistema di notifiche come indicato in questo articolo e creato un sensore di presenza come indicato in quest’altro articolo, modificare all’interno del package nfc.yaml le seguenti porzioni di codice (Ovviamente è possibile sostituire le parti relative agli avvisi con il sistema di notifiche che sì preferisce).

Nel sensore binario nfc_alarm_arm_status sostituire l’entità binary_sensor.alarm_status con il proprio sensore binario di stato allarme/zona, oppure costruire un template personale per determinarne lo stato ad esempio analizzando lo stato di un Alarm Control Panel.

# Generico
# Allarme
# Inserimento
nfc_alarm_arm_status:
  friendly_name: 'Stato Inserimento Allarme'
    value_template: >-
      {% if is_state("binary_sensor.alarm_status", "on") %}
        true
      {% else %}
        false
      {% endif %}
    icon_template: >-
      {% if is_state("binary_sensor.nfc_alarm_arm_status", "on") %}
        mdi:home-lock
      {% elif is_state("binary_sensor.nfc_alarm_arm_status", "off") %}
        mdi:home-lock-open
      {% else %}
        mdi:alert-circle-outline
      {% endif %}
# -------------------------------------------------------------------------------------------------------------------

Modificare poi i 2 sensori bianri nfc_general_command_presence_status_management e nfc_security_command_presence_status_management sostituendo all’interno dei 2 attributi (Valutazione_Smartphone_1 e Valutazione_Smartphone_2) gli attributi presenti nel sensore di presenza precedentemente configurato, assegnando ad uno smartphone il proprietario. Nel caso in esame lo “Smartphone 1” è assegnato a “Vito” e lo “Smartphone 2” ad “Anna”.

# Comandi
# Generici
...
nfc_general_command_presence_status_management:
  friendly_name: 'Stato Presenza Comandi Generici'
  value_template: >-
    {% if is_state("input_boolean.nfc_general_command_presence_management", "on") %}
      {% if is_state("binary_sensor.presence_home_status", "on") %}
        true
      {% elif is_state("binary_sensor.presence_home_status", "off") %}
        false
      {% else %}
        false
      {% endif %}
    {% elif is_state("input_boolean.nfc_general_command_presence_management", "off") %}
      true
    {% else %}
      false
    {% endif %}
  attribute_templates:
    Valutazione_Smartphone_1: '{{ state_attr("binary_sensor.presence_home_status", "Valutazione_Vito") }}'
    Valutazione_Smartphone_2: '{{ state_attr("binary_sensor.presence_home_status", "Valutazione_Anna") }}'
  icon_template: mdi:account-search

Successivamente è necessario predisporre i comandi che andremo ad eseguire.

Con il primo esempio andremo a riavviare Home Assistant. Creare manualmente uno script di riavvio come da esempio sottostante oppure sfruttare quello disponibile nel package “system.yaml” di questo articolo.

# Scripts
script:
  # Home Assistant
  # Riavvio
  system_restart_home_assistant:
    alias: 'Riavvio Home Assistant'
    icon: mdi:home-assistant
    sequence:
    - service: homeassistant.restart
  # -------------------------------------------------------------------------------------------------------------------

Per il secondo esempio, con comandi di sicurezza, andremo a disinserire l’allarme. Creare quindi uno script che esegua il disinserimento del proprio allarme come l’esempio sottostante che sfrutta un Alarm Control Panel (indicare alarm_code nel file secrets.yaml):

# Scripts
script:
  # Allarme
  # Disinserimento
  alarm_disarming:
    alias: 'Disinserimento Allarme'
    icon: mdi:lock-open
    sequence:
    - service: alarm_control_panel.alarm_disarm
      data_template:
        code: !secret alarm_code
        entity_id: alarm_control_panel.allarme
  # -------------------------------------------------------------------------------------------------------------------

Questi script possono essere inseriti nel package nfc.yaml all’interno dell dominio script già presente, oppure tramite altri package personali.

Attenzione: Per la corretta lettura da parte dell’applicazione su smartphone, assicurarsi anche che siano attive le API di Home Assistant come indicato nella documentazione ufficiale ed in questo articolo.

Le automazioni

Predisposto il sistema, analizziamo come funzionano le automazioni di esecuzione.

All’interno del file nfc.yaml sono subito dichiarati svariati input di gestione che abbiamo analizzato in precedenza, e che andranno a condizionare l’esecuzione delle automazioni come spiegato.

Prendiamo in esame la prima automazione di esempio, relativa alla sezione “Comandi Generici” e che eseguirà un riavvio di Home Assistant leggendo il tag 1 tramite il dispositivo Smartphone 1 assegnato a Vito:

# Automations
automation:
  # Dispositivi
  # Smartphone 1
  # TAG 1
  # Riavvio Home Assistant
  - alias: 'NFC - Smartphone 1 - TAG 1'
    initial_state: true
    mode: single
    max_exceeded: silent
    trigger:
    - platform: event
      event_type: tag_scanned
      event_data:
        device_id: !secret nfc_smartphone_1_device_id
        tag_id: !secret nfc_tag_id_1
    condition:
    - condition: state
      entity_id: input_boolean.nfc_general_management
      state: 'on'
    - condition: state
      entity_id: input_boolean.nfc_general_command_management
      state: 'on'
    - condition: state
      entity_id: input_boolean.nfc_device_smartphone_1_management
      state: 'on'
    - condition: state
      entity_id: binary_sensor.nfc_general_command_alarm_status_management
      state: 'on'
    - condition: state
      entity_id: binary_sensor.nfc_general_command_presence_status_management
      state: 'on'
    - condition: template
      value_template: >-
        {% if is_state("input_boolean.nfc_general_command_presence_management", "on") %}
          {% if is_state_attr("binary_sensor.nfc_general_command_presence_status_management", "Valutazione_Smartphone_1", "Positiva") %}
            true
          {% else %}
            false
          {% endif %}
        {% elif is_state("input_boolean.nfc_general_command_presence_management", "off") %}
          true
        {% else %}
          false
        {% endif %}
    action:
    - service: script.turn_on
      entity_id: script.nfc_general_command_executed_status
    - service: script.nfc_general_command_executed_alert
      data_template:
        nfc_tag_name: 'TAG 1'
        nfc_tag_description: 'Riavvio Sistema'
        nfc_device_user: 'Vito'
        nfc_device_name: 'Smartphone 1'
    - delay: '00:00:10'
    - service: script.turn_on
      entity_id: script.system_restart_home_assistant

I trigger:

L’azione che innesca questa automazione è la rilevazione da parte del sistema dell’avvenuta scansione del tag precedentemente definito come “tag 1”.

Poiché il sistema sì concentra sul fattore sicurezza come ribadito più volte, fornendo anche il device_id oltre al tag_id, viene analizzato che il tag venga letto dallo specifico smartphone indicato evitando che l’automazione possa essere innescata dalla lettura del tag da parte di uno smartphone differente, permettendo così di definire con precisione i permessi di esecuzione. Ovviamente lo smartphone è un oggetto personale, quindi sì presume che il dispositivo appartenga ad una sola persona e che sia protetto da riconoscimento biometrico (impronte o volto) o da un codice.

Le condizioni:

Le prime 3 condizioni analizzano che la gestione sia abilitata, che la specifica sezione di esecuzione sia abilitata (Comandi Generici nell’esempio) e che il dispositivo Smartphone 1 sia abilitato all’esecuzione.

Successivamente vengono analizzati i sensori di “Valutazione Allarme” e “Valutazione Presenza” dove nel caso siano attivi faranno procedere con l’analisi.

L’ultima condizione, nel caso in cui la “Valutazione Presenza” generica passasse, permette di definire un ulteriore livello di sicurezza valutando che lo specifico smartphone sia presente all’interno della zona evitando che l’automazione possa essere innescata nel caso sia un’altro smartphone definito nel sensore di presenza ad essere presente nella zona e non quello interessato.

Le azioni:

La prima azione che viene eseguita è l’avvio dello script script.nfc_general_command_executed_status che defice lo “stato esecuzione”. Questo script è opzionale e semplicemente attiva e disattiva tramite ritardo un input boolean specifico per i comandi generici. L’utilizzo di questo input boolean verrà approfondito nella gestione di sicurezza.

Subito dopo verranno inoltrati i dettagli di esecuzione che ci verranno notificati sullo smartphone tramite il nostro sistema di notifiche. Modificare questi dettagli con i valori che sì preferisce. Un esempio lo sì può vedere nell’immagine sottostante.

Poiché l’input boolean prima menzionato ha un ritardo di disattivazione di 6 secondi, e il riavvio di Home Assistant immediato non ne permetterebbe l’analisi se necessaria, viene eseguito un ritardo di 10 secondi e poi lo script di riavvio di Home Assistant precedentemente configurato.

Le verifiche:

Per innescare l’automazione basta avvicinare lo smartphone allo specifico tag NFC, oppure usare un’applicazione di lettura e confermare l’esecuzione tramite l’apposito avviso/banner di avvenuta lettura.

Verificare quindi che le azioni configurate vengano correttamente eseguite, compresa (se abilitati gli avvisi) la ricezione della notifica con i dettagli di esecuzione.

Solitamente la zona di lettura NFC è nella parte posteriore-alta dello smartphone (dove spesso presenti le antenne), ma può variare da dispositivo a dispositivo.

Prendiamo ora in esame la seconda automazione di esempio, relativa alla sezione “Comandi Sicurezza” e che eseguirà il disinserimento dell’allarme e accensione di una luce esterna leggendo il tag 2 tramite il dispositivo Smartphone 2 assegnato ad Anna:

  # Smartphone 2
  # TAG 2
  # Disinserimento Allarme
  - alias: 'NFC - Smartphone 2 - TAG 2'
    initial_state: true
    mode: single
    max_exceeded: silent
    trigger:
    - platform: event
      event_type: tag_scanned
      event_data:
        device_id: !secret nfc_smartphone_2_device_id
        tag_id: !secret nfc_tag_id_2
    condition:
    - condition: state
      entity_id: input_boolean.nfc_general_management
      state: 'on'
    - condition: state
      entity_id: input_boolean.nfc_security_command_management
      state: 'on'
    - condition: state
      entity_id: input_boolean.nfc_device_smartphone_2_management
      state: 'on'
    - condition: state
      entity_id: binary_sensor.nfc_security_command_alarm_status_management
      state: 'on'
    - condition: state
      entity_id: binary_sensor.nfc_security_command_presence_status_management
      state: 'on'
    - condition: template
      value_template: >-
        {% if is_state("input_boolean.nfc_security_command_presence_management", "on") %}
          {% if is_state_attr("binary_sensor.nfc_security_command_presence_status_management", "Valutazione_Smartphone_2", "Positiva") %}
            true
          {% else %}
            false
          {% endif %}
        {% elif is_state("input_boolean.nfc_security_command_presence_management", "off") %}
          true
        {% else %}
          false
        {% endif %}
    action:
    - service: script.turn_on
      entity_id: script.nfc_security_command_executed_status
    - service: script.nfc_security_command_executed_alert
      data_template:
        nfc_tag_name: 'TAG 2'
        nfc_tag_description: 'Disinserimento Allarme'
        nfc_device_user: 'Anna'
        nfc_device_name: 'Smartphone 2'
    - delay: '00:00:01'
    - service: switch.turn_on
      entity_id: switch.luce_esterna
    - service: script.turn_on
      entity_id: script.alarm_disarming

Oltre alle ovvie variazioni nei valori di trigger e condizioni per causa del tag e dispositivo diverso, in questo caso (dopo un ritardo di 1 secondo dalla lettura) verrà invece accesa una luce esterna ed avviato lo script di disinserimento dell’allarme precedentemente configurato.

Essendo un comando di sicurezza variano anche gli elementi posizionati prima del ritardo, come quello relativo alla gestione notifiche e lo script script.nfc_security_command_executed_status.

Analizziamo quindi lo scopo di questi script di “stato esecuzione”.

Come anticipato questi non fanno altro che attivare un input boolean, e dopo 6 secondi disattivarlo. Tramite questo escamotage sfruttabile su praticamente ogni installazione è possibile innescare azioni a catena dopo l’avvenuta lettura di un tag, come:

Analizzarne lo stato in un’automazione che esegue uno “scenario ingresso”. Un esempio pratico è valutare l’intenzionalità di entrata nell’abitazione e non un disinserimento manuale, attivando quindi lo scenario solo quando sì sta entrando realmente in casa;
Esecuzione di un’automazione parallela per gestire gli avvenimenti eseguiti dopo la lettura del tag;
Creazione di un sensore di “Avvenuta scansione” che può evidenziarsi nell’interfaccia grafica (ad esempio su una dashboard a muro);
La gestione di una spia, lampada o avviso vocale per avvisare dell’avvenuta scansione;
L’attivazione di una telecamera su display che inquadra l’area dove posizionato il tag NFC inviandoci una foto tramite notifica.

I 2 input boolean da analizzare sono:

Comandi Generici: input_boolean.nfc_general_command_executed_status_management
Comandi Sicurezza: input_boolean.nfc_security_command_executed_status_management

Dato che nel caso in esame viene accesa una luce alla scansione, per fare un esempio pratico e presupponendo di voler far terminare l’automazione correttamente ma anche di voler far spegnere la luce dopo 1 minuto dall’accensione (solo nel caso in cui sia stata accesa per via del tag NFC) è possibile creare la seguente automazione:

# Automations
automation:
  # Luce Esterna
  # Spegnimento Automatico
  - alias: 'Lights Automations - Spegnimento Automatico Luce Esterna Dopo Lettura TAG 2 NFC'
    initial_state: true
    mode: restart
    max_exceeded: silent
    trigger:
    - platform: state
      entity_id: input_boolean.nfc_security_command_executed_status_management
      from: 'off'
      to: 'on'
    action:
    - delay: '00:01:00'
    - service: switch.turn_off
      entity_id: switch.luce_esterna
  # -------------------------------------------------------------------------------------------------------------------

L’automazione è impostata in modalità “restart” in modo che il ritardo di spegnimento venga ripristinato in caso di un’ulteriore scansione prima dell’effettivo spegnimento della luce.

L'interfaccia utente

L’interfaccia mostrata è possibile realizzarla creando delle card entità.

Ecco il codice delle 3 card mostrate:

type: entities
title: Gestione NFC
show_header_toggle: false
entities:
  - entity: input_boolean.nfc_general_management
  - entity: input_boolean.nfc_alert_management
  - type: divider
    style:
      height: 1px
      width: 90%
      margin-left: auto
      margin-right: auto
      background: '#62717b'
  - entity: input_boolean.nfc_general_command_management
  - entity: input_boolean.nfc_general_command_alarm_management
  - entity: input_boolean.nfc_general_command_presence_management
  - type: divider
    style:
      height: 1px
      width: 90%
      margin-left: auto
      margin-right: auto
      background: '#62717b'
  - entity: input_boolean.nfc_security_command_management
  - entity: input_boolean.nfc_security_command_alarm_management
  - entity: input_boolean.nfc_security_command_presence_management

type: entities
title: Dispositivi NFC
show_header_toggle: false
entities:
  - entity: input_boolean.nfc_device_smartphone_1_management
  - entity: input_boolean.nfc_device_smartphone_2_management

type: entities
title: Sensori
show_header_toggle: false
entities:
  - entity: binary_sensor.nfc_alarm_arm_status
  - entity: binary_sensor.presence_home_status

Ausili alla creazione

Nel caso vogliate testare l’automazione senza avere realmente tutti gli elementi, potete sfruttare il file “fake_items_test.yaml” fornito e creare una card:

type: entities
title: Ausili Creazione Automazione
show_header_toggle: false
entities:
  - entity: input_select.fake_items_test_value_1
  - entity: input_select.fake_items_test_value_2
  - entity: input_select.fake_items_test_value_3
  - entity: input_select.fake_items_test_value_4
  - entity: input_select.fake_items_test_value_5
  - entity: switch.luce_esterna
  - entity: script.system_restart_home_assistant
  - entity: script.alarm_disarming

Per analizzare invece lo stato delle valutazioni della gestione creare la seguente card:

type: entities
title: Stato Valutazioni NFC
show_header_toggle: false
entities:
  - entity: binary_sensor.nfc_general_command_alarm_status_management
  - entity: binary_sensor.nfc_general_command_presence_status_management
  - entity: input_boolean.nfc_general_command_executed_status_management
  - type: divider
    style:
      height: 1px
      width: 90%
      margin-left: auto
      margin-right: auto
      background: '#62717b'  
  - entity: binary_sensor.nfc_security_command_alarm_status_management
  - entity: binary_sensor.nfc_security_command_presence_status_management
  - entity: input_boolean.nfc_security_command_executed_status_management

Impostare i valori manualmente per forzarne lo stato degli elementi e verificare il funzionamento dell’automazione:

Conclusione

Sicuramente la gestione non è una delle più semplici, ma spero vivamente di aver fatto capire come gestire l’NFC nel modo più sicuro possibile permettendo a chiunque di personalizzare le condizioni d’esecuzione e di poter creare le proprie automazioni per ogni tag generato.

Con le opportune modifiche è possibile creare una singola automazione che può essere eseguita tramite molteplici tag NFC, di fatto è molto più sicuro scrivere un identificatore diverso su ogni tag piuttosto che avere dei cloni sparsi in giro così da poterne inibire uno senza dover per forza riscrivere gli altri.