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
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:
-
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 RTOS demo gratuita 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 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
Apri la https://portal.aws.amazon.com/billing/registrazione.
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/
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
-
Accedi AWS Management Console
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 Signing in as the root user della Guida per l'utente di Accedi ad AWS .
-
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
-
Abilita IAM Identity Center.
Per istruzioni, consulta Abilitazione di AWS IAM Identity Center nella Guida per l'utente di AWS IAM Identity Center .
-
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
-
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 .
-
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:
-
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 IAM tramite un provider di identità:
Crea un ruolo per la federazione delle identità. Segui le istruzioni riportate in Creare un ruolo per un provider di identità di terze parti (federazione) nella Guida per l'IAMutente.
-
IAMutenti:
-
Crea un ruolo che l'utente possa assumere. Segui le istruzioni riportate in Creare un ruolo per un IAM utente nella Guida per l'IAMutente.
-
(Non consigliato) Collega una policy direttamente a un utente o aggiungi un utente a un gruppo di utenti. Segui le istruzioni riportate in Aggiungere autorizzazioni a un utente (console) nella Guida per l'IAMutente.
-
Inizia a usare
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 sviluppo ESP32 - DevKit C, vedere la ESP32- Guida introduttiva di DevKit C V4
. -
Per informazioni sulla configurazione dell'hardware della scheda di ESP-WROVER-KIT sviluppo, vedere la Guida introduttiva alla ESP-WROVER-KIT V4.1
.
Importante
Quando arrivi alla sezione Guida introduttiva delle guide di Espressif, fermati e poi torna alle istruzioni in questa pagina.
-
-
Scarica Amazon Free RTOS da GitHub
. (Per istruzioni, consulta il READMEfile.md ). -
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
-
Scarica ESP IDF l'Universal Online Installer per Windows
. -
Esegui l'Universal Online Installer.
-
Quando arrivi alla fase Scarica o usa ESP - IDF, seleziona Usa una IDF cartella esistente ESP - e imposta Scegli esistente ESP - IDF directory su
.freertos
/vendors/espressif/esp-idf -
Completa l'installazione.
macOS
-
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.
-
Aprire una finestra a riga di comando.
-
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
-
Aggiungi gli strumenti della IDF toolchain ESP - al percorso del tuo terminale con il seguente comando.
source vendors/espressif/esp-idf/export.sh
Linux
-
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.
-
Aprire una finestra a riga di comando.
-
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
-
Aggiungi gli strumenti della IDF toolchain ESP - al percorso del tuo terminale con il seguente comando.
source vendors/espressif/esp-idf/export.sh
-
-
Stabilisci una connessione seriale.
-
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
. -
Segui i passaggi per stabilire una connessione seriale con ESP32
. -
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 in
. (Ad esempio, se freertos
/vendors/espressif/boards/board-name
/aws_demos/config_files/FreeRTOSConfig.hAFR_BOARD espressif.esp32_devkitc
viene scelto, il file di configurazione si trova in
.) freertos
/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.xCMD" (se hai incluso questa opzione quando hai installato la IDF toolchain ESP -), 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 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
-
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.
-
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
e imposta i seguenti attributi:freertos
/tools/aws_config_quick_start/configure.jsonafr_source_dir
-
Il percorso completo della directory
sul computer. Assicurarsi di utilizzare le barre per specificare questo percorso.freertos
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)
-
-
-
Esegui lo script di configurazione.
-
Se utilizzi macOS o Linux, apri un prompt del terminale. Se usi Windows, apri l'app "ESP- IDF 4.xCMD" o «Command».
-
Vai alla
directory ed eseguifreertos
/tools/aws_config_quick_startpython 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 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
, vedereREADME.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
-
Passare alla console AWS IoT
. -
Nel riquadro di navigazione, scegli Test, quindi scegli MQTTTest Client.
-
In Argomento sottoscrizione, digitare
, quindi scegliere Effettua sottoscrizione all'argomento.your-thing-name
/example/topic
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)
-
Vai alla radice della tua directory di RTOS download gratuiti.
-
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
-
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
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
-
In una finestra a riga di comando, vai alla radice della cartella dei RTOS download gratuiti.
-
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
-
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
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
-
Segui le istruzioni riportate SDK mobili per dispositivi Bluetooth FreerTOS per scaricarla e installarla SDK per la tua piattaforma mobile sul tuo 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, 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
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 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 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/
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
/demos/include/
- 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
e freertos
/vendors/espressif/boards/esp32/aws_demos/config_files/
. Quindi, nel freertos
/demos/include/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 in
.freertos
/vendors/espressif/boards/esp32/aws_demos/sdkconfig.defaults
Per ulteriori informazioni, consultate la sezione Configurazione del progetto
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. -
Se non
pyserial
può esserepip
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'
-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 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.
- Debug su Windows (- v4.2) ESP IDF
-
Per configurare il debug su Windows
-
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.
-
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 -
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 pin
projects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg
. IDsSono specificati in una riga che inizia conftdi_vid_pid
seguita da un ID fornitore e da un ID prodotto.ftdi_vid_pid 0x0403 0x6014
-
Scarica Open OCD per Windows
. -
Decomprimere il file su
C:\
e aggiungereC:\openocd-esp32\bin
al percorso di sistema. -
Open OCD richiede libusb, che non è installato di default su Windows. Per installare libusb:
-
Scaricare zadig.exe
. -
Esegui
zadig.exe
. Nel menu, Options (Opzioni) scegliere List All Devices (Elenca tutti i dispositivi). -
Dal menu a tendina, scegliete C232HM - -0. DDHSL
-
Nel campo del pilota bersaglio, a destra della freccia verde, scegli Vinci. USB
-
Per l'elenco sotto il campo del driver di destinazione, scegli la freccia, quindi scegli Installa driver. Scegliere Replace Driver (Sostituisci driver).
-
-
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.
-
Apri un nuovo prompt dei comandi, vai alla radice della tua directory di RTOS download gratuito ed esegui
idf.py flash monitor
-
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
-
-
Scarica il FTDIdriver per macOS
. -
Scarica Open OCD
. -
Estrarre il file .tar scaricato e impostare il percorso in
.bash_profile
suOCD_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 di macOS successiva alla 10.9, usa il seguente comando per scaricare il driver Apple. FTDI
sudo kextunload -b com.apple.driver.AppleUSBFTDI
-
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)
-
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 conftdi_vid_pid
. Modifica il valore IDs in modo che IDs corrisponda a quello dell'system_profiler
output del passaggio precedente. -
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.
-
Apri un nuovo terminale e usa il seguente comando per caricare il driver della porta FTDI seriale.
sudo kextload -b com.FTDI.driver.FTDIUSBSerialDriver
-
Vai alla radice della tua directory di RTOS download gratuita ed esegui
idf.py flash monitor
-
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
-
-
Scarica Open. OCD
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
-
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
-
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/ttyUSBn
interfaccia 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. -
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
-
Apri un altro terminale, vai alla radice della tua directory di RTOS download gratuita ed esegui il seguente comando.
idf.py flash monitor
-
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()
.
-