Questa pagina è stata tradotta dall'API Cloud Translation.

Crea un dispositivo Matter

1. Introduzione

Matter è un protocollo di connettività che offre entusiasmanti opportunità per lo sviluppo di smart device. In questo codelab, creerai il tuo primo dispositivo Matter. Per saperne di più su Matter, visita il Developer Center di Google Home: Matter o il sito web della Connectivity Standards Alliance.

Obiettivi didattici

Come integrare un dispositivo fisico con Matter.
Come mettere in servizio e controllare il dispositivo Matter con Google Home

Che cosa ti serve

Un hub, ovvero qualsiasi dispositivo Google Nest che supporta Matter, come Nest Hub (2a generazione).
Può essere una scheda di valutazione Matter ESP32-DevkitC di Espressif Systems o ESP32 M5STACK.
Un PC con Linux.
Conoscenza di base di Linux.

2. Configura l'ambiente

Identifica il dispositivo seriale

Il primo passaggio della configurazione dell'ambiente di sviluppo consiste nel determinare a quale porta seriale è connesso il dispositivo. Queste informazioni ti consentiranno di programmare e interagire con la tua scheda sviluppatori.

Collega la scheda sviluppatore al computer tramite un cavo USB.
Cerca il dispositivo della scheda sviluppatore nel file system /dev. Puoi restringere la ricerca specificando il prefisso del dispositivo della scheda per gli sviluppatori. L'ESP32 di Espressif utilizza /dev/ttyUSBx:
```
user@host $ ls /dev/ttyUSB*
/dev/ttyUSB0
```

Configura l'hub

Configura l'hub utilizzando lo stesso Account Google che intendi usare per questo codelab.

Configurazione dell'ambiente di sviluppo

Prerequisiti

Queste istruzioni sono state testate su Debian Linux e dovrebbero funzionare sulla maggior parte delle distribuzioni Linux basate su Debian, inclusa Ubuntu. Se stai lavorando con una distribuzione Linux diversa, la procedura di configurazione delle dipendenze potrebbe variare rispetto a quanto segue.

Installa le dipendenze

Esegui questo comando per installare i file binari dei pacchetti Linux richiesti che potrebbero non essere già installati:

$ sudo apt-get install git gcc g++ pkg-config libssl-dev libdbus-1-dev \
libglib2.0-dev libavahi-client-dev ninja-build python3-venv python3-dev \
python3-pip unzip libgirepository1.0-dev libcairo2-dev libreadline-dev screen

Configurare l'SDK

Per continuare questo codelab, avrai bisogno dell'SDK Espressif (l'Espressif IoT Development Framework o "ESP-IDF").

Crea una directory che contenga l'ESP-IDF:
```
$ mkdir ~/esp-idf_tools
```

Clona l'ESP-IDF da GitHub in questa directory:

$ cd ~/esp-idf_tools
$ git clone -b v4.4.3 --recursive https://github.com/espressif/esp-idf.git

Completa l'installazione della toolchain:
```
$ cd ./esp-idf
$ ./install.sh
$ cd ~/
```

Configurare l'SDK Matter

Clona il repository Matter open source:

$ git clone https://github.com/project-chip/connectedhomeip.git
$ cd ./connectedhomeip
$ git fetch origin v1.0-branch
$ git checkout FETCH_HEAD

Recupera i sottomoduli del repository:

$ ./scripts/checkout_submodules.py --shallow --platform esp32

Esegui il bootstrap dell'ambiente di sviluppo Matter:
```
$ source ./scripts/bootstrap.sh
```

3. console per gli sviluppatori di Google Home

La Console per gli sviluppatori di Google Home è l'applicazione web in cui puoi gestire le integrazioni Matter con Google Home.

Tutti i dispositivi Matter che hanno superato la certificazione Connectivity Standards Alliance (Alliance) Matter funzionano nell'ecosistema Google Home. I dispositivi in fase di sviluppo che non sono stati certificati possono essere messi in servizio nell'ecosistema Google Home in determinate condizioni. Per ulteriori informazioni, consulta la sezione Limitazioni all'accoppiamento.

Crea un progetto sviluppatore

Inizia dalla console per gli sviluppatori di Google Home:

Fai clic su Crea progetto.
Inserisci un nome univoco per il progetto e fai clic su Crea progetto.
Importante: quando scegli un nome per il progetto, è buona norma renderlo significativo e distinto. Valuta la possibilità di includere il nome della tua azienda e il tipo di dispositivo o l'azione che verrà implementata. Ad esempio, "encom-smartlight-switch" utilizza entrambi questi elementi.
Fai clic su + Aggiungi integrazione per aprire la schermata delle risorse Matter, dove puoi consultare la documentazione per lo sviluppo di Matter e leggere informazioni su alcuni strumenti.
Quando vuoi continuare, fai clic su Successivo: Sviluppo, che visualizza la pagina Elenco di controllo Matter.
Fai clic su Successivo: configurazione
Nella pagina Configurazione, inserisci il Nome del prodotto.
Fai clic su Seleziona tipo di dispositivo e seleziona il tipo di dispositivo dal menu a discesa (in questo caso, Light).
In ID fornitore (VID), seleziona Test VID e seleziona 0xFFF1 dal menu a discesa Test VID. In ID prodotto (PID), inserisci 0x8000 e fai clic su Salva & continua, poi fai clic su Salva nella pagina seguente. Utilizza questi valori VID/PID esatti, da cui dipendono i passaggi successivi del codelab.
Nota: i VID 0xFFF1, 0xFFF2, 0xFFF3 e 0xFFF4 sono riservati ai test. Prima di lanciare un prodotto, devi richiedere un VID presso la Connected Standards Alliance. Inoltre, i PID da 0x8000 a 0x801F hanno DAC di test (certificati di attestazione dei dispositivi) che è possibile utilizzare per degli esempi. A meno che tu non abbia intenzione di configurare un tuo DAC, utilizza un PID compreso in questo intervallo.
Ora vedrai l'integrazione in Integrazioni Matter.
Riavvia l'hub per assicurarti che riceva la configurazione più recente del progetto di integrazione con Matter. Se in un secondo momento devi modificare il VID o il PID, dovrai anche riavviare dopo aver salvato il progetto affinché la modifica venga applicata. Per istruzioni dettagliate sul riavvio, consulta la sezione Riavviare i dispositivi Google Nest o Google Wifi.

4. Crea il dispositivo

Tutti gli esempi in Matter vengono inseriti nella cartella esempi del repository GitHub. Sono disponibili diversi esempi, ma in questo codelab ci concentreremo sull'app Lighting.

In questo esempio si tratta di un semplice dispositivo che viene visualizzato in Google Home come una luce on/off che risponde ai comandi di accensione e spegnimento. Fare in modo che controlli una luce elettrica reale non rientra nello scopo di questo codelab.

Configura la build

Configura l'SDK Matter e attiva l'ambiente di build Matter:

$ cd ~/esp-idf_tools/esp-idf
$ source export.sh
$ cd ~/connectedhomeip
$ source ./scripts/activate.sh

Attiva Ccache, che accelera il processo di creazione:
```
$ export IDF_CCACHE_ENABLE=1
```
Passa alla directory di build ESP32 lighting-app e imposta l'architettura di destinazione:
```
$ cd ./examples/lighting-app/esp32
$ idf.py set-target esp32
```
1. Esegui l'utilità di configurazione:
```
$ idf.py menuconfig
```
2. Seleziona Demo -> Device Type e imposta Device Type su ESP32-DevKitC.
3. Premi il tasto Freccia sinistra per tornare al menu di primo livello.
4. Seleziona Component config --->.
5. Seleziona CHIP Device Layer --->.
6. Seleziona Device Identification Options --->.
7. Imposta Vendor ID sul tuo VID assegnato da Alliance o su un VID di test.
8. Imposta Product ID sul PID impostato nell'integrazione di Matter nella Console per gli sviluppatori di Google Home.
9. Premi S per salvare.
10. Premi Invio per accettare il percorso predefinito in cui verrà salvata la configurazione.
11. Premi Invio per chiudere la finestra di dialogo di conferma del salvataggio.
12. Premi Q per uscire dall'utilità di configurazione.

Esegui la build

Richiama lo script di build:

idf.py build

La build deve essere completata senza errori.

Programma il dispositivo

Collega la scheda sviluppatore al computer tramite un cavo USB.
Elimina eventuali firmware precedenti sul dispositivo (se al computer è collegata una sola scheda sviluppatore, puoi lasciare disattivata l'opzione -p {device}; il dispositivo dovrebbe essere rilevato automaticamente):
```
idf.py -p {device} erase-flash
```
Copia la tua nuova applicazione nella scheda degli sviluppatori con:
```
idf.py -p {device} flash
```

Per ulteriori informazioni sulle opzioni di flashing, consulta la pagina della documentazione di Espressif esptool.py.

5. Connetti al dispositivo

Apri una finestra del terminale.
Prendi nota della directory in cui ti trovi, quindi connettiti al nuovo dispositivo Matter utilizzando GNU screen:
```
$ screen -L {device} 115200
```
Se la console è vuota, premi il pulsante REIMPOSTA per avviare il processo di avvio del dispositivo.
Importante: quando ti connetti al dispositivo con screen, la console si riempie rapidamente di output. Se devi scorrere indietro e guardare l'output precedente e l'emulatore di terminale non ha un buffer scorrevole, ti serve un altro modo per visualizzarlo.

La soluzione alternativa consiste nel visualizzare il file screen0.log, ovvero un file di log che contiene l'output GNU screen e che si trova nella stessa directory in cui hai eseguito screen. Puoi farlo con un editor di testo o in un'altra finestra del terminale utilizzando pager, more o qualsiasi utilità di paging installata sul sistema Linux.

6. Messa in servizio del dispositivo

Nota: questo passaggio andrà a buon fine solo se hai già configurato il tuo progetto nella console per gli sviluppatori di Google Home.

Nest Hub

È necessario un hub per mettere in servizio il dispositivo su Matter fabric. Si tratta di un dispositivo Google Nest, come Nest Hub (2a generazione), che supporta Matter e che fungerà sia da router di confine per i dispositivi compatibili con Thread sia da percorso di distribuzione locale per il routing degli intent della smart home.

Fai riferimento a questo elenco per vedere quali hub supportano Matter.

Prima di iniziare la procedura di messa in servizio, accertati che:

L'hub è accoppiato allo stesso Account Google che hai usato per accedere alla console Google Home.
L'hub si trova sulla stessa rete Wi-Fi del computer che utilizzi per eseguire il dispositivo Virtual Matter.
L'hub si trova nella stessa struttura che utilizzi nell'app Google Home. (La "casa" nel Google Home Graph rappresenta la tua struttura).

Accoppia il dispositivo

Segui le istruzioni per l'accoppiamento di ESP32 per accoppiare il tuo dispositivo.

Nota: se utilizzi un dispositivo M5STACK, tieni presente che lo schermo rimane vuoto dopo il flashing, quindi per visualizzare il codice QR devi utilizzare l'URL visualizzato nella console. In alternativa, puoi digitare il codice di accoppiamento manuale.

Esempio di output della console che mostra l'URL del codice QR:

I (1926) chip[DL]: Done driving station state, nothing else to do...
I (1936) chip[SVR]: SetupQRCode: [MT:X.XXXXXXXXXXXXXXXXX]
I (1936) chip[SVR]: Copy/paste the below URL in a browser to see the QR Code:
I (1946) chip[SVR]: https://project-chip.github.io/connectedhomeip/qrcode.html?data=MT%3XX.KXXXXXXXXXXXXXXXX
I (1956) chip[SVR]: Manual pairing code: [XXXXXXXXXXX]]

Risoluzione dei problemi

Messa in servizio non riuscita

Assicurati di aver creato un progetto con la combinazione VID/PID corretta nella console Google Home.
Assicurati di aver inserito il VID e il PID corretti nella configurazione della build.
Assicurati di aver selezionato il Device Type corretto nella configurazione della build.

Per ulteriori suggerimenti sulla risoluzione dei problemi, visita la pagina relativa alla risoluzione dei problemi Matter.

7. Controlla il dispositivo

Dopo che il dispositivo compatibile con Matter è stato messo in servizio correttamente e appare nell'app Google Home sotto forma di lampadina, puoi provare a controllarlo usando l'Assistente Google, l'app Google Home o il simulatore dell'Assistente Google nell'estensione Google Home per VS Code.

Assistente Google

Usare l'Assistente Google sullo smartphone o sull'hub per attivare/disattivare lo stato del dispositivo dai comandi vocali, ad esempio dicendo "Hey Google, attiva le luci".

Per altri esempi di comandi, consulta la sezione Controllare i dispositivi per la smart home con i comandi vocali di Controllare i dispositivi per la smart home aggiunti all'app Google Home.

App Google Home

Puoi toccare le etichette On e Off accanto all'icona della lampadina mostrata nell'app Google Home.

Per ulteriori informazioni, visita la pagina Controllare i dispositivi con l'app Google Home.

Simulatore dell'Assistente Google

Nell'estensione Google Home per VS Code, utilizzando il Simulatore dell'Assistente Google, puoi emettere enunciati enunciati al tuo dispositivo utilizzando un'interfaccia simile a una chat.

8. Complimenti!

Hai creato e messo in servizio il tuo primo dispositivo Matter. Ottimo!

In questo codelab hai imparato a:

Installa un ambiente di sviluppo Matter passando dai requisiti a uno stato funzionante.
Creare ed eseguire un dispositivo Matter.
Commissione e controlla il dispositivo da Google Home.

Per saperne di più su Matter, consulta questi riferimenti:

Matter Primer di Google Home, in cui scoprirai i concetti e i principi importanti del protocollo Matter.
Matter Specification, Matter Device Library e Matter Application Cluster Library, pubblicato dalla Connected Standard Alliance.
Il repository GitHub Matter.