Botta e risposta con Alexa su Home Assistant: notifiche azionabili in domotica, come usarle

Scopi del pROGETTO: Consentire ad Alexa di porre domande all’utente e, in base alle risposte, agire di conseguenza sulla domotica Home Assistant Livello di difficoltà: Alto Categoria d’integrazione: Cloud Push Concetti affrontati: Configurazione software Componenti software utilizzate: Home Assistant Amazon AWS Componente Home Assistant “Alexa Media Player” Componente Home Assistant “Alexa Actionable notifications”	Prerequisiti: Home Assistant configurato e funzionante Home Assistant remotizzato via HTTPS (spiegato dopo) Alexa integrato come Media Player su Home Assistant (spiegato dopo) Amazon Echo/Alexa configurato e funzionante e relativo account Amazon ad esso collegato Dispositivi fisici utilizzati: Il computer sul quale è in esecuzione Home Assistant Amazon Echo (qualsiasi modello o qualsiasi modello di smart speaker che monti Amazon Alexa come software integrato)
GUIDA INDICATA A UTENTI CON ISTALLAZIONE:
NOTE E DISCLAIMER qualsiasi eventuale modifica agli impianti domestici dev'essere progettata e realizzata SOLO da personale qualificato; qualsiasi modifica non prevista attuata in proprio è a propria responsabilità personale nonché a proprio rischio e pericolo (i contenuti della presenta pagina hanno infatti puro scopo didattico) e fa decadere garanzia, omologazioni e certificazioni di qualità; dei dispositivi interessati; tutte le tecniche descritte si intendono applicate a software e firmware aggiornati alle ultime versioni disponibili; gli articoli di inDomus sono totalmente indipendenti e non sponsorizzati. Se mai questo cambiasse, verrà segnalato chiaramente sulle pagine oggetto di sponsorizzazione; questa pagina è materialmente scritta e manutenuta da più individui: non ci si aspetti né si pretenda un supporto personale. In caso di difficoltà, chiedere supporto alla community sul nostro forum o sulla nostra chat; se hai bisogno di orientarti, c'è la mappa.
Revisione progetto: 1.3

Abstract

Se Home Assistant è il re incontrastato degli HUB per domotica personale e Amazon Alexa l’assistente vocale più diffuso al mondo, non è un caso che l’interazione tra i due non possa che dare risultati particolarmente apprezzati.

Quel che tipicamente è possibile fare è:

• integrare Home Assistant su Amazon Alexa, così da controllare tutte le componenti domotiche ospitate sotto il tetto dell’HUB tramite comandi vocali. A questo abbiamo dedicato due guide importantissime, una realizzabile gratuitamente e una tramite abbonamento su Nabu Casa, nonchè un importante FOCUS esplicativo;
• far sì che Home Assistant possa utilizzare Amazon Alexa come “speaker”, ovvero far sì che al presentarsi di date condizioni Alexa prounci frasi arbitrarie a partire dalle condizioni della propria domotica. Anche a questo abbiamo dedicato una importante guida ad hoc.

Quel che non avevamo ancora documentato sin qui – provvedendo con il presente progetto – è realizzare un’integrazione che consenta alla domotica Home Assistant di far prounciare ad Alexa non delle comuni frasi bensì delle domande le quali, in base alle risposte dell’utente, inneschino o meno azioni specifiche sulla domotica.

Queste sono dette  “Actionable Notification” (notifiche azionabili): questo progetto guida l’utente a capirne il funzionamento e a introdurle sulla propria domotica Home Assistant, grazie all’adozione del progetto open source “alexa-actions” di keatontaylor.

ATTENZIONE: questa guida va attuata CON CALMA E GRANDE ATTENZIONE. Non farlo significa perdere il doppio del tempo per doverla rifare da capo: l’errore è davvero dietro ogni angolo. Meglio con calma, ma una volta sola.

Si parte

• Assunti
  • Controllo remoto
  • Alexa Media Player
• Creazione del token di lunga durata
• Amazon Developer Console
• Creazione aiutante
• Creazione skill
• Configurazione skill
  • Invocation Name
  • Interaction Model
  • Configurazione il codice Python
  • Test
• Home Assistant
  • Script
  • Card e strumenti utili
  • Automazioni
• Uso reale
  • Esempi vari

Assunti

Per realizzare il presente progetto si assume di:

• avere una certa dimestichezza con Home Assistant. Alcuni concetti vengono necessariamente dati per scontati: se si è alle prime armi, si potrebbero riscontrare un po’ di difficoltà;
• disporre di Home Assistant configurato per il controllo remoto tramite protocollo HTTPS (vedi a seguire);
• avere attivato il supporto “Alexa Media Player“, ovvero quello che consente a Home Assistant di utilizzare Alexa come “Media Player” allo scopo di “farlo parlare” alla bisogna (da non confondersi con l’integrazione di Home Assistant su Amazon Alexa per controllare con comandi vocali le entità domotiche presenti sull’HUB).

Controllo remoto

Il primo punto prevede che la propria istanza Home Assistant sia raggiungibile da remoto e tramite protocollo HTTPS. (vedi guida). Le guide disponibili per l’ottenimento di tale (duplice) prerequisito sono:

• guida per qualsiasi installazione di  Home Assistant, usando Reverse Proxy (gratuita e adatta alla stragrande maggioranza dei casi);
• guida per qualsiasi installazione di Home Assistant e qualsiasi tipo di connessione Internet, via Cloudflare (con un costo per l’acquisto del dominio, ma adatta a qualsiasi tipo di connessione – nonché più affidabile).

Se invece si utilizza il servizio Nabu Casa, no problem, va bene lo stesso.

Alexa Media Player

Secondo punto cardinale è aver provveduto ad integrare Amazon Alexa su Home Assistant come Media Player.
La guida allo scopo è la seguente:

Integrare Amazon Alexa come “Media Player” su Home Assistant

Dopo la configurazione, appurare che il meccanismo che fa sì che Alexa “parli” su input di Home Assistant effettivamente funzioni. Allo scopo, seguire quest’altra guida.

Creazione del token di lunga durata

Cominciamo.

Innanzitutto è necessario creare un “TOKEN a lunga durata“, ovvero una chiave d’accesso valida per 10 anni. Per far ciò, da interfaccia Home Assistant cliccare sul circolo colorato contenente la prima lettera del vostro username posta in basso a sinistra nella colonna dell’interfaccia Home Assistant:

Una volta acceduto alla pagina, cliccare in alto su “Sicurezza”, scollare sul fondo fino a trovare la seguente box:

Cliccare ora su “CREA TOKEN” e, alla richiesta del nome del token da creare, inserire “Alexa Actionable Notifications“.

A questo punto salvare da qualche parte la stringa che verrà prodotta da Home Assistant (attenzione: non sarà possibile recuperarla successivamente, quindi salvarsela subito da parte).

Amazon Developer Console

A questo punto è necessario iscriversi (se non lo si è già fatto) alla “Amazon Developer Console“, un sito satellite del classico Amazon.com/.it al quale è necessario essere già precedentemente iscritti.

Recarsi dunque presso https://developer.amazon.com/home.html e utilizzare il proprio username/password (di Amazon.com/.it) per entrare. Successivamente cliccare su “Login with Amazon“. il sito chiederà (qualora non sia stato già fatto in precedenza) di configurare il servizio “Login with Amazon“, il quale permette di utilizzare la propria username/password di Amazon.com/.it (tra l’altro già usata per configurare il proprio ambiente Alexa) in tutti i siti “satellite” come, per l’appunto, “Amazon Developer Console“:

Una volta ottenuto l’accesso, impostare la lingua italiana (solitamente il selettore è in basso a sinistra), poi cliccare su “Crea nuovo profilo di sicurezza“.

Nei campi che verranno richiesti, inserire:

• Nome del profilo di sicurezza: “HASSIO” (o quel che si preferisce, è solo un nome descrittivo);
• Descrizione del profilo di sicurezza: “HASSIO” (o quel che si preferisce, è solo una descrizione);
• URL del consenso della privacy: quello che si crede, è indifferente, dato che la Skill che prepareremo non sarà pubblica ma privata:

Cliccare su “Salva“.
Nella finestra che si aprirà. cliccare sulla rotellina in basso a destra e selezionare “Impostazioni Web“:

La pagina che segue contiene le coordinate del proprio profilo di sicurezza:

Creazione aiutante

A questo punto ci serve una prima entità di tipo “input_text” la quale ospiterà la configurazione temporanea JSON che, ogni volta vorremo che Alexa ponga una domanda all’utente, varierà in funzione della domanda e del caso specifico. In pratica, si tratta di un’entità “di appoggio”.

Per crearla è possibile modificare il codice YAML della configurazione di Home Assistant e riavviare, ma preferiremo utilizzare gli helper (gli “Aiutanti”) via interfaccia grafica, opzione più rapida e semplice.

Rechiamoci quindi alla voce di menu “Impostazioni” > “Dispositivi e servizi” > “Aiutanti” e, cliccando su “Crea aiutante“, creiamo un’entità di tipo “Testo“.

Impostazioni:

• nome: alexa_actionable_notification;
• lunghezza massima: 255;
• modalità di visualizzazione: testo.

Salvando, verrà creata l’entità input_text.alexa_actionable_notification.

A questo punto aggiungere l’entità alla propria dashboard grafica per inserirvi subito dopo, manualmente, il seguente testo:

{"text": "Questo è un test delle notifiche azionabili. Ha funzionato?", "event": "actionable.skill.test", "suppress_confirmation": "false"}

apparirà dunque come segue:

Creazione skill

Tornare alla Amazon Developer Console.

Creare una nuova skill (“Create skill”) con le seguenti caratteristiche:

• nome: Alexa Actionable Notifications;
• locale: Italiano.

Cliccare “avanti” (“Next”) e selezionare poi “Other” > “Custom” > “Alexa-hosted (Python)“.
Infine, nella region (importante!!) selezionare “EU (Ireland)“.

Cliccare ancora una volta su “avanti” (“Next”).

Alla voce “Templates” selezionare “Import skill” e inserire il seguente indirizzo:

https://github.com/keatontaylor/alexa-actions.git

come da immagine:

e cliccare poi “Import“.

Ora potrebbe volerci qualche minuto. Al termine, nella lista delle proprie skill dovrebbe apparire la nuova appena creata:

Da questa schermata, copiare e mettere da parte l’ID della Skill cliccando su “Copy Skill ID” (in grigio, in basso a sinistra). Si tratta di un’informazione necessaria più avanti.

Configurazione skill

Con la skill di fresca creazione, provvediamo ora alla sua configurazione.

Invocation Name

Da dentro la pagina riepilogativa della skill, cliccare su “Invocation Name“:

Alla voce “Skill Invocation Name“, inserire:

actionable notifications

e cliccare su “Save“, in alto.
Successivamente, cliccare su “Build skill“.

Interaction Model

Recarsi alla voce “BUILD“, in alto, e poi a sinistra cliccare su “Interaction Models” > “JSON Editor“. 
Verificare nel codice che la voce invocationName risulti impostata come deciso poco fa nel passo “Invocation Name“.

Una volta verificato, cliccare su “Build Skill“, in alto a destra.

Configurare il codice Python

In alto, selezionare “Codice“.
Sulla sinistra, aprire il percorso “Skill Code” > “lambda” > “lambda_function.py”

Inserire le seguenti informazioni:

• HOME_ASSISTANT_URL: inserire l’indirizzo (preciso) al quale solitamente ci si collega, da remoto, a Home Assistant;
• VERIFY_SSL: True se si possiede un certificato emesso da una Certification Authority, oppure False se è auto-generato (se si usano servizi come Let’s Encrypt, Cloudflare o similari, solitatamente la scelta è la prima);
• TOKEN: inserire il token lunga-vita creato all’inizio.

Al termine, cliccare “Save” e poi “Deploy“, in alto.

Test

In alto, selezionare “Test“.
Questo dà accesso alla sezione in cui è possibile simulare un dialogo con Alexa, semplicemente inserendo dei comandi testuali che verranno interpretati come se fossero vocali.

Selezionare “Italian” e poi inserire “apri actionable notifications” e premere invio: la risposta dovrebbe essere la seguente:

Se tutto ha funzionato, Alexa avrà ripetuto la frase definita nell’input text definito all’inizio su Home Assistant e potremo proseguire olte: la skill è correttamente configurata e funzionante.

Diversamente, in caso il test non vada a buon fine, ribattere quanto sin qui fatto, perché evidentemente è stato commesso un qualche errore.

Home Assistant

È tempo di configurare il nostro HUB in modo di dotarlo degli strumenti operativi che consentano ad Alexa di porre domande all’utente e all’HUB di reagire in funzione delle risposte.

Script

Andiamo a definire in configurazione YAML uno script come segue:

script:
  activate_alexa_actionable_notification:
    alias: activate_alexa_actionable_notification
    description: Attiva le notifiche azionabili verso uno specifico Amazon Echo
    fields:
      text:
        description: Il testo che si vuol far pronunciare ad Alexa.
        example: 'A che temperatura vuoi regolare il termostato?'
      event_id:
        description: Identificativo di risposta
        example: 'richiesta_temperatura'
      alexa_device:
        description: L'echo da utilizzare
        example: 'media_player.echo_camera'
      suppress_confirmation:
        description: Impostare a "true" se non si vuole conferma verbale da parte di Alexa
        example: 'true'
    sequence:
      - action: input_text.set_value
        data_template:
          entity_id: input_text.alexa_actionable_notification
          value: '{"text": "{{ text }}", "event": "{{ event_id }}", "suppress_confirmation": "{{ suppress_confirmation }}"}'
      - action: media_player.play_media
        data_template:
          entity_id: "{{ alexa_device }}"
          media_content_type: skill
          media_content_id: <L'ID della skill creata in precedenza>
    mode: single

avendo cura di sostituire <L’ID della skill creata in precedenza> con, appunto, l’ID della skill copiato nelle fasi precedenti.

Una volta salvata la configurazione e ricaricata, verrà creata l’entità script.activate_alexa_actionable_notification, la quale, quando evocata, innescherà Alexa.

Test

Prima di procedere oltre, verifichiamo che tutto funzioni correttamente. Per farlo, recarsi alla voce di menu “Strumenti per gli sviluppatori” > “Servizi” e, in modalità YAML, inserire il seguente codice:

action: script.activate_alexa_actionable_notification
data:
  text: "Sì o no?"
  event_id: "alexa_actionable_notification_test"
  alexa_device: media_player.<ENTITÀ MEDIA PLAYER DI ECHO>

avendo cura di sostituire <ENTITÀ MEDIA PLAYER DI ECHO> con il nome dell’entità media player relativa all’Amazon Echo da utilizzarsi, frutto dell’integrazione “Alexa Media Player“, per esempio “media_player.amazon_echo_sala“.

Cliccando su “CHIAMA SERVIZIO“, dall’Amazon Echo selezionato dovrebbe essere pronunciata la domanda “Sì o no?“. Se così è, tutto sta funzionando correttamente. Diversamente, in caso il test non vada a buon fine, ribattere quanto sin qui fatto, perché evidentemente è stato commesso un qualche errore.

Card e strumenti utili

A questo punto ci serviono altre entità di servizio di tipo “input_text” e una di tipo “input_button“. Per crearle è possibile modificare il codice YAML della configurazione di Home Assistant e riavviare ma, come prima, preferiremo utilizzare gli helper (gli “Aiutanti”) via interfaccia grafica, opzione più rapida e semplice.

Rechiamoci quindi alla voce di menu “Impostazioni” > “Dispositivi e servizi” > “Aiutanti” e, cliccando su “Crea aiutante“, creiamo due entità di tipo “Testo” e una “Pulsante“.

Impostazioni prima entità “Testo“:

• nome: alexa_actionable_notification_response_type;
• lunghezza massima: 255;
• modalità di visualizzazione: testo.

Impostazioni seconda entità “Testo“:

• nome: alexa_actionable_notification_response;
• lunghezza massima: 255;
• modalità di visualizzazione: testo.

Impostazioni entità “Pulsante“:

• nome: alexa_actionable_notification_trigger.

Salvando, verranno create le entità:

• input_text.alexa_actionable_notification_response_type;
• input_text.alexa_actionable_notification_response;
• input_button.alexa_actionable_notification_trigger

che andranno ad affiancare la già definita entità input_text.alexa_actionable_notification.

---

A questo punto, in dashboard, creiamo una card che accolga tutte le quattro entità create in questo progetto:

cards:
  - type: entities
    title: Alexa Actionable Notifications
    entities:
      - input_text.alexa_actionable_notification
      - input_button.alexa_actionable_notification_trigger
      - input_text.alexa_actionable_notification_response_type
      - input_text.alexa_actionable_notification_response

la quale configurazione produrrà visivamente qualcosa del genere:

Automazioni

Ora è necessario definire delle automazioni che provvedano a intercettare la pressione dell’input_button definito sopra e canalizzare le risposte sugli input_text.

N.b. Quanto stiamo facendo serve a mo’ di esempio per capire come funzioni il tutto. Non è strettamente necessario ma altamente consigliato.

Aggiungere in configurazione la seguente automazione:

automation:
  - alias: Innesco actionable notifications
    id: "innesco_actionable_notifications"
    trigger:
    - platform: state
      entity_id: input_button.alexa_actionable_notification_trigger
    action:
    - action: script.activate_alexa_actionable_notification
      data:
        text: "Sì o no?"
        event_id: aan_test
        alexa_device: media_player.<ENTITÀ MEDIA PLAYER DI ECHO>

avendo cura di sostituire <ENTITÀ MEDIA PLAYER DI ECHO> con il nome dell’entità media player relativa all’Amazon Echo da utilizzarsi, frutto dell’integrazione “Alexa Media Player“, per esempio “media_player.amazon_echo_sala“.

Poi inserire quest’altra automazione:

  - alias: "Risposta actionable notifications"
    id: "risposta_actionable_notifications"
    trigger:
    - platform: event
      event_type: alexa_actionable_notification
      event_data:
        event_id: aan_test
    variables:
      response_type: "{{ trigger.event.data.event_response_type }}"
      response: "{{ trigger.event.data.event_response }}"
    action:
    - action: input_text.set_value
      data:
        value: "{{ response_type }}"
      target:
        entity_id: input_text.alexa_actionable_notification_response_type
    - action: input_text.set_value
      data:
        value: "{{ response }}"
      target:
        entity_id: input_text.alexa_actionable_notification_response

Si tratta di un codice è piuttosto semplice da capire: quando si scatena l’evento “alexa_actionable_notification” (ovvero è stato chiamato lo script che “fa domandare” qualcosa da Alexa), viene raccolto il resposto e copiato sui due input_text.

A questo punto salvare la configurazione e ricaricare le automazioni.

Test

A questo punto, tornando alla dashboard e compilando la domanda da far riprodurre ad Alexa nel campo input_text.alexa_actionable_notification e cliccando su “PREMI“, Alexa farà la domanda e, rispondendole, nei campi response e response_type apparirà la risposta e la sua tipologia – informazioni necessarie, ovviamente, nella gestione delle automazioni che ora andremo a vedere.

Uso reale

A questo punto abbiamo ottenuto:

• una skill funzionante;
• una serie di strumenti lato Home Assistant per innescare le domande di Alexa e per raccoglierne le risposte, cosa utile per definire in proprio automazioni specifiche.

Sì, perché le risposte non sono sempre (e necessariamente) “sì” o “no”: possono essere le più disparate, e gli strumenti definiti sin qui ci aiutano a definire meglio casi specifici.

Fare la domanda…

Domandare è lecito, rispondere è cortesia.
Ovviamente per far sì che Alexa ponga domande non useremo più il pulsante manuale creato in precedenza, ma i trigger di specifiche automazioni.

Ipotizziamo di definire un’automazione che, non rilevando nessun movimento da un sensore di movimento integrato all’HUB (entità binary_sensor.movimento_camera) per più di 30 minuti, ladove le luci della camera (light.camera) siano accese, chieda se c’è qualcuno:

automation:
  - alias: "Luci camera"
    id: "luci_camera"
    trigger:
      platform: state
      entity_id: binary_sensor.movimento_camera
      to: 'off'
      for:
        minutes: 30
    condition:
      - condition: state
        entity_id: light.camera
        state: 'on'
    action:
      - action: script.activate_alexa_actionable_notification
        data_template:
          text: "C'è ancora qualcuno in camera?"
          event_id: "aan_presenza_camera"
          alexa_device: "media_player.echo_camera"

nel blocco action si evoca lo script precedentemente definito, innescando così la domanda da parte di Alexa.

…e gestire la risposta

Definita la prima automazione, ne scriviamo un’altra che, in assenza di risposta (ResponseNone), spenga le luci:

automation:
  - alias: "Luci camera mancata risposta"
    id: "luci_camera_mancata_risposta"
    trigger:
      platform: event
      event_type: alexa_actionable_notification
      event_data:
        event_id: aan_presenza_camera
        event_response_type: ResponseNone
    condition: []
    action:
      - action: light.turn_off
        entity_id: light.camera

Come si capisce facilmente, Home Assistant intercetta l’evento aan_presenza_camera col suo response_type associato per innescare le azioni dell’automazione. Molto facile.

Altri esempi

Vediamo come regolare un termostato tramite indicazione della temperatura quando si va al letto o comunque a un determinato orario:

automation:
  - alias: Climatizzazione notturna
    id: "climatizzazione_notturna"
    trigger:
      - platform: state
        entity_id: binary_sensor.sonno_famiglia
        to: 'on' 
      - platform: time
        at: "23:30:00"  
    condition: []   
    action:
      - action: script.activate_alexa_actionable_notification
        data_template:
          text: 'Durante la notte, vuoi che sia acceso il climatizzatore?'
          event_id: 'aan_climatizzatore_notturno'
          alexa_device: 'media_player.echo_camera'

  - alias: "Climatizzazione notturna risposta"
    trigger:
      platform: event
      event_type: alexa_actionable_notificaiton
      event_data:
        event_id: aan_climatizzatore_notturno
        event_response_type: ResponseNumeric
    condition: []
    action:
      - action: climate.set_temperature
        entity_id: climate.climatizzatore
        data: 
          temperature: "{{ trigger.event.data.event_response }}" 

Vediamo un altro esempio: all’accensione della TV integrata su Home Assistant, voglio che Alexa mi chieda che servizio/canale desidero e provveda di conseguenza:

automation:
  - alias: Servizio TV
    trigger:
      platform: state
      entity_id: media_player.tv
      to: 'on'
    action:
      - action: script.activate_alexa_actionable_notification
        data_template:
          text: 'Quale servizio vuoi tra Netflix, Hulu o YouTube?'
          event_id: 'alexa_notification_media_tv_select'
          alexa_device: 'media_player.living_room_echo'

  - alias: Selezione automatica del servizio
    trigger:
      platform: event
      event_type: alexa_actionable_notification
      event_data:
        event_id: alexa_notification_media_tv_select
    action:
      - action: media_player.select_source
        entity_id: media_player.tv
        data_template:
          source: "{{ trigger.event.data.event_response }}" 

E così via.
Altri esempi sono disponibili qui. 

---

Congratulazioni! Le notifiche attivabili sono operative su Home Assistant.
Ora, il limite nell’usare sta solo nella fantasia – e nelle esigenze – dell’utente.

⚠️ Se di Home Assistant ne sai poco ma sei interessato a capirne di più, ti suggeriamo di partire da qui.

Questa pagina è redatta, manutenuta e aggiornata dallo staff di inDomus, un gruppo di persone molto diverse tra loro che trovi, per domande e supporto, sul forum e sulla chat del sito. Alcuni link sono taggati in qualità di affiliati Amazon e riceviamo un compenso dagli acquisti idonei, utile al sostenimento del sito, ma le nostre recensioni sono tutte indipendenti e non sponsorizzate. Se ti sei perso, a tua disposizione c'è la mappa.