Crea un modello di automazione

1. Introduzione

Obiettivi didattici

  • Come progettare e scrivere un modello di automazione.
  • Come testare un modello di automazione utilizzando Google Home Developer Console.

Che cosa ti serve

  • Uno smartphone Android o iOS con l'app Google Home.
  • Una luce smart integrata nella tua casa o un dispositivo simulato nel playground di Google Home.

Prerequisiti

Dovresti sapere come scrivere un'automazione di Google Home. Se non hai mai scritto un'automazione, ti consigliamo di seguire il codelab Creare un'automazione basata su script prima di procedere con questo.

2. Modelli e istanze di automazione

Gli sviluppatori creano modelli di automazione utilizzando l'editor di modelli di automazione nella console per gli sviluppatori di Google Home. I modelli di automazione contengono l'essenza della logica dello script, facendo riferimento ai tipi di dispositivi, ma non a dispositivi specifici.

Utilizzando l'editor di script per le automazioni di Google Home per il web, gli utenti finali prendono un modello di automazione e creano un'istanza personalizzata che agisce sui dispositivi specifici della propria casa. Una volta salvata, l'istanza viene visualizzata in Routine per la casa nell'app Google Home (GHA).

3. Pianificare il modello di automazione

Quando si crea un'automazione, si inizia pensando al problema che si sta cercando di risolvere e a cosa farà l'automazione per risolverlo. Sono inclusi aspetti quali:

  • Quali dispositivi vuoi automatizzare.
  • Quale comando iniziale (o evento) deve attivare l'esecuzione dell'automazione.
  • Quali condizioni aggiuntive, se presenti, controllano se l'automazione viene eseguita una volta attivata.
  • Quali azioni devono essere eseguite.

Ai fini di questo codelab, l'automazione farà due cose:

  1. Accendere una luce a un orario specifico.
  2. Spegni la stessa luce a un orario specifico.

Tenendo presente questo, puoi aprire l'editor di modelli e scrivere l'automazione.

4. Scrivere il modello di automazione

Le automazioni vengono scritte in modo dichiarativo utilizzando il linguaggio di serializzazione dei dati YAML.

Un modello di automazione è composto da tre sezioni principali:

  1. Metadati: il nome dell'automazione, una descrizione di ciò che fa e, facoltativamente, alcuni tag utilizzati per classificarla. Le parole chiave sono:
    • LUCI E PRESE
    • CLIMATIZZAZIONE ED ENERGIA
    • SICUREZZA E PROTEZIONE
    • INTRATTENIMENTO
    • ELETTRODOMESTICI E ALTRO
  2. Input: definisce il tipo di dispositivo o dispositivi che l'automazione deve controllare. Il motore di automazione utilizza queste informazioni per sapere quali tipi di azioni sono validi per i dispositivi previsti.
  3. Regole di automazione: definiscono la logica di avvio e il comportamento dell'automazione.

Questo è il modello di automazione con cui lavorerai:

metadata:
  name:
    en: Scheduled light
  description:
    en: Turn the light on and off at specific times
  tags:
    - LIGHTING AND PLUGS
input:
  the_light:
    metadata:
      name:
        en: The light
      description:
        en: The light to be controlled
    selector:
      type: device
      multiSelect: true
      supportedTypes:
        - LIGHT
  time_on:
    metadata:
      name:
        en: Time to turn on the light.
      description:
        en: The time of day to turn on the selected light.
    selector:
      type: time
      default: sunset+30min
  time_off:
    metadata:
      name:
        en: Time to turn off the light.
      description:
        en: The time of day to turn off the selected light.
    selector:
      type: time
      default: 10:00 pm
automations:
  - name: Turn on the light
    starters:
      - type: time.schedule
        at: $time_on
    actions:
      - type: device.command.OnOff
        devices: $the_light
        on: true
  - name: Turn off the light
    starters:
      - type: time.schedule
        at: $time_off
    actions:
      - type: device.command.OnOff
        devices: $the_light
        on: false

Leggi il modello e tieni presente quanto segue:

  • La sezione metadata contiene il nome e la descrizione di questa automazione.
  • La sezione input definisce una variabile denominata the_light che specifica un dispositivo di tipo LIGHT. Ciò significa che questo modello può essere utilizzato solo per le luci, non per altri tipi di dispositivi. In altre parole, quando a un utente che configura l'automazione in casa viene chiesto di selezionare un dispositivo per $the_light, la sua scelta è limitata ai dispositivi del tipo specificato.
  • Nella sezione input sono definite anche due variabili denominate time_on e time_off. Questi consentono all'utente di specificare quando avviare le automazioni. time_on rappresenta l'ora in cui la luce viene accesa, mentre time_off rappresenta l'ora in cui la luce viene spenta. Se l'utente non imposta il valore di time_on o time_off, vengono utilizzati i valori predefiniti.
  • La sezione automations della nostra automazione contiene due regole di automazione. Ogni regola ha un singolo comando iniziale time.schedule che indica all'automazione a che ora deve essere avviata.

L'editor di modelli

L'editor di modelli di automazioni è lo strumento che utilizzi per scrivere i modelli di automazioni.

  1. Vai a Google Home Developer Console.
  2. Accedi con lo stesso account con cui è configurato il dispositivo nell'app Google Home.
  3. Crea o seleziona un progetto esistente.
  4. Nella sezione Automazioni, fai clic su Sviluppa.
  5. Fai clic su Crea un modello.
  6. Copia il modello di automazione "Luce programmata".
  7. Incolla il modello di automazione "Luce programmata" nell'editor dei modelli.
  8. Fai clic su Validate (Convalida). Risolvi eventuali errori che potrebbero verificarsi e continua a eseguire la convalida e la correzione finché non vengono segnalati errori.
  9. Fai clic su Salva per salvare il modello.

5. Testare il modello

Ora puoi testare il modello nella console.

  1. Assicurati che la luce sia collegata e visibile nell'app Google Home.
  2. Se la spia è accesa, spegnila.
  3. Vai a Google Home Developer Console.
  4. Apri il progetto in cui hai creato il modello.
  5. Seleziona Automazioni, quindi la scheda Test.
  6. Fai clic su Apri accanto al modello di automazione "Luce programmata".
  7. Seleziona la struttura in cui vuoi testare il modello, poi fai clic su Avanti.
  8. Nell'editor InputValue, specifica il nome della luce. Ad esempio, se la tua luce si chiama "Luce scrivania - Ufficio", devi selezionare Desk light - Office dal menu a discesa visualizzato quando fai clic a destra di lights. In alternativa, puoi digitare il nome del dispositivo.
  9. Sempre nell'editor InputValue, specifica l'ora time_on in un orario, ad esempio, cinque minuti dopo, e modifica l'ora time_off in un orario poco dopo l'ora time_on.
  10. Al termine, l'editor InputValue dovrebbe avere il seguente aspetto: 
    inputValue:
 #add value
 the_light: Desk light - Office
 #add value
 time_off: 11:45 am
 #add value
 time_on: 11:40 am
  11. Fai clic su Attiva test.
  12. Attendi il superamento dei due orari di inizio. La luce dovrebbe accendersi e spegnersi agli orari specificati.

Una volta testato correttamente il modello, sai che l'automazione funziona correttamente.

6. Complimenti!

Hai creato un modello di automazione. Fantastico!

In questo codelab hai imparato a:

  • Come progettare e scrivere un modello di automazione.
  • Come testarlo in Google Home Developer Console.

Passaggi successivi

In questo codelab hai creato un'automazione molto semplice. Le automazioni possono fare molto di più che programmare l'accensione e lo spegnimento di una luce. Ora che hai compreso le nozioni di base per creare e testare un modello di automazione, puoi provare a creare modelli di automazione per altri tipi di dispositivi, utilizzando diversi comandi iniziali, condizioni e azioni.

Per approfondire

Per scoprire di più sulle automazioni di Google Home, consulta la documentazione di riferimento sulle automazioni: