Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Guida introduttiva all' ESP32Espressif -WROOM-32SE
**Importante**
Questa integrazione di riferimento è ospitata nel repository Amazon-FreeRTOS che è obsoleto. Ti consigliamo di [iniziare da qui quando crei un nuovo progetto](freertos-getting-started-modular.md). Se hai già un progetto FreeRTOS esistente basato sull'ormai obsoleto repository Amazon-FreerTOS, consulta il. [Guida alla migrazione del repository Github di Amazon-FreeRTOS](github-repo-migration.md)
**Nota**
[Per scoprire come integrare le librerie e le demo modulari FreerTOS all'interno del tuo progetto Espressif IDF, consulta la nostra integrazione di riferimento in primo piano per la piattaforma -C3. ESP32](https://www.freertos.org/featured-freertos-iot-integration-targeting-an-espressif-esp32-c3-risc-v-mcu/)
Attualmente, la porta FreerTOS ESP32 per -WROOM-32SE non supporta la funzionalità di multiprocessing simmetrico (SMP).
Questo tutorial mostra come iniziare con Espressif -WROOM-32SE. ESP32 [Per acquistarne uno dal nostro partner nel catalogo Partner Device, vedi -WROOM-32SE. AWS ESP32](https://devices.amazonaws.com/detail/a3G0h0000077nRtEAI/ESP32-WROOM-32SE)
## Panoramica di
Questo tutorial descrive le seguenti procedure:
1. Connessione della scheda a un computer host.
1. Installazione del software sul computer host per lo sviluppo e il debug di applicazioni integrate per la scheda con microcontrollore.
1. Compila in modo incrociato un'applicazione demo FreerTOS su un'immagine binaria.
1. Caricamento dell'immagine binaria dell'applicazione sulla scheda in uso e successiva esecuzione dell'applicazione.
1. Monitora ed esegui il debug dell'applicazione in esecuzione utilizzando una connessione seriale.
## Prerequisiti
Prima di iniziare a usare FreerTOS sulla tua scheda Espressif, devi configurare il tuo account e le autorizzazioni. AWS
### Registrati per un Account AWS
Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno.
**Per iscriverti a un Account AWS**
1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup)
1. Segui le istruzioni online.
Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono.
Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L’utente root dispone dell’accesso a tutte le risorse e tutti i Servizi AWS nell’account. Come best practice di sicurezza, assegna l’accesso amministrativo a un utente e utilizza solo l’utente root per eseguire [attività che richiedono l’accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**.
### Crea un utente con accesso amministrativo
Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane.
**Proteggi i tuoi Utente root dell'account AWS**
1. Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password.
Per informazioni sull’accesso utilizzando un utente root, consulta la pagina [Accedere come utente root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) nella *Guida per l’utente di Accedi ad AWS *.
1. Abilita l’autenticazione a più fattori (MFA) per l’utente root.
Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*.
**Crea un utente con accesso amministrativo**
1. Abilita il Centro identità IAM.
Per istruzioni, consulta [Abilitazione del AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l’utente di AWS IAM Identity Center *.
1. Nel Centro identità IAM, assegna l’accesso amministrativo a un utente.
Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*.
**Accesso come utente amministratore**
+ Per accedere come utente del Centro identità IAM, utilizza l’URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l’utente del Centro identità IAM.
Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*.
**Assegnazione dell’accesso ad altri utenti**
1. Nel Centro identità IAM, crea un set di autorizzazioni conforme alla best practice per l’applicazione di autorizzazioni con il privilegio minimo.
Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l’utente di AWS IAM Identity Center *.
1. Assegna al gruppo prima gli utenti e poi l’accesso con autenticazione unica (Single Sign-On).
Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) nella *Guida per l’utente di AWS IAM Identity Center *.
Per fornire l’accesso, aggiungi autorizzazioni agli utenti, gruppi o ruoli:
+ Utenti e gruppi in AWS IAM Identity Center:
Crea un set di autorizzazioni. Segui le istruzioni riportate nella pagina [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) (Creazione di un set di autorizzazioni) nella *Guida per l’utente di AWS IAM Identity Center *.
+ Utenti gestiti in IAM tramite un provider di identità:
Crea un ruolo per la federazione delle identità. Segui le istruzioni riportate nella pagina [Create a role for a third-party identity provider (federation)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) della *Guida per l’utente IAM*.
+ Utenti IAM:
+ Crea un ruolo che l’utente possa assumere. Segui le istruzioni riportate nella pagina [Create a role for an IAM user](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) della *Guida per l’utente IAM*.
+ (Non consigliato) Collega una policy direttamente a un utente o aggiungi un utente a un gruppo di utenti. Segui le istruzioni riportate nella pagina [Aggiunta di autorizzazioni a un utente (console)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) nella *Guida per l’utente IAM*.
## Nozioni di base
**Nota**
I comandi Linux in questo tutorial richiedono l'uso della shell Bash.
1. **Configura l'hardware Espressif.**
[Per informazioni sulla configurazione dell'hardware della scheda di sviluppo ESP32 -WROOM-32SE, consultate la Guida introduttiva - C V4. ESP32 DevKit](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/index.html#installation-step-by-step)
**Importante**
Una volta raggiunta la sezione **Step by Step** della guida, prosegui fino al completamento del Passaggio 4 (Impostazione delle variabili di ambiente). Interrompi dopo aver completato il Passaggio 4 e segui i passaggi rimanenti qui.
1. Scarica Amazon [GitHub](https://github.com/aws/amazon-freertos)FreerTOS da. (Per istruzioni, consulta il file [README.md](https://github.com/aws/amazon-freertos/blob/main/README.md)).
1. **Configura il tuo ambiente di sviluppo.**
Per comunicare con la scheda, è necessario installare una toolchain. Espressif fornisce l'ESP-IDF per sviluppare software per le proprie schede. Poiché l'ESP-IDF ha una propria versione del kernel FreeRTOS integrata come componente, Amazon FreerTOS include una versione personalizzata di ESP-IDF v4.2 con il kernel FreerTOS rimosso. Questo risolve i problemi relativi ai file duplicati durante la compilazione. Per utilizzare la versione personalizzata di ESP-IDF v4.2 inclusa in Amazon FreerTOS, segui le istruzioni riportate di seguito per il sistema operativo della tua macchina host.
**Windows**
1. [Scarica l'Universal Online Installer di ESP-IDF per Windows.](https://dl.espressif.com/dl/esp-idf/?idf=4.2)
1. **Esegui l'Universal Online Installer.**
1. **Quando arrivi alla fase **Scarica o usa ESP-IDF, seleziona Usa una directory ESP-IDF** **esistente e imposta Scegli la directory ESP-IDF** esistente su.** `freertos/vendors/espressif/esp-idf`
1. Completa l'installazione.
**macOS**
1. Segui le istruzioni contenute nella [Configurazione standard dei prerequisiti della Toolchain (ESP-IDF v4.2](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/macos-setup.html)) per macOS.
**Importante**
Quando raggiungi le istruzioni «Scarica ESP-IDF» in **Passaggi successivi, interrompi e poi torna** alle istruzioni in questa pagina.
1. Aprire una finestra a riga di comando.
1. Vai alla directory di download di FreerTOS, quindi esegui lo script seguente per scaricare e installare la toolchain espressif per la tua piattaforma.
```
vendors/espressif/esp-idf/install.sh
```
1. Aggiungi gli strumenti della toolchain ESP-IDF al percorso del tuo terminale con il seguente comando.
```
source vendors/espressif/esp-idf/export.sh
```
**Linux**
1. Segui le istruzioni contenute nella [configurazione standard dei prerequisiti della toolchain (](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/linux-setup.html)ESP-IDF v4.2) per Linux.
**Importante**
Quando raggiungi le istruzioni «Scarica ESP-IDF» riportate nella sezione **Passaggi successivi**, interrompi e torna alle istruzioni riportate in questa pagina.
1. Aprire una finestra a riga di comando.
1. Vai alla directory di download di FreerTOS, quindi esegui lo script seguente per scaricare e installare la toolchain Espressif per la tua piattaforma.
```
vendors/espressif/esp-idf/install.sh
```
1. Aggiungi gli strumenti della toolchain ESP-IDF al percorso del tuo terminale con il seguente comando.
```
source vendors/espressif/esp-idf/export.sh
```
1. **Stabilisci una connessione seriale.**
1. Per stabilire una connessione seriale tra la macchina host e ESP32 -WROOM-32SE, installa i driver VCP da CP210x USB a UART Bridge. È possibile scaricare i driver da [Silicon Labs](https://www.silabs.com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers).
1. [Segui i passaggi per stabilire una connessione seriale con. ESP32](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/establish-serial-connection.html)
1. Dopo aver stabilito una connessione seriale, annotare la porta seriale per la connessione della scheda. Ti serve per eseguire il flashing della demo.
### Configura le applicazioni demo FreerTOS
Per questo tutorial, il file di configurazione di FreerTOS si trova in. `freertos/vendors/espressif/boards/board-name/aws_demos/config_files/FreeRTOSConfig.h` (Ad esempio, se `AFR_BOARD espressif.esp32_devkitc` viene scelto, il file di configurazione si trova in`freertos/vendors/espressif/boards/esp32/aws_demos/config_files/FreeRTOSConfig.h`.)
**Importante**
Il dispositivo ATECC608 A ha un'inizializzazione unica che viene bloccata sul dispositivo la prima volta che viene eseguito un progetto (durante la chiamata a`C_InitToken`). Tuttavia, il progetto demo FreerTOS e il progetto di test hanno configurazioni diverse. Se il dispositivo è bloccato durante le configurazioni del progetto demo, non tutti i test nel progetto di test avranno esito positivo.
1. Configura il FreerTOS Demo Project seguendo i passaggi seguenti. [Configurazione delle demo di FreerTOS](freertos-prereqs.md#freertos-configure) Quando arrivi all'ultimo passaggio **Per formattare AWS IoT le tue credenziali**, fermati ed esegui i seguenti passaggi.
1. Microchip ha fornito diversi strumenti di scripting per facilitare la configurazione delle parti A. ATECC608 Passare alla directory `freertos/vendors/microchip/example_trust_chain_tool` e aprire il file `README.md`.
1. Per effettuare il provisioning del dispositivo, seguite le istruzioni contenute nel `README.md` file. Queste fasi includono quanto segue:
1. Crea e registra un'autorità di certificazione con AWS.
1. Genera le tue chiavi sulla ATECC608 A ed esporta la chiave pubblica e il numero di serie del dispositivo.
1. Genera un certificato per il dispositivo e registralo con AWS.
1. Caricare il certificato CA e il certificato del dispositivo sul dispositivo seguendo le istruzioni in [Distribuzione delle chiavi in modalità sviluppatore](dev-mode-key-provisioning.md).
### Monitoraggio dei messaggi MQTT sul cloud AWS
Prima di eseguire il progetto demo FreerTOS, puoi configurare il client MQTT nella console per monitorare AWS IoT i messaggi che il tuo dispositivo invia al Cloud. AWS
**Per iscriversi all'argomento MQTT con il client MQTT AWS IoT**
1. Accedi alla [console AWS IoT](https://console.aws.amazon.com/iotv2/).
1. Nel pannello di navigazione, scegli **Test**, quindi scegli **MQTT** Test Client.
1. Nell'**argomento Abbonamento**, inserisci `your-thing-name/example/topic` e quindi scegli **Sottoscrivi all'argomento**.
### Compila, esegui il flashing ed esegui il progetto demo FreerTOS utilizzando lo script idf.py
Puoi usare l'utilità IDF di Espressif (`idf.py`) per generare i file di build, creare il binario dell'applicazione e eseguire il flashing dei binari sul tuo dispositivo.
**Nota**
Alcune configurazioni potrebbero richiedere l'utilizzo dell'opzione port "`-p port-name`" con `idf.py` per specificare la porta corretta, come nell'esempio seguente.
```
idf.py -p /dev/cu.usbserial-00101301B flash
```
**Crea ed esegui il flashing di FreerTOS su Windows, Linux e macOS (ESP-IDF v4.2)**
1. Vai alla directory principale della tua cartella di download di FreerTOS.
1. In una finestra a riga di comando, inserisci il seguente comando per aggiungere gli strumenti ESP-IDF al PATH del tuo terminale:
**Windows (app «Comando»)**
```
vendors\espressif\esp-idf\export.bat
```
**Windows (app «ESP-IDF 4.x CMD»)**
(Questa operazione è già stata eseguita quando hai aperto l'app.)
**Linux /macOS**
```
source vendors/espressif/esp-idf/export.sh
```
1. Configura cmake nella `build` directory e crea l'immagine del firmware con il seguente comando.
```
idf.py -DVENDOR=espressif -DBOARD=esp32_ecc608a_devkitc -DCOMPILER=xtensa-esp32 build
```
Dovresti vedere un output come questo nell'esempio seguente.
```
Running cmake in directory /path/to/hello_world/build
Executing "cmake -G Ninja --warn-uninitialized /path/to/hello_world"...
Warn about uninitialized values.
-- Found Git: /usr/bin/git (found version "2.17.0")
-- Building empty aws_iot component due to configuration
-- Component names: ...
-- Component paths: ...
... (more lines of build system output)
[527/527] Generating hello-world.bin
esptool.py v2.3.1
Project build complete. To flash, run this command:
../../../components/esptool_py/esptool/esptool.py -p (PORT) -b 921600 write_flash --flash_mode dio --flash_size detect --flash_freq 40m 0x10000 build/hello-world.bin build 0x1000 build/bootloader/bootloader.bin 0x8000 build/partition_table/partition-table.bin
or run 'idf.py -p PORT flash'
```
Se non ci sono errori, la build genererà i file.bin binari del firmware.
1. Cancellate la memoria flash della scheda di sviluppo con il seguente comando.
```
idf.py erase_flash
```
1. Usa `idf.py` lo script per eseguire il flashing del file binario dell'applicazione sulla tua scheda.
```
idf.py flash
```
1. Monitora l'uscita dalla porta seriale della scheda con il seguente comando.
```
idf.py monitor
```
**Nota**
È possibile combinare questi comandi come nell'esempio seguente.
```
idf.py erase_flash flash monitor
```
Per alcune configurazioni della macchina host, è necessario specificare la porta quando si esegue il flashing della scheda, come nell'esempio seguente.
```
idf.py erase_flash flash monitor -p /dev/ttyUSB1
```
### Crea ed esegui il flashing di FreerTOS con CMake
Oltre a utilizzare lo `idf.py` script fornito dall'IDF SDK per creare ed eseguire il codice, puoi anche creare il progetto con. CMake Attualmente supporta Unix Makefile e il sistema di build Ninja.
**Per creare e aggiornare il progetto**
1. In una finestra a riga di comando, vai alla radice della tua directory di download di FreerTOS.
1. Esegui lo script seguente per aggiungere gli strumenti ESP-IDF al PATH della tua shell.
**Windows**
```
vendors\espressif\esp-idf\export.bat
```
**Linux /macOS**
```
source vendors/espressif/esp-idf/export.sh
```
1. Immettete il seguente comando per generare i file di build.
**Con Unix Makefiles**
```
cmake -DVENDOR=espressif -DBOARD=esp32_plus_ecc608a_devkitc -DCOMPILER=xtensa-esp32 -S . -B ./YOUR_BUILD_DIRECTORY -DAFR_ENABLE_ALL_MODULES=1 -DAFR_ENABLE_TESTS=0
```
**Con Ninja**
```
cmake -DVENDOR=espressif -DBOARD=esp32_plus_ecc608a_devkitc -DCOMPILER=xtensa-esp32 -S . -B ./YOUR_BUILD_DIRECTORY -DAFR_ENABLE_ALL_MODULES=1 -DAFR_ENABLE_TESTS=0 -GNinja
```
1. Cancella il flash e poi fai lampeggiare la lavagna.
**Con Unix Makefiles**
```
make -C ./YOUR_BUILD_DIRECTORY erase_flash
```
```
make -C ./YOUR_BUILD_DIRECTORY flash
```
**Con Ninja**
```
ninja -C ./YOUR_BUILD_DIRECTORY erase_flash
```
```
ninja -C ./YOUR_BUILD_DIRECTORY flash
```
## Informazioni aggiuntive
Per ulteriori informazioni sull'utilizzo e la risoluzione dei problemi delle ESP32 schede Espressif, consulta i seguenti argomenti:
+ [Usare FreerTOS nel proprio progetto per CMake ESP32](getting_started_espressif.md#getting_started_espressif_cmake_project)
+ [Risoluzione dei problemi](getting_started_espressif.md#getting_started_espressif_troubleshooting)
+ [Debug](getting_started_espressif.md#getting_started_espressif_debugging)