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'Espressif ESP32-WROOM-32SE
**Importante**
Questa integrazione di riferimento è ospitata nel Amazon-FreeRTOS repository che è obsoleto. Ti consigliamo di [iniziare da qui](freertos-getting-started-modular.md) quando crei un nuovo progetto. Se hai già un progetto FreerTOS esistente basato sul repository ora obsoleto, Amazon-FreeRTOS consulta il. [Amazon-FreeRTOS Guida alla migrazione del repository Github](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. ESP32-C3 ](https://www.freertos.org/featured-freertos-iot-integration-targeting-an-espressif-esp32-c3-risc-v-mcu/)
Attualmente, la porta FreerTOS ESP32-WROOM-32SE per non supporta la funzionalità di multiprocessing simmetrico (SMP).
Questo tutorial mostra come iniziare a usare Espressif. ESP32-WROOM-32SE Per acquistarne uno dal nostro partner nel catalogo AWS Partner Device, consulta. [ESP32-WROOM-32SE](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
Per iniziare AWS, hai bisogno di un Account AWS. Per informazioni sulla creazione di un Account AWS, vedi Guida [introduttiva a un Account AWS](https://docs.aws.amazon.com//accounts/latest/reference/getting-started.html) nella *Guida Gestione dell'account AWS di riferimento*.
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 ESP32-WROOM-32SE sviluppo, consulta la Guida introduttiva alla [ ESP32-DevKitC V4](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 [README.md](https://github.com/aws/amazon-freertos/blob/main/README.md)file.)
1. **Configura il tuo ambiente di sviluppo**.
Per comunicare con la scheda, è necessario installare una toolchain. Espressif fornisce loro lo sviluppo di software ESP-IDF per le loro schede. Poiché ESP-IDF ha una propria versione del kernel FreerTOS integrata come componente, Amazon FreerTOS include una versione personalizzata della v4.2 con il ESP-IDF kernel FreerTOS rimosso. Questo risolve i problemi relativi ai file duplicati durante la compilazione. Per utilizzare la versione personalizzata della versione ESP-IDF 4.2 inclusa in Amazon FreerTOS, segui le istruzioni riportate di seguito per il sistema operativo della tua macchina host.
**Windows**
1. Scarica ESP-IDF [Universal Online Installer](https://dl.espressif.com/dl/esp-idf/?idf=4.2) per Windows.
1. Esegui l'**Universal Online Installer**.
1. Quando arrivi alla fase **Scarica o usa ESP-IDF**, seleziona **Usa una ESP-IDF directory esistente** e imposta **Scegli una ESP-IDF directory esistente** su. `{{freertos}}/vendors/espressif/esp-idf`
1. Completa l'installazione.
**macOS**
1. Segui le istruzioni nella [configurazione standard dei prerequisiti della Toolchain (ESP-IDF v4.2) per](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/macos-setup.html) macOS.
**Importante**
Quando raggiungi le istruzioni «Ottieni 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 ESP-IDF strumenti della toolchain 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 (ESP-IDF v4.2](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/linux-setup.html)) per Linux.
**Importante**
Quando raggiungi le istruzioni «Ottieni ESP-IDF» riportate nella sezione **Passaggi successivi**, interrompi l'operazione 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 ESP-IDF strumenti della toolchain 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 il ESP32-WROOM-32SE, installa i driver CP210x USB to UART Bridge VCP. È 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. È necessario 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 ATECC608A dispone di 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 diversi strumenti di scripting per facilitare la configurazione delle parti ATECC608A. Passare alla directory `{{freertos}}/vendors/microchip/example_trust_chain_tool` e aprire il file `README.md`.
1. Per effettuare il provisioning del dispositivo, segui le istruzioni contenute nel `README.md` file. Queste fasi includono quanto segue:
1. Crea e registra un'autorità di certificazione con AWS.
1. Generare le chiavi su ATECC608A ed esportare 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 [Developer-mode fornitura di chiavi](dev-mode-key-provisioning.md).
### Monitoraggio dei messaggi MQTT su AWS Cloud
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 iscriverti all'argomento MQTT con il AWS IoT Client MQTT**
1. Accedi alla [console AWS IoT](https://console.aws.amazon.com/iotv2/).
1. Nel riquadro di navigazione, scegliete **Test**, quindi scegliete **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 e esegui il flashing di FreerTOS su Windows, Linux e macOS (v4.2) ESP-IDF**
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 ESP-IDF gli strumenti 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 ESP-IDF gli strumenti 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 schede Espressif ESP32, consulta i seguenti argomenti:
+ [Usare FreerTOS nel proprio progetto CMake per 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)