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-DevKitC et le ESP-WROVER-KIT **Important** Cette intégration de référence est hébergée sur le Amazon-FreeRTOS référentiel qui est obsolète. Nous vous recommandons de [commencer ici](freertos-getting-started-modular.md) lorsque vous créez un nouveau projet. Si vous possédez déjà un projet FreeRTOS basé sur le référentiel désormais Amazon-FreeRTOS obsolète, consultez le. [Amazon-FreeRTOS Guide de migration du référentiel Github](github-repo-migration.md) **Note** [Pour découvrir comment intégrer les bibliothèques modulaires et les démos FreeRTOS dans votre propre projet Espressif IDF, consultez notre article sur l'intégration de référence pour la plateforme. ESP32-C3 ](https://www.freertos.org/featured-freertos-iot-integration-targeting-an-espressif-esp32-c3-risc-v-mcu/) Suivez ce didacticiel pour démarrer avec l'Espressif ESP32-DevKitC équipé de ESP32-WROOM-32 ESP32-SOLO-1, ou de ESP-WROVER modules 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 : + [ESP32-WROOM-32 DevKitC](https://devices.amazonaws.com/detail/a3G0L00000AANtjUAH/ESP32-DevKitC) + [ESP32-SOLO-1](https://devices.amazonaws.com/detail/a3G0h0000076lSMEAY) + [ ESP32-WROVER-KIT](https://devices.amazonaws.com/detail/a3G0L00000AANtlUAH/ESP-WROVER-KIT) 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 la version [ ESP32-DevKitC V4](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/modules-and-boards.html#esp32-devkitc-v4) ou la [ ESP-WROVER-KIT v4.1](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/modules-and-boards.html#esp-wrover-kit-v4-1) sur le site Web d'Espressif. **Note** Actuellement, le port FreeRTOS ESP32-WROVER-KIT pour DevKit ESP C ne prend pas en charge la fonctionnalité de multitraitement symétrique (SMP). ## Présentation de Ce didacticiel vous guide à travers les étapes suivantes : 1. Connexion de votre carte à un appareil hôte. 1. 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. 1. Compilation croisée d'une application de démonstration FreeRTOS en une image binaire. 1. Chargement de l’image binaire de l’application dans votre carte et exécution de l’application. 1. Interaction avec l’application s’exécutant sur votre carte via une connexion série, à des fins de surveillance et de débogage. ## Conditions préalables Avant de commencer à utiliser FreeRTOS sur votre tableau Espressif, vous devez configurer votre compte et vos autorisations. AWS ### Inscrivez-vous pour un Compte AWS Pour commencer AWS, vous avez besoin d'un Compte AWS. Pour plus d'informations sur la création d'un Compte AWS, voir [Getting started with an Compte AWS](https://docs.aws.amazon.com//accounts/latest/reference/getting-started.html) dans le *Guide de Gestion de compte AWS référence*. Pour activer l’accès, ajoutez des autorisations à vos utilisateurs, groupes ou rôles : + Utilisateurs et groupes dans AWS IAM Identity Center : Créez un jeu d’autorisations. Suivez les instructions de la rubrique [Création d’un jeu d’autorisations](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) du *Guide de l’utilisateur AWS IAM Identity Center *. + Utilisateurs gérés dans IAM par un fournisseur d’identité : Créez un rôle pour la fédération d’identité. Suivez les instructions de la rubrique [Création d’un rôle pour un fournisseur d’identité tiers (fédération)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) dans le *Guide de l’utilisateur IAM*. + Utilisateurs IAM : + Créez un rôle que votre utilisateur peut assumer. Suivez les instructions de la rubrique [Création d’un rôle pour un utilisateur IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) dans le *Guide de l’utilisateur IAM*. + (Non recommandé) Attachez une politique directement à un utilisateur ou ajoutez un utilisateur à un groupe d’utilisateurs. Suivez les instructions de la rubrique [Ajout d’autorisations à un utilisateur (console)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) du *Guide de l’utilisateur IAM*. ## Mise en route **Note** Les commandes Linux de ce didacticiel nécessitent que vous utilisiez le shell Bash. 1. **Configurez le matériel Espressif.** + Pour plus d'informations sur la configuration du matériel de la carte de ESP32-DevKitC développement, consultez le [guide ESP32-DevKitC de démarrage](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/esp32/get-started-devkitc.html) de la version 4. + Pour plus d'informations sur la configuration du matériel de la carte de ESP-WROVER-KIT développement, consultez le [ ESP-WROVER-KIT V4.1 Guide de démarrage](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/esp32/get-started-wrover-kit.html). **Important** Lorsque vous **atteignez** la section Get Started des guides Espressif, arrêtez-vous, puis revenez aux instructions de cette page. 1. Téléchargez Amazon [GitHub](https://github.com/aws/amazon-freertos)FreeRTOS depuis. (Pour obtenir des instructions, consultez le [README.md](https://github.com/aws/amazon-freertos/blob/main/README.md)fichier.) 1. **Configurez votre environnement de développement**. Pour communiquer avec votre tableau, vous devez installer une chaîne d'outils. Espressif fournit le logiciel ESP-IDF pour développer des logiciels pour leurs cartes. Comme ESP-IDF sa propre version du noyau FreeRTOS est intégrée en tant que composant, Amazon FreeRTOS inclut une version personnalisée de la ESP-IDF version 4.2 dans laquelle le noyau FreeRTOS a été supprimé. 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 la ESP-IDF version 4.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 ESP-IDF le programme d'[installation universel en ligne](https://dl.espressif.com/dl/esp-idf/?idf=4.2) pour Windows. 1. Exécutez le programme d'**installation en ligne universel**. 1. Lorsque vous arrivez à l'étape **Télécharger ou utiliser ESP-IDF**, sélectionnez **Utiliser un ESP-IDF répertoire existant** et définissez **Choisir un ESP-IDF répertoire existant** sur`{{freertos}}/vendors/espressif/esp-idf`. 1. 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](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/macos-setup.html). **Important** Lorsque vous atteignez les instructions ESP-IDF « Obtenir » sous **Prochaines étapes**, arrêtez-vous, puis revenez aux instructions de cette page. 1. Ouvrez une fenêtre de ligne de commande. 1. Accédez au répertoire de téléchargement de FreeRTOS, 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 ``` 1. Ajoutez les ESP-IDF outils de la chaîne d'outils 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)](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/linux-setup.html) pour Linux. **Important** Lorsque vous atteignez les instructions ESP-IDF « Obtenir » sous **Prochaines étapes**, arrêtez-vous, puis revenez aux instructions de cette page. 1. Ouvrez une fenêtre de ligne de commande. 1. Accédez au répertoire de téléchargement de FreeRTOS, 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 ``` 1. Ajoutez les ESP-IDF outils de la chaîne d'outils au chemin de votre terminal à l'aide de la commande suivante. ``` source vendors/espressif/esp-idf/export.sh ``` 1. **Établissez une connexion série.** 1. Pour établir une connexion série entre votre machine hôte et le ESP32-DevKitC, vous devez installer les pilotes VCP CP210x USB to UART Bridge. Vous pouvez télécharger ces pilotes à partir de [Silicon Labs](https://www.silabs.com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers). Pour établir une connexion série entre votre machine hôte et le ESP32-WROVER-KIT, vous devez installer le pilote de port COM virtuel FTDI. Vous pouvez télécharger ce pilote depuis [FTDI](https://www.ftdichip.com/Drivers/VCP.htm). 1. Suivez les étapes pour [établir une connexion série avec l'ESP32](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/establish-serial-connection.html). 1. 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 démonstration FreeRTOS Pour ce didacticiel, le fichier de configuration FreeRTOS se trouve à l'adresse. `{{freertos}}/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'adresse`{{freertos}}/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 lors de l'installation de la ESP-IDF chaîne d'outils), ou l'application « Command Prompt » dans le cas contraire. 1. 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](https://www.python.org/downloads/). 1. 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 installer la AWS CLI dans l'application « Command » ou « ESP-IDF  4.x CMD ». Si vous utilisez macOS ou Linux, reportez-vous à la section [Installation de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html). 1. Exécuter ``` aws configure ``` et configurez la AWS CLI avec votre ID 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 [Configuration de l'interface CLI AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) (français non garanti). 1. 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](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) pour plus de détails. + Sur macOS ou Linux, exécutez ``` pip install tornado nose --user ``` puis exécutez ``` pip install boto3 --user ``` FreeRTOS inclut `SetupAWS.py` le 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 Wi-Fi réseau. **`wifi_password`** Le mot de passe de votre Wi-Fi réseau. **`wifi_security`** Type de sécurité de votre Wi-Fi réseau. Les types de sécurité suivants sont valides : + `eWiFiSecurityOpen` (Ouvrir, aucune sécurité) + `eWiFiSecurityWEP` (Sécurité WEP) + `eWiFiSecurityWPA` (Sécurité WPA) + `eWiFiSecurityWPA2` (Sécurité WPA2) 1. 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 ». 1. 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 point de terminaison, votre 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. Production-level les applications doivent stocker ces fichiers dans un emplacement sécurisé. Pour plus d'informations`SetupAWS.py`, consultez le `README.md` dans le `{{freertos}}/tools/aws_config_quick_start` répertoire. ### Surveillance des messages MQTT dans le cloud Avant de lancer le projet de démonstration FreeRTOS, vous pouvez configurer le client MQTT dans la console pour surveiller AWS IoT les messages que votre appareil envoie au Cloud. AWS **Pour vous abonner à la rubrique MQTT avec le AWS IoT Client MQTT** 1. Accédez à la [console AWS IoT](https://console.aws.amazon.com/iotv2/). 1. Dans le volet de navigation, choisissez **Test**, puis **MQTT Test Client**. 1. 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 démonstration FreeRTOS à l'aide du script idf.py Vous pouvez utiliser l'utilitaire IDF (`idf.py`) d'Espressif 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 des FreeRTOS sous Windows, Linux et macOS (v4.2) ESP-IDF** 1. Naviguez jusqu'à la racine de votre répertoire de téléchargement de FreeRTOS. 1. Dans une fenêtre de ligne de commande, entrez la commande suivante pour ajouter les ESP-IDF outils au PATH de votre terminal. **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 ``` 1. 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. 1. Effacez la mémoire flash de votre carte de développement à l'aide de la commande suivante. ``` idf.py erase_flash ``` 1. Utilisez le `idf.py` script pour flasher le binaire de l'application sur votre tableau. ``` idf.py flash ``` 1. 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 flashez des FreeRTOS avec CMake Outre le `idf.py` script fourni par le SDK IDF pour créer et exécuter votre code, vous pouvez également créer le projet avec CMake. 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 du répertoire de téléchargement de FreeRTOS. 1. Exécutez le script suivant pour ajouter les ESP-IDF outils au PATH de votre shell. **Windows** ``` vendors\espressif\esp-idf\export.bat ``` **Linux/ macOS** ``` source vendors/espressif/esp-idf/export.sh ``` 1. 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 ``` 1. Générez le projet. **Avec Unix Makefiles** ``` make -C ./YOUR_BUILD_DIRECTORY -j8 ``` **Avec Ninja** ``` ninja -C ./YOUR_BUILD_DIRECTORY -j8 ``` 1. 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 FreeRTOS prend en charge la connectivité[Bibliothèque Bluetooth Low Energy](freertos-ble-library.md). Pour exécuter le projet de démonstration FreeRTOS via Bluetooth Low Energy, vous devez exécuter l'application de démonstration du SDK mobile FreeRTOS Bluetooth Low Energy sur un appareil mobile iOS ou Android. **Pour configurer l'application de démonstration du SDK mobile FreeRTOS Bluetooth Low Energy** 1. Suivez les instructions de [SDK mobiles pour appareils Bluetooth FreeRTOS](freertos-ble-mobile.md) pour télécharger et installer le kit SDK pour votre plateforme mobile sur votre ordinateur hôte. 1. Suivez les instructions de la rubrique [Application de démonstration du SDK FreeRTOS Bluetooth Low Energy Mobile](ble-demo.md#ble-sdk-app) pour configurer la démonstration d'applications mobiles sur votre appareil mobile. Pour savoir comment exécuter la démo MQTT via Bluetooth Low Energy sur votre carte mère, consultez[MQTT sur Bluetooth Low Energy](ble-demo.md#ble-demo-mqtt). Pour obtenir des instructions sur la façon d'exécuter la démonstration de Wi-Fi provisionnement sur votre tableau, consultez[Wi-Fi approvisionnement](ble-demo.md#ble-demo-wifi). ## Utilisation de FreeRTOS dans votre propre projet CMake pour ESP32 Si vous souhaitez utiliser FreeRTOS dans votre propre projet CMake, 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 FreeRTOS auprès de. [GitHub](https://github.com/aws/amazon-freertos) 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 "/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 commandes CMake suivantes. Assurez-vous que le compilateur ESP32 se trouve dans la variable d'environnement PATH. ``` 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 de composants de FreeRTOS Après l'exécution de CMake, vous trouverez tous les composants disponibles dans la sortie récapitulative. 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_mqtt``AFR::ota`, et ainsi de suite. ### Ajoutez des composants personnalisés à l'aide de ESP-IDF Vous pouvez ajouter d'autres composants lors de l'utilisation 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ès`add_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. ### Remplacer les configurations pour FreeRTOS 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 recherche les répertoires `{{freertos}}/vendors/espressif/boards/esp32/aws_demos/config_files/` et `{{freertos}}/demos/include/`. 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 configurations FreeRTOS. ``` - 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 Dans le cas où vous voulez fournir votre propre fichier `sdkconfig.default`, vous pouvez définir la variable CMake `IDF_SDKCONFIG_DEFAULTS` à partir de 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, FreeRTOS utilise le fichier par défaut situé dans. `{{freertos}}/vendors/espressif/boards/esp32/aws_demos/sdkconfig.defaults` Pour plus d'informations, consultez la section [Configuration du projet](https://docs.espressif.com/projects/esp-idf/en/v4.2-beta1/esp32s2/api-reference/kconfig.html) dans la *référence de l'API* Espressif et, si vous rencontrez des problèmes après avoir correctement compilé, consultez la section sur les [options obsolètes et leurs remplacements](https://docs.espressif.com/projects/esp-idf/en/v4.2-beta1/esp32s2/api-reference/kconfig.html#deprecated-options-and-their-replacements) sur cette page. ### Résumé 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 fournies dans le manuel [FTDI Drivers Installation Guide for macOS X](http://www.ftdichip.com/Support/Documents/AppNotes/AN_134_FTDI_Drivers_Installation_Guide_for_MAC_OSX.pdf). + 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](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/api-guides/tools/idf-monitor.html#automatic-address-decoding) sur le site Web d'Espressif. + Il est également possible d'activer GDBStub pour communiquer avec gdb sans nécessiter de matériel JTAG spécial. Pour plus d'informations, consultez [Lancer GDB avec GDBStub](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/api-guides/tools/idf-monitor.html#launching-gdb-with-gdbstub) sur le site Web d'Espressif. + Pour plus d'informations sur la configuration d'un OpenOCD-based environnement si le débogage matériel JTAG est requis, consultez la section Débogage [JTAG](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/jtag-debugging/index.html) 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](https://pypi.org/simple/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_PATH`environnement est définie, nous vous recommandons de l'effacer avant de créer 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 [Utilisation de FreeRTOS dans votre propre projet CMake pour ESP32](#getting_started_espressif_cmake_project) 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 fichier `CMakeLists.txt` (sous le répertoire racine) en utilisant la fonction CMake standard `target_link_libraries`. + ESP-IDF La 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 ESP-IDF version 4.2 : ``` The following Python requirements are not satisfied: click>=5.0 pyserial>=3.0 future>=0.15.2 pyparsing>=2.0.3,<2.4.0 pyelftools>=0.22 gdbgui==0.13.2.0 pygdbmi<=0.9.0.2 reedsolo>=1.5.3,<=1.5.4 bitstring>=3.1.6 ecdsa>=0.16.0 Please follow the instructions found in the "Set up the tools" section of ESP-IDF Getting Started Guide ``` 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, consultez[Résolution des problèmes de mise en route](gsg-troubleshooting.md). ## Débogage ### Code de débogage sur Espressif ESP32-DevKitC et ESP-WROVER-KIT (v4.2) ESP-IDF Cette section explique comment déboguer le matériel Espressif à l'aide de la version 4.2. ESP-IDF Vous avez besoin d'un câble JTAG vers USB. Nous utilisons un câble USB vers MPSSE (par exemple, le [FTDI C232HM-DDHSL-0](http://www.ftdichip.com/Products/Cables/USBMPSSE.htm)). **ESP-DevKitC Configuration du JTAG** Pour le C232HM-DDHSL-0 câble FTDI, il s'agit des 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 Configuration du JTAG** Pour le C232HM-DDHSL-0 câble FTDI, il s'agit des 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 tableaux ont été développés à partir de la [ C232HM-DDHSL-0 fiche technique du FTDI](https://www.ftdichip.com/Support/Documents/DataSheets/Cables/DS_C232HM_MPSSE_CABLE.pdf). Pour plus d'informations, consultez la section « Connexion du câble C232HM MPSSE et détails mécaniques » de la fiche technique. Pour activer le JTAG sur le ESP-WROVER-KIT, placez des jumpers sur les broches TMS, TDO, TDI, TCK et S\_TDI, comme indiqué ici. ![Placement du pull](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/JP8-jumpers.png) **Débogage sous Windows (ESP-IDF v4.2)** **Pour configurer le débogage sous Windows** 1. Connectez le côté USB du FTDI C232HM-DDHSL-0 à votre ordinateur et l'autre côté comme décrit dans[Code de débogage sur Espressif ESP32-DevKitC et ESP-WROVER-KIT (v4.2) ESP-IDF](#debugging-espressif-idf42). Le C232HM-DDHSL-0 périphérique FTDI doit apparaître dans le **Gestionnaire de périphériques** sous **Contrôleurs de bus série universels**. 1. Dans la liste des périphériques de bus série universels, cliquez avec le bouton droit sur le **C232HM-DDHSL-0**périphérique, puis sélectionnez **Propriétés**. **Note** L'appareil peut être répertorié **Port série USB**. 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-DDHSL-0](http://www.ftdichip.com/Drivers/D2XX.htm). 1. Sous l'onglet **Détails** , choisissez **Propriété**, puis **ID du matériel**. 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 que ces ID correspondent à ceux de `projects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg`. Les identifiants sont spécifiés sur une ligne commençant par `ftdi_vid_pid` un identifiant de fournisseur et un identifiant de produit. ``` ftdi_vid_pid 0x0403 0x6014 ``` 1. Téléchargez [OpenOCD for Windows](https://github.com/espressif/openocd-esp32/releases). 1. Décompressez le fichier sur `C:\` et ajoutez `C:\openocd-esp32\bin` à votre chemin système. 1. OpenOCD nécessite libusb, qui n'est pas installé par défaut sur Windows. Pour installer libusb : 1. Téléchargez [zadig.exe](https://zadig.akeo.ie). 1. Exécutez `zadig.exe`. Dans le menu **Options**, choisissez **List All Devices (Afficher tous les périphériques)**. 1. Dans le menu déroulant, choisissez **C232HM-DDHSL-0**. 1. Dans le champ du pilote cible, à droite de la flèche verte, choisissez **WinUSB**. 1. 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)**. 1. Ouvrez une invite de commande, naviguez jusqu'à la racine de votre répertoire de téléchargement de FreeRTOS et exécutez la commande suivante. ``` idf.py openocd ``` Laissez l'invite de commande ouverte. 1. Ouvrez une nouvelle invite de commande, naviguez jusqu'à la racine de votre répertoire de téléchargement de FreeRTOS et exécutez ``` idf.py flash monitor ``` 1. Ouvrez une autre invite de commande, naviguez jusqu'à la racine de votre répertoire de téléchargement de FreeRTOS 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** L'ESP32 prend en charge un maximum de deux points d'arrêt. **Débogage sur macOS (ESP-IDF v4.2)** 1. Téléchargez le [pilote FTDI pour macOS](http://www.ftdichip.com/Drivers/VCP.htm). 1. Téléchargez [OpenOCD](https://github.com/espressif/openocd-esp32/releases). 1. 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`. 1. Utilisez la commande suivante pour effectuer l'installation `libusb` sur macOS. ``` brew install libusb ``` 1. Utilisez la commande suivante pour décharger le pilote du port série. ``` sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver ``` 1. Utilisez la commande suivante pour décharger le pilote du port série. ``` sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver ``` 1. Si vous utilisez une version de macOS ultérieure à 10.9, utilisez la commande suivante pour décharger le pilote Apple FTDI. ``` sudo kextunload -b com.apple.driver.AppleUSBFTDI ``` 1. Utilisez la commande suivante pour obtenir l'ID produit et l'ID fournisseur du câble FTDI. Il répertorie les périphériques USB 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) ``` 1. 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 les ID pour qu'ils correspondent à ceux de la sortie `system_profiler` de l'étape précédente. 1. Ouvrez une fenêtre de terminal, naviguez jusqu'à la racine de votre répertoire de téléchargement de FreeRTOS et utilisez la commande suivante pour exécuter OpenOCD. ``` idf.py openocd ``` Laissez cette fenêtre de terminal ouverte. 1. Ouvrez un nouveau terminal et utilisez la commande suivante pour charger le pilote du port série FTDI. ``` sudo kextload -b com.FTDI.driver.FTDIUSBSerialDriver ``` 1. Naviguez jusqu'à la racine de votre répertoire de téléchargement de FreeRTOS et lancez ``` idf.py flash monitor ``` 1. Ouvrez un autre nouveau terminal, naviguez jusqu'à la racine de votre répertoire de téléchargement de FreeRTOS et lancez ``` idf.py gdb ``` Le programme doit s'arrêter à `main`. **Débogage sous Linux (ESP-IDF v4.2)** 1. Téléchargez [OpenOCD](https://github.com/espressif/openocd-esp32/releases). Extrayez le fichier tarball et suivez les instructions d'installation du fichier readme. 1. Utilisez la commande suivante pour installer libusb sous Linux. ``` sudo apt-get install libusb-1.0 ``` 1. Ouvrez un terminal et saisissez **ls -l /dev/ttyUSB\***pour afficher tous les périphériques USB reliés à votre ordinateur. Cela vous permet de vérifier si les ports USB 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 ``` 1. Déconnectez-vous, puis connectez-vous et répétez l'alimentation de la carte pour que les modifications prennent effet. Dans une invite de terminal, affichez la liste des périphériques USB. 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'interface `/dev/ttyUSBn` avec le nombre inférieur est utilisée pour la communication JTAG. L'autre interface est routée vers le port série (UART) de l'ESP32 et est utilisée pour télécharger du code vers la mémoire flash de l'ESP32. 1. Dans une fenêtre de terminal, naviguez jusqu'à la racine de votre répertoire de téléchargement de FreeRTOS et utilisez la commande suivante pour exécuter OpenOCD. ``` idf.py openocd ``` 1. Ouvrez un autre terminal, naviguez jusqu'à la racine du répertoire de téléchargement de FreeRTOS et exécutez la commande suivante. ``` idf.py flash monitor ``` 1. Ouvrez un autre terminal, naviguez à la racine du répertoire de téléchargement de FreeRTOS et exécutez la commande suivante : ``` idf.py gdb ``` Le programme doit s'arrêter à `main()`.