Commencer à utiliser l'Espressif ESP32 - DevKit C et le ESP-WROVER-KIT - Gratuit RTOS

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Commencer à utiliser l'Espressif ESP32 - DevKit C et le ESP-WROVER-KIT

Important

Cette intégration de référence est hébergée sur le RTOS référentiel Amazon Free, qui est obsolète. Nous vous recommandons de commencer ici lorsque vous créez un nouveau projet. Si vous possédez déjà un RTOS projet gratuit basé sur le RTOS référentiel Amazon Free désormais obsolète, consultez le. Guide de migration du référentiel RTOS Github gratuit sur Amazon

Note

Pour découvrir comment intégrer des bibliothèques RTOS modulaires et des démos gratuites dans votre propre IDF projet Espressif, consultez notre intégration de référence pour ESP32 la plate-forme -C3.

Suivez ce didacticiel pour démarrer avec l'Espressif ESP32 - DevKit C équipé de WROVER modules ESP32 - WROOM -32, ESP32 - SOLO -1 ou ESP - et du. ESP-WROVER-KIT-VB Pour en acheter un auprès de notre partenaire sur le catalogue des appareils AWS partenaires, cliquez sur les liens suivants :

Ces versions des cartes de développement sont prises en charge sur FreeRTOS.

Pour plus d'informations sur les dernières versions de ces cartes, consultez ESP32- DevKit C V4 ou ESP-WROVER-KITv4.1 sur le site Web d'Espressif.

Note

Actuellement, le RTOS port libre pour ESP32 - WROVER - KIT et ESP DevKit C ne prend pas en charge la fonctionnalité de multitraitement symétrique (SMP).

Présentation

Ce didacticiel vous guide à travers les étapes suivantes :

  1. Connexion de votre carte à un appareil hôte.

  2. Installation de logiciels sur la machine hôte pour développer et déboguer des applications intégrées pour votre carte de microcontrôleur.

  3. Compilation croisée d'une application de RTOS démonstration gratuite en une image binaire.

  4. Chargement de l’image binaire de l’application dans votre carte et exécution de l’application.

  5. Interaction avec l’application s’exécutant sur votre carte via une connexion série, à des fins de surveillance et de débogage.

Prérequis

Avant de commencer à utiliser Free RTOS sur votre tableau Espressif, vous devez configurer votre AWS compte et vos autorisations.

Inscrivez-vous pour un Compte AWS

Si vous n'en avez pas Compte AWS, procédez comme suit pour en créer un.

Pour vous inscrire à un Compte AWS
  1. Ouvrez l'https://portal.aws.amazon.com/billing/inscription.

  2. Suivez les instructions en ligne.

    Dans le cadre de la procédure d‘inscription, vous recevrez un appel téléphonique et vous saisirez un code de vérification en utilisant le clavier numérique du téléphone.

    Lorsque vous vous inscrivez à un Compte AWS, un Utilisateur racine d'un compte AWSest créé. Par défaut, seul l‘utilisateur racine a accès à l‘ensemble des Services AWS et des ressources de ce compte. La meilleure pratique de sécurité consiste à attribuer un accès administratif à un utilisateur, et à utiliser uniquement l‘utilisateur racine pour effectuer les tâches nécessitant un accès utilisateur racine.

AWS vous envoie un e-mail de confirmation une fois le processus d'inscription terminé. À tout moment, vous pouvez consulter l'activité actuelle de votre compte et gérer votre compte en accédant à https://aws.amazon.com/et en choisissant Mon compte.

Création d'un utilisateur doté d'un accès administratif

Après vous être inscrit à un Compte AWS, sécurisez Utilisateur racine d'un compte AWS AWS IAM Identity Center, activez et créez un utilisateur administratif afin de ne pas utiliser l'utilisateur root pour les tâches quotidiennes.

Sécurisez votre Utilisateur racine d'un compte AWS
  1. Connectez-vous en AWS Management Consoletant que propriétaire du compte en choisissant Utilisateur root et en saisissant votre adresse Compte AWS e-mail. Sur la page suivante, saisissez votre mot de passe.

    Pour obtenir de l‘aide pour vous connecter en utilisant l‘utilisateur racine, consultez Connexion en tant qu‘utilisateur racine dans le Guide de l‘utilisateur Connexion à AWS .

  2. Activez l'authentification multifactorielle (MFA) pour votre utilisateur root.

    Pour obtenir des instructions, voir Activer un MFA périphérique virtuel pour votre utilisateur Compte AWS root (console) dans le guide de IAM l'utilisateur.

Création d'un utilisateur doté d'un accès administratif
  1. Activez IAM Identity Center.

    Pour obtenir des instructions, consultez Activation d’ AWS IAM Identity Center dans le Guide de l’utilisateur AWS IAM Identity Center .

  2. Dans IAM Identity Center, accordez un accès administratif à un utilisateur.

    Pour un didacticiel sur l'utilisation du Répertoire IAM Identity Center comme source d'identité, voir Configurer l'accès utilisateur par défaut Répertoire IAM Identity Center dans le Guide de AWS IAM Identity Center l'utilisateur.

Connexion en tant qu‘utilisateur doté d'un accès administratif
  • Pour vous connecter avec votre utilisateur IAM Identity Center, utilisez l'URLidentifiant envoyé à votre adresse e-mail lorsque vous avez créé l'utilisateur IAM Identity Center.

    Pour obtenir de l'aide pour vous connecter en utilisant un utilisateur d'IAMIdentity Center, consultez la section Connexion au portail AWS d'accès dans le guide de Connexion à AWS l'utilisateur.

Attribution d'un accès à d'autres utilisateurs
  1. Dans IAM Identity Center, créez un ensemble d'autorisations conforme à la meilleure pratique consistant à appliquer les autorisations du moindre privilège.

    Pour obtenir des instructions, consultez Création d’un ensemble d’autorisations dans le Guide de l’utilisateur AWS IAM Identity Center .

  2. Attribuez des utilisateurs à un groupe, puis attribuez un accès par authentification unique au groupe.

    Pour obtenir des instructions, consultez Ajout de groupes dans le Guide de l’utilisateur AWS IAM Identity Center .

Pour activer l’accès, ajoutez des autorisations à vos utilisateurs, groupes ou rôles :

Mise en route

Note

Les commandes Linux de ce didacticiel nécessitent que vous utilisiez le shell Bash.

  1. Configurez le matériel Espressif.

    Important

    Lorsque vous atteignez la section Get Started des guides Espressif, arrêtez-vous, puis revenez aux instructions de cette page.

  2. Téléchargez Amazon gratuitement RTOS sur GitHub. (Pour obtenir des instructions, consultez le fichier README.md.)

  3. Configurez votre environnement de développement.

    Pour communiquer avec votre tableau, vous devez installer une chaîne d'outils. Espressif fournit les outils nécessaires ESP IDF pour développer des logiciels pour leurs cartes. Étant donné que le ESP - IDF possède sa propre version du RTOS noyau libre intégrée en tant que composant, Amazon Free RTOS inclut une version personnalisée du ESP - IDF v4.2 qui supprime le RTOS noyau libre. Cela permet de résoudre les problèmes liés aux fichiers dupliqués lors de la compilation. Pour utiliser la version personnalisée de ESP - IDF v4.2 incluse dans Amazon FreeRTOS, suivez les instructions ci-dessous correspondant au système d'exploitation de votre machine hôte.

    Windows

    1. Téléchargez le ESP programme IDF d'installation en ligne universel pour Windows.

    2. Exécutez le programme d'installation en ligne universel.

    3. Lorsque vous arrivez à l'étape Télécharger ou utiliser ESP - IDF, sélectionnez Utiliser un IDF répertoire existant ESP et définissez Choisir un IDF répertoire existant ESP surfreertos/vendors/espressif/esp-idf.

    4. Terminez l'installation.

    macOS

    1. Suivez les instructions de la configuration standard des prérequis de la chaîne d'outils (ESP- IDF v4.2) pour macOS.

      Important

      Lorsque vous atteignez les instructions « Obtenir ESP - IDF » sous Prochaines étapes, arrêtez-vous, puis revenez aux instructions de cette page.

    2. Ouvrez une fenêtre de ligne de commande.

    3. Accédez au répertoire de RTOS téléchargement gratuit, puis exécutez le script suivant pour télécharger et installer la chaîne d'outils Espressif pour votre plateforme.

      vendors/espressif/esp-idf/install.sh
    4. Ajoutez les IDF outils ESP - toolchain au chemin de votre terminal à l'aide de la commande suivante.

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

    Linux

    1. Suivez les instructions de la configuration standard des prérequis de la chaîne d'outils (ESP- IDF v4.2) pour Linux.

      Important

      Lorsque vous atteignez les instructions « Obtenir ESP - IDF » sous Prochaines étapes, arrêtez-vous, puis revenez aux instructions de cette page.

    2. Ouvrez une fenêtre de ligne de commande.

    3. Accédez au répertoire de RTOS téléchargement gratuit, puis exécutez le script suivant pour télécharger et installer la chaîne d'outils Espressif pour votre plateforme.

      vendors/espressif/esp-idf/install.sh
    4. Ajoutez les IDF outils ESP - toolchain au chemin de votre terminal à l'aide de la commande suivante.

      source vendors/espressif/esp-idf/export.sh
  4. Établissez une connexion série.

    1. Pour établir une connexion série entre votre machine hôte et le ESP32 DevKit -C, vous devez installer les VCP pilotes CP21 0x USB to UART Bridge. Vous pouvez télécharger ces pilotes à partir de Silicon Labs.

      Pour établir une connexion série entre votre machine hôte et le ESP32 - WROVER -KIT, vous devez installer le pilote de COM port FTDI virtuel. Vous pouvez télécharger ce pilote sur FTDI.

    2. Suivez les étapes pour établir une connexion série avec ESP32.

    3. Une fois que vous avez établi une connexion série, notez le port série pour la connexion de votre carte. Vous en avez besoin pour flasher la démo.

Configuration des applications de RTOS démonstration gratuites

Pour ce didacticiel, le fichier RTOS de configuration gratuit se trouve à l'adressefreertos/vendors/espressif/boards/board-name/aws_demos/config_files/FreeRTOSConfig.h. (Par exemple, si cette option AFR_BOARD espressif.esp32_devkitc est sélectionnée, le fichier de configuration se trouve à l'adressefreertos/vendors/espressif/boards/esp32/aws_demos/config_files/FreeRTOSConfig.h.)

  1. Si vous utilisez macOS ou Linux, ouvrez une invite du terminal. Si vous utilisez Windows, ouvrez l'application « ESP - IDF 4.x CMD » (si vous avez inclus cette option lorsque vous avez installé la IDF chaîne d'outils ESP -), ou l'application « Command Prompt » dans le cas contraire.

  2. Pour vérifier que Python3 est installé, exécutez

    python --version

    La version installée s'affiche. Si Python 3.0.1 ou version ultérieure n'est pas installé, vous pouvez l'installer depuis le site Web de Python.

  3. Vous avez besoin de l'interface de ligne de AWS commande (CLI) pour exécuter AWS IoT des commandes. Si vous utilisez Windows, utilisez la easy_install awscli commande pour l'installer AWS CLI dans l'application « Command » ou « ESP - IDF 4.x CMD ».

    Si vous utilisez macOS ou Linux, consultez la section Installation du AWS CLI.

  4. Exécuter

    aws configure

    et configurez le AWS CLI avec votre identifiant de clé d' AWS accès, votre clé d'accès secrète et votre AWS région par défaut. Pour plus d'informations, consultez la section Configuration du AWS CLI.

  5. Utilisez la commande suivante pour installer le AWS SDK pour Python (boto3) :

    • Sous Windows, dans l'application « Command » ou « ESP - IDF 4.x CMD », exécutez

      pip install boto3 --user
      Note

      Consultez la documentation de Boto3 pour plus de détails.

    • Sur macOS ou Linux, exécutez

      pip install tornado nose --user

      puis exécutez

      pip install boto3 --user

    Free RTOS inclut le SetupAWS.py script pour faciliter la configuration de votre carte Espressif à laquelle vous connecter. AWS IoT Pour configurer le script, ouvrez freertos/tools/aws_config_quick_start/configure.json et définissez les attributs suivants :

    afr_source_dir

    Chemin d’accès complet vers l'annuaire freertos sur votre ordinateur. Assurez-vous d'utiliser des barres obliques pour spécifier ce chemin.

    thing_name

    Le nom que vous souhaitez attribuer à l' AWS IoT élément qui représente votre tableau.

    wifi_ssid

    Le SSID de votre réseau Wi-Fi.

    wifi_password

    Mot de passe de votre réseau Wi-Fi.

    wifi_security

    Type de sécurité de votre réseau Wi-Fi.

    Les types de sécurité suivants sont valides :

    • eWiFiSecurityOpen (Ouvrir, aucune sécurité)

    • eWiFiSecurityWEP(WEPsécurité)

    • eWiFiSecurityWPA(WPAsécurité)

    • eWiFiSecurityWPA2(WPA2sécurité)

  6. Exécutez le script de configuration.

    1. Si vous utilisez macOS ou Linux, ouvrez une invite du terminal. Si vous utilisez Windows, ouvrez l'application « ESP - IDF 4.x CMD » ou « Command ».

    2. Accédez au freertos/tools/aws_config_quick_start répertoire et exécutez

      python SetupAWS.py setup

      Le script effectue les opérations suivantes :

      • Crée un objet, un certificat et une politique IoT.

      • Attache la politique IoT au certificat et le certificat à l' AWS IoT objet.

      • Remplit le aws_clientcredential.h fichier avec votre AWS IoT terminal, votre réseau Wi-Fi SSID et vos informations d'identification.

      • Formate votre certificat et votre clé privée et les écrit dans le fichier aws_clientcredential_keys.h d'en-tête.

      Note

      Le certificat est codé en dur à des fins de démonstration uniquement. Les applications de niveau production doivent stocker ces fichiers dans un emplacement sécurisé.

      Pour plus d'informationsSetupAWS.py, consultez le README.md dans le freertos/tools/aws_config_quick_start répertoire.

Surveillance MQTT des messages sur le cloud

Avant de lancer le projet de RTOS démonstration gratuit, vous pouvez configurer le MQTT client dans la AWS IoT console pour surveiller les messages que votre appareil envoie au AWS Cloud.

Pour s'abonner à la MQTT rubrique avec le AWS IoT MQTT client
  1. Accédez à la console AWS IoT.

  2. Dans le volet de navigation, choisissez Test, puis MQTTTest Client.

  3. Dans le champ Rubrique d'abonnement, saisissez your-thing-name/example/topic, puis choisissez S'abonner à la rubrique.

Lorsque le projet de démonstration s'exécute avec succès sur votre appareil, le message « Hello World ! » s'affiche envoyé plusieurs fois au sujet auquel vous vous êtes abonné.

Créez, flashez et exécutez le projet de RTOS démonstration gratuit à l'aide du script idf.py

Vous pouvez utiliser l'IDFutilitaire Espressif (idf.py) pour créer le projet et flasher les fichiers binaires sur votre appareil.

Note

Certaines configurations peuvent nécessiter que vous utilisiez l'option port "-p port-name" with idf.py pour spécifier le port correct, comme dans l'exemple suivant.

idf.py -p /dev/cu.usbserial-00101301B flash
Créez et flashez gratuitement RTOS sous Windows, Linux et macOS (ESP- IDF v4.2)
  1. Naviguez jusqu'à la racine de votre répertoire de RTOS téléchargement gratuit.

  2. Dans une fenêtre de ligne de commande, entrez la commande suivante pour ajouter les IDF outils ESP - à ceux de votre terminalPATH.

    Windows (application « Command »)
    vendors\espressif\esp-idf\export.bat
    Windows (application « ESP - IDF 4.x CMD »)

    (Cela a déjà été fait lorsque vous avez ouvert l'application.)

    Linux/ macOS
    source vendors/espressif/esp-idf/export.sh
  3. Configurez cmake dans le build répertoire et créez l'image du microprogramme avec la commande suivante.

    idf.py -DVENDOR=espressif -DBOARD=esp32_wrover_kit -DCOMPILER=xtensa-esp32 build

    Vous devriez voir une sortie semblable à la suivante.

    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'

    S'il n'y a aucune erreur, la compilation générera les fichiers binaires .bin du microprogramme.

  4. Effacez la mémoire flash de votre carte de développement à l'aide de la commande suivante.

    idf.py erase_flash
  5. Utilisez le idf.py script pour flasher le binaire de l'application sur votre tableau.

    idf.py flash
  6. Surveillez la sortie du port série de votre carte à l'aide de la commande suivante.

    idf.py monitor
    Note

    Vous pouvez combiner ces commandes comme dans l'exemple suivant.

    idf.py erase_flash flash monitor

    Pour certaines configurations de machine hôte, vous devez spécifier le port lorsque vous flashez la carte, comme dans l'exemple suivant.

    idf.py erase_flash flash monitor -p /dev/ttyUSB1

Créez et utilisez Flash gratuitement RTOS avec CMake

Outre le idf.py script fourni par le IDF SDK pour créer et exécuter votre code, vous pouvez également créer le projet avecCMake. Actuellement, il prend en charge les Makefiles Unix ou le système de construction Ninja.

Pour créer et flasher le projet
  1. Dans une fenêtre de ligne de commande, naviguez jusqu'à la racine de votre répertoire de RTOS téléchargement gratuit.

  2. Exécutez le script suivant pour ajouter les IDF outils ESP - à ceux de votre shellPATH.

    Windows
    vendors\espressif\esp-idf\export.bat
    Linux/ macOS
    source vendors/espressif/esp-idf/export.sh
  3. Entrez la commande suivante pour générer les fichiers de compilation.

    Avec 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
    Avec 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. Générez le projet.

    Avec Unix Makefiles
    make -C ./YOUR_BUILD_DIRECTORY -j8
    Avec Ninja
    ninja -C ./YOUR_BUILD_DIRECTORY -j8
  5. Effacez le flash, puis faites clignoter le tableau.

    Avec Unix Makefiles
    make -C ./YOUR_BUILD_DIRECTORY erase_flash
    make -C ./YOUR_BUILD_DIRECTORY flash
    Avec Ninja
    ninja -C ./YOUR_BUILD_DIRECTORY erase_flash
    ninja -C ./YOUR_BUILD_DIRECTORY flash

Exécuter les démonstrations Bluetooth Low Energy

Free RTOS prend en charge Bibliothèque Bluetooth Low Energy la connectivité.

Pour exécuter le projet de RTOS démonstration gratuit via Bluetooth Low Energy, vous devez exécuter l'application mobile de SDK démonstration gratuite RTOS Bluetooth Low Energy sur un appareil mobile iOS ou Android.

Pour configurer l'application mobile de SDK démonstration gratuite RTOS Bluetooth Low Energy
  1. Suivez les instructions SDK mobiles pour appareils Bluetooth FreeRTOS pour télécharger et installer le SDK pour votre plate-forme mobile sur votre ordinateur hôte.

  2. Suivez les instructions de la rubrique Application de démonstration du SDK FreeRTOS Bluetooth Low Energy Mobile pour configurer la démonstration d'applications mobiles sur votre appareil mobile.

Pour savoir comment exécuter la démonstration MQTT via Bluetooth Low Energy sur votre carte mère, consultezMQTT sur Bluetooth Low Energy.

Pour obtenir des instructions sur la façon d'exécuter la démonstration de configuration Wi-Fi sur votre carte mère, consultezMise en service Wi-Fi.

Utiliser Free RTOS dans votre propre CMake projet pour ESP32

Si vous souhaitez utiliser Free RTOS dans votre propre CMake projet, vous pouvez le configurer en tant que sous-répertoire et le créer avec votre application. Tout d'abord, procurez-vous une copie de Free RTOS from GitHub. Vous pouvez également le configurer en tant que sous-module Git à l'aide de la commande suivante afin de faciliter sa mise à jour à l'avenir.

git submodule add -b release https://github.com/aws/amazon-freertos.git freertos

Si une version ultérieure est publiée, vous pouvez mettre à jour votre copie locale à l'aide de ces commandes.

# 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"

Si la structure de répertoire de votre projet est la suivante :

- freertos (the copy that you obtained from GitHub or the AWS IoT console) - src - main.c (your application code) - CMakeLists.txt

Voici un exemple de CMakeLists.txt fichier de premier niveau qui peut être utilisé pour créer votre application avec 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)

Pour créer le projet, exécutez les CMake commandes suivantes. Assurez-vous que le ESP32 compilateur se trouve dans la variable d'PATHenvironnement.

cmake -S . -B build-directory -DCMAKE_TOOLCHAIN_FILE=freertos/tools/cmake/toolchains/xtensa-esp32.cmake -GNinja
cmake --build build-directory

Pour flasher l'application sur votre carte, exécutez la commande suivante.

cmake --build build-directory --target flash

Utilisation des composants de Free RTOS

Après l'exécutionCMake, vous pouvez trouver tous les composants disponibles dans le résultat récapitulatif. Cela devrait ressembler à l'exemple suivant.

====================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: =========================================================================

Vous pouvez référencer n'importe quel composant de la Modules to build liste. Pour les lier à votre application, placez l'AFR::espace de noms devant le nom, par exemple, AFR::core_mqttAFR::ota, et ainsi de suite.

Ajoutez des composants personnalisés à l'aide de ESP - IDF

Vous pouvez ajouter d'autres composants en utilisant ESP -IDF. Par exemple, en supposant que vous souhaitez ajouter un composant appelé example_component et que votre projet ressemble à ceci :

- freertos - components - example_component - include - example_component.h - src - example_component.c - CMakeLists.txt - src - main.c - CMakeLists.txt

Voici un exemple de CMakeLists.txt fichier pour votre composant.

add_library(example_component src/example_component.c) target_include_directories(example_component PUBLIC include)

Ensuite, dans le CMakeLists.txt fichier de premier niveau, ajoutez le composant en insérant la ligne suivante juste aprèsadd_subdirectory(freertos).

add_subdirectory(component/example_component)

Modifiez ensuite target_link_libraries pour inclure votre composant.

target_link_libraries(my_app PRIVATE AFR::core_mqtt PRIVATE example_component)

Ce composant est désormais automatiquement lié à votre code d'application par défaut. Vous pouvez désormais inclure ses fichiers d'en-tête et appeler les fonctions qu'il définit.

Remplacez les configurations gratuitement RTOS

Il n'existe actuellement aucune approche bien définie pour redéfinir les configurations en dehors de l'arborescence des sources FreeRTOS. Par défaut, CMake recherchera les freertos/demos/include/ répertoires freertos/vendors/espressif/boards/esp32/aws_demos/config_files/ et. Cependant, vous pouvez utiliser une solution de contournement pour demander au compilateur de rechercher d'autres répertoires en premier. Par exemple, vous pouvez ajouter un autre dossier pour les RTOS configurations gratuites.

- freertos - freertos-configs - aws_clientcredential.h - aws_clientcredential_keys.h - iot_mqtt_agent_config.h - iot_config.h - components - src - CMakeLists.txt

Les fichiers sous freertos-configs sont copiés à partir des répertoires freertos/vendors/espressif/boards/esp32/aws_demos/config_files/ et freertos/demos/include/. Ensuite, dans votre CMakeLists.txt fichier de premier niveau, ajoutez cette ligne avant add_subdirectory(freertos) afin que le compilateur recherche d'abord ce répertoire.

include_directories(BEFORE freertos-configs)

Fournir votre propre sdkconfig pour - ESP IDF

Si vous souhaitez fournir la vôtresdkconfig.default, vous pouvez définir la CMake variable IDF_SDKCONFIG_DEFAULTS depuis la ligne de commande :

cmake -S . -B build-directory -DIDF_SDKCONFIG_DEFAULTS=path_to_your_sdkconfig_defaults -DCMAKE_TOOLCHAIN_FILE=freertos/tools/cmake/toolchains/xtensa-esp32.cmake -GNinja

Si vous ne spécifiez pas d'emplacement pour votre propre sdkconfig.default fichier, Free RTOS utilise le fichier par défaut situé à l'emplacementfreertos/vendors/espressif/boards/esp32/aws_demos/sdkconfig.defaults.

Pour plus d'informations, consultez la section Configuration du projet dans la APIréférence Espressif et, si vous rencontrez des problèmes après avoir correctement compilé, consultez la section sur les options obsolètes et leurs remplacements sur cette page.

Récapitulatif

Si vous gérez un projet incluant un composant appelé example_component et que vous voulez remplacer certaines configurations, voici un exemple complet du fichier CMakeLists.txt de niveau supérieur.

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)

Résolution des problèmes

  • Si vous utilisez macOS et que le système d'exploitation ne vous reconnaît pas ESP-WROVER-KIT, assurez-vous que les pilotes D2XX ne sont pas installés. Pour les désinstaller, suivez les instructions du Guide d'installation des FTDI pilotes pour macOS X.

  • L'utilitaire de surveillance fourni par ESP - IDF (et invoqué à l'aide de make monitor) vous aide à décoder les adresses. Pour cette raison, cela peut vous aider à obtenir des traces significatives au cas où l'application cesserait de fonctionner. Pour plus d'informations, consultez la section Décodage automatique des adresses sur le site Web d'Espressif.

  • Il est également possible d'activer GDBstub la communication avec gdb sans nécessiter de JTAG matériel spécial. Pour plus d'informations, consultez Launching GDB with GDBStub sur le site Web d'Espressif.

  • Pour plus d'informations sur la configuration d'un environnement ouvert OCD si un débogage JTAG matériel est requis, consultez la section JTAGDébogage sur le site Web d'Espressif.

  • S'il ne pyserial peut pas être installé pip sur macOS, téléchargez-le sur le site Web de pyserial.

  • Si la carte se réinitialise continuellement, essayez d'effacer le flash en saisissant la commande suivante sur le terminal.

    make erase_flash
  • Si vous voyez des erreurs lorsque vous exécutez idf_monitor.py, utilisez Python 2.7.

  • Les bibliothèques requises de ESP - IDF sont incluses dans FreeRTOS, il n'est donc pas nécessaire de les télécharger en externe. Si la variable d'IDF_PATHenvironnement est définie, nous vous recommandons de l'effacer avant de compiler FreeRTOS.

  • Sur Windows, la génération du projet peut prendre entre 3 et 4 minutes. Pour réduire le temps de construction, vous pouvez utiliser le -j4 commutateur de la commande make.

    make flash monitor -j4
  • Si votre appareil ne parvient pas à se connecter AWS IoT, ouvrez le aws_clientcredential.h fichier et vérifiez que les variables de configuration sont correctement définies dans le fichier. clientcredentialMQTT_BROKER_ENDPOINT[]devrait ressembler à1234567890123-ats.iot.us-east-1.amazonaws.com.

  • Si vous suivez les étapes décrites dans Utiliser Free RTOS dans votre propre CMake projet pour ESP32 et que vous constatez des erreurs de référence non définies dans l'éditeur de liens, c’est généralement en raison de l’absence de bibliothèques ou de démos dépendantes. Pour les ajouter, mettez à jour le CMakeLists.txt fichier (sous le répertoire racine) à l'aide de la CMake fonction standardtarget_link_libraries.

  • ESP- La IDF version 4.2 prend en charge l'utilisation du xtensa \ -esp32 \ -elf \ -gcc 8 \ .2 \ .0 \. chaîne d'outils. Si vous utilisez une version antérieure de la chaîne d'outils Xtensa, téléchargez la version requise.

  • Si vous voyez un journal d'erreurs comme le suivant concernant les dépendances de python qui ne sont pas respectées pour la IDF version 4.2 ESP :

    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

    Installez les dépendances Python sur votre plateforme à l'aide de la commande Python suivante :

    root/vendors/espressif/esp-idf/requirements.txt

Pour plus d'informations sur la résolution des problèmes, consultezRésolution des problèmes de mise en route.

Débogage

Code de débogage sur Espressif ESP32 - DevKit C et ESP-WROVER-KIT (- v4.2) ESP IDF

Cette section explique comment déboguer le matériel Espressif à l'aide ESP de - v4.2. IDF Vous avez besoin JTAG d'un USB câble. Nous utilisons un MPSSE câble USB de raccordement (par exemple, le FTDIC232HM- -0) DDHSL.

ESP- JTAG Configuration DevKit C

Pour le câble FTDI C232HM- DDHSL -0, voici les connexions au 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 JTAGconfiguration

Pour le câble FTDI C232HM- DDHSL -0, voici les connexions au - -. 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 |

Ces tables ont été développées à partir de la fiche technique FTDIC232HM- DDHSL -0. Pour plus d'informations, consultez la section « Connexion du MPSSE câble C232HM et détails mécaniques » de la fiche technique.

Pour l'activer JTAG sur le ESP-WROVER-KIT, placez des cavaliers sur les TDI épingles TMSTDO,TDI,TCK, et S_ comme indiqué ici.

Placement du pull
Débogage sous Windows (ESP- IDF v4.2)
Pour configurer le débogage sous Windows
  1. Connectez le USB côté du FTDI C232HM- DDHSL -0 à votre ordinateur et l'autre côté comme décrit dans. Code de débogage sur Espressif ESP32 - DevKit C et ESP-WROVER-KIT (- v4.2) ESP IDF Le périphérique FTDI C232HM- DDHSL -0 doit apparaître dans le Gestionnaire de périphériques sous Universal Serial Bus Controllers.

  2. Dans la liste des périphériques de bus série universels, cliquez avec le bouton droit sur le périphérique C232HM- DDHSL -0, puis sélectionnez Propriétés.

    Note

    Le périphérique est peut-être répertorié comme port USB série.

    Pour voir les propriétés de l'appareil, dans la fenêtre des propriétés, cliquez sur l'onglet Détails. Si le périphérique n'est pas répertorié, installez le pilote Windows pour FTDI C232HM - -0. DDHSL

  3. Dans l'onglet Détails, choisissez Propriété, puis Matériel IDs. Vous devriez voir quelque chose comme ça dans le champ Valeur.

    FTDIBUS\COMPORT&VID_0403&PID_6014

    Dans cet exemple, l'ID du fournisseur est 0403 et celui du produit est 6014.

    Vérifiez qu'ils IDs correspondent IDs à l'entréeprojects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg. Ils IDs sont spécifiés dans une ligne commençant par ftdi_vid_pid un identifiant de fournisseur et un identifiant de produit.

    ftdi_vid_pid 0x0403 0x6014
  4. Téléchargez Open OCD pour Windows.

  5. Décompressez le fichier sur C:\ et ajoutez C:\openocd-esp32\bin à votre chemin système.

  6. Open OCD nécessite libusb, qui n'est pas installé par défaut sous Windows. Pour installer libusb :

    1. Téléchargez zadig.exe.

    2. Exécutez zadig.exe. Dans le menu Options, choisissez List All Devices (Afficher tous les périphériques).

    3. Dans le menu déroulant, choisissez C232HM - -0. DDHSL

    4. Dans le champ du pilote cible, à droite de la flèche verte, choisissez Win USB.

    5. Pour la liste située sous le champ du pilote cible, cliquez sur la flèche, puis choisissez Installer le pilote. Choisissez Replace Driver (Remplacer le pilote).

  7. Ouvrez une invite de commande, naviguez jusqu'à la racine de votre répertoire de RTOS téléchargement gratuit et exécutez la commande suivante.

    idf.py openocd

    Laissez l'invite de commande ouverte.

  8. Ouvrez une nouvelle invite de commande, naviguez jusqu'à la racine de votre répertoire de RTOS téléchargement gratuit et exécutez

    idf.py flash monitor
  9. Ouvrez une autre invite de commande, naviguez jusqu'à la racine de votre répertoire de RTOS téléchargement gratuit et attendez que la démo commence à s'exécuter sur votre forum. Quand c'est le cas, courez

    idf.py gdb

    Le programme doit s'arrêter dans la fonction main.

    Note

    Le ESP32 supporte un maximum de deux points de rupture.

Débogage sur macOS (ESP- IDF v4.2)
  1. Téléchargez le FTDIpilote pour macOS.

  2. Téléchargement ouvert OCD.

  3. Extrayez le fichier .tar téléchargé et définissez le chemin d'accès dans .bash_profile sur OCD_INSTALL_DIR/openocd-esp32/bin.

  4. Utilisez la commande suivante pour effectuer l'installation libusb sur macOS.

    brew install libusb
  5. Utilisez la commande suivante pour décharger le pilote du port série.

    sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
  6. Utilisez la commande suivante pour décharger le pilote du port série.

    sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
  7. Si vous utilisez une version de macOS ultérieure à 10.9, utilisez la commande suivante pour décharger le pilote AppleFTDI.

    sudo kextunload -b com.apple.driver.AppleUSBFTDI
  8. Utilisez la commande suivante pour obtenir l'identifiant du produit et l'identifiant du fournisseur du FTDI câble. Il répertorie les USB appareils connectés.

    system_profiler SPUSBDataType

    Le résultat de system_profiler doit ressembler à ce qui suit.

    DEVICE: Product ID: product-ID Vendor ID: vendor-ID (Future Technology Devices International Limited)
  9. Ouvrez le fichier projects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg. Les ID de fournisseur de produit de votre appareil sont spécifiés dans une ligne qui commence par ftdi_vid_pid. Modifiez le IDs pour qu'il IDs corresponde à celui de la system_profiler sortie de l'étape précédente.

  10. Ouvrez une fenêtre de terminal, naviguez jusqu'à la racine de votre répertoire de RTOS téléchargement gratuit et utilisez la commande suivante pour exécuter OpenOCD.

    idf.py openocd

    Laissez cette fenêtre de terminal ouverte.

  11. Ouvrez un nouveau terminal et utilisez la commande suivante pour charger le pilote du port FTDI série.

    sudo kextload -b com.FTDI.driver.FTDIUSBSerialDriver
  12. Naviguez jusqu'à la racine de votre répertoire de RTOS téléchargement gratuit et lancez

    idf.py flash monitor
  13. Ouvrez un autre nouveau terminal, naviguez jusqu'à la racine de votre répertoire de RTOS téléchargement gratuit et lancez

    idf.py gdb

    Le programme doit s'arrêter à main.

Débogage sous Linux (ESP- IDF v4.2)
  1. Téléchargement ouvert OCD. Extrayez le fichier tarball et suivez les instructions d'installation du fichier readme.

  2. Utilisez la commande suivante pour installer libusb sous Linux.

    sudo apt-get install libusb-1.0
  3. Ouvrez un terminal et entrez ls -l /dev/ttyUSB* pour répertorier tous les USB appareils connectés à votre ordinateur. Cela vous permet de vérifier si les USB ports de la carte sont reconnus par le système d'exploitation. Vous devriez voir une sortie semblable à la suivante.

    $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. Déconnectez-vous, puis connectez-vous et répétez l'alimentation de la carte pour que les modifications prennent effet. Dans une invite du terminal, dressez la liste des USB appareils. Assurez-vous que le propriétaire du groupe est passé de dialout àplugdev.

    $ls -l /dev/ttyUSB* crw-rw---- 1 root plugdev 188, 0 Jul 10 19:04 /dev/ttyUSB0 crw-rw---- 1 root plugdev 188, 1 Jul 10 19:04 /dev/ttyUSB1

    L'/dev/ttyUSBninterface dont le chiffre est inférieur est utilisée pour JTAG la communication. L'autre interface est routée vers le port série ESP32 du (UART) et est utilisée pour télécharger le code vers la mémoire flash ESP32 du.

  5. Dans une fenêtre de terminal, naviguez jusqu'à la racine de votre répertoire de RTOS téléchargement gratuit et utilisez la commande suivante pour exécuter OpenOCD.

    idf.py openocd
  6. Ouvrez un autre terminal, naviguez jusqu'à la racine de votre répertoire de RTOS téléchargement gratuit et exécutez la commande suivante.

    idf.py flash monitor
  7. Ouvrez un autre terminal, naviguez à la racine de votre répertoire de RTOS téléchargement gratuit et exécutez la commande suivante :

    idf.py gdb

    Le programme doit s'arrêter à main().