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-S2 **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/) Questo tutorial mostra come iniziare con il SoC e le schede di sviluppo Espressif. ESP32-S2 [ESP32-S2-Saola-1](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. Cross-compile 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 ### 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-S2 sviluppo, consulta la [ ESP32-S2-Saola-1 Guida introduttiva](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 Guida introduttiva** 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 [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 con i 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/esp32s2/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/esp32s2/get-started/linux-setup.html)) per Linux. **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 ``` 1. **Stabilisci una connessione seriale.** 1. Per stabilire una connessione seriale tra la macchina host e il ESP32-DevKitC, 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`.) 1. Se utilizzi macOS o Linux, apri un prompt del terminale. Se usi Windows, apri l'app "ESP-IDF 4.x CMD» (se hai incluso questa opzione quando hai installato la ESP-IDF toolchain), 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`** L'SSID della tua rete. Wi-Fi **`wifi_password`** La password per la tua rete. Wi-Fi **`wifi_security`** Il tipo di sicurezza per la tua Wi-Fi rete. Di seguito sono riportati i tipi di sicurezza validi: + `eWiFiSecurityOpen` (Aperto, nessuna protezione) + `eWiFiSecurityWEP` (Sicurezza WEP) + `eWiFiSecurityWPA` (Sicurezza WPA) + `eWiFiSecurityWPA2` (Sicurezza WPA2) 1. Se utilizzi macOS o Linux, apri un prompt del terminale. Se usi Windows, apri l'app "ESP-IDF 4.x CMD» o «Command». 1. Vai alla `{{freertos}}/tools/aws_config_quick_start` directory ed esegui ``` 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' Wi-Fi SSID 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. Production-level le applicazioni devono archiviare questi file in un luogo sicuro. Per ulteriori informazioni in merito`SetupAWS.py`, vedere `README.md` nella `{{freertos}}/tools/aws_config_quick_start` directory. ### 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 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. 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\!» 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 e esegui il flashing di FreerTOS su Windows, Linux e macOS (v4.2) ESP-IDF 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 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=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 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=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 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)