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. # Débuter avec l'Espressif ESP32-S2 **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/) Ce didacticiel explique comment démarrer avec le ESP32-S2 SoC Espressif et les cartes de [ESP32-S2-Saola-1](https://devices.amazonaws.com/detail/a3G0h00000AkFngEAF/ESP32-S2-Saola-1)développement. ## Présentation de Ce didacticiel vous guide à travers les étapes suivantes : 1. Connectez votre carte à un appareil hôte. 1. Installation du logiciel sur votre machine hôte pour développer et déboguer les applications intégrées de votre carte de microcontrôleur. 1. Cross-compile une application de démonstration FreeRTOS sur une image binaire. 1. Chargement de l’image binaire de l’application dans votre carte et exécution de l’application. 1. Surveillance et débogage de l'application en cours d'exécution à l'aide d'une connexion série. ## 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-S2 développement, consultez le [ ESP32-S2-Saola-1 Guide de démarrage](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32s2/hw-reference/esp32s2/user-guide-saola-1-v1.2.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 résout 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/esp32s2/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/esp32s2/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, installez 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). 1. Suivez les étapes pour [ établir une connexion série avec 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 ce qui suit : ``` 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 ``` easy_install boto3 ``` + 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 exécuter le script de configuration** 1. 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. 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 AWS IoT objet, un certificat et une politique. + Attache la AWS IoT politique 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 à ce sujet`SetupAWS.py`, consultez le `README.md` dans le `{{freertos}}/tools/aws_config_quick_start` répertoire. ### Surveillance des messages MQTT sur le AWS 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. Connectez-vous à 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 d'Espressif pour générer les fichiers de compilation, créer le binaire de l'application et flasher votre tableau. #### Créez et flashez des FreeRTOS sous Windows, Linux et macOS (v4.2) ESP-IDF Utilisez le `idf.py` script 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 ``` **Pour créer et flasher le projet** 1. Accédez à la racine du 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 à l'aide de la commande suivante. ``` idf.py -DVENDOR=espressif -DBOARD=esp32s2_saola_1 -DCOMPILER=xtensa-esp32s2 build ``` Vous devriez voir une sortie comme dans l'exemple suivant. ``` Executing action: all (aliases: build) Running cmake in directory /path/to/hello_world/build Executing "cmake -G Ninja -DPYTHON_DEPS_CHECKED=1 -DESP_PLATFORM=1 -DVENDOR=espressif -DBOARD=esp32s2_saola_1 -DCOMPILER=xtensa-esp32s2 -DCCACHE_ENABLE=0 /path/to/hello_world"... -- The C compiler identification is GNU 8.4.0 -- The CXX compiler identification is GNU 8.4.0 -- The ASM compiler identification is GNU ... (more lines of build system output) [1628/1628] Generating binary image from built executable esptool.py v3.0 Generated /path/to/hello_world/build/aws_demos.bin Project build complete. To flash, run this command: esptool.py -p (PORT) -b 460800 --before default_reset --after hard_reset --chip esp32s2 write_flash --flash_mode dio --flash_size detect --flash_freq 80m 0x1000 build/bootloader/bootloader.bin 0x8000 build/partition_table/partition-table.bin 0x16000 build/ota_data_initial.bin 0x20000 build/aws_demos.bin or run 'idf.py -p (PORT) flash' ``` S'il n'y a aucune erreur, la compilation génère 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 l'utilisation du `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 supporte Unix Makefile et 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=esp32s2_saola_1 -DCOMPILER=xtensa-esp32s2 -S . -B ./{{YOUR_BUILD_DIRECTORY}} -DAFR_ENABLE_ALL_MODULES=1 -DAFR_ENABLE_TESTS=0 ``` + Avec Ninja ``` cmake -DVENDOR=espressif -DBOARD=esp32s2_saola_1 -DCOMPILER=xtensa-esp32s2 -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 ``` ## Informations supplémentaires Pour plus d'informations sur l'utilisation et le dépannage des cartes Espressif ESP32, consultez les rubriques suivantes : + [Utilisation de FreeRTOS dans votre propre projet CMake pour ESP32](getting_started_espressif.md#getting_started_espressif_cmake_project) + [Résolution des problèmes](getting_started_espressif.md#getting_started_espressif_troubleshooting) + [Débogage](getting_started_espressif.md#getting_started_espressif_debugging)