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 -S2 ESP32
**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/)
[Questo tutorial mostra come iniziare con le schede di sviluppo Espressif -S2 SoC e -S2-Saola-1. ESP32 ESP32](https://devices.amazonaws.com/detail/a3G0h00000AkFngEAF/ESP32-S2-Saola-1)
## 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. Monitoraggio ed esecuzione del 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
### Iscriviti 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 -S2, consulta la Guida introduttiva di -S2-Saola-1. ESP32](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32s2/hw-reference/esp32s2/user-guide-saola-1-v1.2.html)
**Importante**
Quando arrivi alla sezione **Get Started** delle guide Espressif, fermati e poi torna alle istruzioni in questa pagina.
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 nella [configurazione standard dei prerequisiti della Toolchain (ESP-IDF v4.2](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32s2/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/esp32s2/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 il dispositivo ESP32 - DevKit C, 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`.)
1. Se utilizzi macOS o Linux, apri un prompt del terminale. Se utilizzi Windows, apri l'app «ESP-IDF 4.x CMD» (se hai incluso questa opzione quando hai installato la toolchain ESP-IDF), altrimenti l'app «Command Prompt».
1. Per verificare che Python3 sia installato, esegui quanto segue:
```
python --version
```
Viene visualizzata la versione installata. [Se non avete installato Python 3.0.1 o versioni successive, potete installarlo dal sito Web di Python.](https://www.python.org/downloads/)
1. È necessaria l'interfaccia CLI ( AWS Command Line Interface) per eseguire AWS IoT i comandi. Se utilizzi Windows, usa il `easy_install awscli` comando per installare la AWS CLI nell'app «Command» o «ESP-IDF 4.x CMD».
Se utilizzi macOS o Linux, consulta [Installazione della CLI AWS](https://docs.aws.amazon.com/cli/latest/userguide/installing.html).
1. Esecuzione
```
aws configure
```
e configura la AWS CLI con l'ID della chiave di AWS accesso, la chiave di accesso segreta e la regione predefinita AWS . Per ulteriori informazioni, consulta [Configurazione di AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).
1. Usa il seguente comando per installare l' AWS SDK per Python (boto3):
+ Su Windows, nell'app «Command» o «ESP-IDF 4.x CMD», esegui
```
easy_install boto3
```
+ Su macOS o Linux, esegui
```
pip install tornado nose --user
```
e poi esegui
```
pip install boto3 --user
```
FreerTOS include lo script per semplificare `SetupAWS.py` la configurazione della scheda Espressif a cui connettersi. AWS IoT
**Per eseguire lo script di configurazione**
1. Per configurare lo script, apri `freertos/tools/aws_config_quick_start/configure.json` e imposta i seguenti attributi:
**`afr_source_dir`**
Il percorso completo della directory `freertos` sul computer. Assicurarsi di utilizzare le barre per specificare questo percorso.
**`thing_name`**
Il nome che vuoi assegnare all'oggetto che rappresenta la AWS IoT tua scheda.
**`wifi_ssid`**
Il SSID della rete Wi-Fi.
**`wifi_password`**
La password della rete Wi-Fi.
**`wifi_security`**
Il tipo di sicurezza della rete Wi-Fi. I seguenti sono tipi di sicurezza validi:
+ `eWiFiSecurityOpen` (Aperto, nessuna protezione)
+ `eWiFiSecurityWEP` (Sicurezza WEP)
+ `eWiFiSecurityWPA` (Sicurezza WPA)
+ `eWiFiSecurityWPA2`(WPA2 sicurezza)
1. Se utilizzi macOS o Linux, apri un prompt del terminale. Se utilizzi Windows, apri l'app «ESP-IDF 4.x CMD» o «Command».
1. Vai alla directory ed esegui `freertos/tools/aws_config_quick_start`
```
python SetupAWS.py setup
```
Lo script svolge le seguenti funzioni:
+ Crea qualsiasi AWS IoT cosa, certificato e criterio.
+ Allega la AWS IoT policy al certificato e il certificato all' AWS IoT oggetto.
+ Compila il `aws_clientcredential.h` file con l' AWS IoT endpoint, l'SSID Wi-Fi e le credenziali.
+ Formatta il certificato e la chiave privata e li scrive nel file di intestazione. `aws_clientcredential_keys.h`
**Nota**
Il certificato è codificato solo a scopo dimostrativo. Le applicazioni a livello di produzione devono archiviare questi file in un percorso sicuro.
Per ulteriori informazioni in merito`SetupAWS.py`, vedere `README.md` nella directory. `freertos/tools/aws_config_quick_start`
### 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. In **Argomento sottoscrizione**, digitare `your-thing-name/example/topic`, quindi scegliere **Effettua sottoscrizione all'argomento**.
Quando il progetto demo viene eseguito correttamente sul dispositivo, viene visualizzato «Hello World\$1» inviato più volte all'argomento a cui ti sei iscritto.
### Compila, esegui il flashing ed esegui il progetto demo FreerTOS utilizzando lo script idf.py
Puoi usare l'utilità IDF di Espressif per generare i file di build, creare il binario dell'applicazione e aggiornare la tua scheda.
#### Crea ed esegui il flashing di FreerTOS su Windows, Linux e macOS (ESP-IDF v4.2)
Usa `idf.py` lo script per creare il progetto ed esegui il flashing dei file binari sul tuo dispositivo.
**Nota**
Alcune configurazioni potrebbero richiedere l'utilizzo dell'opzione port `-p port-name` with `idf.py` per specificare la porta corretta, come nell'esempio seguente.
```
idf.py -p /dev/cu.usbserial-00101301B flash
```
**Per creare e aggiornare il progetto**
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=esp32s2_saola_1 -DCOMPILER=xtensa-esp32s2 build
```
Dovresti vedere un output come questo nell'esempio seguente.
```
Executing action: all (aliases: build)
Running cmake in directory /path/to/hello_world/build
Executing "cmake -G Ninja -DPYTHON_DEPS_CHECKED=1 -DESP_PLATFORM=1 -DVENDOR=espressif -DBOARD=esp32s2_saola_1 -DCOMPILER=xtensa-esp32s2 -DCCACHE_ENABLE=0 /path/to/hello_world"...
-- The C compiler identification is GNU 8.4.0
-- The CXX compiler identification is GNU 8.4.0
-- The ASM compiler identification is GNU
... (more lines of build system output)
[1628/1628] Generating binary image from built executable
esptool.py v3.0
Generated /path/to/hello_world/build/aws_demos.bin
Project build complete. To flash, run this command:
esptool.py -p (PORT) -b 460800 --before default_reset --after hard_reset --chip esp32s2 write_flash --flash_mode dio --flash_size detect --flash_freq 80m 0x1000 build/bootloader/bootloader.bin 0x8000 build/partition_table/partition-table.bin 0x16000 build/ota_data_initial.bin 0x20000 build/aws_demos.bin
or run 'idf.py -p (PORT) flash'
```
Se non ci sono errori, la build genera 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=esp32s2_saola_1 -DCOMPILER=xtensa-esp32s2 -S . -B ./YOUR_BUILD_DIRECTORY -DAFR_ENABLE_ALL_MODULES=1 -DAFR_ENABLE_TESTS=0
```
+ Con Ninja
```
cmake -DVENDOR=espressif -DBOARD=esp32s2_saola_1 -DCOMPILER=xtensa-esp32s2 -S . -B ./YOUR_BUILD_DIRECTORY -DAFR_ENABLE_ALL_MODULES=1 -DAFR_ENABLE_TESTS=0 -GNinja
```
1. Compilare il progetto.
+ Con Unix Makefiles
```
make -C ./YOUR_BUILD_DIRECTORY -j8
```
+ Con Ninja
```
ninja -C ./YOUR_BUILD_DIRECTORY -j8
```
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)