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 - DevKit C e al ESP-WROVER-KIT **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 disponi già di 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/) Segui questo tutorial per iniziare a usare Espressif ESP32 - DevKit C dotato dei moduli -WROOM-32, -SOLO-1 o ESP-WROVER e il. ESP32 ESP32 ESP-WROVER-KIT-VB Per acquistarne uno dal nostro partner sul catalogo Partner Device, utilizza i seguenti link: AWS + [ESP32-WROOM-32 C DevKit](https://devices.amazonaws.com/detail/a3G0L00000AANtjUAH/ESP32-DevKitC) + [ESP32-SOLO-1](https://devices.amazonaws.com/detail/a3G0h0000076lSMEAY) + [ ESP32-KIT WROVER](https://devices.amazonaws.com/detail/a3G0L00000AANtlUAH/ESP-WROVER-KIT) Queste versioni di schede di sviluppo sono supportate su FreerTOS. Per ulteriori informazioni sulle ultime versioni di queste schede, vedere [ ESP32- DevKit C V4 o [ ESP-WROVER-KITv4.1](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/modules-and-boards.html#esp-wrover-kit-v4-1)](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/modules-and-boards.html#esp32-devkitc-v4) sul sito Web di Espressif. **Nota** Attualmente, la porta FreerTOS ESP32 per -WROVER-KIT ed DevKit ESP C non supporta la funzionalità Symmetric multiprocessing (SMP). ## Panoramica di Questo tutorial descrive le seguenti procedure: 1. Connessione della scheda a un computer host. 1. Installazione di software sul computer host per lo sviluppo e il debug di applicazioni integrate per la scheda a microcontroller. 1. Compilazione incrociata di un'applicazione demo FreerTOS con un'immagine binaria. 1. Caricamento dell'immagine binaria dell'applicazione sulla scheda in uso e successiva esecuzione dell'applicazione. 1. Interazione con l'applicazione in esecuzione sulla scheda attraverso una connessione seriale, per scopi di monitoraggio e debug. ## 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 - DevKit C, vedere la [ ESP32- Guida introduttiva di DevKit C V4](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/esp32/get-started-devkitc.html). + Per informazioni sulla configurazione dell'hardware della scheda di ESP-WROVER-KIT sviluppo, vedere la [Guida introduttiva alla ESP-WROVER-KIT V4.1](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/esp32/get-started-wrover-kit.html). **Importante** Quando **arrivi alla sezione Guida introduttiva** delle guide di 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 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» nella sezione **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 il dispositivo ESP32 - DevKit C, è necessario installare 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). Per stabilire una connessione seriale tra la macchina host e ESP32 -WROVER-KIT, è necessario installare il driver della porta COM virtuale FTDI. [È possibile scaricare questo driver da FTDI.](https://www.ftdichip.com/Drivers/VCP.htm) 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 ``` 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 ``` pip install boto3 --user ``` **Nota** [Consulta la documentazione di Boto3 per i dettagli.](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) + 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 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. Esegui lo script di configurazione. 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 un oggetto, un certificato e una policy IoT. + Allega la policy IoT 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 in 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 iscriversi all'argomento MQTT con il client MQTT AWS IoT** 1. Passare 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 (`idf.py`) per creare il progetto e eseguire 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 ``` **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 della 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_wrover_kit -DCOMPILER=xtensa-esp32 build ``` L'output restituito dovrebbe essere simile al 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 allo `idf.py` script fornito dall'IDF SDK per creare ed eseguire il codice, puoi anche creare il progetto con. CMake Attualmente supporta Unix Makefiles o 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_wrover_kit -DCOMPILER=xtensa-esp32 -S . -B ./YOUR_BUILD_DIRECTORY -DAFR_ENABLE_ALL_MODULES=1 -DAFR_ENABLE_TESTS=0 ``` **Con Ninja** ``` cmake -DVENDOR=espressif -DBOARD=esp32_wrover_kit -DCOMPILER=xtensa-esp32 -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 ``` ## Esecuzione delle demo Bluetooth Low-Energy [Libreria Bluetooth Low Energy](freertos-ble-library.md)FreerTOS supporta la connettività. Per eseguire il progetto demo FreerTOS su Bluetooth Low Energy, è necessario eseguire l'applicazione demo FreerTOS Bluetooth Low Energy Mobile SDK su un dispositivo mobile iOS o Android. **Per configurare l'applicazione demo SDK mobile FreerTOS Bluetooth Low Energy** 1. Seguire le istruzioni in [Mobile SDKs per dispositivi Bluetooth FreerTOS](freertos-ble-mobile.md) per scaricare e installare l'SDK per la piattaforma mobile sul computer host. 1. Seguire le istruzioni in [Applicazione dimostrativa FreerTOS Bluetooth Low Energy Mobile SDK](ble-demo.md#ble-sdk-app) per configurare l'applicazione demo mobile sul dispositivo mobile. Per istruzioni su come eseguire la demo MQTT tramite Bluetooth Low Energy sulla scheda, vedere. [MQTT su Bluetooth Low Energy](ble-demo.md#ble-demo-mqtt) Per istruzioni su come eseguire la demo del provisioning Wi-Fi sulla scheda, vedere. [Provisioning Wi-Fi](ble-demo.md#ble-demo-wifi) ## Usare FreerTOS nel proprio progetto per CMake ESP32 Se vuoi utilizzare FreerTOS nel CMake tuo progetto, puoi configurarlo come sottodirectory e crearlo insieme alla tua applicazione. Per prima cosa, procurati una copia di FreerTOS da. [GitHub](https://github.com/aws/amazon-freertos) Puoi anche configurarlo come sottomodulo Git con il seguente comando in modo che sia più facile aggiornarlo in futuro. ``` git submodule add -b release https://github.com/aws/amazon-freertos.git freertos ``` Se viene rilasciata una versione successiva, puoi aggiornare la tua copia locale con questi comandi. ``` # Pull the latest changes from the remote tracking branch. git submodule update --remote -- freertos ``` ``` # Commit the submodule change because it is pointing to a different revision now. git add freertos ``` ``` git commit -m "Update FreeRTOS to a new release" ``` Se il progetto ha la seguente struttura di cartelle: ``` - freertos (the copy that you obtained from GitHub or the AWS IoT console) - src - main.c (your application code) - CMakeLists.txt ``` Quindi quello che segue è un esempio del `CMakeLists.txt` file di primo livello che può essere usato per creare la tua applicazione insieme a FreerTOS. ``` cmake_minimum_required(VERSION 3.13) project(freertos_examples) # Tell IDF build to link against this target. set(IDF_EXECUTABLE_SRCS "/src/main.c") set(IDF_PROJECT_EXECUTABLE my_app) # Add FreeRTOS as a subdirectory. AFR_BOARD tells which board to target. set(AFR_BOARD espressif.esp32_devkitc CACHE INTERNAL "") add_subdirectory(freertos) # Link against the mqtt library so that we can use it. Dependencies are transitively # linked. target_link_libraries(my_app PRIVATE AFR::core_mqtt) ``` Per creare il progetto, esegui i seguenti comandi. CMake Assicurati che il ESP32 compilatore sia nella variabile di ambiente PATH. ``` cmake -S . -B build-directory -DCMAKE_TOOLCHAIN_FILE=freertos/tools/cmake/toolchains/xtensa-esp32.cmake -GNinja ``` ``` cmake --build build-directory ``` Per eseguire il flashing dell'applicazione sulla scheda, esegui il comando seguente. ``` cmake --build build-directory --target flash ``` ### Utilizzo di componenti di FreerTOS Dopo l'esecuzione CMake, puoi trovare tutti i componenti disponibili nell'output di riepilogo. Dovrebbe assomigliare all'esempio seguente. ``` ====================Configuration for FreeRTOS==================== Version: 202107.00 Git version: 202107.00-g79ad6defb Target microcontroller: vendor: Espressif board: ESP32-DevKitC description: Development board produced by Espressif that comes in two variants either with ESP-WROOM-32 or ESP32-WROVER module family: ESP32 data ram size: 520KB program memory size: 4MB Host platform: OS: Linux-4.15.0-66-generic Toolchain: xtensa-esp32 Toolchain path: /opt/xtensa-esp32-elf CMake generator: Ninja FreeRTOS modules: Modules to build: backoff_algorithm, common, common_io, core_http, core_http_demo_dependencies, core_json, core_mqtt, core_mqtt_agent, core_mqtt_agent_demo_dependencies, core_mqtt_demo_dependencies, crypto, defender, dev_mode_key_ provisioning, device_defender, device_defender_demo_ dependencies, device_shadow, device_shadow_demo_dependencies, freertos_cli_plus_uart, freertos_plus_cli, greengrass, http_demo_helpers, https, jobs, jobs_demo_dependencies, kernel, logging, mqtt, mqtt_agent_interface, mqtt_demo_ helpers, mqtt_subscription_manager, ota, ota_demo_ dependencies, ota_demo_version, pkcs11, pkcs11_helpers, pkcs11_implementation, pkcs11_utils, platform, secure_sockets, serializer, shadow, tls, transport_interface_secure_sockets, wifi Enabled by user: common_io, core_http_demo_dependencies, core_json, core_mqtt_agent_demo_dependencies, core_mqtt_demo_ dependencies, defender, device_defender, device_defender_demo_ dependencies, device_shadow, device_shadow_demo_dependencies, freertos_cli_plus_uart, freertos_plus_cli, greengrass, https, jobs, jobs_demo_dependencies, logging, ota_demo_dependencies, pkcs11, pkcs11_helpers, pkcs11_implementation, pkcs11_utils, platform, secure_sockets, shadow, wifi Enabled by dependency: backoff_algorithm, common, core_http, core_mqtt, core_mqtt_agent, crypto, demo_base, dev_mode_key_provisioning, freertos, http_demo_helpers, kernel, mqtt, mqtt_agent_ interface, mqtt_demo_helpers, mqtt_subscription_manager, ota, ota_demo_version, pkcs11_mbedtls, serializer, tls, transport_interface_secure_sockets, utils 3rdparty dependencies: jsmn, mbedtls, pkcs11, tinycbor Available demos: demo_cli_uart, demo_core_http, demo_core_mqtt, demo_core_mqtt_ agent, demo_device_defender, demo_device_shadow, demo_greengrass_connectivity, demo_jobs, demo_ota_core_http, demo_ota_core_mqtt, demo_tcp Available tests: ========================================================================= ``` È possibile fare riferimento a qualsiasi componente dall'`Modules to build`elenco. Per collegarli all'applicazione, inserite lo spazio dei `AFR::` nomi davanti al nome, ad esempio `AFR::core_mqtt``AFR::ota`, e così via. ### Aggiungi componenti personalizzati utilizzando ESP-IDF È possibile aggiungere altri componenti durante l'utilizzo di ESP-IDF. Ad esempio, supponendo che tu voglia aggiungere un componente denominato `example_component` e il tuo progetto sia simile a questo: ``` - freertos - components - example_component - include - example_component.h - src - example_component.c - CMakeLists.txt - src - main.c - CMakeLists.txt ``` Di seguito è riportato un esempio del `CMakeLists.txt` file per il componente. ``` add_library(example_component src/example_component.c) target_include_directories(example_component PUBLIC include) ``` Quindi, nel `CMakeLists.txt` file di primo livello, aggiungete il componente inserendo la riga seguente subito dopo`add_subdirectory(freertos)`. ``` add_subdirectory(component/example_component) ``` Quindi, modificate `target_link_libraries` per includere il componente. ``` target_link_libraries(my_app PRIVATE AFR::core_mqtt PRIVATE example_component) ``` Questo componente è ora automaticamente collegato al codice dell'applicazione per impostazione predefinita. Ora puoi includere i suoi file di intestazione e richiamare le funzioni che definisce. ### Sovrascrivi le configurazioni per FreerTOS Al momento non esiste un approccio ben definito per ridefinire le configurazioni al di fuori dell'albero dei sorgenti di FreerTOS. Per impostazione predefinita, CMake cercherà le directory and. `freertos/vendors/espressif/boards/esp32/aws_demos/config_files/` `freertos/demos/include/` Tuttavia, è possibile utilizzare una soluzione alternativa per indicare al compilatore di cercare prima altre directory. Ad esempio, puoi aggiungere un'altra cartella per le configurazioni di FreerTOS. ``` - freertos - freertos-configs - aws_clientcredential.h - aws_clientcredential_keys.h - iot_mqtt_agent_config.h - iot_config.h - components - src - CMakeLists.txt ``` I file in `freertos-configs` vengono copiati dalle directory `freertos/vendors/espressif/boards/esp32/aws_demos/config_files/` e `freertos/demos/include/`. Quindi, nel `CMakeLists.txt` file di primo livello, aggiungi prima questa riga `add_subdirectory(freertos)` in modo che il compilatore cerchi prima questa directory. ``` include_directories(BEFORE freertos-configs) ``` ### Fornire il file sdkconfig per ESP-IDF Nel caso in cui desideri fornire la tua`sdkconfig.default`, puoi impostare la CMake variabile `IDF_SDKCONFIG_DEFAULTS` dalla riga di comando: ``` cmake -S . -B build-directory -DIDF_SDKCONFIG_DEFAULTS=path_to_your_sdkconfig_defaults -DCMAKE_TOOLCHAIN_FILE=freertos/tools/cmake/toolchains/xtensa-esp32.cmake -GNinja ``` Se non specifichi una posizione per il tuo `sdkconfig.default` file, FreerTOS utilizza il file predefinito che si trova in. `freertos/vendors/espressif/boards/esp32/aws_demos/sdkconfig.defaults` Per maggiori informazioni, consulta la sezione [Configurazione del progetto](https://docs.espressif.com/projects/esp-idf/en/v4.2-beta1/esp32s2/api-reference/kconfig.html) nell'Espressif *API Reference* e, se riscontri problemi dopo la compilazione con successo, consulta la sezione sulle opzioni [obsolete e le loro sostituzioni](https://docs.espressif.com/projects/esp-idf/en/v4.2-beta1/esp32s2/api-reference/kconfig.html#deprecated-options-and-their-replacements) in quella pagina. ### Riepilogo Se hai un progetto con un componente denominato `example_component`, e vuoi sovrascrivere alcune configurazioni, ecco un esempio completo del file `CMakeLists.txt` di livello superiore. ``` cmake_minimum_required(VERSION 3.13) project(freertos_examples) set(IDF_PROJECT_EXECUTABLE my_app) set(IDF_EXECUTABLE_SRCS "src/main.c") # Tell IDF build to link against this target. set(IDF_PROJECT_EXECUTABLE my_app) # Add some extra components. IDF_EXTRA_COMPONENT_DIRS is a variable used by ESP-IDF # to collect extra components. get_filename_component( EXTRA_COMPONENT_DIRS "components/example_component" ABSOLUTE ) list(APPEND IDF_EXTRA_COMPONENT_DIRS ${EXTRA_COMPONENT_DIRS}) # Override the configurations for FreeRTOS. include_directories(BEFORE freertos-configs) # Add FreeRTOS as a subdirectory. AFR_BOARD tells which board to target. set(AFR_BOARD espressif.esp32_devkitc CACHE INTERNAL "") add_subdirectory(freertos) # Link against the mqtt library so that we can use it. Dependencies are transitively # linked. target_link_libraries(my_app PRIVATE AFR::core_mqtt) ``` ## Risoluzione dei problemi + Se utilizzi macOS e il sistema operativo non riconosce il tuo ESP-WROVER-KIT, assicurati di non avere i driver D2XX installati. Per disinstallarli, segui le istruzioni contenute in [FTDI Drivers Installation Guide for macOS X](http://www.ftdichip.com/Support/Documents/AppNotes/AN_134_FTDI_Drivers_Installation_Guide_for_MAC_OSX.pdf) (Guida per l'installazione dei driver FTDI per macOS X). + L'utilità di monitoraggio fornita da ESP-IDF (e richiamata utilizzando make monitor) ti aiuta a decodificare gli indirizzi. Per questo motivo, può aiutarti a ottenere alcuni backtrace significativi nel caso in cui l'applicazione smetta di funzionare. Per ulteriori informazioni, consulta [Automatic Address Decoding](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/api-guides/tools/idf-monitor.html#automatic-address-decoding) sul sito web di Espressif. + È anche possibile abilitare GDBstub la comunicazione con gdb senza richiedere alcun hardware JTAG speciale. Per maggiori informazioni, consulta [Launching GDB with GDBStub](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/api-guides/tools/idf-monitor.html#launching-gdb-with-gdbstub) sul sito web di Espressif. + [Per informazioni sulla configurazione di un ambiente basato su OpenOCD se è necessario il debug basato su hardware JTAG, vedere JTAG Debugging sul sito Web di Espressif.](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/jtag-debugging/index.html) + Se non `pyserial` può essere `pip` installato utilizzando macOS, scaricalo dal sito Web [pyserial](https://pypi.org/simple/pyserial). + Se la scheda si resetta continuamente, prova a cancellare il flash inserendo il seguente comando sul terminale. ``` make erase_flash ``` + Se riscontri errori quando esegui `idf_monitor.py`, utilizza Python 2.7. + Le librerie richieste da ESP-IDF sono incluse in FreerTOS, quindi non è necessario scaricarle esternamente. Se la variabile di `IDF_PATH` ambiente è impostata, ti consigliamo di cancellarla prima di creare FreerTOS. + In Windows, la creazione del progetto può richiedere 3-4 minuti. Per ridurre il tempo di compilazione, puoi usare l'`-j4`interruttore sul comando make. ``` make flash monitor -j4 ``` + Se il dispositivo ha problemi di connessione AWS IoT, apri il `aws_clientcredential.h` file e verifica che le variabili di configurazione siano definite correttamente nel file. `clientcredentialMQTT_BROKER_ENDPOINT[]`dovrebbe assomigliare a`1234567890123-ats.iot.us-east-1.amazonaws.com`. + Se stai seguendo la procedura descritta in [Usare FreerTOS nel proprio progetto per CMake ESP32](#getting_started_espressif_cmake_project) e visualizzi errori di riferimento non definiti dal linker, in genere è dovuto alla mancanza di librerie dipendenti o demo. Per aggiungerli, aggiorna il `CMakeLists.txt` file (nella directory principale) usando la CMake funzione standard`target_link_libraries`. + ESP-IDF v4.2 supporta l'uso di *xtensa\$1 -esp32\$1 -elf\$1 -gcc 8\$1 .2\$1 .0\$1*. catena di strumenti. Se utilizzi una versione precedente della toolchain Xtensa, scarica la versione richiesta. + Se vedi un registro degli errori come il seguente sulle dipendenze di Python che non vengono soddisfatte per ESP-IDF v4.2: ``` The following Python requirements are not satisfied: click>=5.0 pyserial>=3.0 future>=0.15.2 pyparsing>=2.0.3,<2.4.0 pyelftools>=0.22 gdbgui==0.13.2.0 pygdbmi<=0.9.0.2 reedsolo>=1.5.3,<=1.5.4 bitstring>=3.1.6 ecdsa>=0.16.0 Please follow the instructions found in the "Set up the tools" section of ESP-IDF Getting Started Guide ``` Installa le dipendenze python sulla tua piattaforma usando il seguente comando Python: ``` root/vendors/espressif/esp-idf/requirements.txt ``` Per ulteriori informazioni sulla risoluzione dei problemi, vedere. [Nozioni di base sulla risoluzione dei problemi](gsg-troubleshooting.md) ## Debug ### Codice di debug su Espressif ESP32 - DevKit C e (ESP-IDF v4.2) ESP-WROVER-KIT Questa sezione mostra come eseguire il debug dell'hardware Espressif utilizzando ESP-IDF v4.2. È necessario un cavo da JTAG a USB. [Utilizziamo un cavo da USB a MPSSE (ad esempio, FTDI C232HM-DDHSL-0).](http://www.ftdichip.com/Products/Cables/USBMPSSE.htm) **DevKitConfigurazione ESP-C JTAG** Per il cavo FTDI C232HM-DDHSL-0, queste sono le connessioni al devKitC. ESP32 ``` | C232HM-DDHSL-0 Wire Color | ESP32 GPIO Pin | JTAG Signal Name | | ------------------------- | -------------- | ---------------- | | Brown (pin 5) | IO14 | TMS | | Yellow (pin 3) | IO12 | TDI | | Black (pin 10) | GND | GND | | Orange (pin 2) | IO13 | TCK | | Green (pin 4) | IO15 | TDO | ``` **ESP-WROVER-KIT Configurazione JTAG** Per il cavo FTDI C232HM-DDHSL-0, queste sono le connessioni al -WROVER-KIT. ESP32 ``` | C232HM-DDHSL-0 Wire Color | ESP32 GPIO Pin | JTAG Signal Name | | ------------------------- | -------------- | ---------------- | | Brown (pin 5) | IO14 | TMS | | Yellow (pin 3) | IO12 | TDI | | Orange (pin 2) | IO13 | TCK | | Green (pin 4) | IO15 | TDO | ``` Queste tabelle sono state sviluppate dalla [ scheda tecnica FTDI C232HM-DDHSL-0](https://www.ftdichip.com/Support/Documents/DataSheets/Cables/DS_C232HM_MPSSE_CABLE.pdf). Per ulteriori informazioni, vedere la sezione «Connessione via cavo MPSSE C232HM e dettagli meccanici» nella scheda tecnica. Per abilitare JTAG su ESP-WROVER-KIT, posizionate i ponticelli sui pin TMS, TDO, TDI, TCK e S\$1TDI come mostrato qui. ![\[Posizionamento dei ponticelli\]](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/JP8-jumpers.png) **Debug su Windows (ESP-IDF v4.2)** **Per configurare il debug su Windows** 1. Collegare il lato USB di FTDI C232HM-DDHSL-0 sul tuo computer e sull'altro lato come descritto in [Codice di debug su Espressif ESP32 - DevKit C e (ESP-IDF v4.2) ESP-WROVER-KIT](#debugging-espressif-idf42). Il dispositivo FTDI C232HM-DDHSL-0 deve essere visualizzato in **Device Manager (Gestione dispositivi)** in **Universal Serial Bus Controllers (Controller bus seriale universale)**. 1. **Nell'elenco dei dispositivi Universal Serial Bus, fate clic con il pulsante destro del mouse sul dispositivo **C232HM-DDHSL-0**, quindi scegliete Proprietà.** **Nota** Il dispositivo potrebbe essere elencato come **USB Serial Port (Porta seriale USB)**. **Per visualizzare le proprietà del dispositivo, nella finestra delle proprietà, scegli la scheda Dettagli.** Se il dispositivo non è nell'elenco, installa il [driver Windows per FTDI C232HM-DDHSL-0](http://www.ftdichip.com/Drivers/D2XX.htm). 1. ****Nella **scheda Dettagli**, scegliete Proprietà, quindi scegliete Hardware. IDs**** Dovresti vedere qualcosa di simile nel campo **Valore**. ``` FTDIBUS\COMPORT&VID_0403&PID_6014 ``` In questo esempio, l'ID fornitore è 0403 e l'ID prodotto è 6014. Verifica che IDs corrispondano al IDs pin`projects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg`. IDs Sono specificati in una riga che inizia con `ftdi_vid_pid` seguita da un ID fornitore e da un ID prodotto. ``` ftdi_vid_pid 0x0403 0x6014 ``` 1. Scaricare [OpenOCD per Windows](https://github.com/espressif/openocd-esp32/releases). 1. Decomprimere il file su `C:\` e aggiungere `C:\openocd-esp32\bin` al percorso di sistema. 1. OpenOCD richiede libusb, che non è installato per impostazione predefinita in Windows. Per installare libusb: 1. Scaricare [zadig.exe](https://zadig.akeo.ie). 1. Esegui `zadig.exe`. Nel menu, **Options (Opzioni)** scegliere **List All Devices (Elenca tutti i dispositivi)**. 1. **Dal menu a tendina, scegliete C232HM-DDHSL-0.** 1. Nel campo driver di destinazione, a destra della freccia verde, selezionare **WinUSB (WinUSB)**. 1. **Per l'elenco sotto il campo del driver di destinazione, scegli la freccia, quindi scegli Installa driver.** Scegliere **Replace Driver (Sostituisci driver)**. 1. Apri un prompt dei comandi, vai alla radice della directory di download di FreerTOS ed esegui il seguente comando. ``` idf.py openocd ``` Lasciare questo prompt dei comandi aperto. 1. Apri un nuovo prompt dei comandi, vai alla radice della directory di download di FreerTOS ed esegui ``` idf.py flash monitor ``` 1. Apri un altro prompt dei comandi, vai alla directory principale della cartella di download di FreerTOS e attendi che la demo inizi a funzionare sulla tua scheda. Quando lo fa, esegui ``` idf.py gdb ``` Il programma deve arrestarsi nella funzione `main`. **Nota** ESP32 Supporta un massimo di due punti di interruzione. **Debug su macOS (ESP-IDF v4.2)** 1. Scaricare il [driver FTDI per macOS](http://www.ftdichip.com/Drivers/VCP.htm). 1. Scaricare [OpenOCD](https://github.com/espressif/openocd-esp32/releases). 1. Estrarre il file .tar scaricato e impostare il percorso in `.bash_profile` su `OCD_INSTALL_DIR/openocd-esp32/bin`. 1. Usa il seguente comando per l'installazione `libusb` su macOS. ``` brew install libusb ``` 1. Usa il seguente comando per scaricare il driver della porta seriale. ``` sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver ``` 1. Usa il seguente comando per scaricare il driver della porta seriale. ``` sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver ``` 1. Se utilizzi una versione macOS successiva alla 10.9, usa il seguente comando per scaricare il driver FTDI Apple. ``` sudo kextunload -b com.apple.driver.AppleUSBFTDI ``` 1. Utilizzare il comando seguente per ottenere l'ID prodotto e l'ID fornitore del cavo FTDI. Elenca i dispositivi USB collegati. ``` system_profiler SPUSBDataType ``` L'output di `system_profiler` dovrebbe essere simile al seguente. ``` DEVICE: Product ID: product-ID Vendor ID: vendor-ID (Future Technology Devices International Limited) ``` 1. Apri il file `projects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg`. L'ID fornitore e l'ID prodotto sono specificati in una riga che inizia con `ftdi_vid_pid`. Modifica il valore IDs in modo che IDs corrisponda a quello dell'`system_profiler`output del passaggio precedente. 1. Apri una finestra di terminale, vai alla radice della tua directory di download di FreerTOS e usa il seguente comando per eseguire OpenOCD. ``` idf.py openocd ``` Lascia aperta questa finestra del terminale. 1. Apri un nuovo terminale e usa il seguente comando per caricare il driver della porta seriale FTDI. ``` sudo kextload -b com.FTDI.driver.FTDIUSBSerialDriver ``` 1. Vai alla radice della tua directory di download di FreerTOS ed esegui ``` idf.py flash monitor ``` 1. Apri un altro nuovo terminale, vai alla radice della cartella di download di FreerTOS ed esegui ``` idf.py gdb ``` Il programma deve interrompersi su `main`. **Debug su Linux (ESP-IDF v4.2)** 1. Scaricare [OpenOCD](https://github.com/espressif/openocd-esp32/releases). Estrarre il tarball e seguire le istruzioni per l'installazione del file readme. 1. Usa il seguente comando per installare libusb su Linux. ``` sudo apt-get install libusb-1.0 ``` 1. Aprire un terminale e immettere **ls -l /dev/ttyUSB\$1** per elencare tutti i dispositivi USB collegati al computer. Questo ti aiuta a verificare se le porte USB della scheda sono riconosciute dal sistema operativo. L'output restituito dovrebbe essere simile al seguente. ``` $ls -l /dev/ttyUSB* crw-rw---- 1 root dialout 188, 0 Jul 10 19:04 /dev/ttyUSB0 crw-rw---- 1 root dialout 188, 1 Jul 10 19:04 /dev/ttyUSB1 ``` 1. Uscire ed effettuare di nuovo l'accesso e spegnere e accendere la scheda per rendere le modifiche effettive. In un prompt del terminale, elencare i dispositivi USB. Assicurati che il proprietario del gruppo sia passato da `dialout` a`plugdev`. ``` $ls -l /dev/ttyUSB* crw-rw---- 1 root plugdev 188, 0 Jul 10 19:04 /dev/ttyUSB0 crw-rw---- 1 root plugdev 188, 1 Jul 10 19:04 /dev/ttyUSB1 ``` L'interfaccia `/dev/ttyUSBn` con il numero inferiore viene utilizzato per le comunicazioni JTAG. L'altra interfaccia viene indirizzata alla ESP32 porta seriale (UART) e viene utilizzata per caricare il codice nella memoria flash ESP32 del computer. 1. In una finestra di terminale, vai alla radice della tua directory di download di FreerTOS e usa il seguente comando per eseguire OpenOCD. ``` idf.py openocd ``` 1. Apri un altro terminale, vai alla radice della tua directory di download di FreerTOS ed esegui il seguente comando. ``` idf.py flash monitor ``` 1. Apri un altro terminale, naviga nella directory principale della cartella di download di FreerTOS ed esegui il seguente comando: ``` idf.py gdb ``` Il programma deve interrompersi su `main()`.