Guida introduttiva all'Espressif ESP32 - DevKit C e al ESP-WROVER-KIT - Gratuito RTOS

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 RTOS repository Amazon-Free che è obsoleto. Ti consigliamo di iniziare da qui quando crei un nuovo progetto. Se hai già un RTOS progetto Free esistente basato sull'ormai obsoleto repository Amazon-FreeRTOS, consulta il. Guida alla migrazione del RTOS repository Github gratuito da Amazon

Segui questo tutorial per iniziare a usare i moduli Espressif ESP32 - DevKit C dotati di - WROOM -32, - -1 o ESP32 - e il. ESP32 SOLO ESP WROVER ESP-WROVER-KIT-VB Per acquistarne uno dal nostro partner sul catalogo AWS Partner Device, utilizza i seguenti link:

Queste versioni delle 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 sul sito Web di Espressif.

Nota

Attualmente, la RTOS porta gratuita per ESP32 - WROVER - KIT e ESP DevKit C non supporta la funzionalità Symmetric multiprocessing (). SMP

Panoramica

Questo tutorial descrive le seguenti procedure:

  1. Connessione della scheda a un computer host.

  2. Installazione di software sul computer host per lo sviluppo e il debug di applicazioni integrate per la scheda a microcontroller.

  3. Compilazione incrociata di un'applicazione RTOS demo gratuita con un'immagine binaria.

  4. Caricamento dell'immagine binaria dell'applicazione sulla scheda in uso e successiva esecuzione dell'applicazione.

  5. Interazione con l'applicazione in esecuzione sulla scheda attraverso una connessione seriale, per scopi di monitoraggio e debug.

Prerequisiti

Prima di iniziare a usare Free RTOS sulla tua bacheca Espressif, devi configurare il tuo AWS account e le autorizzazioni.

Registrati per un Account AWS

Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno.

Per iscriverti a un Account AWS
  1. Apri la https://portal.aws.amazon.com/billing/registrazione.

  2. Segui le istruzioni online.

    Nel corso della procedura di registrazione riceverai una telefonata, durante la quale sarà necessario inserire un codice di verifica attraverso la tastiera del telefono.

    Quando ti iscrivi a un Account AWS, Utente root dell'account AWSviene 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.

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/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 AWS Management Consolecome 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 Signing in as the root user della Guida per l'utente di Accedi ad AWS .

  2. Attiva l'autenticazione a più fattori (MFA) per il tuo utente root.

    Per istruzioni, consulta Abilitare un MFA dispositivo virtuale per l'utente Account AWS root (console) nella Guida per l'IAMutente.

Crea un utente con accesso amministrativo
  1. Abilita IAM Identity Center.

    Per istruzioni, consulta Abilitazione di AWS IAM Identity Center nella Guida per l'utente di AWS IAM Identity Center .

  2. In IAM Identity Center, concedi 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 i valori predefiniti IAM Identity Center directory nella Guida per l'AWS IAM Identity Center utente.

Accesso come utente amministratore
  • Per accedere con l'utente dell'IAMIdentity Center, utilizza l'accesso URL che è stato inviato al tuo indirizzo e-mail quando hai creato l'utente IAM Identity Center.

    Per informazioni sull'accesso tramite un utente di IAM Identity Center, consulta Accesso al portale di AWS accesso nella Guida per l'Accedi ad AWS utente.

Assegna l'accesso a ulteriori utenti
  1. In IAM Identity Center, crea un set di autorizzazioni che segua la migliore pratica di applicazione delle autorizzazioni con privilegi minimi.

    Segui le istruzioni riportate nella pagina Creazione di un set di autorizzazioni nella Guida per l'utente di AWS IAM Identity Center .

  2. Assegna al gruppo prima gli utenti e poi l'accesso con autenticazione unica (Single Sign-On).

    Per istruzioni, consulta Aggiungere gruppi nella Guida per l'utente di AWS IAM Identity Center .

Per fornire l'accesso, aggiungi autorizzazioni ai tuoi utenti, gruppi o ruoli:

Inizia a usare

Nota

I comandi Linux in questo tutorial richiedono l'uso della shell Bash.

  1. Configura l'hardware Espressif.

    Importante

    Quando arrivi alla sezione Guida introduttiva delle guide di Espressif, fermati e poi torna alle istruzioni in questa pagina.

  2. Scarica Amazon Free RTOS da GitHub. (Per istruzioni, consulta il READMEfile.md).

  3. Configura il tuo ambiente di sviluppo.

    Per comunicare con la scheda, è necessario installare una toolchain. Espressif fornisce la ESP possibilità di sviluppare software IDF per le proprie schede. Poiché ESP - IDF ha una propria versione del RTOS kernel gratuito integrata come componente, Amazon Free RTOS include una versione personalizzata di ESP - IDF v4.2 con il RTOS kernel gratuito 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 ESP IDF l'Universal Online Installer per Windows.

    2. Esegui l'Universal Online Installer.

    3. Quando arrivi alla fase Scarica o usa ESP - IDF, seleziona Usa una IDF cartella esistente ESP - e imposta Scegli esistente ESP - IDF directory sufreertos/vendors/espressif/esp-idf.

    4. Completa l'installazione.

    macOS

    1. Segui le istruzioni nella configurazione standard dei prerequisiti della Toolchain (ESP- IDF v4.2) per macOS.

      Importante

      Quando raggiungi le istruzioni «Ottieni ESP -IDF» in Passaggi successivi, interrompi e poi torna alle istruzioni in questa pagina.

    2. Aprire una finestra a riga di comando.

    3. Vai alla directory dei RTOS download gratuiti, quindi esegui lo script seguente per scaricare e installare la toolchain espressif per la tua piattaforma.

      vendors/espressif/esp-idf/install.sh
    4. Aggiungi gli strumenti della IDF toolchain ESP - al percorso del tuo terminale con il seguente comando.

      source vendors/espressif/esp-idf/export.sh

    Linux

    1. Segui le istruzioni riportate nella Configurazione standard dei prerequisiti della Toolchain (ESP- IDF v4.2) per Linux.

      Importante

      Quando raggiungi le istruzioni «Ottieni ESP -IDF» riportate nella sezione Passaggi successivi, interrompi e torna alle istruzioni riportate in questa pagina.

    2. Aprire una finestra a riga di comando.

    3. Vai alla directory dei RTOS download gratuiti, quindi esegui lo script seguente per scaricare e installare la toolchain Espressif per la tua piattaforma.

      vendors/espressif/esp-idf/install.sh
    4. Aggiungi gli strumenti della IDF toolchain ESP - al percorso del tuo terminale con il seguente comando.

      source vendors/espressif/esp-idf/export.sh
  4. Stabilisci una connessione seriale.

    1. Per stabilire una connessione seriale tra la macchina host e ESP32 - DevKit C, è necessario installare i VCP driver CP21 0x USB to UART Bridge. È possibile scaricare i driver da Silicon Labs.

      Per stabilire una connessione seriale tra la macchina host e il ESP32 - WROVER -KIT, è necessario installare il driver della COM porta FTDI virtuale. È possibile scaricare questo driver da FTDI.

    2. Segui i passaggi per stabilire una connessione seriale con ESP32.

    3. 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 RTOS demo gratuite

Per questo tutorial, il file RTOS di configurazione gratuito si trova infreertos/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 infreertos/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.xCMD" (se hai incluso questa opzione quando hai installato la IDF toolchain ESP -), altrimenti l'app «Command Prompt».

  2. 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.

  3. È necessaria l'interfaccia a riga di AWS comando (CLI) per eseguire i comandi. AWS IoT Se usi Windows, usa il easy_install awscli comando per installarlo AWS CLI nell'app «Comando» o "ESP- IDF 4.xCMD».

    Se utilizzi macOS o Linux, consulta Installazione di. AWS CLI

  4. Esecuzione

    aws configure

    e configurali AWS CLI con l'ID della chiave di AWS accesso, la chiave di accesso segreta e la AWS regione predefinita. Per ulteriori informazioni, vedere Configurazione di AWS CLI.

  5. Usa il seguente comando per installare AWS SDK for Python (boto3):

    • Su Windows, nell'app «Comando» o "ESP- IDF 4.xCMD", esegui

      pip install boto3 --user
      Nota

      Consulta la documentazione di Boto3 per i dettagli.

    • Su macOS o Linux, esegui

      pip install tornado nose --user

      e poi esegui

      pip install boto3 --user

    Free RTOS include lo SetupAWS.py script per semplificare 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' AWS IoT oggetto che rappresenta la tua scheda.

    wifi_ssid

    La SSID tua 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(WEPsicurezza)

    • eWiFiSecurityWPA(WPAsicurezza)

    • eWiFiSecurityWPA2(WPA2sicurezza)

  6. Esegui lo script di configurazione.

    1. Se utilizzi macOS o Linux, apri un prompt del terminale. Se usi Windows, apri l'app "ESP- IDF 4.xCMD" o «Command».

    2. Vai alla freertos/tools/aws_config_quick_start directory ed esegui

      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, la rete Wi-Fi SSID e le credenziali.

      • Formatta il certificato e la chiave privata e li scrive nel file di intestazioneaws_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 meritoSetupAWS.py, vedere README.md nella directory. freertos/tools/aws_config_quick_start

Monitoraggio MQTT dei messaggi sul cloud

Prima di eseguire il progetto RTOS demo gratuito, puoi configurare il MQTT client nella AWS IoT console per monitorare i messaggi che il tuo dispositivo invia al AWS Cloud.

Per iscriverti all'MQTTargomento con il AWS IoT MQTT cliente
  1. Passare alla console AWS IoT.

  2. Nel riquadro di navigazione, scegli Test, quindi scegli MQTTTest Client.

  3. In Argomento sottoscrizione, digitare your-thing-name/example/topic, quindi scegliere Effettua sottoscrizione all'argomento.

Quando il progetto demo viene eseguito correttamente sul tuo dispositivo, viene visualizzato «Hello World!» inviato più volte all'argomento a cui ti sei iscritto.

Crea, esegui il flashing ed esegui il progetto RTOS demo gratuito utilizzando lo script idf.py

Puoi usare l'IDFutilità di Espressif (idf.py) per creare il progetto ed 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 flash gratuitamente RTOS su Windows, Linux e macOS (ESP- IDF v4.2)
  1. Vai alla radice della tua directory di RTOS download gratuiti.

  2. In una finestra a riga di comando, inserisci il seguente comando per aggiungere gli IDF strumenti ESP - al tuo terminalePATH.

    Windows (app «Comando»)
    vendors\espressif\esp-idf\export.bat
    Windows (app» ESP - IDF CMD 4x")

    (Questa operazione è già stata eseguita quando hai aperto l'app).

    Linux /macOS
    source vendors/espressif/esp-idf/export.sh
  3. 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.

  4. Cancellate la memoria flash della scheda di sviluppo con il seguente comando.

    idf.py erase_flash
  5. Usa idf.py lo script per eseguire il flashing del file binario dell'applicazione sulla tua scheda.

    idf.py flash
  6. 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

Build and Flash Free con RTOS CMake

Oltre allo idf.py script fornito da IDF SDK per creare ed eseguire il codice, puoi anche creare il progetto conCMake. 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 cartella dei RTOS download gratuiti.

  2. Esegui lo script seguente per aggiungere gli IDF strumenti ESP - alla shellPATH.

    Windows
    vendors\espressif\esp-idf\export.bat
    Linux /macOS
    source vendors/espressif/esp-idf/export.sh
  3. 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
  4. Compilare il progetto.

    Con Unix Makefiles
    make -C ./YOUR_BUILD_DIRECTORY -j8
    Con Ninja
    ninja -C ./YOUR_BUILD_DIRECTORY -j8
  5. 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

Free RTOS supporta la Libreria Bluetooth Low Energy connettività.

Per eseguire il progetto RTOS demo gratuito su Bluetooth Low Energy, è necessario eseguire l'applicazione SDK demo mobile RTOS Bluetooth Low Energy gratuita su un dispositivo mobile iOS o Android.

Per configurare l'applicazione SDK demo mobile Free RTOS Bluetooth Low Energy
  1. Segui le istruzioni riportate SDK mobili per dispositivi Bluetooth FreerTOS per scaricarla e installarla SDK per la tua piattaforma mobile sul tuo computer host.

  2. Seguire le istruzioni in Applicazione dimostrativa FreerTOS Bluetooth Low Energy Mobile SDK per configurare l'applicazione demo mobile sul dispositivo mobile.

Per istruzioni su come eseguire la demo MQTT tramite Bluetooth Low Energy sulla scheda, vediMQTT su Bluetooth Low Energy.

Per istruzioni su come eseguire la demo del provisioning Wi-Fi sulla scheda, consultaProvisioning Wi-Fi.

Usa Free RTOS nel tuo CMake progetto per ESP32

Se vuoi utilizzare Free RTOS nel tuo CMake progetto, puoi configurarlo come sottodirectory e crearlo insieme alla tua applicazione. Per prima cosa, richiedi una copia di Free RTOS from GitHub. 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

Di seguito è riportato un esempio del CMakeLists.txt file di primo livello che può essere utilizzato per creare l'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 "<complete_path>/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 CMake comandi. Assicurati che il ESP32 compilatore sia nella variabile di PATH ambiente.

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 dei componenti di Free RTOS

Dopo l'esecuzioneCMake, 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 buildelenco. Per collegarli all'applicazione, inserite lo spazio dei AFR:: nomi davanti al nome, ad esempio AFR::core_mqttAFR::ota, e così via.

Aggiungi componenti personalizzati usando - ESP IDF

Puoi aggiungere altri componenti mentre usi 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 dopoadd_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 gratuitamente RTOS

Al momento non esiste un approccio ben definito per ridefinire le configurazioni al di fuori dell'albero dei sorgenti gratuiti. RTOS 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 RTOS configurazioni gratuite.

- 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 proprio sdkconfig per - ESP IDF

Nel caso in cui desideri fornire la tuasdkconfig.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, Free RTOS utilizza il file predefinito che si trova infreertos/vendors/espressif/boards/esp32/aws_demos/sdkconfig.defaults.

Per ulteriori informazioni, consultate la sezione Configurazione del progetto in Espressif APIReference e, se riscontrate problemi dopo la compilazione con successo, consultate la sezione sulle opzioni obsolete e le loro sostituzioni 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 nella Guida all'installazione FTDI dei driver per macOS X.

  • L'utilità monitor 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 sul sito web di Espressif.

  • È anche possibile abilitare la comunicazione con gdb senza GDBstub richiedere hardware speciale. JTAG Per maggiori informazioni, consulta Launching GDB with GDBStub sul sito web di Espressif.

  • Per informazioni sulla configurazione di un ambiente open OCD based se è richiesto il debug basato su JTAG hardware, consulta Debugging on the Espressif Web. JTAG

  • Se non pyserial può essere pip installato utilizzando macOS, scaricalo dal sito Web 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 Free. RTOS

  • In Windows, la creazione del progetto può richiedere 3-4 minuti. Per ridurre il tempo di compilazione, puoi usare l'-j4interruttore 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 a1234567890123-ats.iot.us-east-1.amazonaws.com.

  • Se stai seguendo la procedura descritta in Usa Free RTOS nel tuo CMake progetto per ESP32 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 standardtarget_link_libraries.

  • ESP- la IDF v4.2 supporta l'uso di xtensa\ -esp32\ -elf\ -gcc 8\ .2\ .0\. toolchain. 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 - v4.2: ESP IDF

    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

Debug

Codice di debug su Espressif ESP32 - C e (- DevKit v4.2) ESP-WROVER-KIT ESP IDF

Questa sezione mostra come eseguire il debug dell'hardware Espressif utilizzando - v4.2. ESP IDF È necessario un cavo To. JTAG USB Utilizziamo un MPSSE cavo USB a (ad esempio, il FTDIC232HM- DDHSL -0).

ESP- Configurazione C DevKit 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 JTAGconfigurazione

Per il cavo FTDI C232HM- DDHSL -0, questi sono i collegamenti al - -. ESP32 WROVER KIT

| 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 a partire dalla scheda tecnica FTDIC232HM - -0. DDHSL Per ulteriori informazioni, vedere la sezione «Collegamento MPSSE via cavo C232HM e dettagli meccanici» nella scheda tecnica.

Per attivarla JTAG ESP-WROVER-KIT, posizionate i ponticelli sui pinTMS,, TDO TDITCK, e S_ TDI come mostrato qui.

Posizionamento dei ponticelli
Debug su Windows (- v4.2) ESP IDF
Per configurare il debug su Windows
  1. Connect il USB lato del FTDI C232HM- DDHSL -0 al computer e l'altro lato come descritto in. Codice di debug su Espressif ESP32 - C e (- DevKit v4.2) ESP-WROVER-KIT ESP IDF Il dispositivo FTDI C232HM- DDHSL -0 dovrebbe apparire in Gestione dispositivi sotto Universal Serial Bus Controller.

  2. 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 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 - -0. DDHSL

  3. Nella scheda Dettagli, scegli Proprietà, quindi scegli 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 pinprojects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg. IDsSono 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
  4. Scarica Open OCD per Windows.

  5. Decomprimere il file su C:\ e aggiungere C:\openocd-esp32\bin al percorso di sistema.

  6. Open OCD richiede libusb, che non è installato di default su Windows. Per installare libusb:

    1. Scaricare zadig.exe.

    2. Esegui zadig.exe. Nel menu, Options (Opzioni) scegliere List All Devices (Elenca tutti i dispositivi).

    3. Dal menu a tendina, scegliete C232HM - -0. DDHSL

    4. Nel campo del pilota bersaglio, a destra della freccia verde, scegli Vinci. USB

    5. Per l'elenco sotto il campo del driver di destinazione, scegli la freccia, quindi scegli Installa driver. Scegliere Replace Driver (Sostituisci driver).

  7. Apri il prompt dei comandi, vai alla radice della directory di RTOS download gratuito ed esegui il comando seguente.

    idf.py openocd

    Lasciare questo prompt dei comandi aperto.

  8. Apri un nuovo prompt dei comandi, vai alla radice della tua directory di RTOS download gratuito ed esegui

    idf.py flash monitor
  9. Apri un altro prompt dei comandi, vai alla radice della cartella dei RTOS download gratuiti e attendi che la demo inizi a funzionare sulla tua scheda. Quando lo fa, corri

    idf.py gdb

    Il programma deve arrestarsi nella funzione main.

    Nota

    ESP32Supporta un massimo di due punti di interruzione.

Debug su macOS (- v4.2) ESP IDF
  1. Scarica il FTDIdriver per macOS.

  2. Scarica Open OCD.

  3. Estrarre il file .tar scaricato e impostare il percorso in .bash_profile su OCD_INSTALL_DIR/openocd-esp32/bin.

  4. Usa il seguente comando per l'installazione libusb su macOS.

    brew install libusb
  5. Usa il seguente comando per scaricare il driver della porta seriale.

    sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
  6. Usa il seguente comando per scaricare il driver della porta seriale.

    sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
  7. Se utilizzi una versione di macOS successiva alla 10.9, usa il seguente comando per scaricare il driver Apple. FTDI

    sudo kextunload -b com.apple.driver.AppleUSBFTDI
  8. Usa il comando seguente per ottenere l'ID del prodotto e l'ID del fornitore del cavo. FTDI Elenca i USB dispositivi 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)
  9. 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_profileroutput del passaggio precedente.

  10. Apri una finestra di terminale, vai alla radice della tua directory di RTOS download gratuito e usa il seguente comando per eseguire OpenOCD.

    idf.py openocd

    Lascia aperta questa finestra del terminale.

  11. Apri un nuovo terminale e usa il seguente comando per caricare il driver della porta FTDI seriale.

    sudo kextload -b com.FTDI.driver.FTDIUSBSerialDriver
  12. Vai alla radice della tua directory di RTOS download gratuita ed esegui

    idf.py flash monitor
  13. Apri un altro nuovo terminale, vai alla radice della tua directory di RTOS download gratuita ed esegui

    idf.py gdb

    Il programma deve interrompersi su main.

Debug su Linux (- v4.2) ESP IDF
  1. Scarica Open. OCD Estrarre il tarball e seguire le istruzioni per l'installazione del file readme.

  2. Usa il seguente comando per installare libusb su Linux.

    sudo apt-get install libusb-1.0
  3. Apri un terminale ed entra ls -l /dev/ttyUSB* per elencare tutti i USB dispositivi collegati al tuo computer. Questo ti aiuta a verificare se le USB porte 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
  4. Uscire ed effettuare di nuovo l'accesso e spegnere e accendere la scheda per rendere le modifiche effettive. In un prompt del terminale, elenca i USB dispositivi. Assicurati che il proprietario del gruppo sia cambiato da dialout aplugdev.

    $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'/dev/ttyUSBninterfaccia con il numero inferiore viene utilizzata per la JTAG comunicazione. L'altra interfaccia viene indirizzata alla ESP32 porta seriale (UART) e viene utilizzata per caricare il codice nella memoria flash ESP32 del computer.

  5. In una finestra di terminale, vai alla radice della tua directory di RTOS download gratuito e usa il seguente comando per eseguire Open. OCD

    idf.py openocd
  6. Apri un altro terminale, vai alla radice della tua directory di RTOS download gratuita ed esegui il seguente comando.

    idf.py flash monitor
  7. Apri un altro terminale, naviga nella directory principale della cartella dei RTOS download gratuiti ed esegui il seguente comando:

    idf.py gdb

    Il programma deve interrompersi su main().