Panoramica di Prerequisiti Nozioni di base Esecuzione delle demo Bluetooth Low-Energy Usare FreerTOS nel proprio progetto CMake per ESP32 Risoluzione dei problemi Debug

Guida introduttiva all'Espressif ESP32-DevKitC e al ESP-WROVER-KIT

Importante

Questa integrazione di riferimento è ospitata nel Amazon-FreeRTOS repository che è obsoleto. Ti consigliamo di iniziare da qui 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

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

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

Queste versioni di schede di sviluppo sono supportate su FreerTOS.

Per ulteriori informazioni sulle ultime versioni di queste schede, consulta la versione ESP32-DevKitC V4 o la versione ESP-WROVER-KIT 4.1 sul sito Web di Espressif.

Nota

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

Panoramica di

Questo tutorial descrive le seguenti procedure:

Connessione della scheda a un computer host.
Installazione di software sul computer host per lo sviluppo e il debug di applicazioni integrate per la scheda a microcontroller.
Compilazione incrociata di un'applicazione demo FreerTOS con un'immagine binaria.
Caricamento dell'immagine binaria dell'applicazione sulla scheda in uso e successiva esecuzione dell'applicazione.
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

Per iniziare AWS, hai bisogno di un Account AWS. Per informazioni sulla creazione di un Account AWS, vedi Guida introduttiva a un Account AWS 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 (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) 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 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) nella Guida per l’utente IAM.

Nozioni di base

Nota

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

Configura l'hardware Espressif.
- Per informazioni sulla configurazione dell'hardware della scheda di ESP32-DevKitC sviluppo, consulta la Guida introduttiva alla ESP32-DevKitC V4.
- Per informazioni sulla configurazione dell'hardware della scheda di ESP-WROVER-KIT sviluppo, consulta la Guida ESP-WROVER-KIT V4.1 introduttiva.
Importante
Quando arrivi alla sezione Guida introduttiva delle guide Espressif, fermati e poi torna alle istruzioni in questa pagina.
Scarica Amazon GitHubFreerTOS da. (Per istruzioni, consulta il README.mdfile.)
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 per Windows.
2. Esegui l'Universal Online Installer.
3. 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
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 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
```
4. 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) per Linux.
  
  Importante
  Quando raggiungi le istruzioni «Ottieni ESP-IDF» riportate nella sezione Passaggi successivi, interrompi l'operazione e torna alle istruzioni riportate in questa pagina.
2. Aprire una finestra a riga di comando.
3. 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
```
4. Aggiungi gli ESP-IDF strumenti della toolchain al percorso del tuo terminale con il seguente comando.
```
source vendors/espressif/esp-idf/export.sh
```
Stabilisci una connessione seriale.
1. Per stabilire una connessione seriale tra il computer host e il ESP32-DevKitC, è necessario installare i driver CP210x USB to UART Bridge VCP. È possibile scaricare i driver da Silicon Labs.
  
  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.
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. Ne hai bisogno 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 infreertos/vendors/espressif/boards/esp32/aws_demos/config_files/FreeRTOSConfig.h.)

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».
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.
È 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.
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.
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.
- 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

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)
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.x CMD» 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, 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 meritoSetupAWS.py, vedere README.md nella freertos/tools/aws_config_quick_start directory.

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 iscriverti all'argomento MQTT con AWS IoT Client MQTT

Passare alla console AWS IoT.
Nel riquadro di navigazione, scegliete Test, quindi scegliete MQTT Test Client.
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 (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 e esegui il flashing di FreerTOS su Windows, Linux e macOS (v4.2) ESP-IDF

Vai alla directory principale della tua cartella di download di FreerTOS.
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
```

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.

Cancellate la memoria flash della scheda di sviluppo con il seguente comando.
```
idf.py erase_flash
```
Usa idf.py lo script per eseguire il flashing del file binario dell'applicazione sulla tua scheda.
```
idf.py flash
```
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

In una finestra a riga di comando, vai alla radice della tua directory di download di FreerTOS.
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
```

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

Compilare il progetto.

Con Unix Makefiles


make -C ./YOUR_BUILD_DIRECTORY -j8

Con Ninja


ninja -C ./YOUR_BUILD_DIRECTORY -j8

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 EnergyFreerTOS 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

Seguire le istruzioni in SDK mobili per dispositivi Bluetooth FreerTOS per scaricare e installare l'SDK per la piattaforma mobile sul computer host.
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, vedere. MQTT su Bluetooth Low Energy

Per istruzioni su come eseguire la demo di Wi-Fi provisioning sulla scheda, vedere. Wi-Fi approvvigionamento

Usare FreerTOS nel proprio progetto CMake per ESP32

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

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 "<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, eseguire i seguenti comandi CMake. Assicurarsi che il compilatore ESP32 si trovi 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 seguente comando.


cmake --build build-directory --target flash

Utilizzo di componenti di FreerTOS

Dopo aver eseguito CMake, è possibile 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 utilizzando ESP-IDF

È possibile aggiungere altri componenti durante l'utilizzo 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 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 freertos/vendors/espressif/boards/esp32/aws_demos/config_files/ e 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 proprio sdkconfig per ESP-IDF

Nel caso in cui desideri fornire il tuo file sdkconfig.default, puoi impostare la variabile CMake 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 nell'Espressif API Reference e, se riscontri problemi dopo la compilazione con successo, consulta 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 contenute in FTDI Drivers Installation Guide for macOS X (Guida per l'installazione dei driver FTDI 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 GDBStub per la comunicazione con gdb senza richiedere alcun hardware JTAG speciale. Per ulteriori informazioni, consulta Launching GDB with GDBStub sul sito web di Espressif.
Per informazioni sulla configurazione di un OpenOCD-based ambiente se è richiesto il debug basato su hardware JTAG, consulta JTAG Debugging sul sito Web di Espressif.
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 FreerTOS.
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 Usare FreerTOS nel proprio progetto CMake 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 file CMakeLists.txt (sotto la directory principale) usando la funzione CMake standard target_link_libraries.
ESP-IDF la 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 per la 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 ESP32-DevKitC Espressif e (v4.2) ESP-WROVER-KIT ESP-IDF

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

ESP-DevKitC Configurazione JTAG

Per il C232HM-DDHSL-0 cavo FTDI, 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 C232HM-DDHSL-0 cavo FTDI, queste sono le connessioni a. 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 FTDI C232HM-DDHSL-0 . 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_TDI come mostrato qui.

Debug su Windows (v4.2) ESP-IDF

Per configurare il debug su Windows

Connect il lato USB dell'FTDI C232HM-DDHSL-0 al computer e l'altro lato come descritto inCodice di debug su ESP32-DevKitC Espressif e (v4.2) ESP-WROVER-KIT ESP-IDF. Il C232HM-DDHSL-0 dispositivo FTDI dovrebbe apparire in Device Manager sotto Universal Serial Bus Controllers.
Nell'elenco dei dispositivi Universal Serial Bus, fate clic con il pulsante destro del mouse C232HM-DDHSL-0sul dispositivo, 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.
Nella scheda Details (Dettagli), selezionare Property (Proprietà), quindi Hardware IDs (ID hardware). 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.

Verificare che questi ID corrispondano a quelli presenti in projects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg. Gli ID 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
```
Scaricare OpenOCD per Windows.
Decomprimere il file su C:\ e aggiungere C:\openocd-esp32\bin al percorso di sistema.
OpenOCD richiede libusb, che non è installato per impostazione predefinita in 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, scegli. C232HM-DDHSL-0
4. Nel campo driver di destinazione, a destra della freccia verde, selezionare WinUSB (WinUSB).
5. Per l'elenco sotto il campo del driver di destinazione, scegli la freccia, quindi scegli Installa driver. Scegliere Replace Driver (Sostituisci driver).
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.
Apri un nuovo prompt dei comandi, vai alla radice della cartella di download di FreerTOS ed esegui
```
idf.py flash monitor
```
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 (v4.2) ESP-IDF

Scaricare il driver FTDI per macOS.
Scaricare OpenOCD.
Estrarre il file .tar scaricato e impostare il percorso in .bash_profile su OCD_INSTALL_DIR/openocd-esp32/bin.
Usa il seguente comando per l'installazione libusb su macOS.
```
brew install libusb
```
Usa il seguente comando per scaricare il driver della porta seriale.
```
sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
```
Usa il seguente comando per scaricare il driver della porta seriale.
```
sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
```
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
```
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) 
```
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 gli ID affinché corrispondano agli ID dall'output system_profiler della fase precedente.
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.
Apri un nuovo terminale e usa il seguente comando per caricare il driver della porta seriale FTDI.
```
sudo kextload -b com.FTDI.driver.FTDIUSBSerialDriver
```
Vai alla radice della tua directory di download di FreerTOS ed esegui
```
idf.py flash monitor
```
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 (v4.2) ESP-IDF

Scaricare OpenOCD. Estrarre il tarball e seguire le istruzioni per l'installazione del file readme.
Usa il seguente comando per installare libusb su Linux.
```
sudo apt-get install libusb-1.0
```
Aprire un terminale e immettere ls -l /dev/ttyUSB* 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 
```
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 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'interfaccia /dev/ttyUSBn con il numero inferiore viene utilizzato per le comunicazioni JTAG. L'altra interfaccia viene indirizzata alla porta seriale dell'ESP32 (UART) e viene utilizzata per caricare il codice nella memoria flash dell'ESP32.
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 
```
Apri un altro terminale, vai alla radice della directory di download di FreerTOS ed esegui il seguente comando.
```
idf.py flash monitor 
```
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().

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Elemento di sicurezza Microchip ATECC608A con simulatore Windows

Guida introduttiva all'Espressif ESP32-WROOM-32SE

Guida introduttiva all'Espressif ESP32-DevKitC e al ESP-WROVER-KIT

Importante

Nota

Nota

Panoramica di

Prerequisiti

Registrati per un Account AWS

Nozioni di base

Nota

Importante

Importante

Importante

Configura le applicazioni demo FreerTOS

Nota

Nota

Monitoraggio dei messaggi MQTT in cloud

Per iscriverti all'argomento MQTT con AWS IoT Client MQTT

Compila, esegui il flashing ed esegui il progetto demo FreerTOS utilizzando lo script idf.py

Nota

Crea e esegui il flashing di FreerTOS su Windows, Linux e macOS (v4.2) ESP-IDF

Nota

Crea ed esegui il flashing di FreerTOS con CMake

Per creare e aggiornare il progetto

Esecuzione delle demo Bluetooth Low-Energy

Per configurare l'applicazione demo SDK mobile FreerTOS Bluetooth Low Energy

Usare FreerTOS nel proprio progetto CMake per ESP32

Utilizzo di componenti di FreerTOS

Aggiungi componenti personalizzati utilizzando ESP-IDF

Sovrascrivi le configurazioni per FreerTOS

Fornire il proprio sdkconfig per ESP-IDF

Riepilogo

Risoluzione dei problemi

Debug

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

Per configurare il debug su Windows

Nota

Nota