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émos de FreeRTOS
FreeRTOS inclut quelques applications de démonstration dans `demos` le dossier, sous le répertoire principal de FreeRTOS. Tous les exemples pouvant être exécutés par FreeRTOS apparaissent dans `common` le dossier, sous. `demos` Il existe également un dossier pour chaque plateforme qualifiée pour FreeRTOS sous le dossier. `demos`
Avant de tester la démonstration des applications, nous vous recommandons de terminer le didacticiel [Commencez avec FreeRTOS](freertos-getting-started.md). Il explique comment configurer et exécuter la démo de l'agent CoreMQTT.
## Exécution des démos de FreeRTOS
Les rubriques suivantes expliquent comment configurer et exécuter les démos de FreeRTOS :
+ [Applications de démonstration Bluetooth Low Energy](ble-demo.md)
+ [Bootloader de démonstration pour le Microchip Curiosity MZEF PIC32](microchip-bootloader.md)
+ [AWS IoT Device Defender démo](dd-demo.md)
+ [AWS IoT Greengrass Application de démonstration V1 Discovery](gg-demov1.md)
+ [AWS IoT Greengrass V2](gg-demov2.md)
+ [Démos CoreHTTP](core-http-demo.md)
+ [AWS IoT Démo de la bibliothèque d'emplois](freertos-jobs-demo.md)
+ [Démos de CoreMQTT](mqtt-demo.md)
+ [Over-the-air met à jour l'application de démonstration](ota-demo.md)
+ [Démonstration du client Secure Sockets Echo](secure-sockets-demo.md)
+ [AWS IoT Application de démonstration Device Shadow](shadow-demo.md)
La `DEMO_RUNNER_RunDemos` fonction, située dans le `freertos/demos/demo_runner/iot_demo_runner.c` fichier, initialise un thread détaché sur lequel s'exécute une seule application de démonstration. Par défaut, appelle et démarre `DEMO_RUNNER_RunDemos` uniquement la démo de l'agent CoreMQTT. En fonction de la configuration que vous avez sélectionnée lors du téléchargement de FreeRTOS et de l'endroit où vous avez téléchargé FreeRTOS, les autres exemples de fonctions d'exécution peuvent démarrer par défaut. Pour activer une application de démonstration, ouvrez le `freertos/vendors/vendor/boards/board/aws_demos/config_files/aws_demo_config.h` fichier et définissez la démo que vous souhaitez exécuter.
**Note**
Les combinaisons d'exemples ne fonctionnent pas toutes ensemble. Selon la combinaison, il est possible que le logiciel ne s'exécute pas sur la cible sélectionnée en raison de contraintes de mémoire. Nous vous recommandons d'exécuter une démonstration à la fois.
## Configuration des démonstrations
Les démos ont été configurées pour vous aider à faire vos premiers pas rapidement. Il se peut que vous souhaitiez modifier certaines configurations pour que votre projet puisse créer une version qui s'exécute sur votre plateforme. Vous pouvez trouver les fichiers de configuration dans `vendors/vendor/boards/board/aws_demos/config_files`.
# Applications de démonstration Bluetooth Low Energy
**Important**
Cette démo est hébergée sur le référentiel Amazon-FreeRTOS 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
## Présentation de
FreeRTOS Bluetooth Low Energy inclut trois applications de démonstration :
+ Démonstration [MQTT sur Bluetooth Low Energy](#ble-demo-mqtt)
Cette application montre comment utiliser le MQTT sur le service Bluetooth Low Energy.
+ Démonstration [Mise en service Wi-Fi](#ble-demo-wifi)
Cette application explique comment utiliser le service Bluetooth Low Energy Wi-Fi Provisioning.
+ Démonstration [Serveur d'attributs générique (GATT)](#ble-demo-server)
Cette application montre comment utiliser le APIs middleware Bluetooth Low Energy FreeRTOS pour créer un serveur GATT simple.
**Note**
Pour configurer et exécuter les démos de FreeRTOS, suivez les étapes décrites dans. [Commencez avec FreeRTOS](freertos-getting-started.md)
## Conditions préalables
Pour suivre ces démonstrations, vous avez besoin d'un microcontrôleur équipé de fonctionnalités Bluetooth Low Energy. Vous avez également besoin du [SDK iOS pour appareils Bluetooth FreeRTOS](freertos-ble-mobile.md#freertos-ble-ios) ou du [SDK Android pour appareils Bluetooth FreeRTOS](freertos-ble-mobile.md#freertos-ble-android).
### Configuration AWS IoT et Amazon Cognito pour FreeRTOS Bluetooth Low Energy
Pour connecter vos AWS IoT appareils à MQTT, vous devez configurer Amazon AWS IoT Cognito.
**Pour configurer AWS IoT**
1. Créez un AWS compte sur [https://aws.amazon.com/](https://aws.amazon.com/).
1. Ouvrez la [console AWS IoT](https://console.aws.amazon.com/iot/), puis, dans le volet de navigation, choisissez **Gérer**, puis **Objets**.
1. Choisissez **Créer**, puis **Créer un seul objet**.
1. Entrez un nom pour votre appareil, puis choisissez **Suivant**.
1. Si vous connectez votre microcontrôleur au cloud via un appareil mobile, choisissez **Créer un objet sans certificat**. Étant donné que le mobile SDKs utilise Amazon Cognito pour l'authentification des appareils, il n'est pas nécessaire de créer un certificat d'appareil pour les démonstrations utilisant Bluetooth Low Energy.
Si vous connectez votre microcontrôleur au cloud directement par Wi-Fi, choisissez **Créer un certificat**, puis **Activer**, puis téléchargez le certificat, la clé publique et la clé privée de l'objet.
1. Choisissez l'objet que vous venez de créer dans la liste des objets enregistrés, puis choisissez **Interagir** à partir de la page de l'objet. Notez le point de terminaison de l' AWS IoT API REST.
Pour plus d'informations sur la configuration, consultez la section [Getting Started with AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-gs.html).
**Pour créer un groupe d'utilisateurs Amazon Cognito**
1. Ouvrez la console Amazon Cognito et choisissez **Gérer les groupes d'utilisateurs**.
1. Sélectionnez **Create a user pool**.
1. Attribuez un nom au groupe d'utilisateurs, puis choisissez **Consulter les valeurs par défaut**.
1. Dans le volet de navigation, choisissez **Clients d'application**, puis **Ajouter un client d'application**.
1. Tapez un nom pour le client d'application, puis cliquez sur **Créer un client d'application**.
1. Dans le volet de navigation, sélectionnez **Vérification**, puis **Créer un groupe**.
Prenez note de l'ID du groupe qui s'affiche sur la page **Paramètres généraux** de votre groupe d'utilisateurs.
1. Dans le volet de navigation, choisissez **Clients d'application**, puis **Afficher les détails**. Notez l'ID et le code secret du client d'application.
**Pour créer un pool d'identités Amazon Cognito**
1. Ouvrez la console Amazon Cognito et choisissez **Manage Identity** Pools.
1. Saisissez un nom pour le groupe d'identités.
1. Développez **Fournisseurs d'authentification**, choisissez l'onglet **Cognito**, puis entrez l'ID de votre groupe d'utilisateurs et l'ID du client d'application.
1. Sélectionnez **Créer une réserve**.
1. Développez **Afficher les détails** et notez les deux noms de rôle IAM. Choisissez **Autoriser** pour créer les rôles IAM pour les identités authentifiées et non authentifiées afin d'accéder à Amazon Cognito.
1. Choisissez **Edit identity groupe (Modifier le groupe d'identités)**. Prenez note de l'ID du groupe d'identités. Il devrait avoir la forme `us-west-2:12345678-1234-1234-1234-123456789012`.
Pour plus d'informations sur la configuration d'Amazon Cognito, consultez la section [Getting Started with Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-getting-started.html).
**Pour créer et associer une politique IAM à l'identité authentifiée**
1. Ouvrez la console IAM, puis dans le volet de navigation, sélectionnez **Rôles**.
1. Recherchez et choisissez le rôle de votre identité authentifiée, choisissez **Attacher des stratégies**, puis **Ajouter une stratégie en ligne**.
1. Choisissez l'onglet **JSON**, puis collez le JSON suivant :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"iot:AttachPolicy",
"iot:AttachPrincipalPolicy",
"iot:Connect",
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:GetThingShadow",
"iot:UpdateThingShadow",
"iot:DeleteThingShadow"
],
"Resource":[
"*"
]
}
]
}
```
------
1. Choisissez **Examiner une stratégie**, entrez un nom pour la stratégie, puis choisissez **Créer une stratégie**.
Gardez vos informations AWS IoT et celles d'Amazon Cognito à portée de main. Vous avez besoin du point de terminaison et IDs de l'authentification de votre application mobile auprès du AWS Cloud.
### Configurez votre environnement FreeRTOS pour Bluetooth Low Energy
Pour configurer votre environnement, vous devez télécharger FreeRTOS sur votre microcontrôleur, puis télécharger et configurer [Bibliothèque Bluetooth Low Energy](freertos-ble-library.md) le SDK mobile pour les appareils Bluetooth FreeRTOS sur votre appareil mobile.
**Pour configurer l'environnement de votre microcontrôleur avec FreeRTOS Bluetooth Low Energy**
1. Téléchargez ou clonez FreeRTOS depuis. [GitHub](https://github.com/aws/amazon-freertos) Consultez le fichier [README.md](https://github.com/aws/amazon-freertos/blob/main/README.md) pour obtenir des instructions.
1. Configurez FreeRTOS sur votre microcontrôleur.
[Pour plus d'informations sur la prise en main de FreeRTOS sur un microcontrôleur compatible FreeRTOS, consultez le guide de votre carte dans Getting Started with FreeRTOS.](https://docs.aws.amazon.com/freertos/latest/userguide/freertos-getting-started.html)
**Note**
Vous pouvez exécuter les démos sur n'importe quel microcontrôleur compatible Bluetooth Low Energy doté de FreeRTOS et de bibliothèques FreeRTOS Bluetooth Low Energy portées. Actuellement, le projet de démonstration [MQTT sur Bluetooth Low Energy](#ble-demo-mqtt) FreeRTOS est entièrement porté sur les appareils Bluetooth Low Energy suivants :
[Espressif ESP32 - DevKit C et le ESP-WROVER-KIT](https://docs.aws.amazon.com/freertos/latest/userguide/getting_started_espressif.html)
[Nordic en RF52840 -DK](https://docs.aws.amazon.com/freertos/latest/userguide/getting_started_nordic.html)
## Composants communs
Les applications de démonstration FreeRTOS ont deux composants communs :
+ Network Manager
+ Application de démonstration du kit SDK pour appareils mobiles Bluetooth Low Energy
### Network Manager
Le gestionnaire de réseau gère la connexion réseau de vos microcontrôleurs. Il se trouve dans votre répertoire FreeRTOS à l'adresse. `demos/network_manager/aws_iot_network_manager.c` Si le gestionnaire de réseau est activé pour Wi-Fi et Bluetooth Low Energy, les démonstrations commencent avec Bluetooth Low Energy par défaut. Si la connexion Bluetooth Low Energy est interrompue et que votre carte mère l'est Wi-Fi-enabled, le gestionnaire de réseau passe à une connexion Wi-Fi disponible pour vous empêcher de vous déconnecter du réseau.
Pour activer un type de connexion réseau avec le Network Manager, ajoutez le type de connexion réseau au `configENABLED_NETWORKS` paramètre dans `vendors/vendor/boards/board/aws_demos/config_files/aws_iot_network_config.h` (où *vendor* il s'agit du nom du fournisseur et du nom de la carte que vous utilisez pour exécuter les démos). *board*
Par exemple, si Bluetooth Low Energy et le Wi-Fi sont tous les deux activés, la ligne qui commence par `#define configENABLED_NETWORKS` dans `aws_iot_network_config.h` se présente comme suit :
```
#define configENABLED_NETWORKS ( AWSIOT_NETWORK_TYPE_BLE | AWSIOT_NETWORK_TYPE_WIFI )
```
Pour obtenir une liste des types de connexion réseau actuellement pris en charge, consultez les lignes qui commencent par `#define AWSIOT_NETWORK_TYPE` dans `aws_iot_network.h`.
### Application de démonstration du SDK FreeRTOS Bluetooth Low Energy Mobile
[L'application de démonstration du SDK FreeRTOS Bluetooth Low Energy Mobile se trouve GitHub sur le SDK [Android pour les appareils Bluetooth FreeRTOS sous et `amazon-freertos-ble-android-sdk/app` sur le SDK iOS pour les appareils Bluetooth FreeRTOS sous](https://github.com/aws/amazon-freertos-ble-android-sdk).](https://github.com/aws/amazon-freertos-ble-ios-sdk) `amazon-freertos-ble-ios-sdk/Example/AmazonFreeRTOSDemo` Dans cet exemple, nous utilisons des captures d'écran de la version iOS de l'application de démonstration pour mobile.
**Note**
Si vous utilisez un appareil iOS, vous avez besoin de Xcode pour générer l’application de démonstration pour mobile. Si vous utilisez un appareil Android, vous pouvez utiliser Android Studio pour générer l’application de démonstration pour mobile.
**Pour configurer l'application de démonstration du kit SDK iOS**
Lorsque vous définissez des variables de configuration, utilisez le format des valeurs d'espace réservé prévu dans les fichiers de configuration.
1. Confirmez que le [SDK iOS pour appareils Bluetooth FreeRTOS](freertos-ble-mobile.md#freertos-ble-ios) est installé.
1. Exécutez la commande suivante à partir de `amazon-freertos-ble-ios-sdk/Example/AmazonFreeRTOSDemo/` :
```
$ pod install
```
1. Ouvrez le projet `amazon-freertos-ble-ios-sdk/Example/AmazonFreeRTOSDemo/AmazonFreeRTOSDemo.xcworkspace` avec Xcode et remplacez le compte développeur de signature par votre compte.
1. Créez une AWS IoT politique dans votre région (si ce n'est pas déjà fait).
**Note**
Cette politique est différente de la politique IAM créée pour l'identité authentifiée Amazon Cognito.
1. Ouvrez la [AWS IoT console](https://console.aws.amazon.com/iot/).
1. Dans le volet de navigation, choisissez successivement **Sécurisé**, **Stratégies** et **Créer**. Entrez un nom pour identifier votre stratégie. Dans la section **Ajouter des instructions**, choisissez **Mode avancé**. Copiez et collez le code JSON suivant dans la fenêtre de l'éditeur de stratégie. Remplacez *aws-region* et *aws-account* par votre AWS région et votre numéro de compte.
1. Choisissez **Créer**.
1. Ouvrez `amazon-freertos-ble-ios-sdk/Example/AmazonFreeRTOSDemo/AmazonFreeRTOSDemo/Amazon/AmazonConstants.swift` et redéfinissez les variables suivantes :
+ `region`: Votre AWS région.
+ `iotPolicyName`: le nom AWS IoT de votre police.
+ `mqttCustomTopic` : la rubrique MQTT dans laquelle vous voulez publier.
1. Ouvrir `amazon-freertos-ble-ios-sdk/Example/AmazonFreeRTOSDemo/AmazonFreeRTOSDemo/Support/awsconfiguration.json`.
Sous `CognitoIdentity`, redéfinissez les variables suivantes :
+ `PoolId`: l'identifiant de votre pool d'identités Amazon Cognito.
+ `Region`: Votre AWS région.
Sous `CognitoUserPool`, redéfinissez les variables suivantes :
+ `PoolId`: l'identifiant de votre groupe d'utilisateurs Amazon Cognito.
+ `AppClientId` : ID de votre client d'application.
+ `AppClientSecret` : clé secrète de votre client d'application.
+ `Region`: Votre AWS région.
**Pour configurer l'application de démonstration du kit SDK Android**
Lorsque vous définissez des variables de configuration, utilisez le format des valeurs d'espace réservé prévu dans les fichiers de configuration.
1. Confirmez que le [SDK Android pour appareils Bluetooth FreeRTOS](freertos-ble-mobile.md#freertos-ble-android) est installé.
1. Créez une AWS IoT politique dans votre région (si ce n'est pas déjà fait).
**Note**
Cette politique est différente de la politique IAM créée pour l'identité authentifiée Amazon Cognito.
1. Ouvrez la [AWS IoT console](https://console.aws.amazon.com/iot/).
1. Dans le volet de navigation, choisissez successivement **Sécurisé**, **Stratégies** et **Créer**. Entrez un nom pour identifier votre stratégie. Dans la section **Ajouter des instructions**, choisissez **Mode avancé**. Copiez et collez le code JSON suivant dans la fenêtre de l'éditeur de stratégie. Remplacez *aws-region* et *aws-account* par votre AWS région et votre numéro de compte.
1. Choisissez **Créer**.
1. Ouvrez [ https://github.com/aws/amazon-freertos-ble-android- sdk/blob/master/app/src/main/java/software/amazon/freertos/demo/DemoConstants .java](https://github.com/aws/amazon-freertos-ble-android-sdk/blob/master/app/src/main/java/software/amazon/freertos/demo/DemoConstants.java) et redéfinissez les variables suivantes :
+ `AWS_IOT_POLICY_NAME`: le nom AWS IoT de votre police.
+ `AWS_IOT_REGION`: Votre AWS région.
1. Ouvrez [ https://github.com/aws/amazon-freertos-ble-android- sdk/blob/master/app/src/main/res/raw/awsconfiguration .json.](https://github.com/aws/amazon-freertos-ble-android-sdk/blob/master/app/src/main/res/raw/awsconfiguration.json)
Sous `CognitoIdentity`, redéfinissez les variables suivantes :
+ `PoolId`: l'identifiant de votre pool d'identités Amazon Cognito.
+ `Region`: Votre AWS région.
Sous `CognitoUserPool`, redéfinissez les variables suivantes :
+ `PoolId`: l'identifiant de votre groupe d'utilisateurs Amazon Cognito.
+ `AppClientId` : ID de votre client d'application.
+ `AppClientSecret` : clé secrète de votre client d'application.
+ `Region`: Votre AWS région.
**Pour découvrir et établir des connexions sécurisées avec votre microcontrôleur sur Bluetooth Low Energy**
1. Pour coupler votre microcontrôleur et votre appareil mobile en toute sécurité (étape 6), vous avez besoin d'un émulateur de terminal série doté à la fois de capacités d'entrée et de sortie (par exemple). TeraTerm Configurez le terminal pour vous connecter à votre carte via une connexion série, comme indiqué dans [Installation d'un émulateur de terminal](gsg-troubleshooting.md#uart-term).
1. Exécutez le projet de démonstration Bluetooth Low Energy sur votre microcontrôleur.
1. Exécutez l'application de démonstration du kit SDK mobile Bluetooth Low Energy sur votre appareil mobile.
Pour démarrer l'application de démonstration dans le kit SDK Android à partir de la ligne de commande, exécutez la commande suivante :
```
$ ./gradlew installDebug
```
1. Confirmez que votre microcontrôleur s'affiche sous **Appareils** dans l'application de démonstration du kit SDK mobile Bluetooth Low Energy.
![\[Page de gestion des appareils affichant un ESP32 appareil avec son identifiant unique.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/ble-device-list1.png)
**Note**
Tous les appareils équipés de FreeRTOS et du service d'information sur les appareils `freertos/.../device_information` () situés à portée apparaissent dans la liste.
1. Choisissez votre microcontrôleur dans la liste d'appareils. L'application établit une connexion avec la carte, et une ligne verte s'affiche en regard de l'appareil connecté.
![\[ESP32 ID de l'appareil affiché.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/ble-device-list2.png)
Vous pouvez vous déconnecter de votre microcontrôleur en faisant glisser la ligne vers la gauche.
![\[Page des appareils affichant un identifiant d' ESP32 appareil et un autre identifiant d'appareil.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/ble-device-list3.png)
1. Si vous y êtes invité, couplez votre microcontrôleur et votre appareil mobile.
![\[Sortie de console indiquant la déconnexion de l'appareil BLE, la déconnexion du service MQTT, le démarrage de la publicité, la connexion BLE au périphérique distant et une invite de comparaison numérique.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/pairing-board.png)
![\[Boîte de dialogue de demande de couplage Bluetooth pour l'appareil « ESP32 » affichant le code « 465520 » pour confirmer l'activation de « ». ESP32\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/pairing-mobile.png)
Si le code de comparaison numérique est le même pour les deux appareils, associez-les.
**Note**
L'application de démonstration du SDK Bluetooth Low Energy Mobile utilise Amazon Cognito pour l'authentification des utilisateurs. Assurez-vous que vous avez configuré un utilisateur et des groupes d'identités Amazon Cognito, et que vous avez associé des politiques IAM aux identités authentifiées.
## MQTT sur Bluetooth Low Energy
Dans la démonstration MQTT over Bluetooth Low Energy, votre microcontrôleur publie des messages dans le AWS Cloud via un proxy MQTT.
**Pour vous abonner à une rubrique MQTT de démonstration**
1. Connectez-vous à la AWS IoT console.
1. Dans le volet de navigation, choisissez **Test**, puis choisissez **MQTT test client** pour ouvrir le client MQTT.
1. Dans le champ **Rubrique d'abonnement**, saisissez ***thing-name*/example/topic1**, puis choisissez **S'abonner à la rubrique**.
Si vous utilisez Bluetooth Low Energy pour associer le microcontrôleur à votre appareil mobile, les messages MQTT sont acheminés via l'application de démonstration du kit SDK Bluetooth Low Energy mobile sur votre appareil mobile.
**Pour activer la démonstration via Bluetooth Low Energy**
1. Ouvrez `vendors/vendor/boards/board/aws_demos/config_files/aws_demo_config.h` et définissez `CONFIG_MQTT_BLE_TRANSPORT_DEMO_ENABLED`.
1. Ouvrez `demos/include/aws_clientcredential.h` et configurez `clientcredentialMQTT_BROKER_ENDPOINT` avec le point de terminaison du AWS IoT courtier. Configurez `clientcredentialIOT_THING_NAME` avec le nom de l'objet du microcontrôleur BLE. Le point de terminaison du AWS IoT broker peut être obtenu à partir de la AWS IoT console en choisissant **Paramètres** dans le volet de navigation de gauche, ou via la CLI en exécutant la commande :`aws iot describe-endpoint --endpoint-type=iot:Data-ATS`.
**Note**
Le point de terminaison du AWS IoT courtier et le nom de l'objet doivent tous deux se trouver dans la même région où l'identité cognito et le groupe d'utilisateurs sont configurés.
**Pour exécuter la démonstration**
1. Créez et exécutez le projet de démonstration sur votre microcontrôleur.
1. Assurez-vous que vous avez associé votre carte et votre appareil mobile à l'aide de l'[Application de démonstration du SDK FreeRTOS Bluetooth Low Energy Mobile](#ble-sdk-app).
1. Dans la liste **Appareils** de d'application mobile de démonstration, choisissez votre microcontrôleur, puis choisissez **MQTT Proxy** pour ouvrir les paramètres de proxy MQTT.
![\[Liste des trois ESP32 appareils IDs, avec les options MQTT Proxy, Network Config et Custom GATT MQTT ci-dessous.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/ble-device-list4.png)
1. Une fois que vous avez activé le proxy MQTT, les messages MQTT apparaissent dans la rubrique `thing-name/example/topic1`, et les données sont imprimées sur le terminal UART.
## Mise en service Wi-Fi
Wi-Fi Provisioning est un service FreeRTOS Bluetooth Low Energy qui vous permet d'envoyer en toute sécurité les informations d'identification du réseau Wi-Fi d'un appareil mobile à un microcontrôleur via Bluetooth Low Energy. Le code source de la mise en service Wi-Fi est disponible sous `freertos/.../wifi_provisioning`.
**Note**
La démo de provisionnement Wi-Fi est actuellement prise en charge sur l'Espressif - C. ESP32 DevKit
**Pour activer la démonstration**
1. Activez le service de mise en service Wi-Fi. Ouvrez `vendors/vendor/boards/board/aws_demos/config_files/iot_ble_config.h` et réglez `#define IOT_BLE_ENABLE_WIFI_PROVISIONING` sur `1` (où *vendor* il s'agit du nom du fournisseur et du *board* nom de la carte que vous utilisez pour exécuter les démos).
**Note**
Le service de mise en service Wi-Fi est désactivé par défaut.
1. Configurez le [Network Manager](#ble-demo-network-manager) pour activer Bluetooth Low Energy et Wi-Fi.
**Pour exécuter la démonstration**
1. Créez et exécutez le projet de démonstration sur votre microcontrôleur.
1. Assurez-vous d'avoir jumelé votre microcontrôleur et votre appareil mobile à l'aide du[Application de démonstration du SDK FreeRTOS Bluetooth Low Energy Mobile](#ble-sdk-app).
1. Dans la liste **Devices (Appareils)** de l'application mobile de démonstration, choisissez votre microcontrôleur, puis choisissez **Network Config (Configuration réseau)** pour ouvrir les paramètres de configuration du réseau.
![\[Liste des trois ESP32 appareils IDs, avec les options MQTT Proxy, Network Config et Custom GATT MQTT ci-dessous.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/ble-device-list4.png)
1. Une fois que vous avez choisi **Network Config** pour votre carte, le microcontrôleur envoie une liste des réseaux à proximité à l'appareil mobile. Les réseaux Wi-Fi disponibles s'affichent dans une liste sous **Scanned Networks**.
![\[ESP32 interface de gestion des appareils n'affichant aucun réseau enregistré, deux réseaux Wi-Fi ouverts scannés, l'un avec WPA2 sécurité et RSSI de -29, l'autre avec sécurité ouverte et RSSI de -50.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/ble-network-config1.png)
Dans la liste **Scanned Networks**, choisissez votre réseau, puis saisissez le SSID et le mot de passe, le cas échéant.
![\[Boîte de dialogue de saisie du mot de passe du réseau Wi-Fi avec champ de mot de passe vide, boutons Annuler et Enregistrer.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/ble-wifi-password.png)
Le microcontrôleur se connecte au réseau et l'enregistre. Le réseau s'affiche sous **Réseaux enregistrés**.
![\[Interface réseau affichant WiFi les réseaux enregistrés et scannés, l'un sécurisé par WPA2, l'autre ouvert, avec des indicateurs de puissance du signal.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/ble-network-config2.png)
Vous pouvez enregistrer plusieurs réseaux dans l'application mobile de démonstration. Lorsque vous redémarrez l'application et la démonstration, le microcontrôleur se connecte au premier réseau enregistré disponible, en commençant par le haut de la liste **Saved Networks**.
Pour modifier l'ordre de priorité des réseaux ou pour supprimer des réseaux, sur la page **Network Configuration**, choisissez **Editing Mode**. Pour modifier l'ordre de priorité des réseaux, sélectionnez le côté droit du réseau dont vous souhaitez modifier la priorité, puis faites-le glisser vers le haut ou vers le bas. Pour supprimer un réseau, sélectionnez le bouton rouge sur le côté gauche du réseau que vous souhaitez supprimer.
![\[Écran des paramètres du réseau Wi-Fi affichant les réseaux enregistrés, les options de modification pour supprimer ou modifier la priorité et les réseaux scannés.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/ble-network-editing.png)
## Serveur d'attributs générique (GATT)
Dans cet exemple, une application de serveur d'attributs génériques (GATT) de démonstration sur votre microcontrôleur envoie une simple valeur de compteur à l'[Application de démonstration du SDK FreeRTOS Bluetooth Low Energy Mobile](#ble-sdk-app).
À l'aide du Bluetooth Low Energy Mobile SDKs, vous pouvez créer votre propre client GATT pour un appareil mobile qui se connecte au serveur GATT sur votre microcontrôleur et fonctionne en parallèle avec l'application mobile de démonstration.
**Pour activer la démonstration**
1. Activez la démonstration GATT Bluetooth Low Energy. Dans `vendors/vendor/boards/board/aws_demos/config_files/iot_ble_config.h` (où *vendor* il s'agit du nom du fournisseur et du *board* tableau que vous utilisez pour exécuter les démos), ajoutez `#define IOT_BLE_ADD_CUSTOM_SERVICES ( 1 )` à la liste des instructions de définition.
**Note**
La démonstration GATT Bluetooth Low Energy est désactivée par défaut.
1. Ouvrez `freertos/vendors/vendor/boards/board/aws_demos/config_files/aws_demo_config.h`, commentez `#define CONFIG_CORE_MQTT_MUTUAL_AUTH_DEMO_ENABLED` et définissez `CONFIG_BLE_GATT_SERVER_DEMO_ENABLED`.
**Pour exécuter la démonstration**
1. Créez et exécutez le projet de démonstration sur votre microcontrôleur.
1. Assurez-vous que vous avez associé votre carte et votre appareil mobile à l'aide de l'[Application de démonstration du SDK FreeRTOS Bluetooth Low Energy Mobile](#ble-sdk-app).
1. Dans la liste **Appareils** de d'application, choisissez votre carte, puis choisissez **MQTT Proxy** pour ouvrir les options de proxy MQTT.
![\[Liste des trois ESP32 appareils IDs, avec les options MQTT Proxy, Network Config et Custom GATT MQTT ci-dessous.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/ble-device-list4.png)
1. Revenez à la liste **Appareils**, choisissez votre carte, puis choisissez **Custom GATT MQTT** pour ouvrir les options personnalisées du service GATT.
1. Choisissez **Start Counter** pour commencer à publier des données à la rubrique MQTT ***your-thing-name*/example/topic**.
Une fois que vous avez activé le proxy MQTT, Hello World et des messages de compteur incrémentiels s'affichent sur la rubrique `your-thing-name/example/topic`.
# Bootloader de démonstration pour le Microchip Curiosity MZEF PIC32
**Important**
Cette démo est hébergée sur le référentiel Amazon-FreeRTOS 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
**Note**
En accord avec Microchip, nous retirons le Curiosity PIC32 MZEF (DM320104) de la branche principale du référentiel FreeRTOS Reference Integration et ne le proposerons plus dans les nouvelles versions. Microchip a publié un [avis officiel indiquant](https://www.microchip.com/DevelopmentTools/ProductDetails/PartNO/DM320104) que le PIC32 MZEF (DM320104) n'est plus recommandé pour les nouveaux modèles. Les projets et le code source de PIC32 MZEF sont toujours accessibles via les balises de version précédentes. Microchip recommande aux clients d'utiliser la [carte de développement Curiosity PIC32 MZ-EF-2.0 (DM320209](https://devices.amazonaws.com/detail/a3G0h0000077I69EAE/Curiosity-PIC32MZ-EF-2-0-Development-Board)) pour les nouvelles conceptions. La PIC32 MZv1 plate-forme se trouve toujours dans la version [v202012.00 du](https://github.com/aws/amazon-freertos/tree/202012.00) référentiel FreeRTOS Reference Integration. Cependant, la plateforme n'est plus prise en charge par la version [v202107.00 du](https://github.com/aws/amazon-freertos/tree/202107.00) FreeRTOS Reference.
Cette démonstration du chargeur de démarrage implémente le contrôle de la version du microprogramme, la vérification de la signature de chiffrement et le test automatique de l'application. Ces fonctionnalités prennent en charge les mises à jour du microprogramme over-the-air (OTA) pour FreeRTOS.
La vérification du microprogramme inclut la vérification de l'intégrité et l'authenticité des nouveaux micrologiciels reçus à distance. Le chargeur de démarrage vérifie la signature cryptographique de l'application avant le démarrage. La démonstration utilise l'algorithme ECDSA (Elliptic Curve Digital Signature Algorithm) sur SHA256. Les utilitaires fournis peuvent être utilisés pour générer une application signée qui peut être flashée sur le périphérique.
Le chargeur de démarrage prend en charge les fonctionnalités suivantes requises pour OTA :
+ Gère les images d'application sur l'appareil et les basculements de l'une à l'autre.
+ Autorise l'exécution d'un test automatique de l'image OTA reçue et annule en cas d'échec.
+ Vérifie la signature et la version de l'image de la mise à jour OTA.
**Note**
Pour configurer et exécuter les démos de FreeRTOS, suivez les étapes décrites dans. [Commencez avec FreeRTOS](freertos-getting-started.md)
## États du chargeur de démarrage
Le processus du chargeur de démarrage est présenté dans la machine d'état suivante.
![\[Démarrez la machine à états Bootloader affichant les états d'initialisation, de vérification, d'exécution et d'erreur avec l'option Notify Error.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/bootloader-states.png)
Le tableau suivant décrit les états du chargeur de démarrage.
| État du chargeur de démarrage | Description |
| --- | --- |
| Initialisation | Le chargeur de démarrage est dans l'état d'initialisation. |
| Vérification | Le chargeur de démarrage vérifie les images présentes sur l'appareil. |
| Exécuter l'image | Le chargeur de démarrage lance l'image sélectionnée. |
| Exécuter par défaut | Le chargeur de démarrage lance l'image par défaut. |
| Erreur | Le chargeur de démarrage est dans l'état d'erreur. |
Dans le schéma précédent, `Execute Image` et `Execute Default` ont tous deux l'état `Execution`.
**Etat d'exécution du chargeur de démarrage**
Le chargeur de démarrage est dans l'état `Execution` et est prêt à lancer l'image vérifiée sélectionnée. Si l'image à lancer se trouve dans la banque supérieure, les banques sont échangées avant l'exécution de l'image, car l'application est toujours créée pour la banque inférieure.
**Etat d'exécution du chargeur de démarrage par défaut**
Si l'option de configuration pour lancer l'image par défaut est activée, le chargeur de démarrage lance l'application à partir d'une adresse d'exécution par défaut. Cette option doit être désactivée sauf pendant le débogage.
**État d'erreur du chargeur de démarrage**
Le chargeur de démarrage est dans un état d'erreur et aucune image valide n'est présente sur l'appareil. Le chargeur de démarrage doit informer l'utilisateur. L'implémentation par défaut envoie un message de journal à la console et le voyant lumineux de la carte clignote rapidement et indéfiniment.
## Périphérique flash
La plateforme Microchip Curiosity PIC32 MZEF contient un flash de programme interne de deux mégaoctets (Mo) divisé en deux banques. Il prend en charge la permutation des cartographies mémoire entre ces deux banques, ainsi que les mises à jour en direct. Le chargeur de démarrage de démonstration est programmé dans une autre région flash du démarrage inférieur.
![\[Schéma de configuration de la mémoire montrant les régions Lower Boot Flash, Lower Program Flash de 1 Mo et Upper Program Flash de 2 Mo mappées respectivement au Bootloader, à la banque d'applications 0 et à la banque d'applications 1.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/flash-device.png)
## Structure d'image d'application
![\[Structure d'image OTA montrant les sections d'en-tête, de descripteur, de binaire d'application (signé par le service de signature) et de bande-annonce avec des champs tels que le code magique, les numéros de séquence, les adresses de début et de fin, l'adresse d'exécution, l'identifiant du matériel.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/application-image-structure.png)
Le schéma illustre les principaux composants de l'image d'application stockée sur chaque banque de l'appareil.
| Composant | Taille (en octets) |
| --- | --- |
| En-tête d'image | 8 bytes |
| Descripteur d'image | 24 bytes |
| Application binaire | < 1 Mo - (324) |
| Trailer | 292 bytes |
## En-tête d'image
Les images des applications présentes sur l'appareil doivent commencer par un en-tête qui se compose d'un code magique et d'indicateurs d'image.
| Champ d'en-tête | Taille (en octets) |
| --- | --- |
| Code magique | 7 octets |
| Indicateurs d'image | 1 octet |
### Code magique
L'image sur l'appareil flash doit commencer par un code magique. Le code magique par défaut est `@AFRTOS`. Le chargeur de démarrage vérifie si un code magique valide est présent avant de démarrer l'image. Il s'agit de la première étape de la vérification.
### Indicateurs d'image
Les indicateurs d'image sont utilisés pour stocker le statut des images d'application. Les indicateurs sont utilisés dans le processus OTA. Les indicateurs d'image des deux banques déterminent l'état de l'appareil. Si l'image en cours d'exécution est marquée comme validation en attente, cela signifie que l'appareil est dans la phase de test automatique OTA. Même si les images sur les appareils sont marquées comme valides, elles passent par les mêmes étapes de vérification à chaque démarrage. Si une image est marquée comme nouvelle, le chargeur de démarrage la marque comme en attente de validation et la lance pour le test automatique après la vérification. Le chargeur de démarrage initialise et démarre aussi le temporisateur de surveillance de telle sorte que si la nouvelle image OTA échoue au test automatique, l'appareil redémarre et le chargeur de démarrage rejette l'image en l'effaçant et en exécutant l'image précédente valide.
L'appareil ne peut avoir qu'une seule image valide. L'autre image peut être une nouvelle image OTA ou une validation en attente (test automatique). Après une mise à jour OTA réussie, l'ancienne image est effacée de l'appareil.
| Statut | Valeur | Description |
| --- | --- | --- |
| Nouvelle image | 0xFF | L'image d'application est nouvelle et jamais exécutée. |
| Validation en attente | 0xFE | L'image d'application est marquée en vue de l'exécution du test. |
| Valide | 0xFC | L'image d'application est marquée comme valide et validée. |
| Non valide | 0xF8 | L'image d'application est marquée comme non valide. |
## Descripteur d'image
L'image d'application sur l'appareil flash doit contenir le descripteur d'image après l'en-tête d'image. Le descripteur d'image est généré par un utilitaire de post-build qui utilise les fichiers de configuration (`ota-descriptor.config`) pour générer le descripteur approprié et l'ajouter à l'application binaire. Le résultat de cette étape post-build est l'image binaire qui peut être utilisée pour l'OTA.
| Champ descripteur | Taille (en octets) |
| --- | --- |
| Numéro de séquence | 4 bytes |
| Adresse de début | 4 bytes |
| Adresse de fin | 4 bytes |
| Adresse d'exécution | 4 bytes |
| ID matériel | 4 bytes |
| Instances réservées | 4 bytes |
**Numéro de séquence**
Le numéro de séquence doit être incrémenté avant de créer une nouvelle image OTA. Consultez le fichier `ota-descriptor.config`. Le chargeur de démarrage utilise ce nombre pour déterminer l'image à démarrer. Les valeurs valides sont comprises entre 1 et 4294967295.
**Adresse de début**
Adresse de début de l'image d'application sur l'appareil. Comme le descripteur d'image est préajouté à l'application binaire, cette adresse est le début du descripteur d'image.
**Adresse de fin**
Adresse de fin de l'image d'application sur l'appareil, à l'exclusion de la fin de l'image.
**Adresse d'exécution**
Adresse d'exécution de l'image.
**ID matériel**
ID matériel unique utilisé par le chargeur de démarrage pour vérifier que l'image OTA est conçue pour la bonne plateforme.
**Instances réservées**
Ce champ est réservé pour une utilisation future.
## Fin d'image
La fin d'image est ajoutée à l'application binaire. Elle contient la chaîne de type signature, la taille de la signature et la signature de l'image.
| Champ de fin | Taille (en octets) |
| --- | --- |
| Type de signature | 32 bytes |
| Taille de la signature | 4 bytes |
| Signature | 256 bytes |
**Type de signature**
Le type de signature est une chaîne qui représente l'algorithme de chiffrement utilisé et qui sert de marqueur pour la fin. Le chargeur de démarrage prend en charge l'algorithme ECDSA. La valeur par défaut est sig-sha256-ecdsa.
**Taille de la signature**
Taille de la signature de chiffrement, en octets.
**Signature**
Signature de chiffrement de l'application binaire préfixée par le descripteur de l'image.
## Configuration du chargeur de démarrage
Les options de base de configuration du chargeur de démarrage sont fournies dans `freertos/vendors/microchip/boards/curiosity_pic32mzef/bootloader/config_files/aws_boot_config.h`. Certaines options sont fournies à des fins de débogage uniquement.
**Activer le démarrage par défaut**
Active l'exécution de l'application à partir de l'adresse par défaut et doit être activé pour le débogage uniquement. L'image est exécutée à partir de l'adresse par défaut sans aucune vérification.
**Activer la vérification de la signature de chiffrement**
Active la vérification de la signature de chiffrement au démarrage. Les images défaillantes sont effacées de l'appareil. Cette option est fournie à des fins de débogage uniquement et doit rester activée en production.
**Effacer l'image non valide**
Active un effacement complet de la banque si la vérification de l'image sur cette banque échoue. Cette option est fournie à des fins de débogage uniquement et doit rester activée en production.
**Activer la vérification de l'ID du matériel**
Active la vérification de l'ID du matériel dans le descripteur de l'image OTA et l'ID matériel programmé dans le chargeur de démarrage. Facultatif. Peut être désactivé si la vérification de l'ID du matériel n'est pas obligatoire.
**Activer la vérification de l'adresse**
Active la vérification des adresses de début, de fin et d'exécution, dans le descripteur de l'image OTA. Nous vous recommandons de garder cette option activée.
## Création du chargeur de démarrage
Le bootloader de démonstration est inclus en tant que projet chargeable dans le `aws_demos` projet situé `freertos/vendors/microchip/boards/curiosity_pic32mzef/aws_demos/mplab/` dans le référentiel de code source FreeRTOS. Lorsque le projet `aws_demos` est créé, il crée d'abord le chargeur de démarrage, puis l'application. La sortie finale est une image hexadécimale unifiée incluant le chargeur de démarrage et l'application. L'utilitaire `factory_image_generator.py` est fourni pour générer une image hexadécimale unifiée avec signature de chiffrement. Les scripts du chargeur de démarrage sont situés dans `freertos/demos/ota/bootloader/utility/`.
### Étape de pré-build du chargeur de démarrage
Cette étape de pré-build exécute un script utilitaire appelé `codesigner_cert_utility.py` qui extrait la clé publique à partir du certificat de signature de code et génère un fichier d'en-tête C qui contient la clé publique au format codé ASN.1. Cet en-tête est compilé dans le projet du chargeur de démarrage. L'en-tête généré contient deux constantes : un tableau de la clé publique et la longueur de la clé. Le projet du chargeur de démarrage peut également être généré sans `aws_demos` et débogué comme une application normale.
# AWS IoT Device Defender démo
**Important**
Cette démo est hébergée sur le référentiel Amazon-FreeRTOS, 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
## Introduction
Cette démo vous montre comment utiliser la bibliothèque AWS IoT Device Defender pour vous connecter à [AWS IoT Device Defender](https://docs.aws.amazon.com/iot/latest/developerguide/device-defender.html). La démo utilise la bibliothèque CoreMQTT pour établir une connexion MQTT via TLS (authentification mutuelle) avec le courtier AWS IoT MQTT et la bibliothèque CoreJSON pour valider et analyser les réponses reçues du service. AWS IoT Device Defender La démo vous montre comment créer un rapport au format JSON à l'aide des métriques collectées à partir de l'appareil, et comment soumettre le rapport créé au AWS IoT Device Defender service. La démo montre également comment enregistrer une fonction de rappel dans la bibliothèque CoreMQTT pour gérer les réponses du AWS IoT Device Defender service afin de confirmer si un rapport envoyé a été accepté ou rejeté.
**Note**
Pour configurer et exécuter les démos de FreeRTOS, suivez les étapes décrites dans. [Commencez avec FreeRTOS](freertos-getting-started.md)
## Fonctionnalité
Cette démonstration crée une tâche d'application unique qui montre comment collecter des métriques, créer un rapport Device Defender au format JSON et le soumettre au AWS IoT Device Defender service via une connexion MQTT sécurisée au courtier AWS IoT MQTT. La démo inclut les métriques réseau standard ainsi que les métriques personnalisées. Pour les métriques personnalisées, la démo inclut :
+ Une métrique nommée « `task_numbers` » qui est une liste de tâches FreeRTOS. IDs Le type de cette métrique est « liste de nombres ».
+ Une métrique nommée « `stack_high_water_mark` » qui est le filigrane correspondant à la taille maximale de la tâche de l'application de démonstration. Le type de cette métrique est « nombre ».
La manière dont nous collectons les métriques réseau dépend de la pile TCP/IP utilisée. Pour FreeRTOS\$1TCP et les configurations LWip prises en charge, nous proposons des implémentations de collecte de métriques qui collectent des métriques réelles à partir de l'appareil et les soumettent dans le rapport. AWS IoT Device Defender [Vous pouvez trouver les implémentations pour [FreeRTOS\$1TCP](https://github.com/aws/amazon-freertos/blob/main/demos/device_defender_for_aws/metrics_collector/freertos_plus_tcp/metrics_collector.c) et LWiP sur.](https://github.com/aws/amazon-freertos/blob/main/demos/device_defender_for_aws/metrics_collector/lwip/metrics_collector.c) GitHub
Pour les cartes utilisant une autre pile TCP/IP, nous fournissons des définitions provisoires des fonctions de collecte de métriques qui renvoient des zéros pour toutes les métriques réseau. Implémentez les fonctions `freertos/demos/device_defender_for_aws/metrics_collector/stub/metrics_collector.c` de votre pile réseau afin d'envoyer des métriques réelles. Le fichier est également disponible sur le [ GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/device_defender_for_aws/metrics_collector/stub/metrics_collector.c)site Web.
En effet ESP32, la configuration LWip par défaut n'utilise pas le verrouillage du noyau et, par conséquent, la démo utilisera des métriques bloquées. Si vous souhaitez utiliser l'implémentation de la collecte de métriques LWip de référence, définissez les macros suivantes dans : `lwiopts.h`
```
#define LINK_SPEED_OF_YOUR_NETIF_IN_BPS 0
#define LWIP_TCPIP_CORE_LOCKING 1
#define LWIP_STATS 1
#define MIB2_STATS 1
```
Voici un exemple de sortie lorsque vous exécutez la démo.
![\[Sortie du journal de console indiquant les événements de connexion MQTT, de publication et d'utilisation de la mémoire pour l' DemoThing application.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/Defender_p4_supported.png)
Si votre carte n'utilise pas FreeRTOS\$1TCP ou une configuration LWip prise en charge, le résultat ressemblera à ce qui suit.
![\[Messages de journal indiquant l'établissement d'une connexion MQTT, les tentatives d'abonnement à des rubriques, les charges utiles de publication et le traitement des paquets pour une application de démonstration.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/Defender_p4_unsupported.png)
Le code source de la démo se trouve dans le `freertos/demos/device_defender_for_aws/` répertoire de téléchargement ou sur le [GitHub](https://github.com/aws/amazon-freertos/tree/main/demos/device_defender_for_aws)site Web.
### Abonnement à des sujets AWS IoT Device Defender
La fonction [ subscribeToDefenderRubriques](https://github.com/aws/amazon-freertos/blob/main/demos/device_defender_for_aws/defender_demo.c#L514-L530) s'abonne aux rubriques MQTT pour lesquelles les réponses aux rapports Device Defender publiés seront reçues. Il utilise la macro `DEFENDER_API_JSON_ACCEPTED` pour créer la chaîne thématique sur laquelle les réponses aux signalements Device Defender acceptés sont reçues. Il utilise la macro `DEFENDER_API_JSON_REJECTED` pour créer la chaîne thématique sur laquelle les réponses aux signalements rejetés par Device Defender seront reçues.
### Collecte des métriques relatives aux appareils
La [ collectDeviceMetrics](https://github.com/aws/amazon-freertos/blob/main/demos/device_defender_for_aws/defender_demo.c#L376-L511)fonction collecte des métriques réseau à l'aide des fonctions définies dans`metrics_collector.h`. Les métriques collectées sont le nombre d'octets et de paquets envoyés et reçus, les ports TCP ouverts, les ports UDP ouverts et les connexions TCP établies.
### Génération du AWS IoT Device Defender rapport
La fonction [ generateDeviceMetricsReport génère un rapport](https://github.com/aws/amazon-freertos/blob/main/demos/device_defender_for_aws/defender_demo.c#L552-L581) Device Defender à l'aide de la fonction définie dans`report_builder.h`. Cette fonction prend les métriques réseau et une mémoire tampon, crée un document JSON au format attendu AWS IoT Device Defender et l'écrit dans la mémoire tampon fournie. Le format du document JSON attendu par AWS IoT Device Defender est spécifié dans les [métriques côté appareil](https://docs.aws.amazon.com/iot/latest/developerguide/detect-device-side-metrics.html) du Guide du *AWS IoT développeur*.
### Publication du AWS IoT Device Defender rapport
Le AWS IoT Device Defender rapport est publié sur la rubrique MQTT pour la publication de AWS IoT Device Defender rapports JSON. Le rapport est construit à l'aide de la macro`DEFENDER_API_JSON_PUBLISH`, comme indiqué dans cet [extrait de code](https://github.com/aws/amazon-freertos/blob/main/demos/device_defender_for_aws/defender_demo.c#L691-L695) sur le GitHub site Web.
### Rappel pour gérer les réponses
La fonction [PublishCallback](https://github.com/aws/amazon-freertos/blob/main/demos/device_defender_for_aws/defender_demo.c#L302-L373) gère les messages de publication MQTT entrants. Il utilise l'`Defender_MatchTopic`API de la AWS IoT Device Defender bibliothèque pour vérifier si le message MQTT entrant provient du AWS IoT Device Defender service. Si le message provient du AWS IoT Device Defender service, il analyse la réponse JSON reçue et extrait l'ID du rapport dans la réponse. L'identifiant du rapport est ensuite vérifié pour être le même que celui envoyé dans le rapport.
# AWS IoT Greengrass Application de démonstration V1 Discovery
**Important**
Cette démo est hébergée sur le référentiel Amazon-FreeRTOS 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
Avant de lancer la démo AWS IoT Greengrass Discovery pour FreeRTOS, vous devez AWS configurer AWS IoT Greengrass, et. AWS IoT Pour procéder à la configuration AWS, suivez les instructions de l'adresse[Configuration de votre AWS compte et de vos autorisations](freertos-prereqs.md#freertos-account-and-permissions). Pour le configurer AWS IoT Greengrass, vous devez créer un groupe Greengrass, puis ajouter un noyau Greengrass. Pour plus d'informations sur la configuration AWS IoT Greengrass, consultez [Getting Started with AWS IoT Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-gs.html).
Après avoir configuré AWS et AWS IoT Greengrass, vous devez configurer des autorisations supplémentaires pour AWS IoT Greengrass.
**Pour configurer les AWS IoT Greengrass autorisations**
1. Accédez à la [console IAM.](https://console.aws.amazon.com/iam/home)
1. Dans le volet de navigation, choisissez **Roles**, puis recherchez et choisissez **Greengrass\$1 ServiceRole**.
1. Choisissez **Joindre des politiques**, sélectionnez **AmazonS3 FullAccess** et **AWSIoTFullAccess**, puis choisissez **Attacher une** politique.
1. Accédez à la [console AWS IoT](https://console.aws.amazon.com/iotv2/).
1. Dans le panneau de navigation, choisissez **Greengrass**, **Groupes**, puis sélectionnez le groupe Greengrass que vous avez créé précédemment.
1. Choisissez **Paramètres**, puis **Ajouter un rôle**.
1. **Choisissez **Greengrass\$1 ServiceRole**, puis cliquez sur Enregistrer.**
Connectez votre tableau à votre démo de FreeRTOS AWS IoT et configurez-la.
1. [Enregistrement de votre carte MCU auprès de AWS IoT](freertos-prereqs.md#get-started-freertos-thing)
Une fois que vous avez enregistré votre carte, vous devrez créer et attacher une nouvelle stratégie Greengrass au certificat de l'appareil.
**Pour créer une nouvelle AWS IoT Greengrass politique**
1. Accédez à la [console AWS IoT](https://console.aws.amazon.com/iotv2/).
1. Dans le volet de navigation, choisissez successivement **Sécurisé**, **Stratégies** et **Créer**.
1. Entrez un nom pour identifier votre stratégie.
1. Dans la section **Ajouter des instructions**, choisissez **Mode avancé**. Copiez et collez le code JSON suivant dans la fenêtre de l'éditeur de stratégie :
```
{
"Effect": "Allow",
"Action": [
"greengrass:*"
],
"Resource": "*"
}
```
Cette politique accorde des AWS IoT Greengrass autorisations à toutes les ressources.
1. Sélectionnez **Create** (Créer).
**Pour joindre la AWS IoT Greengrass politique au certificat de votre appareil**
1. Accédez à la [console AWS IoT](https://console.aws.amazon.com/iotv2/).
1. Dans le panneau de navigation, choisissez **Gérer**, choisissez **Objets**, puis choisissez l'objet que vous avez créé précédemment.
1. Choisissez **Sécurité**, puis choisissez le certificat attaché à votre appareil.
1. Choisissez **Stratégies**, **Actions**, puis **Attacher une stratégie**.
1. Recherchez et choisissez la stratégie Greengrass que vous avez créée précédemment, puis choisissez **Attacher**.
1. [Téléchargement de FreeRTOS](freertos-prereqs.md#freertos-download)
**Note**
**Si vous téléchargez FreeRTOS depuis la console FreeRTOS, choisissez Connect to - au lieu de **Connect to AWS IoT Greengrass-**. *Platform* AWS IoT*Platform***
1. [Configuration des démos de FreeRTOS](freertos-prereqs.md#freertos-configure).
Ouvrez `freertos/vendors/vendor/boards/board/aws_demos/config_files/aws_demo_config.h`, commentez `#define CONFIG_CORE_MQTT_MUTUAL_AUTH_DEMO_ENABLED` et définissez `CONFIG_GREENGRASS_DISCOVERY_DEMO_ENABLED`.
Après avoir configuré AWS IoT et téléchargé et configuré FreeRTOS AWS IoT Greengrass, vous pouvez créer, flasher et exécuter la démo de Greengrass sur votre appareil. Pour configurer l'environnement de développement du matériel et des logiciels de votre carte, suivez les instructions fournies dans [Manuels de mise en route spécifiques aux cartes](getting-started-guides.md).
La démo de Greengrass publie une série de messages destinés au noyau de Greengrass et au client MQTT. AWS IoT Pour afficher les messages dans le client AWS IoT MQTT, ouvrez la [AWS IoT console](https://console.aws.amazon.com/iotv2/), choisissez **Test**, choisissez le **client de test MQTT**, puis ajoutez un abonnement à. `freertos/demos/ggd`
Dans le client MQTT, vous devez voir les chaînes suivantes :
```
Message from Thing to Greengrass Core: Hello world msg #1!
Message from Thing to Greengrass Core: Hello world msg #0!
Message from Thing to Greengrass Core: Address of Greengrass Core found! 123456789012.us-west-2.compute.amazonaws.com
```
## Utilisation d'une EC2 instance Amazon
**Si vous travaillez avec une EC2 instance Amazon**
1. Trouvez le DNS public (IPv4) associé à votre EC2 instance Amazon : accédez à la EC2 console Amazon, puis dans le panneau de navigation de gauche, sélectionnez **Instances**. Choisissez votre EC2 instance Amazon, puis choisissez le panneau **Description**. Recherchez l'entrée correspondant au **DNS public (IPv4)** et notez-la.
1. Recherchez l'entrée relative aux **groupes de sécurité** et choisissez le groupe de sécurité attaché à votre EC2 instance Amazon.
1. Choisissez l'onglet **Règles entrantes** puis choisissez **Modifier les règles entrantes** et ajoutez les règles suivantes.
**Règles entrantes**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/gg-demov1.html)
1. Dans la AWS IoT console, choisissez **Greengrass**, puis **Groups**, puis choisissez le groupe Greengrass que vous avez créé précédemment. Sélectionnez **Paramètres**. Modifiez la **Détection de la connexion locale** en **Gérer manuellement les informations de connexion**.
1. Dans le panneau de navigation, choisissez **Noyaux** puis sélectionnez votre noyau de groupe.
1. Choisissez **Connectivité** et assurez-vous que vous n'avez qu'un seul point de terminaison principal (supprimez tout le reste) et qu'il ne s'agit pas d'une adresse IP (car elle peut être modifiée). La meilleure option est d'utiliser le DNS public (IPv4) que vous avez noté à la première étape.
1. Ajoutez l'objet IoT FreeRTOS que vous avez créé au groupe GG.
1. Cliquez sur la flèche de retour pour revenir à la page AWS IoT Greengrass du groupe. Dans le panneau de navigation, choisissez **Périphériques** puis **Ajouter un périphérique**.
1. Choisissez **Sélectionner un objet IoT**. Choisissez votre appareil, puis sélectionnez **Terminer**.
1. Ajoutez les abonnements nécessaires : sur la page **Greengrass Group**, choisissez **Abonnements**, puis choisissez **Ajouter un abonnement** et entrez les informations comme indiqué ici.
**Abonnements**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/gg-demov1.html)
Où « Source » est le nom donné à l' AWS IoT objet créé dans la AWS IoT console lorsque vous avez enregistré votre forum, « TIGG1 » dans l'exemple donné ici.
1. Démarrez le déploiement de votre AWS IoT Greengrass groupe et assurez-vous que le déploiement est réussi. Vous devriez maintenant être en mesure d'exécuter correctement la démonstration de AWS IoT Greengrass découverte.
# AWS IoT Greengrass V2
## Compatibilité avec les AWS IoT Greengrass V2 appareils
AWS IoT Greengrass V2 le support des appareils clients est rétrocompatible avec. AWS IoT Greengrass V1 Vous pouvez connecter les appareils clients FreeRTOS aux appareils principaux de la V2 sans modifier le code de l'application. Pour permettre aux appareils clients de se connecter à un périphérique principal V2, procédez comme suit.
+ Déployez le logiciel Greengrass sur l'appareil principal de Greengrass. Voir [Connecter les appareils clients aux appareils principaux](https://docs.aws.amazon.com//greengrass/v2/developerguide/connect-client-devices.html) auxquels connecter un appareil AWS IoT Greengrass V2.
+ [Pour relayer des messages (y compris les fonctions Lambda) entre les appareils clients, le service AWS IoT Core cloud et les composants Greengrass, déployez et configurez le composant de pont MQTT.](https://docs.aws.amazon.com//greengrass/v2/developerguide/mqtt-bridge-component.html)
+ Déployez le [composant de détection IP](https://docs.aws.amazon.com//greengrass/v2/developerguide/ip-detector-component.html) pour détecter automatiquement les informations de connectivité ou gérez manuellement les points de terminaison.
+ Voir [Interagir avec les AWS IoT appareils locaux](https://docs.aws.amazon.com//greengrass/v2/developerguide/interact-with-local-iot-devices.html) pour plus d'informations.
Pour plus de détails, consultez AWS la documentation sur l'exécution d'[AWS IoT Greengrass V1 applications sur AWS IoT Greengrass V2](https://docs.aws.amazon.com//greengrass/v2/developerguide/migrate-from-v1.html#connect-v1-greengrass-devices).
# Démos CoreHTTP
**Important**
Cette démo est hébergée sur le référentiel Amazon-FreeRTOS 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
Ces démos peuvent vous aider à apprendre à utiliser la bibliothèque CoreHTTP.
**Topics**
+ [Démo d'authentification mutuelle CoreHTTP](core-http-ma-demo.md)
+ [Démo de téléchargement de CoreHTTP Basic sur Amazon S3](core-http-s3-upload-demo.md)
+ [Démo de téléchargement de CoreHTTP basic S3](core-http-s3-download-demo.md)
+ [Démo multithread de base de CoreHTTP](core-http-bmt-demo.md)
# Démo d'authentification mutuelle CoreHTTP
**Important**
Cette démo est hébergée sur le référentiel Amazon-FreeRTOS 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
## Introduction
Le projet de démonstration CoreHTTP (Mutual Authentication) vous montre comment établir une connexion à un serveur HTTP à l'aide du protocole TLS avec authentification mutuelle entre le client et le serveur. Cette démonstration utilise une implémentation d'interface de transport basée sur MBEDTLS pour établir une connexion TLS authentifiée par le serveur et le client, et illustre un flux de travail de réponse aux demandes en HTTP.
**Note**
Pour configurer et exécuter les démos de FreeRTOS, suivez les étapes décrites dans. [Commencez avec FreeRTOS](freertos-getting-started.md)
## Fonctionnalité
Cette démonstration crée une tâche d'application unique avec des exemples qui montrent comment effectuer les opérations suivantes :
+ Connectez-vous au serveur HTTP sur le AWS IoT point de terminaison.
+ Envoyez une requête POST.
+ Recevez la réponse.
+ Déconnectez-vous du serveur.
Une fois ces étapes terminées, la démo génère un résultat similaire à la capture d'écran suivante.
![\[Sortie du journal indiquant l'initialisation de la AWS IoT démonstration, l'établissement de sessions TLS, les requêtes HTTP POST et les mesures de mémoire indiquant la réussite de la démonstration.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/coreHTTP.output.png)
La AWS IoT console génère une sortie similaire à la capture d'écran suivante.
![\[AWS IoT console affichant le message « Bonjour depuis AWS IoT la console » publié sur un sujet le 20 novembre 2020 à 19:09:09 UTC.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/coreHTTP.console.png)
## Organisation du code source
Le fichier source de démonstration est nommé `http_demo_mutual_auth.c` et se trouve dans le `freertos/demos/coreHTTP/` répertoire et sur le [ GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/coreHTTP/http_demo_mutual_auth.c)site Web.
## Connexion au serveur AWS IoT HTTP
La [ connectToServerWithBackoffRetries](https://github.com/aws/amazon-freertos/blob/main/demos/common/http_demo_helpers/http_demo_utils.c#L131-L170)fonction tente d'établir une connexion TLS mutuellement authentifiée avec le serveur AWS IoT HTTP. Si la connexion échoue, elle réessaie après un délai d'expiration. La valeur du délai d'attente augmente de façon exponentielle jusqu'à ce que le nombre maximum de tentatives soit atteint ou que la valeur maximale du délai d'attente soit atteinte. La `RetryUtils_BackoffAndSleep` fonction fournit des valeurs de délai d'attente qui augmentent de façon exponentielle et revient `RetryUtilsRetriesExhausted` lorsque le nombre maximum de tentatives a été atteint. La `connectToServerWithBackoffRetries` fonction renvoie un état d'échec si la connexion TLS au broker ne peut pas être établie après le nombre de tentatives configuré.
## Envoi d'une requête HTTP et réception de la réponse
La fonction [ prvSendHttpRequest](https://github.com/aws/amazon-freertos/blob/main/demos/coreHTTP/http_demo_mutual_auth.c#L402-L507) montre comment envoyer une requête POST au serveur AWS IoT HTTP. Pour plus d'informations sur l'envoi d'une requête à l'API REST dans AWS IoT, voir [Protocoles de communication entre appareils - HTTPS](https://docs.aws.amazon.com/iot/latest/developerguide/http.html). La réponse est reçue avec le même appel d'API CoreHTTP,`HTTPClient_Send`.
# Démo de téléchargement de CoreHTTP Basic sur Amazon S3
**Important**
Cette démo est hébergée sur le référentiel Amazon-FreeRTOS 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
## Introduction
Cet exemple montre comment envoyer une requête PUT au serveur HTTP Amazon Simple Storage Service (Amazon S3) et comment télécharger un petit fichier. Il exécute également une requête GET pour vérifier la taille du fichier après le téléchargement. Cet exemple utilise une [interface de transport réseau](https://freertos.org/network-interface.html) qui utilise mbedTLS pour établir une connexion authentifiée mutuellement entre un client d'appareil IoT exécutant CoreHTTP et le serveur HTTP Amazon S3.
**Note**
Pour configurer et exécuter les démos de FreeRTOS, suivez les étapes décrites dans. [Commencez avec FreeRTOS](freertos-getting-started.md)
### À filetage unique ou à filetage multiple
Il existe deux modèles d'utilisation de CoreHTTP, *monothread et multithread* *(multitâche*). Bien que la démonstration présentée dans cette section exécute la bibliothèque HTTP dans un thread, elle montre en fait comment utiliser CoreHTTP dans un environnement à thread unique. Dans cette démo, une seule tâche utilise l'API HTTP. Bien que les applications à thread unique doivent appeler à plusieurs reprises la bibliothèque HTTP, les applications multithread peuvent à la place envoyer des requêtes HTTP en arrière-plan dans le cadre d'une tâche d'agent (ou de démon).
## Organisation du code source
Le fichier source de démonstration est nommé `http_demo_s3_upload.c` et se trouve dans le `freertos/demos/coreHTTP/` répertoire et sur le [ GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/coreHTTP/http_demo_s3_upload.c)site Web.
## Configuration de la connexion au serveur HTTP Amazon S3
Cette démonstration utilise une URL pré-signée pour se connecter au serveur HTTP Amazon S3 et autoriser l'accès à l'objet à télécharger. La connexion TLS du serveur HTTP Amazon S3 utilise uniquement l'authentification du serveur. Au niveau de l'application, l'accès à l'objet est authentifié à l'aide de paramètres dans la requête d'URL pré-signée. Suivez les étapes ci-dessous pour configurer votre connexion à AWS.
1. Créez un AWS compte :
1. Si ce n'est pas déjà fait, [créez un AWS compte](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/).
1. Les comptes et les autorisations sont définis à l'aide de Gestion des identités et des accès AWS (IAM). Vous utilisez IAM pour gérer les autorisations de chaque utilisateur de votre compte. Par défaut, un utilisateur ne dispose d'aucune autorisation tant que le propriétaire root ne l'a pas accordée.
1. Pour ajouter un utilisateur à votre AWS compte, consultez le [guide de l'utilisateur IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/).
1. Autorisez votre AWS compte à accéder à FreeRTOS AWS IoT et en ajoutant cette politique :
+ Amazon S3 FullAccess
1. Créez un compartiment dans Amazon S3 en suivant les étapes [décrites dans Comment créer un compartiment S3 ?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*.
1. Chargez un fichier sur Amazon S3 en suivant les étapes décrites dans [Comment télécharger des fichiers et des dossiers dans un compartiment S3 ?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html) .
1. Générez une URL pré-signée à l'aide du script situé dans le `FreeRTOS-Plus/Demo/coreHTTP_Windows_Simulator/Common/presigned_url_generator/presigned_urls_gen.py` fichier.
Pour les instructions d'utilisation, consultez le `FreeRTOS-Plus/Demo/coreHTTP_Windows_Simulator/Common/presigned_url_generator/README.md` fichier.
## Fonctionnalité
La démo se connecte d'abord au serveur HTTP Amazon S3 avec l'authentification du serveur TLS. Il crée ensuite une requête HTTP pour télécharger les données spécifiées dans`democonfigDEMO_HTTP_UPLOAD_DATA`. Après avoir chargé le fichier, il vérifie que le fichier a bien été téléchargé en demandant la taille du fichier. Le code source de la démo se trouve sur le [GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/coreHTTP/http_demo_s3_upload.c)site Web.
### Connexion au serveur HTTP Amazon S3
La [ connectToServerWithBackoffRetries](https://github.com/aws/amazon-freertos/blob/main/demos/common/http_demo_helpers/http_demo_utils.c#L131-L170)fonction tente d'établir une connexion TCP avec le serveur HTTP. Si la connexion échoue, elle réessaie après un délai d'expiration. La valeur du délai d'attente augmentera de façon exponentielle jusqu'à ce que le nombre maximum de tentatives soit atteint ou que la valeur maximale du délai d'expiration soit atteinte. La `connectToServerWithBackoffRetries` fonction renvoie un état d'échec si la connexion TCP au serveur ne peut pas être établie après le nombre de tentatives configuré.
La `prvConnectToServer` fonction montre comment établir une connexion au serveur HTTP Amazon S3 en utilisant uniquement l'authentification du serveur. Il utilise l'interface de transport basée sur MBEDTLS qui est implémentée dans le fichier. `FreeRTOS-Plus/Source/Application-Protocols/network_transport/freertos_plus_tcp/using_mbedtls/using_mbedtls.c` La définition de `prvConnectToServer` se trouve sur le [GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/coreHTTP/http_demo_s3_upload.c#L306-L366)site Web.
### Charger des données
La `prvUploadS3ObjectFile` fonction montre comment créer une requête PUT et spécifier le fichier à télécharger. Le compartiment Amazon S3 dans lequel le fichier est chargé et le nom du fichier à télécharger sont spécifiés dans l'URL pré-signée. Pour économiser de la mémoire, la même mémoire tampon est utilisée à la fois pour les en-têtes de demande et pour recevoir la réponse. La réponse est reçue de manière synchrone à l'aide de la fonction `HTTPClient_Send` API. Un code d'état de `200 OK` réponse est attendu du serveur HTTP Amazon S3. Tout autre code d'état est une erreur.
Le code source de `prvUploadS3ObjectFile()` se trouve sur le [ GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/coreHTTP/http_demo_s3_upload.c#L539-L632)site Web.
### Vérification du téléchargement
La `prvVerifyS3ObjectFileSize` fonction appelle `prvGetS3ObjectFileSize` pour récupérer la taille de l'objet dans le compartiment S3. Le serveur HTTP Amazon S3 ne prend actuellement pas en charge les requêtes HEAD utilisant une URL pré-signée. Le 0ème octet est donc demandé. La taille du fichier est indiquée dans le champ d'`Content-Range`en-tête de la réponse. Une `206 Partial Content` réponse est attendue du serveur. Tout autre code d'état de réponse est une erreur.
Le code source de `prvGetS3ObjectFileSize()` se trouve sur le [ GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/coreHTTP/http_demo_s3_upload.c#L370-L535)site Web.
# Démo de téléchargement de CoreHTTP basic S3
**Important**
Cette démo est hébergée sur le référentiel Amazon-FreeRTOS 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
## Introduction
Cette démonstration montre comment utiliser les [requêtes de plage](https://tools.ietf.org/html/rfc7233) pour télécharger des fichiers depuis le serveur HTTP Amazon S3. Les requêtes Range sont prises en charge de manière native dans l'API CoreHTTP lorsque vous les utilisez `HTTPClient_AddRangeHeader` pour créer la requête HTTP. Pour un environnement de microcontrôleur, les demandes de plage sont vivement encouragées. En téléchargeant un fichier volumineux dans des plages séparées, au lieu d'une seule demande, chaque section du fichier peut être traitée sans bloquer le socket réseau. Les demandes de plage réduisent le risque de perte de paquets, qui nécessitent des retransmissions sur la connexion TCP, et réduisent ainsi la consommation d'énergie de l'appareil.
Cet exemple utilise une [interface de transport réseau](https://freertos.org/network-interface.html) qui utilise mbedTLS pour établir une connexion authentifiée mutuellement entre un client d'appareil IoT exécutant CoreHTTP et le serveur HTTP Amazon S3.
**Note**
Pour configurer et exécuter les démos de FreeRTOS, suivez les étapes décrites dans. [Commencez avec FreeRTOS](freertos-getting-started.md)
### À filetage unique ou à filetage multiple
Il existe deux modèles d'utilisation de CoreHTTP, *monothread et multithread* *(multitâche*). Bien que la démonstration présentée dans cette section exécute la bibliothèque HTTP dans un thread, elle montre en fait comment utiliser CoreHTTP dans un environnement à thread unique (une seule tâche utilise l'API HTTP dans la démo). Bien que les applications à thread unique doivent appeler à plusieurs reprises la bibliothèque HTTP, les applications multithread peuvent à la place envoyer des requêtes HTTP en arrière-plan dans le cadre d'une tâche d'agent (ou de démon).
## Organisation du code source
Le projet de démonstration porte un nom `http_demo_s3_download.c` et se trouve dans le `freertos/demos/coreHTTP/` répertoire et sur le [ GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/coreHTTP/http_demo_s3_download.c)site Web.
## Configuration de la connexion au serveur HTTP Amazon S3
Cette démonstration utilise une URL pré-signée pour se connecter au serveur HTTP Amazon S3 et autoriser l'accès à l'objet à télécharger. La connexion TLS du serveur HTTP Amazon S3 utilise uniquement l'authentification du serveur. Au niveau de l'application, l'accès à l'objet est authentifié à l'aide de paramètres dans la requête d'URL pré-signée. Suivez les étapes ci-dessous pour configurer votre connexion à AWS.
1. Créez un AWS compte :
1. Si ce n'est pas déjà fait, [créez et activez un AWS compte](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/).
1. Les comptes et les autorisations sont définis à l'aide de Gestion des identités et des accès AWS (IAM). IAM vous permet de gérer les autorisations pour chaque utilisateur de votre compte. Par défaut, un utilisateur ne dispose d'aucune autorisation tant que le propriétaire root ne l'a pas accordée.
1. Pour ajouter un utilisateur à votre AWS compte, consultez le [guide de l'utilisateur IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/).
1. Autorisez votre AWS compte à accéder à FreeRTOS AWS IoT et en ajoutant les politiques suivantes :
+ Amazon S3 FullAccess
1. Créez un compartiment dans S3 en suivant les étapes [décrites dans Comment créer un compartiment S3 ?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html) dans le *guide de l'utilisateur de la console Amazon Simple Storage Service*.
1. Chargez un fichier sur S3 en suivant les étapes décrites dans [Comment télécharger des fichiers et des dossiers dans un compartiment S3 ?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html) .
1. Générez une URL pré-signée à l'aide du script situé à `FreeRTOS-Plus/Demo/coreHTTP_Windows_Simulator/Common/presigned_url_generator/presigned_urls_gen.py` l'adresse. Pour les instructions d'utilisation, voir`FreeRTOS-Plus/Demo/coreHTTP_Windows_Simulator/Common/presigned_url_generator/README.md`.
## Fonctionnalité
La démo récupère d'abord la taille du fichier. Ensuite, il demande chaque plage d'octets de manière séquentielle, dans une boucle, avec des tailles de plage de`democonfigRANGE_REQUEST_LENGTH`.
Le code source de la démo se trouve sur le [GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/coreHTTP/http_demo_s3_download.c)site Web.
### Connexion au serveur HTTP Amazon S3
La fonction [ connectToServerWithBackoffRetries()](https://github.com/aws/amazon-freertos/blob/main/demos/common/http_demo_helpers/http_demo_utils.c#L131-L170) tente d'établir une connexion TCP avec le serveur HTTP. Si la connexion échoue, elle réessaie après un délai d'expiration. La valeur du délai d'attente augmentera de façon exponentielle jusqu'à ce que le nombre maximum de tentatives soit atteint ou que la valeur maximale du délai d'expiration soit atteinte. `connectToServerWithBackoffRetries()`renvoie un état d'échec si la connexion TCP au serveur ne peut pas être établie après le nombre de tentatives configuré.
La fonction `prvConnectToServer()` montre comment établir une connexion au serveur HTTP Amazon S3 en utilisant uniquement l'authentification du serveur. [Il utilise l'interface de transport basée sur MbeDTLS qui est implémentée dans le fichier FreeRTOS- \$1mbedtls.c. Plus/Source/Application-Protocols/network\$1transport/freertos\$1plus\$1tcp/using\$1mbedtls/using](https://github.com/FreeRTOS/FreeRTOS/blob/202012.00/FreeRTOS-Plus/Source/Application-Protocols/network_transport/freertos_plus_tcp/using_mbedtls/using_mbedtls.c)
Le code source de `prvConnectToServer()` se trouve sur [ GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/coreHTTP/http_demo_s3_download.c#L273-L333).
### Création d'une demande de plage
La fonction API `HTTPClient_AddRangeHeader()` prend en charge la sérialisation d'une plage d'octets dans les en-têtes de requête HTTP pour former une demande de plage. Les demandes de plage sont utilisées dans cette démo pour récupérer la taille du fichier et pour demander chaque section du fichier.
La fonction `prvGetS3ObjectFileSize()` récupère la taille du fichier dans le compartiment S3. L'`Connection: keep-alive`en-tête est ajouté dans cette première demande à Amazon S3 afin de maintenir la connexion ouverte après l'envoi de la réponse. Le serveur HTTP S3 ne prend actuellement pas en charge les requêtes HEAD utilisant une URL pré-signée, c'est pourquoi le 0ème octet est demandé. La taille du fichier est indiquée dans le champ d'`Content-Range`en-tête de la réponse. Une `206 Partial Content` réponse est attendue du serveur ; tout autre code d'état de réponse reçu est une erreur.
Le code source de `prvGetS3ObjectFileSize()` se trouve sur [ GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/coreHTTP/http_demo_s3_download.c#L337-L502).
Après avoir récupéré la taille du fichier, cette démonstration crée une nouvelle demande de plage pour chaque plage d'octets du fichier à télécharger. Il utilise `HTTPClient_AddRangeHeader()` pour chaque section du fichier.
### Envoi de demandes de portée et réception de réponses
La fonction `prvDownloadS3ObjectFile()` envoie les demandes de plage en boucle jusqu'à ce que le fichier entier soit téléchargé. La fonction API `HTTPClient_Send()` envoie une demande et reçoit la réponse de manière synchrone. Lorsque la fonction revient, la réponse est reçue dans un fichier`xResponse`. Le code d'état est ensuite vérifié `206 Partial Content` et le nombre d'octets téléchargés jusqu'à présent est incrémenté par la valeur de l'`Content-Length`en-tête.
Le code source de `prvDownloadS3ObjectFile()` se trouve sur [ GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/coreHTTP/http_demo_s3_download.c#L506-L651).
# Démo multithread de base de CoreHTTP
**Important**
Cette démo est hébergée sur le référentiel Amazon-FreeRTOS 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
## Introduction
Cette démo utilise les [files d'attente sécurisées de FreeRTOS](https://freertos.org/a00018.html) pour contenir les demandes et les réponses en attente de traitement. Dans cette démo, il y a trois tâches à prendre en compte.
+ La tâche principale attend que les demandes apparaissent dans la file d'attente des demandes. Il enverra ces demandes sur le réseau, puis placera la réponse dans la file d'attente des réponses.
+ Une tâche de demande crée des objets de requête de bibliothèque HTTP à envoyer au serveur et les place dans la file d'attente des demandes. Chaque objet de demande spécifie une plage d'octets du fichier S3 que l'application a configuré pour le téléchargement.
+ Une tâche de réponse attend que les réponses apparaissent dans la file d'attente des réponses. Il enregistre toutes les réponses qu'il reçoit.
Cette démo multithread de base est configurée pour utiliser une connexion TLS avec authentification du serveur uniquement, ce qui est requis par le serveur HTTP Amazon S3. L'authentification de la couche application est effectuée à l'aide des paramètres [Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) dans la [requête d'URL présignée](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html).
## Organisation du code source
Le projet de démonstration porte un nom `http_demo_s3_download_multithreaded.c` et se trouve dans le `freertos/demos/coreHTTP/` répertoire et [ GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/coreHTTP/http_demo_s3_download_multithreaded.c)sur le site Web.
## Création du projet de démonstration
Le projet de démonstration utilise l'[édition communautaire gratuite de Visual Studio](https://visualstudio.microsoft.com/vs/community/). Pour créer la démo :
1. Ouvrez le fichier de solution `mqtt_multitask_demo.sln` Visual Studio depuis l'IDE Visual Studio.
1. Sélectionnez **Build Solution** dans le menu **Build** de l'IDE.
**Note**
Si vous utilisez Microsoft Visual Studio 2017 ou une version antérieure, vous devez sélectionner un jeu d'**outils de plate-forme compatible avec votre version : Projet -> RTOSDemos Propriétés -> Ensemble** **d'outils de plate-forme**.
## Configuration du projet de démonstration
[La démo utilise la [ TCP/IP pile FreeRTOS\$1TCP](https://freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/index.html). Suivez donc les instructions fournies au projet de démarrage TCP/IP pour :](https://freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html)
1. Installez les [composants requis](https://freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html#prerequisites) (tels que WinPCap).
1. [Définissez éventuellement une adresse IP statique ou dynamique, une adresse de passerelle et un masque réseau](https://freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html#static-dynamic).
1. [Définissez éventuellement une adresse MAC](https://freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html#mac-addr).
1. [Sélectionnez une interface réseau Ethernet](https://freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html#network-interface) sur votre machine hôte.
1. **Il est important** de [tester votre connexion réseau](https://freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html#connectivity-test) avant d'essayer d'exécuter la démo HTTP.
## Configuration de la connexion au serveur HTTP Amazon S3
Suivez les instructions de la *démo [Configuration de la connexion au serveur HTTP Amazon S3](core-http-s3-download-demo.md#core-http-s3-download-demo-configure-server) de téléchargement de base de CoreHTTP*.
## Fonctionnalité
La démo crée trois tâches au total :
+ Celui qui envoie des demandes et reçoit des réponses sur le réseau.
+ Celui qui crée des demandes à envoyer.
+ Celui qui traite les réponses reçues.
Dans cette démonstration, la tâche principale est la suivante :
1. Crée les files d'attente de demandes et de réponses.
1. Crée la connexion au serveur.
1. Crée les tâches de demande et de réponse.
1. Attend que la file d'attente envoie des demandes sur le réseau.
1. Place les réponses reçues sur le réseau dans la file d'attente des réponses.
La tâche de demande :
1. Crée chacune des demandes de plage.
La tâche de réponse :
1. Traite chacune des réponses reçues.
## Typedefs
La démo définit les structures suivantes pour prendre en charge le multithreading.
**Demander des articles**
Les structures suivantes définissent un élément de demande à placer dans la file d'attente des demandes. L'élément de demande est copié dans la file d'attente une fois que la tâche de demande crée une requête HTTP.
```
/**
* @brief Data type for the request queue.
*
* Contains the request header struct and its corresponding buffer, to be
* populated and enqueued by the request task, and read by the main task. The
* buffer is included to avoid pointer inaccuracy during queue copy operations.
*/
typedef struct RequestItem
{
HTTPRequestHeaders_t xRequestHeaders;
uint8_t ucHeaderBuffer[ democonfigUSER_BUFFER_LENGTH ];
} RequestItem_t;
```
**Élément de réponse**
Les structures suivantes définissent un élément de réponse à placer dans la file d'attente des réponses. L'élément de réponse est copié dans la file d'attente une fois que la tâche HTTP principale reçoit une réponse sur le réseau.
```
/**
* @brief Data type for the response queue.
*
* Contains the response data type and its corresponding buffer, to be enqueued
* by the main task, and interpreted by the response task. The buffer is
* included to avoid pointer inaccuracy during queue copy operations.
*/
typedef struct ResponseItem
{
HTTPResponse_t xResponse;
uint8_t ucResponseBuffer[ democonfigUSER_BUFFER_LENGTH ];
} ResponseItem_t;
```
## Tâche d'envoi HTTP principale
Tâche principale de l'application :
1. Analyse l'URL présignée de l'adresse de l'hôte afin d'établir une connexion avec le serveur HTTP Amazon S3.
1. Analyse l'URL présignée pour le chemin d'accès aux objets du compartiment S3.
1. Se connecte au serveur HTTP Amazon S3 à l'aide du protocole TLS avec authentification du serveur.
1. Crée les files d'attente de demandes et de réponses.
1. Crée les tâches de demande et de réponse.
La fonction `prvHTTPDemoTask()` effectue cette configuration et donne le statut de démonstration. Le code source de cette fonction se trouve sur [Github](https://github.com/FreeRTOS/FreeRTOS/blob/main/FreeRTOS-Plus/Demo/coreHTTP_Windows_Simulator/HTTP_S3_Download_Multithreaded/DemoTasks/S3DownloadMultithreadedHTTPExample.c#L451-L650).
Dans la fonction`prvDownloadLoop()`, la tâche principale bloque et attend les demandes provenant de la file d'attente de demandes. Lorsqu'il reçoit une demande, il l'envoie à l'aide de la fonction API`HTTPClient_Send()`. Si la fonction API est réussie, elle place la réponse dans la file d'attente des réponses.
Le code source de se `prvDownloadLoop()` trouve sur [Github](https://github.com/FreeRTOS/FreeRTOS/blob/main/FreeRTOS-Plus/Demo/coreHTTP_Windows_Simulator/HTTP_S3_Download_Multithreaded/DemoTasks/S3DownloadMultithreadedHTTPExample.c#L1071-L1174).
## Tâche de requête HTTP
La tâche de demande est spécifiée dans la fonction`prvRequestTask`. Le code source de cette fonction se trouve sur [Github](https://github.com/FreeRTOS/FreeRTOS/blob/main/FreeRTOS-Plus/Demo/coreHTTP_Windows_Simulator/HTTP_S3_Download_Multithreaded/DemoTasks/S3DownloadMultithreadedHTTPExample.c#L778-L876).
La tâche de demande récupère la taille du fichier dans le compartiment Amazon S3. Cela se fait dans la fonction`prvGetS3ObjectFileSize`. L'en-tête « Connection : keep-alive » est ajouté à cette demande adressée à Amazon S3 afin de maintenir la connexion ouverte après l'envoi de la réponse. Le serveur HTTP Amazon S3 ne prend actuellement pas en charge les requêtes HEAD utilisant une URL présignée. Le 0ème octet est donc demandé. La taille du fichier est indiquée dans le champ d'`Content-Range`en-tête de la réponse. Une `206 Partial Content` réponse est attendue du serveur ; tout autre code d'état de réponse reçu est une erreur.
Le code source de se `prvGetS3ObjectFileSize` trouve sur [Github](https://github.com/FreeRTOS/FreeRTOS/blob/main/FreeRTOS-Plus/Demo/coreHTTP_Windows_Simulator/HTTP_S3_Download_Multithreaded/DemoTasks/S3DownloadMultithreadedHTTPExample.c#L757-L774).
Après avoir récupéré la taille du fichier, la tâche de demande continue de demander chaque plage du fichier. Chaque demande de plage est placée dans la file d'attente de la tâche principale à envoyer. Les plages de fichiers sont configurées par l'utilisateur de démonstration dans la macro`democonfigRANGE_REQUEST_LENGTH`. Les demandes de plage sont prises en charge de manière native dans l'API de la bibliothèque cliente HTTP à l'aide de cette fonction`HTTPClient_AddRangeHeader`. La fonction `prvRequestS3ObjectRange` montre comment utiliser`HTTPClient_AddRangeHeader()`.
Le code source de la fonction se `prvRequestS3ObjectRange` trouve sur [Github](https://github.com/FreeRTOS/FreeRTOS/blob/main/FreeRTOS-Plus/Demo/coreHTTP_Windows_Simulator/HTTP_S3_Download_Multithreaded/DemoTasks/S3DownloadMultithreadedHTTPExample.c#L694-L753).
## Tâche de réponse HTTP
Les tâches de réponse attendent dans la file d'attente les réponses reçues sur le réseau. La tâche principale remplit la file de réponses lorsqu'elle reçoit avec succès une réponse HTTP. Cette tâche traite les réponses en enregistrant le code d'état, les en-têtes et le corps. Une application du monde réel peut traiter la réponse en écrivant le corps de la réponse dans une mémoire flash, par exemple. Si le code d'état de la réponse ne l'est pas`206 partial content`, la tâche indique à la tâche principale que la démonstration doit échouer. La tâche de réponse est spécifiée dans la fonction`prvResponseTask`. Le code source de cette fonction se trouve sur [Github](https://github.com/FreeRTOS/FreeRTOS/blob/main/FreeRTOS-Plus/Demo/coreHTTP_Windows_Simulator/HTTP_S3_Download_Multithreaded/DemoTasks/S3DownloadMultithreadedHTTPExample.c#L961-L1047).
# AWS IoT Démo de la bibliothèque d'emplois
**Important**
Cette démo est hébergée sur le référentiel Amazon-FreeRTOS, 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
## Introduction
La démo de la bibliothèque de AWS IoT tâches vous montre comment vous connecter au [service AWS IoT Jobs](https://docs.aws.amazon.com/iot/latest/developerguide/iot-jobs.html) via une connexion MQTT, récupérer une tâche et la traiter sur un appareil. AWS IoT Le projet de démonstration AWS IoT Jobs utilise le port [FreeRTOS pour Windows](https://www.freertos.org/FreeRTOS-Windows-Simulator-Emulator-for-Visual-Studio-and-Eclipse-MingW.html), de sorte qu'il peut être créé et évalué avec [la version Visual Studio](https://visualstudio.microsoft.com/vs/community/) Community sous Windows. Aucun microcontrôleur n'est nécessaire. La démo établit une connexion sécurisée avec le broker AWS IoT MQTT à l'aide du protocole TLS de la même manière que le. [Démo de l'authentification mutuelle CoreMQTT](mqtt-demo-ma.md)
**Note**
Pour configurer et exécuter les démos de FreeRTOS, suivez les étapes décrites dans. [Commencez avec FreeRTOS](freertos-getting-started.md)
## Organisation du code source
Le code de démonstration se trouve dans le `jobs_demo.c` fichier et peut être trouvé sur le [GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/jobs_for_aws/jobs_demo.c)site Web ou dans le `freertos/demos/jobs_for_aws/` répertoire.
## Configuration de la connexion au broker AWS IoT MQTT
Dans cette démonstration, vous utilisez une connexion MQTT au broker AWS IoT MQTT. Cette connexion est configurée de la même manière que le[Démo de l'authentification mutuelle CoreMQTT](mqtt-demo-ma.md).
## Fonctionnalité
La démo montre le flux de travail utilisé pour recevoir des tâches AWS IoT et les traiter sur un appareil. La démo est interactive et vous oblige à créer des tâches à l'aide de la AWS IoT console ou du AWS Command Line Interface (AWS CLI). Pour plus d'informations sur la création d'une tâche, consultez la section [create-job](https://docs.aws.amazon.com/cli/latest/reference/iot/create-job.html) dans le manuel de référence des *AWS CLI commandes*. La démo nécessite que le document de travail comporte une `action` clé configurée `print` pour imprimer un message sur la console.
Consultez le format suivant pour ce document de travail.
```
{
"action": "print",
"message": "ADD_MESSAGE_HERE"
}
```
Vous pouvez utiliser le AWS CLI pour créer une tâche comme dans l'exemple de commande suivant.
```
aws iot create-job \
--job-id t12 \
--targets arn:aws:iot:region:123456789012:thing/device1 \
--document '{"action":"print","message":"hello world!"}'
```
La démo utilise également un document de travail dont la `action` clé est définie `publish` pour republier le message dans un sujet. Consultez le format suivant pour ce document de travail.
```
{
"action": "publish",
"message": "ADD_MESSAGE_HERE",
"topic": "topic/name/here"
}
```
La démo s'exécute en boucle jusqu'à ce qu'elle reçoive un document de travail dont la `action` touche est réglée `exit` pour quitter la démo. Le format du document de travail est le suivant.
```
{
"action: "exit"
}
```
### Point d'entrée de la démo Jobs
Le code source de la fonction de point d'entrée de démonstration de Jobs se trouve sur [ GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/jobs_for_aws/jobs_demo.c#L773-L967). Cette fonction effectue les opérations suivantes :
1. Établissez une connexion MQTT à l'aide des fonctions d'assistance dans. `mqtt_demo_helpers.c`
1. Abonnez-vous à la rubrique MQTT relative à l'`NextJobExecutionChanged`API, en utilisant les fonctions d'assistance dans. `mqtt_demo_helpers.c` La chaîne de rubrique a été assemblée plus tôt, à l'aide de macros définies par la bibliothèque AWS IoT Jobs.
1. Publiez dans la rubrique MQTT de l'`StartNextPendingJobExecution`API, à l'aide des fonctions d'assistance dans. `mqtt_demo_helpers.c` La chaîne de rubrique a été assemblée plus tôt, à l'aide de macros définies par la bibliothèque AWS IoT Jobs.
1. Appelez `MQTT_ProcessLoop` à plusieurs reprises pour recevoir les messages entrants qui sont remis `prvEventCallback` pour traitement.
1. Une fois que la démo a reçu l'action de sortie, désabonnez-vous du sujet MQTT et déconnectez-vous à l'aide des fonctions d'assistance du `mqtt_demo_helpers.c` fichier.
### Rappel pour les messages MQTT reçus
La [ prvEventCallback](https://github.com/aws/amazon-freertos/blob/main/demos/jobs_for_aws/jobs_demo.c#L674-L769)fonction appelle `Jobs_MatchTopic` depuis la bibliothèque AWS IoT Jobs pour classer le message MQTT entrant. Si le type de message correspond à une nouvelle tâche, `prvNextJobHandler()` il est appelé.
La fonction [ prvNextJobHandler](https://github.com/aws/amazon-freertos/blob/main/demos/jobs_for_aws/jobs_demo.c#L601-L670) et les fonctions qu'elle appelle analysent le document de travail à partir du message au format JSON et exécutent l'action spécifiée par le travail. La `prvSendUpdateForJob` fonction est particulièrement intéressante.
### Envoyer une mise à jour pour une tâche en cours
La fonction [ prvSendUpdateForJob()](https://github.com/aws/amazon-freertos/blob/main/demos/jobs_for_aws/jobs_demo.c#L413-L457) appelle `Jobs_Update()` depuis la bibliothèque Jobs pour renseigner la chaîne de rubrique utilisée dans l'opération de publication MQTT qui suit immédiatement.
# Démos de CoreMQTT
**Important**
Cette démo est hébergée sur le référentiel Amazon-FreeRTOS 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
Ces démos peuvent vous aider à apprendre à utiliser la bibliothèque CoreMQTT.
**Topics**
+ [Démo de l'authentification mutuelle CoreMQTT](mqtt-demo-ma.md)
+ [Démonstration du partage de connexion avec l'agent CoreMQTT](mqtt-demo-cs.md)
# Démo de l'authentification mutuelle CoreMQTT
**Important**
Cette démo est hébergée sur le référentiel Amazon-FreeRTOS 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
## Introduction
Le projet de démonstration d'authentification mutuelle CoreMQTT vous montre comment établir une connexion avec un courtier MQTT à l'aide du protocole TLS avec authentification mutuelle entre le client et le serveur. [Cette démonstration utilise une implémentation d'interface de transport basée sur MBEDTLS pour établir une connexion TLS authentifiée par le serveur et le client, et illustre le flux de travail d'abonnement/publication de MQTT au niveau QoS 1.](http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/errata01/os/mqtt-v3.1.1-errata01-os-complete.html#_Toc442180914) Il s'abonne à un filtre de rubrique, puis publie dans les rubriques correspondant au filtre et attend la réception de ces messages du serveur au niveau QoS 1. Ce cycle de publication auprès du courtier et de réception du même message de la part du courtier se répète indéfiniment. Les messages de cette démo sont envoyés à QoS 1, ce qui garantit au moins une livraison conformément à la spécification MQTT.
**Note**
Pour configurer et exécuter les démos de FreeRTOS, suivez les étapes décrites dans. [Commencez avec FreeRTOS](freertos-getting-started.md)
## Code source
Le fichier source de démonstration est nommé `mqtt_demo_mutual_auth.c` et se trouve dans le `freertos/demos/coreMQTT/` répertoire et [ GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/coreMQTT/mqtt_demo_mutual_auth.c)sur le site Web.
## Fonctionnalité
La démo crée une tâche d'application unique qui passe en revue un ensemble d'exemples illustrant comment se connecter au courtier, s'abonner à une rubrique sur le courtier, publier dans une rubrique sur le courtier, puis enfin, se déconnecter du courtier. L'application de démonstration s'abonne et publie sur le même sujet. Chaque fois que la démo publie un message au broker MQTT, celui-ci renvoie le même message à l'application de démonstration.
Une démonstration réussie générera un résultat similaire à l'image suivante.
![\[Sortie du terminal de démonstration MQTT en cas de réussite\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/coremqtt-mad-output.png)
La AWS IoT console générera une sortie similaire à l'image suivante.
![\[Sortie de la console de démonstration MQTT en cas de réussite\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/coremqtt-mad-console.png)
## Réessayez la logique avec un recul et une instabilité exponentiels
La fonction [ prvBackoffForRetry](https://github.com/aws/amazon-freertos/blob/main/demos/coreMQTT/mqtt_demo_mutual_auth.c#L671-L717) montre comment les opérations réseau ayant échoué avec le serveur, par exemple les connexions TLS ou les demandes d'abonnement MQTT, peuvent être réessayées avec un retard et une instabilité exponentiels. La fonction calcule la période d'attente pour la prochaine tentative et effectue le délai d'annulation si les tentatives n'ont pas été épuisées. Comme le calcul de la période d'attente nécessite la génération d'un nombre aléatoire, la fonction utilise le PKCS11 module pour générer le nombre aléatoire. L'utilisation du PKCS11 module permet d'accéder à un véritable générateur de nombres aléatoires (TRNG) si la plateforme du fournisseur le prend en charge. Nous vous recommandons d'amorcer le générateur de nombres aléatoires avec une source d'entropie spécifique à l'appareil afin de réduire la probabilité de collisions avec des appareils lors de nouvelles tentatives de connexion.
## Connexion au courtier MQTT
La [ prvConnectToServerWithBackoffRetries](https://github.com/aws/amazon-freertos/blob/main/demos/coreMQTT/mqtt_demo_mutual_auth.c#L721-L782)fonction tente d'établir une connexion TLS mutuellement authentifiée avec le broker MQTT. Si la connexion échoue, elle réessaie après une période d'attente. La période d'attente augmentera de façon exponentielle jusqu'à ce que le nombre maximum de tentatives soit atteint ou que la période d'interruption maximale soit atteinte. La `BackoffAlgorithm_GetNextBackoff` fonction fournit une valeur de retard qui augmente de façon exponentielle et revient `RetryUtilsRetriesExhausted` lorsque le nombre maximum de tentatives a été atteint. La `prvConnectToServerWithBackoffRetries` fonction renvoie un état d'échec si la connexion TLS au broker ne peut pas être établie après le nombre de tentatives configuré.
La MQTTConnection WithBroker fonction [PrvCreate](https://github.com/aws/amazon-freertos/blob/main/demos/coreMQTT/mqtt_demo_mutual_auth.c#L785-L848) montre comment établir une connexion MQTT avec un broker MQTT avec une session propre. Il utilise l'interface de transport TLS, qui est implémentée dans le `FreeRTOS-Plus/Source/Application-Protocols/platform/freertos/transport/src/tls_freertos.c` fichier. N'oubliez pas que nous définissons les secondes pendant lesquelles le courtier doit rester actif. `xConnectInfo`
La fonction suivante montre comment l'interface de transport TLS et la fonction de temps sont définies dans un contexte MQTT à l'aide de la `MQTT_Init` fonction. Il montre également comment une fonction de rappel d'événement pointer (`prvEventCallback`) est définie. Ce rappel est utilisé pour signaler les messages entrants.
## Abonnement à un sujet MQTT
La MQTTSubscribe WithBackoffRetries fonction [prv](https://github.com/aws/amazon-freertos/blob/main/demos/coreMQTT/mqtt_demo_mutual_auth.c#L871-L969) montre comment s'abonner à un filtre de sujet sur le broker MQTT. L'exemple montre comment s'abonner à un filtre de sujet, mais il est possible de transmettre une liste de filtres de sujets dans le même appel d'API d'abonnement pour s'abonner à plusieurs filtres de sujets. De plus, si le courtier MQTT rejette la demande d'abonnement, l'abonnement réessaiera, avec un retard exponentiel, pour. `RETRY_MAX_ATTEMPTS`
## Publication dans une rubrique
La MQTTPublish ToTopic fonction [prv](https://github.com/aws/amazon-freertos/blob/main/demos/coreMQTT/mqtt_demo_mutual_auth.c#L972-L1004) montre comment publier sur un sujet sur le broker MQTT.
## Réception de messages entrants
L'application enregistre une fonction de rappel d'événement avant de se connecter au broker, comme décrit précédemment. La `prvMQTTDemoTask` fonction appelle la `MQTT_ProcessLoop` fonction pour recevoir les messages entrants. Lorsqu'un message MQTT entrant est reçu, il appelle la fonction de rappel d'événements enregistrée par l'application. La [ prvEventCallback](https://github.com/aws/amazon-freertos/blob/main/demos/coreMQTT/mqtt_demo_mutual_auth.c#L1139-L1154)fonction est un exemple d'une telle fonction de rappel d'événements. `prvEventCallback`examine le type de paquet entrant et appelle le gestionnaire approprié. Dans l'exemple ci-dessous, la fonction appelle soit à gérer `prvMQTTProcessIncomingPublish()` les messages de publication entrants, soit `prvMQTTProcessResponse()` à gérer les accusés de réception (ACK).
## Traitement des paquets de publication MQTT entrants
La MQTTProcess IncomingPublish fonction [prv](https://github.com/aws/amazon-freertos/blob/main/demos/coreMQTT/mqtt_demo_mutual_auth.c#L1108-L1135) montre comment traiter un paquet de publication à partir du broker MQTT.
## Se désabonner d'un sujet
La dernière étape du flux de travail consiste à se désabonner du sujet afin que le courtier n'envoie aucun message publié depuis`mqttexampleTOPIC`. Voici la définition de la fonction [prv MQTTUnsubscribe FromTopic](https://github.com/aws/amazon-freertos/blob/main/demos/coreMQTT/mqtt_demo_mutual_auth.c#L1007-L1043).
## Modification de l'autorité de certification racine utilisée dans la démo
Par défaut, les démos FreeRTOS utilisent le certificat Amazon Root CA 1 (clé RSA 2048 bits) pour s'authentifier auprès du serveur. AWS IoT Core Il est possible d'utiliser d'autres [certificats CA pour l'authentification du serveur](https://docs.aws.amazon.com/iot/latest/developerguide/server-authentication.html#server-authentication-certs), notamment le certificat Amazon Root CA 3 (clé ECC 256 bits). Pour modifier l'autorité de certification racine pour la démonstration d'authentification mutuelle CoreMQTT :
1. Dans un éditeur de texte, ouvrez le fichier `freertos/vendors/vendor/boards/board/aws_demos/config_files/mqtt_demo_mutual_auth_config.h`.
1. Dans le fichier, repérez la ligne suivante.
```
* #define democonfigROOT_CA_PEM "...insert here..."
```
Décommentez cette ligne et, si nécessaire, déplacez-la au-delà de la fin ` */` du bloc de commentaires.
1. Copiez le certificat CA que vous souhaitez utiliser, puis collez-le dans le `"...insert here..."` texte. Le résultat doit ressembler à l'exemple suivant :
```
#define democonfigROOT_CA_PEM "-----BEGIN CERTIFICATE-----\n"\
"MIIBtjCCAVugAwIBAgITBmyf1XSXNmY/Owua2eiedgPySjAKBggqhkjOPQQDAjA5\n"\
"MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g\n"\
"Um9vdCBDQSAzMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG\n"\
"A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg\n"\
"Q0EgMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCmXp8ZBf8ANm+gBG1bG8lKl\n"\
"ui2yEujSLtf6ycXYqm0fc4E7O5hrOXwzpcVOho6AF2hiRVd9RFgdszflZwjrZt6j\n"\
"QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSr\n"\
"ttvXBp43rDCGB5Fwx5zEGbF4wDAKBggqhkjOPQQDAgNJADBGAiEA4IWSoxe3jfkr\n"\
"BqWTrBqYaGFy+uGh0PsceGCmQ5nFuMQCIQCcAu/xlJyzlvnrxir4tiz+OpAUFteM\n"\
"YyRIHN8wfdVoOw==\n"\
"-----END CERTIFICATE-----\n"
```
1. (Facultatif) Vous pouvez modifier l'autorité de certification racine pour les autres démos. Répétez les étapes 1 à 3 pour chaque `freertos/vendors/vendor/boards/board/aws_demos/config_files/demo-name_config.h` fichier.
# Démonstration du partage de connexion avec l'agent CoreMQTT
**Important**
Cette démo est hébergée sur le référentiel Amazon-FreeRTOS 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
## Introduction
Le projet de démonstration du partage de connexion CoreMQTT vous montre comment utiliser une application multithread pour établir une connexion au broker AWS MQTT à l'aide du protocole TLS avec authentification mutuelle entre le client et le serveur. [Cette démonstration utilise une implémentation d'interface de transport basée sur MBEDTLS pour établir une connexion TLS authentifiée par le serveur et le client, et illustre le flux de travail d'abonnement/publication de MQTT au niveau QoS 1.](http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/errata01/os/mqtt-v3.1.1-errata01-os-complete.html#_Toc442180914) La démo s'abonne à un filtre de rubrique, publie les rubriques correspondant au filtre, puis attend de recevoir ces messages du serveur au niveau QoS 1. Ce cycle de publication auprès du courtier et de réception du même message de la part du courtier est répété plusieurs fois pour chaque tâche créée. Les messages de cette démo sont envoyés à QoS 1, ce qui garantit au moins une livraison conformément à la spécification MQTT.
**Note**
Pour configurer et exécuter les démos de FreeRTOS, suivez les étapes décrites dans. [Commencez avec FreeRTOS](freertos-getting-started.md)
Cette démonstration utilise une file d'attente sécurisée par thread pour contenir les commandes permettant d'interagir avec l'API MQTT. Il y a deux tâches à prendre en compte dans cette démonstration.
+ Une tâche (principale) de l'agent MQTT traite les commandes de la file de commandes tandis que les autres tâches les mettent en file d'attente. Cette tâche entre dans une boucle au cours de laquelle elle traite les commandes de la file de commandes. Si une commande de fin est reçue, cette tâche sera interrompue.
+ Une tâche de sous-publication de démonstration crée un abonnement à un sujet MQTT, puis crée des opérations de publication et les place dans la file de commandes. Ces opérations de publication sont ensuite exécutées par la tâche de l'agent MQTT. La tâche de sous-publication de démonstration attend la fin de la publication, ce qui est indiqué par l'exécution du rappel de fin de commande, puis entre dans un court délai avant de commencer la publication suivante. Cette tâche montre des exemples de la manière dont les tâches d'application utiliseraient l'API de l'agent CoreMQTT.
Pour les messages de publication entrants, l'agent CoreMQTT invoque une seule fonction de rappel. Cette démo inclut également un gestionnaire d'abonnements qui permet aux tâches de spécifier un rappel à invoquer pour les messages de publication entrants sur les sujets auxquels elles sont abonnées. Dans le cadre de cette démonstration, le rappel de publication entrant de l'agent appelle le gestionnaire d'abonnements pour répartir les publications sur toute tâche ayant enregistré un abonnement.
Cette démonstration utilise une connexion TLS avec authentification mutuelle pour se connecter AWS. Si le réseau se déconnecte de façon inattendue pendant la démonstration, le client tente de se reconnecter en utilisant une logique d'interruption exponentielle. Si le client se reconnecte avec succès, mais que le courtier ne peut pas reprendre la session précédente, le client se réabonnera aux mêmes sujets que lors de la session précédente.
### Monothread ou multithread
Il existe deux modèles d'utilisation de CoreMQTT, monothread et multithread (multitâche). Le modèle à thread unique utilise la bibliothèque CoreMQTT uniquement à partir d'un thread et vous oblige à effectuer des appels explicites répétés dans la bibliothèque MQTT. Les cas d'utilisation multithread peuvent à la place exécuter le protocole MQTT en arrière-plan dans une tâche d'agent (ou de démon), comme le montre la démonstration documentée ici. Lorsque vous exécutez le protocole MQTT dans une tâche d'agent, vous n'avez pas besoin de gérer explicitement un état MQTT ni d'appeler la fonction `MQTT_ProcessLoop` API. En outre, lorsque vous utilisez une tâche d'agent, plusieurs tâches d'application peuvent partager une seule connexion MQTT sans avoir besoin de primitives de synchronisation telles que des mutex.
## Code source
Les fichiers source de démonstration sont nommés `mqtt_agent_task.c` `simple_sub_pub_demo.c` et se trouvent dans le `freertos/demos/coreMQTT_Agent/` répertoire et sur le [GitHub](https://github.com/aws/amazon-freertos/tree/main/demos/coreMQTT_Agent/)site Web.
## Fonctionnalité
Cette démonstration crée au moins deux tâches : une tâche principale qui traite les demandes d'appels d'API MQTT, et un nombre configurable de sous-tâches qui créent ces demandes. Dans cette démonstration, la tâche principale crée les sous-tâches, appelle la boucle de traitement et effectue ensuite le nettoyage. La tâche principale crée une connexion MQTT unique avec le broker, qui est partagée entre les sous-tâches. Les sous-tâches créent un abonnement MQTT auprès du courtier, puis y publient des messages. Chaque sous-tâche utilise un sujet unique pour ses publications.
## Tâche principale
La tâche principale de l'application, [ RunCoreMQTTAgentDemo](https://github.com/aws/amazon-freertos/blob/main/demos/coreMQTT_Agent/mqtt_agent_task.c#L435-L480), établit une session MQTT, crée les sous-tâches et exécute la boucle de traitement [ MQTTAgent\$1 CommandLoop](https://github.com/aws/amazon-freertos/blob/main/demos/coreMQTT_Agent/mqtt_agent_task.c#L856) jusqu'à ce qu'une commande de fin soit reçue. Si le réseau se déconnecte de façon inattendue, la démo se reconnecte au courtier en arrière-plan et rétablit les abonnements auprès du courtier. Une fois la boucle de traitement terminée, elle se déconnecte du broker.
### Commandes
Lorsque vous appelez une API d'agent CoreMQTT, elle crée une commande qui est envoyée à la file d'attente de la tâche de l'agent, qui est traitée dans. `MQTTAgent_CommandLoop()` Au moment de la création de la commande, le rappel de fin facultatif et les paramètres de contexte peuvent être transmis. Une fois la commande correspondante terminée, le rappel d'achèvement sera invoqué avec le contexte transmis et toutes les valeurs de retour créées à la suite de la commande. La signature du rappel de fin est la suivante :
```
typedef void (* MQTTAgentCommandCallback_t )( void * pCmdCallbackContext,
MQTTAgentReturnInfo_t * pReturnInfo );
```
Le contexte d'exécution des commandes est défini par l'utilisateur ; pour cette démo, il s'agit de : [ MQTTAgentCommandContextstruct](https://github.com/aws/amazon-freertos/blob/main/demos/coreMQTT_Agent/simple_sub_pub_demo.c#L105-L115).
Les commandes sont considérées comme terminées lorsque :
+ S'abonne, se désabonne et publie avec QoS > 0 : une fois que le paquet d'accusé de réception correspondant a été reçu.
+ Toutes les autres opérations : une fois que l'API CoreMQTT correspondante a été invoquée.
Toutes les structures utilisées par la commande, y compris les informations de publication, les informations d'abonnement et les contextes d'achèvement, doivent rester dans le champ d'application jusqu'à ce que la commande soit terminée. Une tâche appelante ne doit réutiliser aucune des structures d'une commande avant l'invocation du rappel de fin. Notez que puisque le rappel d'achèvement est invoqué par l'agent MQTT, il s'exécutera avec le contexte de thread de la tâche de l'agent, et non avec la tâche qui a créé la commande. Les mécanismes de communication entre processus, tels que les notifications de tâches ou les files d'attente, peuvent être utilisés pour signaler à la tâche appelante que la commande est terminée.
### Exécution de la boucle de commande
Les commandes sont traitées en continu dans`MQTTAgent_CommandLoop()`. S'il n'y a aucune commande à traiter, la boucle attendra au maximum qu'une commande soit ajoutée à la file d'attente et, si aucune commande n'est ajoutée, elle exécutera une seule itération de`MQTT_ProcessLoop()`. `MQTT_AGENT_MAX_EVENT_QUEUE_WAIT_TIME` Cela garantit à la fois que MQTT Keep-Alive est géré et que toutes les publications entrantes sont reçues même s'il n'y a aucune commande dans la file d'attente.
La fonction de boucle de commande sera renvoyée pour les raisons suivantes :
+ Une commande renvoie tout autre code d'état`MQTTSuccess`. L'état de l'erreur est renvoyé par la boucle de commande, vous pouvez donc décider comment le gérer. Dans cette démonstration, la connexion TCP est rétablie et une tentative de reconnexion est effectuée. En cas d'erreur, une reconnexion peut se produire en arrière-plan sans aucune intervention de la part d'autres tâches utilisant MQTT.
+ Une commande de déconnexion (de`MQTTAgent_Disconnect`) est traitée. La boucle de commande se termine afin que le protocole TCP puisse être déconnecté.
+ Une commande de fin (depuis`MQTTAgent_Terminate`) est traitée. Cette commande marque également comme une erreur toute commande encore dans la file d'attente ou en attente d'un paquet d'accusé de réception, avec un code de retour de. `MQTTRecvFailed`
### Gestionnaire d'abonnements
Comme la démo utilise plusieurs sujets, un gestionnaire d'abonnements est un moyen pratique d'associer les sujets souscrits à des rappels ou à des tâches uniques. Le gestionnaire d'abonnement de cette démo est mono-thread, il ne doit donc pas être utilisé par plusieurs tâches simultanément. Dans cette démo, les fonctions du gestionnaire d'abonnements sont uniquement appelées à partir des fonctions de rappel transmises à l'agent MQTT et exécutées uniquement avec le contexte du thread de la tâche de l'agent.
## Tâche simple d'abonnement/de publication
Chaque instance de [ prvSimpleSubscribePublishTask](https://github.com/aws/amazon-freertos/blob/main/demos/coreMQTT_Agent/simple_sub_pub_demo.c#L447-L569)crée un abonnement à un sujet MQTT et crée des opérations de publication pour ce sujet. Pour illustrer plusieurs types de publication, les tâches à numéro pair utilisent QoS 0 (qui sont terminées une fois le paquet de publication envoyé) et les tâches impaires utilisent QoS 1 (qui sont terminées à la réception d'un paquet PUBACK).
# Over-the-air met à jour l'application de démonstration
FreeRTOS inclut une application de démonstration qui démontre les fonctionnalités de over-the-air la bibliothèque (OTA). L'application de démonstration OTA se trouve dans le `freertos/demos/ota/ota_demo_core_mqtt/ota_demo_core_mqtt.c` ou le `freertos/demos/ota/ota_demo_core_http/ota_demo_core_http.c` fichier.
L'application de démonstration OTA effectue les opérations suivantes :
1. Initialise la pile de réseau FreeRTOS et le pool de tampons MQTT.
1. Crée une tâche à utiliser par la bibliothèque OTA`vRunOTAUpdateDemo()`.
1. Crée un client MQTT avec `_establishMqttConnection()`.
1. Se connecte au broker AWS IoT MQTT en utilisant `IotMqtt_Connect()` et enregistre un rappel de déconnexion MQTT :. `prvNetworkDisconnectCallback`
1. Elle appelle `OTA_AgentInit()` pour créer la tâche OTA et enregistrer un rappel à utiliser une fois la tâche OTA terminée.
1. Réutilise la connexion MQTT avec `xOTAConnectionCtx.pvControlClient = _mqttConnection;`
1. Si MQTT se déconnecte, l'application suspend l'agent OTA, tente de se reconnecter en utilisant un délai exponentiel avec instabilité, puis reprend l'agent OTA.
Avant de pouvoir utiliser les mises à jour OTA, remplissez tous les prérequis dans [Mises à jour de FreeRTOS Over-the-Air](freertos-ota-dev.md)
Une fois la configuration des mises à jour OTA terminée, téléchargez, compilez, flashez et exécutez la démo de FreeRTOS OTA sur une plateforme compatible avec les fonctionnalités OTA. Des instructions de démonstration spécifiques à l'appareil sont disponibles pour les appareils compatibles FreeRTOS suivants :
+ [Texas Instruments CC3220 SF-LAUNCHXL](download-ota-ti.md)
+ [Microchip Curiosity MZEF PIC32](download-ota-mchip.md)
+ [Espressif ESP32](download-ota-esp.md)
+ [Téléchargez, compilez, flashez et exécutez la démo de FreeRTOS OTA sur le Renesas N RX65](download-rx65n-ota.md)
Après avoir créé, flashé et exécuté l'application de démonstration OTA sur votre appareil, vous pouvez utiliser la AWS IoT console ou créer une tâche de mise à jour OTA. AWS CLI Une fois que vous avez créé une tâche de mise à jour OTA, connectez un émulateur de terminal pour afficher la progression de la mise à jour OTA. Notez les erreurs générées au cours du processus.
Une tâche de mise à jour OTA réussie affiche une sortie similaire à la suivante. Quelques lignes de cet exemple ont été supprimées de la liste par souci de concision.
```
249 21207 [iot_thread] [ota_demo_core_mqtt.c:1850] [INFO] [MQTT] Received: 0 Queued: 0 Processed: 0 Dropped: 0
250 21247 [MQTT Agent Task] [core_mqtt.c:886] [INFO] [MQTT] Packet received. ReceivedBytes=601.
251 21247 [MQTT Agent Task] [core_mqtt.c:1045] [INFO] [MQTT] De-serialized incoming PUBLISH packet: DeserializerResult=MQTTSuccess.
252 21248 [MQTT Agent Task] [core_mqtt.c:1058] [INFO] [MQTT] State record updated. New state=MQTTPubAckSend.
253 21249 [MQTT Agent Task] [ota_demo_core_mqtt.c:976] [INFO] [MQTT] Received job message callback, size 548.
254 21252 [OTA Agent Task] [ota.c:1645] [INFO] [OTA] Extracted parameter: [key: value]=[execution.jobId: AFR_OTA-9702f1a3-b747-4c3e-a0eb-a3b0cf83ddbb]
255 21253 [OTA Agent Task] [ota.c:1645] [INFO] [OTA] Extracted parameter: [key: value]=[execution.jobDocument.afr_ota.streamname: AFR_OTA-945d320b-a18b-441b-b435-4a18d4e7671f]
256 21255 [OTA Agent Task] [ota.c:1645] [INFO] [OTA] Extracted parameter: [key: value]=[execution.jobDocument.afr_ota.protocols: ["MQTT"]]
257 21256 [OTA Agent Task] [ota.c:1645] [INFO] [OTA] Extracted parameter: [key: value]=[filepath: aws_demos.bin]
258 21257 [OTA Agent Task] [ota.c:1684] [INFO] [OTA] Extracted parameter: [key: value]=[filesize: 1164016]
259 21258 [OTA Agent Task] [ota.c:1684] [INFO] [OTA] Extracted parameter: [key: value]=[fileid: 0]
260 21259 [OTA Agent Task] [ota.c:1645] [INFO] [OTA] Extracted parameter: [key: value]=[certfile: ecdsa-sha256-signer.crt.pem]
261 21260 [OTA Agent Task] [ota.c:1575] [INFO] [OTA] Extracted parameter [ sig-sha256-ecdsa: MEQCIE1SFkIHHiZAvkPpu6McJtx7SYoD... ]
262 21261 [OTA Agent Task] [ota.c:1684] [INFO] [OTA] Extracted parameter: [key: value]=[fileType: 0]
263 21262 [OTA Agent Task] [ota.c:2199] [INFO] [OTA] Job document was accepted. Attempting to begin the update.
264 21263 [OTA Agent Task] [ota.c:2323] [INFO] [OTA] Job parsing success: OtaJobParseErr_t=OtaJobParseErrNone, Job name=AFR_OTA-9702f1a3-b747-4c3e-a0eb-a3b0cf83ddbb
265 21318 [iot_thread] [ota_demo_core_mqtt.c:1850] [INFO] [MQTT] Received: 0 Queued: 0 Processed: 0 Dropped: 0
266 21418 [iot_thread] [ota_demo_core_mqtt.c:1850] [INFO] [MQTT] Received: 0 Queued: 0 Processed: 0 Dropped: 0
267 21469 [OTA Agent Task] [ota.c:938] [INFO] [OTA] Setting OTA data interface.
268 21470 [OTA Agent Task] [ota.c:2839] [INFO] [OTA] Current State=[CreatingFile], Event=[ReceivedJobDocument], New state=[CreatingFile]
269 21482 [MQTT Agent Task] [core_mqtt.c:886] [INFO] [MQTT] Packet received. ReceivedBytes=3.
270 21483 [OTA Agent Task] [ota_demo_core_mqtt.c:1503] [INFO] [MQTT] SUBSCRIBED to topic $aws/things/__test_infra_thing71/streams/AFR_OTA-945d320b-a18b-441b-b435-4a18d4e7671f/data/cbor to bro
271 21484 [OTA Agent Task] [ota.c:2839] [INFO] [OTA] Current State=[RequestingFileBlock], Event=[CreateFile], New state=[RequestingFileBlock]
272 21518 [iot_thread] [ota_demo_core_mqtt.c:1850] [INFO] [MQTT] Received: 0 Queued: 0 Processed: 0 Dropped: 0
273 21532 [MQTT Agent Task] [core_mqtt_agent_command_functions.c:76] [INFO] [MQTT] Publishing message to $aws/things/__test_infra_thing71/streams/AFR_OTA-945d320b-a18b-441b-b435-4a18d4e7671f/
274 21534 [OTA Agent Task] [ota_demo_core_mqtt.c:1553] [INFO] [MQTT] Sent PUBLISH packet to broker $aws/things/__test_infra_thing71/streams/AFR_OTA-945d320b-a18b-441b-b435-4a18d4e7671f/get/cbor
275 21534 [OTA Agent Task] [ota_mqtt.c:1112] [INFO] [OTA] Published to MQTT topic to request the next block: topic=$aws/things/__test_infra_thing71/streams/AFR_OTA-945d320b-a18b-441b-b435-4a1
276 21537 [OTA Agent Task] [ota.c:2839] [INFO] [OTA] Current State=[WaitingForFileBlock], Event=[RequestFileBlock], New state=[WaitingForFileBlock]
277 21558 [MQTT Agent Task] [core_mqtt.c:886] [INFO] [MQTT] Packet received. ReceivedBytes=4217.
278 21559 [MQTT Agent Task] [core_mqtt.c:1045] [INFO] [MQTT] De-serialized incoming PUBLISH packet: DeserializerResult=MQTTSuccess.
279 21560 [MQTT Agent Task] [core_mqtt.c:1058] [INFO] [MQTT] State record updated. New state=MQTTPublishDone.
280 21561 [MQTT Agent Task] [ota_demo_core_mqtt.c:1026] [INFO] [MQTT] Received data message callback, size 4120.
281 21563 [OTA Agent Task] [ota.c:2464] [INFO] [OTA] Received valid file block: Block index=0, Size=4096
282 21566 [OTA Agent Task] [ota.c:2683] [INFO] [OTA] Number of blocks remaining: 284
... // Output removed for brevity
3672 42745 [OTA Agent Task] [ota.c:2464] [INFO] [OTA] Received valid file block: Block index=284, Size=752
3673 42747 [OTA Agent Task] [ota.c:2633] [INFO] [OTA] Received final block of the update.
(428298) ota_pal: No such certificate file: ecdsa-sha256-signer.crt.pem. Using certificate in ota_demo_config.h.
3674 42818 [iot_thread] [ota_demo_core_mqtt.c:1850] [INFO] [MQTT] Received: 285 Queued: 285 Processed: 284 Dropped: 0
3675 42918 [iot_thread] [ota_demo_core_mqtt.c:1850] [INFO] [MQTT] Received: 285 Queued: 285 Processed: 284 Dropped: 0
... // Output removed for brevity
3678 43197 [OTA Agent Task] [ota.c:2654] [INFO] [OTA] Received entire update and validated the signature.
3685 43215 [OTA Agent Task] [ota_demo_core_mqtt.c:862] [INFO] [MQTT] Received OtaJobEventActivate callback from OTA Agent.
... // Output removed for brevity
2 39 [iot_thread] [INFO ][DEMO][390] ---------STARTING DEMO---------
[0;32mI (3633) WIFI: WIFI_EVENT_STA_CONNECTED
[0;32mI (4373) WIFI: SYSTEM_EVENT_STA_GOT_IP
... // Output removed for brevity
4 351 [sys_evt] [INFO ][DEMO][3510] Connected to WiFi access point, ip address: 255.255.255.0.
5 351 [iot_thread] [INFO ][DEMO][3510] Successfully initialized the demo. Network type for the demo: 1
6 351 [iot_thread] [ota_demo_core_mqtt.c:1902] [INFO] [MQTT] OTA over MQTT demo, Application version 0.9.1
7 351 [iot_thread] [ota_demo_core_mqtt.c:1323] [INFO] [MQTT] Creating a TLS connection to -ats.iot.us-west-2.amazonaws.com:8883.
9 718 [iot_thread] [core_mqtt.c:886] [INFO] [MQTT] Packet received. ReceivedBytes=2.
10 718 [iot_thread] [core_mqtt_serializer.c:970] [INFO] [MQTT] CONNACK session present bit not set.
11 718 [iot_thread] [core_mqtt_serializer.c:912] [INFO] [MQTT] Connection accepted.
... // Output removed for brevity
17 736 [OTA Agent Task] [ota_demo_core_mqtt.c:1503] [INFO] [MQTT] SUBSCRIBED to topic $aws/things/__test_infra_thing71/jobs/notify-next to broker.
18 737 [OTA Agent Task] [ota_mqtt.c:381] [INFO] [OTA] Subscribed to MQTT topic: $aws/things/__test_infra_thing71/jobs/notify-next
30 818 [iot_thread] [ota_demo_core_mqtt.c:1850] [INFO] [MQTT] Received: 0 Queued: 0 Processed: 0 Dropped: 0
31 819 [OTA Agent Task] [ota.c:1645] [INFO] [OTA] Extracted parameter: [key: value]=[execution.jobId: AFR_OTA-9702f1a3-b747-4c3e-a0eb-a3b0cf83ddbb]
32 820 [OTA Agent Task] [ota.c:1684] [INFO] [OTA] Extracted parameter: [key: value]=[execution.statusDetails.updatedBy: 589824]
33 822 [OTA Agent Task] [ota.c:1645] [INFO] [OTA] Extracted parameter: [key: value]=[execution.jobDocument.afr_ota.streamname: AFR_OTA-945d320b-a18b-441b-b435-4a18d4e7671f]
34 823 [OTA Agent Task] [ota.c:1645] [INFO] [OTA] Extracted parameter: [key: value]=[execution.jobDocument.afr_ota.protocols: ["MQTT"]]
35 824 [OTA Agent Task] [ota.c:1645] [INFO] [OTA] Extracted parameter: [key: value]=[filepath: aws_demos.bin]
36 825 [OTA Agent Task] [ota.c:1684] [INFO] [OTA] Extracted parameter: [key: value]=[filesize: 1164016]
37 826 [OTA Agent Task] [ota.c:1684] [INFO] [OTA] Extracted parameter: [key: value]=[fileid: 0]
38 827 [OTA Agent Task] [ota.c:1645] [INFO] [OTA] Extracted parameter: [key: value]=[certfile: ecdsa-sha256-signer.crt.pem]
39 828 [OTA Agent Task] [ota.c:1575] [INFO] [OTA] Extracted parameter [ sig-sha256-ecdsa: MEQCIE1SFkIHHiZAvkPpu6McJtx7SYoD... ]
40 829 [OTA Agent Task] [ota.c:1684] [INFO] [OTA] Extracted parameter: [key: value]=[fileType: 0]
41 830 [OTA Agent Task] [ota.c:2102] [INFO] [OTA] In self test mode.
42 830 [OTA Agent Task] [ota.c:1936] [INFO] [OTA] New image has a higher version number than the current image: New image version=0.9.1, Previous image version=0.9.0
43 832 [OTA Agent Task] [ota.c:2120] [INFO] [OTA] Image version is valid: Begin testing file: File ID=0
53 896 [OTA Agent Task] [ota.c:794] [INFO] [OTA] Beginning self-test.
62 971 [OTA Agent Task] [ota_demo_core_mqtt.c:1553] [INFO] [MQTT] Sent PUBLISH packet to broker $aws/things/__test_infra_thing71/jobs/AFR_OTA-9702f1a3-b747-4c3e-a0eb-a3b0cf83ddbb/update to br63 971 [MQTT Agent Task] [core_mqtt.c:1045] [INFO] [MQTT] De-serialized incoming PUBLISH packet: DeserializerResult=MQTTSuccess.
65 973 [MQTT Agent Task] [core_mqtt.c:1058] [INFO] [MQTT] State record updated. New state=MQTTPublishDone.
64 973 [OTA Agent Task] [ota_demo_core_mqtt.c:902] [INFO] [MQTT] Successfully updated with the new image.
```
# Over-the-air configurations de démonstration
Les configurations de démonstration OTA sont des options de configuration spécifiques aux démos fournies dans. `aws_iot_ota_update_demo.c` Ces configurations sont différentes des configurations de bibliothèque OTA fournies dans le fichier de configuration de bibliothèque OTA.
**OTA\$1DEMO\$1KEEP\$1ALIVE\$1SECONDS**
Pour le client MQTT, cette configuration correspond à l'intervalle de temps maximal qui peut s'écouler entre la fin de la transmission d'un paquet de contrôle et le début de l'envoi du suivant. En l'absence de paquet de contrôle, un PINGREQ est envoyé. Le courtier doit déconnecter un client qui n'envoie pas de message ou de paquet PINGREQ pendant une fois et demie pendant cet intervalle de maintien en vie. Cette configuration doit être ajustée en fonction des exigences de l'application.
**OTA\$1DEMO\$1CONN\$1RETRY\$1BASE\$1INTERVAL\$1SECONDS**
Intervalle de base, en secondes, avant une nouvelle tentative de connexion réseau. La démo OTA essaiera de se reconnecter après cet intervalle de temps de base. L'intervalle est doublé après chaque tentative infructueuse. Un délai aléatoire, jusqu'à un maximum de ce délai de base, est également ajouté à l'intervalle.
**OTA\$1DEMO\$1CONN\$1RETRY\$1MAX\$1INTERVAL\$1SECONDS**
Intervalle maximal, en secondes, avant une nouvelle tentative de connexion réseau. Le délai de reconnexion est doublé à chaque tentative infructueuse, mais il ne peut atteindre que cette valeur maximale, plus une instabilité correspondant au même intervalle.
# Téléchargez, compilez, flashez et exécutez la démo de FreeRTOS OTA sur le Texas Instruments SF-LAUNCHXL CC3220
**Important**
Cette intégration de référence est hébergée sur le référentiel Amazon-FreeRTOS, 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
**Pour télécharger FreeRTOS et le code de démonstration OTA**
+ Vous pouvez télécharger le code source sur le GitHub site [https://github.com/FreeRTOS/FreeRTOS](https://github.com/FreeRTOS/FreeRTOS).
**Pour créer l'application de démonstration**
1. Suivez les instructions ci-dessous [Commencez avec FreeRTOS](freertos-getting-started.md) pour importer le `aws_demos` projet dans Code Composer Studio, configurer votre AWS IoT terminal, votre SSID et votre mot de passe Wi-Fi, ainsi qu'une clé privée et un certificat pour votre tableau.
1. Ouvrez`freertos/vendors/vendor/boards/board/aws_demos/config_files/aws_demo_config.h`, commentez `#define CONFIG_CORE_MQTT_MUTUAL_AUTH_DEMO_ENABLED` et définissez `CONFIG_OTA_MQTT_UPDATE_DEMO_ENABLED` ou`CONFIG_OTA_HTTP_UPDATE_DEMO_ENABLED`.
1. Générez la solution et assurez-vous qu'elle se génère sans erreurs.
1. Démarrez un émulateur de terminal et utilisez les paramètres suivants pour vous connecter à votre carte :
+ Vitesse de transmission : 115200
+ Bits de données : 8
+ Parité : aucune
+ Bits d'arrêt : 1
1. Exécutez le projet sur votre carte pour vous assurer qu'elle peut se connecter au Wi-Fi et à l'agent de message MQTT AWS IoT .
Lorsqu'il s'exécute, l'émulateur de terminal doit afficher un texte semblable au suivant :
```
0 1000 [Tmr Svc] Simple Link task created
Device came up in Station mode
1 2534 [Tmr Svc] Write certificate...
2 5486 [Tmr Svc] [ERROR] Failed to destroy object. PKCS11_PAL_DestroyObject failed.
3 5486 [Tmr Svc] Write certificate...
4 5776 [Tmr Svc] Security alert threshold = 15
5 5776 [Tmr Svc] Current number of alerts = 1
6 5778 [Tmr Svc] Running Demos.
7 5779 [iot_thread] [INFO ][DEMO][5779] ---------STARTING DEMO---------
8 5779 [iot_thread] [INFO ][INIT][5779] SDK successfully initialized.
Device came up in Station mode
[WLAN EVENT] STA Connected to the AP: afrlab-pepper , BSSID: 74:83:c2:b4:46:27
[NETAPP EVENT] IP acquired by the device
Device has connected to afrlab-pepper
Device IP Address is 192.168.36.176
9 8283 [iot_thread] [INFO ][DEMO][8282] Successfully initialized the demo. Network type for the demo: 1
10 8283 [iot_thread] [INFO] OTA over MQTT demo, Application version 0.9.0
11 8283 [iot_thread] [INFO] Creating a TLS connection to -ats.iot.us-west-2.amazonaws.com:8883.
12 8852 [iot_thread] [INFO] Creating an MQTT connection to -ats.iot.us-west-2.amazonaws.com.
13 8914 [iot_thread] [INFO] Packet received. ReceivedBytes=2.
14 8914 [iot_thread] [INFO] CONNACK session present bit not set.
15 8914 [iot_thread] [INFO] Connection accepted.
16 8914 [iot_thread] [INFO] Received MQTT CONNACK successfully from broker.
17 8914 [iot_thread] [INFO] MQTT connection established with the broker.
18 8915 [iot_thread] [INFO] Received: 0 Queued: 0 Processed: 0 Dropped: 0
19 8953 [OTA Agent T] [INFO] Current State=[RequestingJob], Event=[Start], New state=[RequestingJob]
20 9008 [MQTT Agent ] [INFO] Packet received. ReceivedBytes=3.
21 9015 [OTA Agent T] [INFO] SUBSCRIBED to topic $aws/things/__test_infra_thing73/jobs/notify-next to broker.
22 9015 [OTA Agent T] [INFO] Subscribed to MQTT topic: $aws/things/__test_infra_thing73/jobs/notify-next
23 9504 [MQTT Agent ] [INFO] Publishing message to $aws/things/__test_infra_thing73/jobs/$next/get.
24 9535 [MQTT Agent ] [INFO] Packet received. ReceivedBytes=2.
25 9535 [MQTT Agent ] [INFO] Ack packet deserialized with result: MQTTSuccess.
26 9536 [MQTT Agent ] [INFO] State record updated. New state=MQTTPublishDone.
27 9537 [OTA Agent T] [INFO] Sent PUBLISH packet to broker $aws/things/__test_infra_thing73/jobs/$next/get to broker.
28 9537 [OTA Agent T] [WARN] OTA Timer handle NULL for Timerid=0, can't stop.
29 9537 [OTA Agent T] [INFO] Current State=[WaitingForJob], Event=[RequestJobDocument], New state=[WaitingForJob]
30 9539 [MQTT Agent ] [INFO] Packet received. ReceivedBytes=120.
31 9539 [MQTT Agent ] [INFO] De-serialized incoming PUBLISH packet: DeserializerResult=MQTTSuccess.
32 9540 [MQTT Agent ] [INFO] State record updated. New state=MQTTPublishDone.
33 9540 [MQTT Agent ] [INFO] Received job message callback, size 62.
34 9616 [OTA Agent T] [INFO] Failed job document content check: Required job document parameter was not extracted: parameter=execution
35 9616 [OTA Agent T] [INFO] Failed job document content check: Required job document parameter was not extracted: parameter=execution.jobId
36 9617 [OTA Agent T] [INFO] Failed job document content check: Required job document parameter was not extracted: parameter=execution.jobDocument
37 9617 [OTA Agent T] [INFO] Failed job document content check: Required job document parameter was not extracted: parameter=execution.jobDocument.afr_ota
38 9617 [OTA Agent T] [INFO] Failed job document content check: Required job document parameter was not extracted: parameter=execution.jobDocument.afr_ota.protocols
39 9618 [OTA Agent T] [INFO] Failed job document content check: Required job document parameter was not extracted: parameter=execution.jobDocument.afr_ota.files
40 9618 [OTA Agent T] [INFO] Failed job document content check: Required job document parameter was not extracted: parameter=filesize
41 9618 [OTA Agent T] [INFO] Failed job document content check: Required job document parameter was not extracted: parameter=fileid
42 9619 [OTA Agent T] [INFO] Failed to parse JSON document as AFR_OTA job: DocParseErr_t=7
43 9619 [OTA Agent T] [INFO] No active job available in received job document: OtaJobParseErr_t=OtaJobParseErrNoActiveJobs
44 9619 [OTA Agent T] [ERROR] Failed to execute state transition handler: Handler returned error: OtaErr_t=OtaErrJobParserError
45 9620 [OTA Agent T] [INFO] Current State=[WaitingForJob], Event=[ReceivedJobDocument], New state=[CreatingFile]
46 9915 [iot_thread] [INFO] Received: 0 Queued: 0 Processed: 0 Dropped: 0
47 10915 [iot_thread] [INFO] Received: 0 Queued: 0 Processed: 0 Dropped: 0
48 11915 [iot_thread] [INFO] Received: 0 Queued: 0 Processed: 0 Dropped: 0
49 12915 [iot_thread] [INFO] Received: 0 Queued: 0 Processed: 0 Dropped: 0
50 13915 [iot_thread] [INFO] Received: 0 Queued: 0 Processed: 0 Dropped: 0
51 14915 [iot_thread] [INFO] Received: 0 Queued: 0 Processed: 0 Dropped: 0
```
# Téléchargez, compilez, flashez et exécutez la démo de FreeRTOS OTA sur le Microchip Curiosity MZEF PIC32
**Important**
Cette intégration de référence est hébergée sur le référentiel Amazon-FreeRTOS, 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
**Note**
En accord avec Microchip, nous supprimons le Curiosity PIC32 MZEF (DM320104) de la branche principale du référentiel FreeRTOS Reference Integration et ne le proposerons plus dans les nouvelles versions. Microchip a publié un [avis officiel indiquant](https://www.microchip.com/DevelopmentTools/ProductDetails/PartNO/DM320104) que le PIC32 MZEF (DM320104) n'est plus recommandé pour les nouveaux modèles. Les projets et le code source de PIC32 MZEF sont toujours accessibles via les balises de version précédentes. Microchip recommande aux clients d'utiliser la carte de [développement Curiosity PIC32 MZ-EF-2.0 () DM320209 pour les nouvelles](https://devices.amazonaws.com/detail/a3G0h0000077I69EAE/Curiosity-PIC32MZ-EF-2-0-Development-Board) conceptions. La PIC32 MZv1 plate-forme se trouve toujours dans la version [v202012.00 du](https://github.com/aws/amazon-freertos/tree/202012.00) référentiel FreeRTOS Reference Integration. Cependant, la plateforme n'est plus prise en charge par la version [v202107.00 du](https://github.com/aws/amazon-freertos/tree/202107.00) FreeRTOS Reference.
**Pour télécharger le code de démonstration FreeRTOS OTA**
+ Vous pouvez télécharger le code source sur le GitHub site [https://github.com/FreeRTOS/FreeRTOS](https://github.com/FreeRTOS/FreeRTOS).
**Pour créer l'application de démonstration de la mise à jour OTA**
1. Suivez les instructions ci-dessous [Commencez avec FreeRTOS](freertos-getting-started.md) pour importer le `aws_demos` projet dans l'IDE MPLAB X, configurer votre AWS IoT terminal, votre SSID et votre mot de passe Wi-Fi, ainsi qu'une clé privée et un certificat pour votre carte.
1. Ouvrez le `vendors/vendor/boards/board/aws_demos/config_files/ota_demo_config.h` fichier et entrez votre certificat.
```
[] = "your-certificate-key";
```
1. Collez le contenu de votre certificat de signature de code ici :
```
#define otapalconfigCODE_SIGNING_CERTIFICATE [] = "your-certificate-key";
```
Suivez le même format que `aws_clientcredential_keys.h` : chaque ligne doit se terminer par le nouveau caractère de ligne («\$1n») et être placée entre guillemets.
Par exemple, votre certificat doit se présenter comme suit :
```
"-----BEGIN CERTIFICATE-----\n"
"MIIBXTCCAQOgAwIBAgIJAM4DeybZcTwKMAoGCCqGSM49BAMCMCExHzAdBgNVBAMM\n"
"FnRlc3Rf62lnbmVyQGFtYXpvbi5jb20wHhcNMTcxMTAzMTkxODM1WhcNMTgxMTAz\n"
"MTkxODM2WjAhMR8wHQYDVQBBZZZ0ZXN0X3NpZ25lckBhbWF6b24uY29tMFkwEwYH\n"
"KoZIzj0CAQYIKoZIzj0DAQcDQgAERavZfvwL1X+E4dIF7dbkVMUn4IrJ1CAsFkc8\n"
"gZxPzn683H40XMKltDZPEwr9ng78w9+QYQg7ygnr2stz8yhh06MkMCIwCwYDVR0P\n"
"BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMDMAoGCCqGSM49BAMCA0gAMEUCIF0R\n"
"r5cb7rEUNtWOvGd05MacrgOABfSoVYvBOK9fP63WAqt5h3BaS123coKSGg84twlq\n"
"TkO/pV/xEmyZmZdV+HxV/OM=\n"
"-----END CERTIFICATE-----\n";
```
1. Installez [Python 3](https://www.python.org/downloads/) ou version ultérieure.
1. Installez `pyOpenSSL` en exécutant `pip install pyopenssl`.
1. Copiez votre certificat de signature de code au format .pem dans le chemin d'accès `demos/ota/bootloader/utility/codesigner_cert_utility/`. Renommez le fichier de certificat `aws_ota_codesigner_certificate.pem`.
1. Ouvrez`freertos/vendors/vendor/boards/board/aws_demos/config_files/aws_demo_config.h`, commentez `#define CONFIG_CORE_MQTT_MUTUAL_AUTH_DEMO_ENABLED` et définissez `CONFIG_OTA_MQTT_UPDATE_DEMO_ENABLED` ou`CONFIG_OTA_HTTP_UPDATE_DEMO_ENABLED`.
1. Générez la solution et assurez-vous qu'elle se génère sans erreurs.
1. Démarrez un émulateur de terminal et utilisez les paramètres suivants pour vous connecter à votre carte :
+ Vitesse de transmission : 115200
+ Bits de données : 8
+ Parité : aucune
+ Bits d'arrêt : 1
1. Débranchez le débogueur de votre carte et lancez le projet sur votre carte pour vérifier qu'il peut se connecter au Wi-Fi et au courtier de messages AWS IoT MQTT.
Lorsque vous exécutez le projet, l'IDE MPLAB X doit ouvrir une fenêtre de sortie. Assurez-vous que l'**ICD4**onglet est sélectionné. Le résultat suivant doit s'afficher.
```
Bootloader version 00.09.00
[prvBOOT_Init] Watchdog timer initialized.
[prvBOOT_Init] Crypto initialized.
[prvValidateImage] Validating image at Bank : 0
[prvValidateImage] No application image or magic code present at: 0xbd000000
[prvBOOT_ValidateImages] Validation failed for image at 0xbd000000
[prvValidateImage] Validating image at Bank : 1
[prvValidateImage] No application image or magic code present at: 0xbd100000
[prvBOOT_ValidateImages] Validation failed for image at 0xbd100000
[prvBOOT_ValidateImages] Booting default image.
>0 36246 [IP-task] vDHCPProcess: offer ac140a0eip
1 36297 [IP-task] vDHCPProcess: offer ac140a0eip
2 36297 [IP-task]
IP Address: 172.20.10.14
3 36297 [IP-task] Subnet Mask: 255.255.255.240
4 36297 [IP-task] Gateway Address: 172.20.10.1
5 36297 [IP-task] DNS Server Address: 172.20.10.1
6 36299 [OTA] OTA demo version 0.9.2
7 36299 [OTA] Creating MQTT Client...
8 36299 [OTA] Connecting to broker...
9 38673 [OTA] Connected to broker.
10 38793 [OTA Task] [prvSubscribeToJobNotificationTopics] OK: $aws/things/devthingota/jobs/$next/get/accepted
11 38863 [OTA Task] [prvSubscribeToJobNotificationTopics] OK: $aws/things/devthingota/jobs/notify-next
12 38863 [OTA Task] [OTA_CheckForUpdate] Request #0
13 38964 [OTA] [OTA_AgentInit] Ready.
14 38973 [OTA Task] [prvParseJSONbyModel] Extracted parameter [ clientToken: 0:devthingota ]
15 38973 [OTA Task] [prvParseJSONbyModel] parameter not present: execution
16 38973 [OTA Task] [prvParseJSONbyModel] parameter not present: jobId
17 38973 [OTA Task] [prvParseJSONbyModel] parameter not present: jobDocument
18 38973 [OTA Task] [prvParseJSONbyModel] parameter not present: streamname
19 38973 [OTA Task] [prvParseJSONbyModel] parameter not present: files
20 38975 [OTA Task] [prvParseJSONbyModel] parameter not present: filepath
21 38975 [OTA Task] [prvParseJSONbyModel] parameter not present: filesize
22 38975 [OTA Task] [prvParseJSONbyModel] parameter not present: fileid
23 38975 [OTA Task] [prvParseJSONbyModel] parameter not present: certfile
24 38975 [OTA Task] [prvParseJSONbyModel] parameter not present: sig-sha256-ecdsa
25 38975 [OTA Task] [prvParseJobDoc] Ignoring job without ID.
26 38975 [OTA Task] [prvOTA_Close] Context->0x8003b620
27 38975 [OTA Task] [prvPAL_Abort] Abort - OK
28 39964 [OTA] State: Ready Received: 1 Queued: 1 Processed: 1 Dropped: 0
29 40964 [OTA] State: Ready Received: 1 Queued: 1 Processed: 1 Dropped: 0
30 41964 [OTA] State: Ready Received: 1 Queued: 1 Processed: 1 Dropped: 0
31 42964 [OTA] State: Ready Received: 1 Queued: 1 Processed: 1 Dropped: 0
32 43964 [OTA] State: Ready Received: 1 Queued: 1 Processed: 1 Dropped: 0
33 44964 [OTA] State: Ready Received: 1 Queued: 1 Processed: 1 Dropped: 0
34 45964 [OTA] State: Ready Received: 1 Queued: 1 Processed: 1 Dropped: 0
35 46964 [OTA] State: Ready Received: 1 Queued: 1 Processed: 1 Dropped: 0
36 47964 [OTA] State: Ready Received: 1 Queued: 1 Processed: 1 Dropped: 0
```
L'émulateur de terminal doit afficher un texte semblable au suivant :
```
AWS Validate: no valid signature in descr: 0xbd000000
AWS Validate: no valid signature in descr: 0xbd100000
>AWS Launch: No Map performed. Running directly from address: 0x9d000020?
AWS Launch: wait for app at: 0x9d000020
WILC1000: Initializing...
0 0
>[None] Seed for randomizer: 1172751941
1 0 [None] Random numbers: 00004272 00003B34 00000602 00002DE3
Chip ID 1503a0
[spi_cmd_rsp][356][nmi spi]: Failed cmd response read, bus error...
[spi_read_reg][1086][nmi spi]: Failed cmd response, read reg (0000108c)...
[spi_read_reg][1116]Reset and retry 10 108c
Firmware ver. : 4.2.1
Min driver ver : 4.2.1
Curr driver ver: 4.2.1
WILC1000: Initialization successful!
Start Wi-Fi Connection...
Wi-Fi Connected
2 7219 [IP-task] vDHCPProcess: offer c0a804beip
3 7230 [IP-task] vDHCPProcess: offer c0a804beip
4 7230 [IP-task]
IP Address: 192.168.4.190
5 7230 [IP-task] Subnet Mask: 255.255.240.0
6 7230 [IP-task] Gateway Address: 192.168.0.1
7 7230 [IP-task] DNS Server Address: 208.67.222.222
8 7232 [OTA] OTA demo version 0.9.0
9 7232 [OTA] Creating MQTT Client...
10 7232 [OTA] Connecting to broker...
11 7232 [OTA] Sending command to MQTT task.
12 7232 [MQTT] Received message 10000 from queue.
13 8501 [IP-task] Socket sending wakeup to MQTT task.
14 10207 [MQTT] Received message 0 from queue.
15 10256 [IP-task] Socket sending wakeup to MQTT task.
16 10256 [MQTT] Received message 0 from queue.
17 10256 [MQTT] MQTT Connect was accepted. Connection established.
18 10256 [MQTT] Notifying task.
19 10257 [OTA] Command sent to MQTT task passed.
20 10257 [OTA] Connected to broker.
21 10258 [OTA Task] Sending command to MQTT task.
22 10258 [MQTT] Received message 20000 from queue.
23 10306 [IP-task] Socket sending wakeup to MQTT task.
24 10306 [MQTT] Received message 0 from queue.
25 10306 [MQTT] MQTT Subscribe was accepted. Subscribed.
26 10306 [MQTT] Notifying task.
27 10307 [OTA Task] Command sent to MQTT task passed.
28 10307 [OTA Task] [OTA] Subscribed to topic: $aws/things/Microchip/jobs/$next/get/accepted
29 10307 [OTA Task] Sending command to MQTT task.
30 10307 [MQTT] Received message 30000 from queue.
31 10336 [IP-task] Socket sending wakeup to MQTT task.
32 10336 [MQTT] Received message 0 from queue.
33 10336 [MQTT] MQTT Subscribe was accepted. Subscribed.
34 10336 [MQTT] Notifying task.
35 10336 [OTA Task] Command sent to MQTT task passed.
36 10336 [OTA Task] [OTA] Subscribed to topic: $aws/things/Microchip/jobs/notify-next
37 10336 [OTA Task] [OTA] Check For Update #0
38 10336 [OTA Task] Sending command to MQTT task.
39 10336 [MQTT] Received message 40000 from queue.
40 10366 [IP-task] Socket sending wakeup to MQTT task.
41 10366 [MQTT] Received message 0 from queue.
42 10366 [MQTT] MQTT Publish was successful.
43 10366 [MQTT] Notifying task.
44 10366 [OTA Task] Command sent to MQTT task passed.
45 10376 [IP-task] Socket sending wakeup to MQTT task.
46 10376 [MQTT] Received message 0 from queue.
47 10376 [OTA Task] [OTA] Set job doc parameter [ clientToken: 0:Microchip ]
48 10376 [OTA Task] [OTA] Missing job parameter: execution
49 10376 [OTA Task] [OTA] Missing job parameter: jobId
50 10376 [OTA Task] [OTA] Missing job parameter: jobDocument
51 10378 [OTA Task] [OTA] Missing job parameter: ts_ota
52 10378 [OTA Task] [OTA] Missing job parameter: files
53 10378 [OTA Task] [OTA] Missing job parameter: streamname
54 10378 [OTA Task] [OTA] Missing job parameter: certfile
55 10378 [OTA Task] [OTA] Missing job parameter: filepath
56 10378 [OTA Task] [OTA] Missing job parameter: filesize
57 10378 [OTA Task] [OTA] Missing job parameter: sig-sha256-ecdsa
58 10378 [OTA Task] [OTA] Missing job parameter: fileid
59 10378 [OTA Task] [OTA] Missing job parameter: attr
60 10378 [OTA Task] [OTA] Returned buffer to MQTT Client.
61 11367 [OTA] [OTA] Queued: 1 Processed: 1 Dropped: 0
62 12367 [OTA] [OTA] Queued: 1 Processed: 1 Dropped: 0
63 13367 [OTA] [OTA] Queued: 1 Processed: 1 Dropped: 0
64 14367 [OTA] [OTA] Queued: 1 Processed: 1 Dropped: 0
65 15367 [OTA] [OTA] Queued: 1 Processed: 1 Dropped: 0
66 16367 [OTA] [OTA] Queued: 1 Processed: 1 Dropped: 0
```
Cette sortie montre que le Microchip Curiosity PIC32 MZEF peut se connecter AWS IoT et s'abonner aux rubriques MQTT requises pour les mises à jour OTA. Les messages `Missing job parameter`sont attendus, car il n'y a pas de tâches de mise à jour OTA en attente.
# Téléchargez, compilez, flashez et exécutez la démo de FreeRTOS OTA sur l'Espressif ESP32
**Important**
Cette intégration de référence est hébergée sur le référentiel Amazon-FreeRTOS, 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
1. Téléchargez le code source FreeRTOS à partir de. [GitHub](https://github.com/aws/amazon-freertos) Consultez le fichier [README.md](https://github.com/aws/amazon-freertos/blob/main/README.md) pour obtenir des instructions. Créez un projet dans votre environnement IDE qui inclut toutes les sources et bibliothèques requises.
1. Suivez les instructions de [Mise en route avec Espressif](https://docs.aws.amazon.com/freertos/latest/userguide/getting_started_espressif.html) pour configurer la chaîne d'outils basée sur GCC requise.
1. Ouvrez`freertos/vendors/vendor/boards/board/aws_demos/config_files/aws_demo_config.h`, commentez `#define CONFIG_CORE_MQTT_MUTUAL_AUTH_DEMO_ENABLED` et définissez `CONFIG_OTA_MQTT_UPDATE_DEMO_ENABLED` ou`CONFIG_OTA_HTTP_UPDATE_DEMO_ENABLED`.
1. Générez le projet de démonstration en exécutant `make` dans le répertoire `vendors/espressif/boards/esp32/aws_demos`. Vous pouvez flasher le programme de démonstration et vérifier sa sortie en exécutant `make flash monitor`, comme décrit dans [Mise en route avec Espressif](https://docs.aws.amazon.com/freertos/latest/userguide/getting_started_espressif.html).
1. Avant d'exécuter la démonstration de mise à jour OTA :
+ Ouvrez`freertos/vendors/vendor/boards/board/aws_demos/config_files/aws_demo_config.h`, commentez `#define CONFIG_CORE_MQTT_MUTUAL_AUTH_DEMO_ENABLED` et définissez `CONFIG_OTA_MQTT_UPDATE_DEMO_ENABLED` ou`CONFIG_OTA_HTTP_UPDATE_DEMO_ENABLED`.
+ Ouvrez `vendors/vendor/boards/board/aws_demos/config_files/ota_demo_config.h` et copiez votre certificat de signature de code SHA-256/ECDSA dans :
```
#define otapalconfigCODE_SIGNING_CERTIFICATE [] = "your-certificate-key";
```
# Téléchargez, compilez, flashez et exécutez la démo de FreeRTOS OTA sur le Renesas N RX65
**Important**
Cette intégration de référence est hébergée sur le référentiel Amazon-FreeRTOS, 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
Ce chapitre explique comment télécharger, créer, flasher et exécuter les applications de démonstration FreeRTOS OTA sur le Renesas N. RX65
**Topics**
+ [Configurez votre environnement d'exploitation](#download-rx65n-ota-environment)
+ [Configurez vos AWS ressources](#download-rx65n-ota-setup)
+ [Importez, configurez le fichier d'en-tête et compilez aws\$1demos et boot\$1loader](#download-rx65n-ota-import-configure)
## Configurez votre environnement d'exploitation
Les procédures décrites dans cette section utilisent les environnements suivants :
+ **IDE** : e 2 studio 7.8.0, e 2 studio 2020-07
+ **Chaînes d'outils : compilateur** CCRX v3.0.1
+ **Appareils cibles** : RSKRX65 N-2MB
+ **Débogueurs** : émulateur E 2, E 2 Lite
+ **Logiciel** : Renesas Flash Programmer, Renesas Secure Flash Programmer.exe, Tera Term
**Pour configurer votre matériel**
1. Connectez l'émulateur E 2 Lite et le port série USB à votre carte RX65 N et à votre PC.
1. Connectez la source d'alimentation au RX65 N.
## Configurez vos AWS ressources
1. Pour exécuter les démos de FreeRTOS, vous devez disposer d' AWS un compte auprès d'un utilisateur IAM autorisé à accéder aux services. AWS IoT Si ce n'est pas déjà fait, suivez les étapes décrites dans[Configuration de votre AWS compte et de vos autorisations](freertos-prereqs.md#freertos-account-and-permissions).
1. Pour configurer les mises à jour OTA, suivez les étapes décrites dans[Conditions préalables aux mises à jour OTA](ota-prereqs.md). En particulier, suivez les étapes décrites dans[Conditions préalables aux mises à jour OTA via MQTT](ota-mqtt-freertos.md).
1. Ouvrez la [AWS IoT console](https://console.aws.amazon.com/iot/home).
1. Dans le volet de navigation de gauche, choisissez **Gérer**, puis choisissez **Objets** pour créer un objet.
Un objet est une représentation d'un périphérique ou d'une entité logique dans AWS IoT. Il peut s'agir d'un appareil physique ou d'un capteur (par exemple, une ampoule ou un interrupteur sur un mur). Il peut également s'agir d'une entité logique, telle qu'une instance d'une application ou d'une entité physique qui ne se connecte pas AWS IoT, mais qui est associée à des appareils qui le font (par exemple, une voiture équipée de capteurs de moteur ou d'un panneau de commande). AWS IoT fournit un registre d'objets qui vous aide à gérer vos objets.
1. Choisissez **Create**, puis **Create a single thing**.
1. Entrez un **nom** pour votre objet, puis choisissez **Next**.
1. Choisissez **Create certificate** (Créer un certificat).
1. Téléchargez les trois fichiers créés, puis choisissez **Activer**.
1. Choisissez **Attacher une stratégie**.
![\[écran de console affichant les fichiers à télécharger\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/download-these-files-rx65n.png)
1. Sélectionnez la politique que vous avez créée dans[Politique en matière d'appareils](ota-mqtt-freertos.md#ota-mqtt-freertos-device-policy).
Chaque appareil qui reçoit une mise à jour OTA à l'aide de MQTT doit être enregistré en tant qu'objet AWS IoT et doit être associé à une politique similaire à celle répertoriée. Vous trouverez plus d'informations sur les éléments dans les objets `"Action"` et `"Resource"` dans [Actions de stratégie AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-policy-actions.html) et [Ressources d'action AWS IoT Core](https://docs.aws.amazon.com/iot/latest/developerguide/iot-action-resources.html).
**Remarques**
+ Les `iot:Connect` autorisations permettent à votre appareil de se connecter AWS IoT via MQTT.
+ Les autorisations `iot:Publish` et `iot:Subscribe` sur les rubriques des tâches AWS IoT (`.../jobs/*`) permettent au périphérique connecté de recevoir des notifications de travail et des documents de travail, et de publier l'état d'achèvement d'une exécution de travail.
+ Les `iot:Publish` autorisations `iot:Subscribe` et sur le thème des flux AWS IoT OTA (`.../streams/*`) permettent à l'appareil connecté de récupérer les données de mise à jour OTA à partir de AWS IoT. Ces autorisations sont requises pour effectuer des mises à jour du firmware sur MQTT.
+ Les `iot:Receive` autorisations permettent AWS IoT Core de publier des messages sur ces sujets sur l'appareil connecté. Cette autorisation est vérifiée à chaque remise d'un message MQTT. Vous pouvez utiliser cette autorisation pour révoquer l'accès aux clients actuellement abonnés à une rubrique.
1. Pour créer un profil de signature de code et enregistrer un certificat de signature de code sur. AWS
1. Pour créer les clés et la certification, consultez la section 7.3 « Génération de paires de clés ECDSA avec OpenSSL » dans la SHA256 politique de conception de mise à jour du microprogramme du microcontrôleur [Renesas](https://www.renesas.com/us/en/document/apn/renesas-mcu-firmware-update-design-policy).
1. Ouvrez la [AWS IoT console](https://console.aws.amazon.com/iot/home). Dans le volet de navigation de gauche, sélectionnez **Gérer**, puis **Jobs**. Sélectionnez **Créer une tâche**, puis **Créer une tâche de mise à jour OTA**.
1. Sous **Sélectionner les appareils à mettre à jour**, choisissez **Sélectionner**, puis choisissez l'élément que vous avez créé précédemment. Sélectionnez **Suivant**.
1. Sur la page **Créer une tâche de mise à jour FreeRTOS OTA**, procédez comme suit :
1. Pour **sélectionner le protocole de transfert d'image du microprogramme**, choisissez **MQTT**.
1. Pour **Sélectionner et signer l'image de votre microprogramme**, choisissez **Signer une nouvelle image du microprogramme pour moi**.
1. Pour le **profil de signature de code**, choisissez **Create**.
1. Dans la fenêtre **Créer un profil de signature de code**, entrez un **nom de profil**. Pour la **plate-forme matérielle de l'appareil**, sélectionnez **Windows Simulator**. Pour le **certificat de signature de code**, choisissez **Importer**.
1. Naviguez pour sélectionner le certificat (`secp256r1.crt`), la clé privée du certificat (`secp256r1.key`) et la chaîne de certificats (`ca.crt`).
1. Entrez le **nom de chemin du certificat de signature de code sur l'appareil**. Ensuite, choisissez **Créer**.
1. Pour autoriser l'accès à la signature de code pour AWS IoT, suivez les étapes décrites dans[Accorder l'accès à la signature de code pour AWS IoT](code-sign-policy.md).
Si Tera Term n'est pas installé sur votre PC, vous pouvez le télécharger depuis [https://ttssh2.osdn.jp/index.html.en](https://ttssh2.osdn.jp/index.html.en) et le configurer comme indiqué ici. Assurez-vous de brancher le port USB série entre votre appareil et votre PC.
![\[Fenêtre de configuration du port série Tera Term\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/tera-team-rx65n.png)
## Importez, configurez le fichier d'en-tête et compilez aws\$1demos et boot\$1loader
Pour commencer, vous sélectionnez la dernière version du package FreeRTOS, qui sera téléchargée GitHub et importée automatiquement dans le projet. De cette façon, vous pouvez vous concentrer sur la configuration de FreeRTOS et sur l'écriture du code de l'application.
1. Lancez le studio e 2.
1. Choisissez **File (Fichier)**, puis **Import (Importer)**.
1. Sélectionnez le **projet GitHub FreeRTOS (avec bibliothèques IoT)** de Renesas.
![\[fenêtre d'importation d'e-squared studio\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/import-renesas-project-rx65n.png)
1. Choisissez **Rechercher une autre version... pour** afficher la boîte de dialogue de téléchargement.
![\[fenêtre de dialogue de téléchargement d'e-squared studio\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/check-more-version-rx65n.png)
1. Sélectionnez le dernier package.
![\[fenêtre de dialogue de téléchargement du module e-squared studio\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/choose-latest-version-rx65n.png)
1. Choisissez **Accepter** pour accepter le contrat de licence de l'utilisateur final.
![\[boîte de dialogue EULA e-squared studio\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/eula-rx65n.png)
1. Attendez que le téléchargement soit terminé.
![\[barre de progression du téléchargement\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/downloading-rx65n.png)
1. **Sélectionnez les projets **aws\$1demos** et **boot\$1loader**, puis choisissez Terminer pour les importer.**
![\[fenêtre d'importation de projets\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/import-projects-rx65n.png)
1. Pour les deux projets, ouvrez les propriétés du projet. Dans le volet de navigation, choisissez **Tool Chain Editor**.
1. Choisissez la **chaîne d'outils actuelle**.
1. Choisissez le **générateur actuel**.
![\[fenêtre des propriétés du studio e-squared\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/project-properties-rx65n.png)
1. Dans le panneau de navigation, sélectionnez **Settings** (Paramètres). **Choisissez l'onglet **Chaîne d'outils**, puis choisissez la version de la chaîne d'outils.**
![\[Paramètres d'intégration de la chaîne d'outils pour Renesas CCRX version v3.01.00, avec option de modification de la chaîne d'outils.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/project-properties-toolchain-rx65n.png)
Choisissez l'onglet **Paramètres de l'outil**, développez le **convertisseur**, puis choisissez **Sortie**. Dans la fenêtre principale, assurez-vous que le **fichier hexadécimal de sortie** est sélectionné, puis choisissez le **type de fichier de sortie**.
![\[C/C++ Build fenêtre des paramètres de configuration affichant les options du compilateur et de l'éditeur de liens telles que le fichier hexadécimal de sortie, le type de fichier de sortie, le répertoire de sortie et les options de division de fichiers.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/project-properties-settings-rx65n.png)
![\[Arborescence des paramètres de l'interface avec options pour l'analyse de la pile, l'éditeur de chaîne d'outils, le C/C++ General, le MCU, les références de projet, etc.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/project-properties-settings-2-rx65n.png)
1. Dans le projet bootloader, ouvrez `projects\renesas\rx65n-rsk\e2studio\boot_loader\src\key\code_signer_public_key.h` et saisissez la clé publique. [Pour plus d'informations sur la création d'une clé publique, consultez [Comment implémenter FreeRTOS OTA à l'aide d'Amazon Web Services RX65 sur](https://www.renesas.com/us/en/document/apn/rx-family-how-implement-freertos-ota-using-amazon-web-services-rx65n) N et la section 7.3 « Génération de paires de SHA256 clés ECDSA avec OpenSSL » dans la politique de conception de mise à jour du microprogramme des microcontrôleurs de Renesas.](https://www.renesas.com/us/en/document/apn/renesas-mcu-firmware-update-design-policy)
![\[Éditeur de code affichant un fichier d'en-tête C avec la définition de CODE_SIGNER_PUBLIC_KEY et une variable de clé publique de signature de code codée au format PEM.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/open-bootloader-project-rx65n.png)
Construisez ensuite le projet à créer`boot_loader.mot`.
1. Ouvrez le `aws_demos` projet.
1. Ouvrez la [AWS IoT console](https://console.aws.amazon.com/iot/home).
1. Dans le panneau de navigation de gauche, choisissez **Paramètres**. Notez votre point de terminaison personnalisé dans la zone de texte Terminal de **données de l'appareil**.
1. Choisissez **Gérer**, puis choisissez **Objets**. Notez le nom de l' AWS IoT objet de votre tableau.
1. Dans le `aws_demos` projet, ouvrez `demos/include/aws_clientcredential.h` et spécifiez les valeurs suivantes.
```
#define clientcredentialMQTT_BROKER_ENDPOINT[] = "Your AWS IoT endpoint";
#define clientcredentialIOT_THING_NAME "The AWS IoT thing name of your board"
```
![\[Extrait de code indiquant le nom de l' AWS IoT objet et les paramètres de configuration du point de terminaison du broker.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/client-credential-rx65n.png)
1. Ouvrez le fichier `tools/certificate_configuration/CertificateConfigurator.html`.
1. Importez le fichier PEM de certificat et le fichier PEM de clé privée que vous avez téléchargés précédemment.
1. Choisissez **Generate, enregistrez aws\$1clientcredential\$1keys.h** et remplacez ce fichier dans le répertoire. `demos/include/`
![\[Outil de configuration de certificats avec des champs pour fournir des fichiers PEM de certificat client et de clé privée à partir de la AWS IoT console, et un bouton pour générer et enregistrer le fichier aws_clientcredential_keys.h.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/certificate-config-tool-rx65n.png)
1. Ouvrez le `vendors/renesas/boards/rx65n-rsk/aws_demos/config_files/ota_demo_config.h` fichier et spécifiez ces valeurs.
```
#define otapalconfigCODE_SIGNING_CERTIFICATE [] = "your-certificate-key";
```
Où *your-certificate-key* se trouve la valeur du fichier`secp256r1.crt`. N'oubliez pas d'ajouter « \$1 » après chaque ligne de la certification. [Pour plus d'informations sur la création du `secp256r1.crt` fichier, consultez [Comment implémenter FreeRTOS OTA à l'aide d'Amazon Web Services RX65 sur](https://www.renesas.com/us/en/document/apn/rx-family-how-implement-freertos-ota-using-amazon-web-services-rx65n) N et la section 7.3 « Génération de paires de SHA256 clés ECDSA avec OpenSSL » dans la politique de conception de mise à jour du microprogramme des microcontrôleurs de Renesas.](https://www.renesas.com/us/en/document/apn/renesas-mcu-firmware-update-design-policy)
![\[Fichier de code source montrant le code C définissant une chaîne constante de certificat de signataire de code codée PEM avec des données de certificat expurgées.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/codesigner-cert-rx65n.png)
1. **Tâche A : Installation de la version initiale du microprogramme**
1. Ouvrez le `vendors/renesas/boards/board/aws_demos/config_files/aws_demo_config.h` fichier, commentez `#define CONFIG_CORE_MQTT_MUTUAL_AUTH_DEMO_ENABLED` et définissez l'un `CONFIG_OTA_MQTT_UPDATE_DEMO_ENABLED` ou l'autre`CONFIG_OTA_HTTP_UPDATE_DEMO_ENABLED`.
1. Ouvrez le `demos/include/ aws_application_version.h` fichier et définissez la version initiale du microprogramme sur`0.9.2`.
![\[Extrait de code présentant les définitions de version d'une application, y compris les macros pour les numéros de version majeure, mineure et de version de version.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/firmware-version-rx65n.png)
1. Modifiez les paramètres suivants dans l'**afficheur de sections**.
![\[Fenêtre de visualisation des sections affichant les adresses mémoire, les noms de sections tels que SU, SI, les registres et les composants d'interface tels que les tampons réseau, les exceptions et les boutons d'action.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/section-viewer-rx65n.png)
1. Choisissez **Build** pour créer le `aws_demos.mot` fichier.
1. Créez le fichier `userprog.mot` avec le Renesas Secure Flash Programmer. `userprog.mot`est une combinaison de `aws_demos.mot` et`boot_loader.mot`. Vous pouvez flasher ce fichier sur le RX65 N-RSK pour installer le microprogramme initial.
1. Téléchargez [ https://github.com/renesas/Amazon-FreeRTOS-Tools](https://github.com/renesas/Amazon-FreeRTOS-Tools) et ouvrez-le. `Renesas Secure Flash Programmer.exe`
1. Choisissez l'onglet **Firme initiale**, puis définissez les paramètres suivants :
+ **Chemin de clé privée** : emplacement de`secp256r1.privatekey`.
+ **Chemin du fichier Boot Loader** : emplacement de `boot_loader.mot` (`projects\renesas\rx65n-rsk\e2studio\boot_loader\HardwareDebug`).
+ **Chemin du fichier** : emplacement du `aws_demos.mot` (`projects\renesas\rx65n-rsk\e2studio\aws_demos\HardwareDebug`).
![\[Fenêtre Renesas Secure Flash Programmer avec microcontrôleur, vérification du microprogramme, numéro de séquence, chemin de clé AES et champs de chemin de fichier.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/secure-flash-rx65n.png)
1. Créez un répertoire nommé `init_firmware` `userprog.mot` Generate et enregistrez-le `init_firmware` dans le répertoire. Vérifiez que la génération a réussi.
1. Flashez le microprogramme initial sur le RX65 N-RSK.
1. Téléchargez la dernière version du programmateur Flash Renesas (interface graphique de programmation) à l'adresse [ https://www.renesas.com/tw/en/products/software-tools/tools/programmer/renesas- flash-programmer-programming-gui](https://www.renesas.com/tw/en/products/software-tools/tools/programmer/renesas-flash-programmer-programming-gui.html) .html.
1. Ouvrez le `vendors\renesas\rx_mcu_boards\boards\rx65n-rsk\aws_demos\flash_project\erase_from_bank\ erase.rpj` fichier pour effacer les données de la banque.
1. Choisissez **Démarrer** pour effacer la banque.
![\[Fenêtre de Renesas Flash Programmer affichant les détails du projet du microcontrôleur RX Group, le chemin du fichier et les options de fonctionnement du flash telles que Erase, Program et Verify à l'aide des boutons Démarrer et OK.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/flash-programmer-erasing-rx65n.png)
1. Pour flasher`userprog.mot`, choisissez **Parcourir...** et naviguez jusqu'au `init_firmware` répertoire, sélectionnez le `userprog.mot` fichier et choisissez **Démarrer**.
![\[Fenêtre Renesas Flash Programmer affichant les paramètres d'opération d'effacement, y compris le microcontrôleur RX Group, l'option permettant de parcourir le fichier du programme, les boutons Effacer et Démarrer, et les détails de l'état des blocs sélectionnés à effacer.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/flash-programmer-complete-rx65n.png)
1. La version 0.9.2 (version initiale) du firmware a été installée sur votre RX65 N-RSK. Le conseil d'administration du RX65 N-RSK est actuellement à l'écoute des mises à jour de l'OTA. Si vous avez ouvert Tera Term sur votre PC, vous verrez quelque chose comme ceci lorsque le microprogramme initial s'exécute.
```
-------------------------------------------------
RX65N secure boot program
-------------------------------------------------
Checking flash ROM status.
bank 0 status = 0xff [LIFECYCLE_STATE_BLANK]
bank 1 status = 0xfc [LIFECYCLE_STATE_INSTALLING]
bank info = 1. (start bank = 0)
start installing user program.
copy secure boot (part1) from bank0 to bank1...OK
copy secure boot (part2) from bank0 to bank1...OK
update LIFECYCLE_STATE from [LIFECYCLE_STATE_INSTALLING] to [LIFECYCLE_STATE_VALID]
bank1(temporary area) block0 erase (to update LIFECYCLE_STATE)...OK
bank1(temporary area) block0 write (to update LIFECYCLE_STATE)...OK
swap bank...
-------------------------------------------------
RX65N secure boot program
-------------------------------------------------
Checking flash ROM status.
bank 0 status = 0xf8 [LIFECYCLE_STATE_VALID]
bank 1 status = 0xff [LIFECYCLE_STATE_BLANK]
bank info = 0. (start bank = 1)
integrity check scheme = sig-sha256-ecdsa
bank0(execute area) on code flash integrity check...OK
jump to user program
0 1 [ETHER_RECEI] Deferred Interrupt Handler Task started
1 1 [ETHER_RECEI] Network buffers: 3 lowest 3
2 1 [ETHER_RECEI] Heap: current 234192 lowest 234192
3 1 [ETHER_RECEI] Queue space: lowest 8
4 1 [IP-task] InitializeNetwork returns OK
5 1 [IP-task] xNetworkInterfaceInitialise returns 0
6 101 [ETHER_RECEI] Heap: current 234592 lowest 233392
7 2102 [ETHER_RECEI] prvEMACHandlerTask: PHY LS now 1
8 3001 [IP-task] xNetworkInterfaceInitialise returns 1
9 3092 [ETHER_RECEI] Network buffers: 2 lowest 2
10 3092 [ETHER_RECEI] Queue space: lowest 7
11 3092 [ETHER_RECEI] Heap: current 233320 lowest 233320
12 3193 [ETHER_RECEI] Heap: current 233816 lowest 233120
13 3593 [IP-task] vDHCPProcess: offer c0a80a09ip
14 3597 [ETHER_RECEI] Heap: current 233200 lowest 233000
15 3597 [IP-task] vDHCPProcess: offer c0a80a09ip
16 3597 [IP-task] IP Address: 192.168.10.9
17 3597 [IP-task] Subnet Mask: 255.255.255.0
18 3597 [IP-task] Gateway Address: 192.168.10.1
19 3597 [IP-task] DNS Server Address: 192.168.10.1
20 3600 [Tmr Svc] The network is up and running
21 3622 [Tmr Svc] Write certificate...
22 3697 [ETHER_RECEI] Heap: current 232320 lowest 230904
23 4497 [ETHER_RECEI] Heap: current 226344 lowest 225944
24 5317 [iot_thread] [INFO ][DEMO][5317] ---------STARTING DEMO---------
25 5317 [iot_thread] [INFO ][INIT][5317] SDK successfully initialized.
26 5317 [iot_thread] [INFO ][DEMO][5317] Successfully initialized the demo. Network type for the demo: 4
27 5317 [iot_thread] [INFO ][MQTT][5317] MQTT library successfully initialized.
28 5317 [iot_thread] [INFO ][DEMO][5317] OTA demo version 0.9.2
29 5317 [iot_thread] [INFO ][DEMO][5317] Connecting to broker...
30 5317 [iot_thread] [INFO ][DEMO][5317] MQTT demo client identifier is rx65n-gr-rose (length 13).
31 5325 [ETHER_RECEI] Heap: current 206944 lowest 206504
32 5325 [ETHER_RECEI] Heap: current 206440 lowest 206440
33 5325 [ETHER_RECEI] Heap: current 206240 lowest 206240
38 5334 [ETHER_RECEI] Heap: current 190288 lowest 190288
39 5334 [ETHER_RECEI] Heap: current 190088 lowest 190088
40 5361 [ETHER_RECEI] Heap: current 158512 lowest 158168
41 5363 [ETHER_RECEI] Heap: current 158032 lowest 158032
42 5364 [ETHER_RECEI] Network buffers: 1 lowest 1
43 5364 [ETHER_RECEI] Heap: current 156856 lowest 156856
44 5364 [ETHER_RECEI] Heap: current 156656 lowest 156656
46 5374 [ETHER_RECEI] Heap: current 153016 lowest 152040
47 5492 [ETHER_RECEI] Heap: current 141464 lowest 139016
48 5751 [ETHER_RECEI] Heap: current 140160 lowest 138680
49 5917 [ETHER_RECEI] Heap: current 138280 lowest 138168
59 7361 [iot_thread] [INFO ][MQTT][7361] Establishing new MQTT connection.
62 7428 [iot_thread] [INFO ][MQTT][7428] (MQTT connection 81cfc8, CONNECT operation 81d0e8) Wait complete with result SUCCESS.
63 7428 [iot_thread] [INFO ][MQTT][7428] New MQTT connection 4e8c established.
64 7430 [iot_thread] [OTA_AgentInit_internal] OTA Task is Ready.
65 7430 [OTA Agent T] [prvOTAAgentTask] Called handler. Current State [Ready] Event [Start] New state [RequestingJob]
66 7431 [OTA Agent T] [INFO ][MQTT][7431] (MQTT connection 81cfc8) SUBSCRIBE operation scheduled.
67 7431 [OTA Agent T] [INFO ][MQTT][7431] (MQTT connection 81cfc8, SUBSCRIBE operation 818c48) Waiting for operation completion.
68 7436 [ETHER_RECEI] Heap: current 128248 lowest 127992
69 7480 [OTA Agent T] [INFO ][MQTT][7480] (MQTT connection 81cfc8, SUBSCRIBE operation 818c48) Wait complete with result SUCCESS.
70 7480 [OTA Agent T] [prvSubscribeToJobNotificationTopics] OK: $aws/things/rx65n-gr-rose/jobs/$next/get/accepted
71 7481 [OTA Agent T] [INFO ][MQTT][7481] (MQTT connection 81cfc8) SUBSCRIBE operation scheduled.
72 7481 [OTA Agent T] [INFO ][MQTT][7481] (MQTT connection 81cfc8, SUBSCRIBE operation 818c48) Waiting for operation completion.
73 7530 [OTA Agent T] [INFO ][MQTT][7530] (MQTT connection 81cfc8, SUBSCRIBE operation 818c48) Wait complete with result SUCCESS.
74 7530 [OTA Agent T] [prvSubscribeToJobNotificationTopics] OK: $aws/things/rx65n-gr-rose/jobs/notify-next
75 7530 [OTA Agent T] [prvRequestJob_Mqtt] Request #0
76 7532 [OTA Agent T] [INFO ][MQTT][7532] (MQTT connection 81cfc8) MQTT PUBLISH operation queued.
77 7532 [OTA Agent T] [INFO ][MQTT][7532] (MQTT connection 81cfc8, PUBLISH operation 818b80) Waiting for operation completion.
78 7552 [OTA Agent T] [INFO ][MQTT][7552] (MQTT connection 81cfc8, PUBLISH operation 818b80) Wait complete with result SUCCESS.
79 7552 [OTA Agent T] [prvOTAAgentTask] Called handler. Current State [RequestingJob] Event [RequestJobDocument] New state [WaitingForJob]
80 7552 [OTA Agent T] [prvParseJSONbyModel] Extracted parameter [ clientToken: 0:rx65n-gr-rose ]
81 7552 [OTA Agent T] [prvParseJSONbyModel] parameter not present: execution
82 7552 [OTA Agent T] [prvParseJSONbyModel] parameter not present: jobId
83 7552 [OTA Agent T] [prvParseJSONbyModel] parameter not present: jobDocument
84 7552 [OTA Agent T] [prvParseJSONbyModel] parameter not present: afr_ota
85 7552 [OTA Agent T] [prvParseJSONbyModel] parameter not present: protocols
86 7552 [OTA Agent T] [prvParseJSONbyModel] parameter not present: files
87 7552 [OTA Agent T] [prvParseJSONbyModel] parameter not present: filepath
99 7651 [ETHER_RECEI] Heap: current 129720 lowest 127304
100 8430 [iot_thread] [INFO ][DEMO][8430] State: Ready Received: 1 Queued: 0 Processed: 0 Dropped: 0
101 9430 [iot_thread] [INFO ][DEMO][9430] State: WaitingForJob Received: 1 Queued: 0 Processed: 0 Dropped: 0
102 10430 [iot_thread] [INFO ][DEMO][10430] State: WaitingForJob Received: 1 Queued: 0 Processed: 0 Dropped: 0
103 11430 [iot_thread] [INFO ][DEMO][11430] State: WaitingForJob Received: 1 Queued: 0 Processed: 0 Dropped: 0
104 12430 [iot_thread] [INFO ][DEMO][12430] State: WaitingForJob Received: 1 Queued: 0 Processed: 0 Dropped: 0
105 13430 [iot_thread] [INFO ][DEMO][13430] State: WaitingForJob Received: 1 Queued: 0 Processed: 0 Dropped: 0
106 14430 [iot_thread] [INFO ][DEMO][14430] State: WaitingForJob Received: 1 Queued: 0 Processed: 0 Dropped: 0
107 15430 [iot_thread] [INFO ][DEMO][15430] State: WaitingForJob Received: 1 Queued: 0 Processed: 0 Dropped: 0
```
1. **Tâche B : mettre à jour la version de votre microprogramme**
1. Ouvrez le `demos/include/aws_application_version.h` fichier et augmentez la valeur du `APP_VERSION_BUILD` jeton à`0.9.3`.
1. Regénérez le projet.
1. Créez le `userprog.rsu` fichier avec le Renesas Secure Flash Programmer pour mettre à jour la version de votre firmware.
1. Ouvrez le fichier `Amazon-FreeRTOS-Tools\Renesas Secure Flash Programmer.exe`.
1. Choisissez l'onglet **Update Firm** et définissez les paramètres suivants :
+ **Chemin du fichier** : emplacement du `aws_demos.mot` fichier (`projects\renesas\rx65n-rsk\e2studio\aws_demos\HardwareDebug`).
1. Créez un répertoire nommé `update _firmware`. Générez-le `userprog.rsu` et enregistrez-le `update_firmware` dans le répertoire. Vérifiez que la génération a réussi.
![\[Fenêtre Renesas Secure Flash Programmer avec sélection du microcontrôleur, type de vérification du microprogramme, numéro de séquence, champ de clé AES MAC et entrée du chemin du fichier pour générer un microprogramme sécurisé.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/update-firmware-rx65n.png)
1. Téléchargez la mise à jour du microprogramme dans un compartiment Amazon S3`userproj.rsu`, comme décrit dans[Créez un compartiment Amazon S3 pour stocker votre mise à jour](dg-ota-bucket.md).
![\[Interface de gestion des compartiments Amazon S3 avec options de dossiers, de téléchargements, de versions et d'autorisations\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/upload-firmware-rx65n.png)
1. Créez une tâche pour mettre à jour le microprogramme sur le RX65 N-RSK.
AWS IoT Jobs est un service qui avertit un ou plusieurs appareils connectés d'un [Job](https://docs.aws.amazon.com/iot/latest/developerguide/iot-jobs.html) en attente. Une tâche peut être utilisée pour gérer un parc d'appareils, mettre à jour le microprogramme et les certificats de sécurité des appareils, ou effectuer des tâches administratives telles que le redémarrage des appareils et l'exécution de diagnostics.
1. Connectez-vous à la [console AWS IoT](https://console.aws.amazon.com/iotv2/). Dans le volet de navigation, choisissez **Manage**, puis **Jobs**.
1. Choisissez **Create a job**, puis **Create OTA Update job**. Sélectionnez un élément, puis cliquez sur **Suivant**.
1. Créez une tâche de mise à jour FreeRTOS OTA comme suit :
+ Choisissez **MQTT**.
+ Sélectionnez le profil de signature de code que vous avez créé dans la section précédente.
+ Sélectionnez l'image du microprogramme que vous avez chargée dans un compartiment Amazon S3.
+ Pour le **chemin de l'image du microprogramme sur l'appareil**, entrez**test**.
+ Choisissez le rôle IAM que vous avez créé dans la section précédente.
1. Choisissez **Suivant**.
![\[Signalisation de l'image du microprogramme et paramètres de mise à jour OTA avec options permettant de signer le nouveau microprogramme, de sélectionner le microprogramme précédemment signé, d'utiliser un microprogramme signé personnalisé, de spécifier le profil de signature de code, le fichier image du microprogramme, le chemin sur l'appareil et le rôle IAM pour la tâche de mise à jour OTA.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/create-job-next-rx65n.png)
1. Entrez un identifiant, puis choisissez **Créer**.
1. Rouvrez Tera Term pour vérifier que le microprogramme a été correctement mis à jour vers la version de démonstration OTA 0.9.3.
![\[Sortie de ligne de commande indiquant l'initialisation et la connexion d'un thread à un broker.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/update-successful-rx65n.png)
1. Sur la AWS IoT console, vérifiez que le statut de la tâche est **Réussi**.
![\[Vue d'ensemble de la tâche de test AFR OTA-Demo indiquant qu'une ressource a réussi.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/completed-succeeded-rx65n.png)
# Tutoriel : Effectuez des mises à jour OTA sur Espressif à l'aide de ESP32 FreeRTOS Bluetooth Low Energy
**Important**
Cette intégration de référence est hébergée sur le référentiel Amazon-FreeRTOS, 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
Ce didacticiel explique comment mettre à jour un ESP32 microcontrôleur Espressif connecté à un proxy Bluetooth Low Energy MQTT sur un appareil Android. Il met à jour l'appareil à l'aide de tâches de mise à jour AWS IoT Over-the-air (OTA). L'appareil se connecte à AWS IoT l'aide des informations d'identification Amazon Cognito saisies dans l'application de démonstration Android. Un opérateur autorisé lance la mise à jour OTA depuis le cloud. Lorsque l'appareil se connecte via l'application de démonstration Android, la mise à jour OTA est lancée et le micrologiciel est mis à jour sur l'appareil.
Les versions majeures de FreeRTOS 2019.06.00 et ultérieures incluent le support du proxy Bluetooth Low Energy MQTT qui peut être utilisé pour le provisionnement Wi-Fi et les connexions sécurisées aux services. AWS IoT En utilisant la fonction Bluetooth Low Energy, vous pouvez créer des appareils à faible consommation qui peuvent être couplés à un appareil mobile pour la connectivité sans avoir besoin du Wi-Fi. Les appareils peuvent communiquer à l'aide de MQTT en se connectant via Bluetooth Low Energy Android ou iOS SDKs qui utilisent des profils de profil d'accès générique (GAP) et d'attributs génériques (GATT).
Voici les étapes que nous allons suivre pour autoriser les mises à jour OTA via Bluetooth Low Energy :
1. **Configuration du stockage :** créez un compartiment et des politiques Amazon S3 et configurez un utilisateur capable d'effectuer des mises à jour.
1. **Création d'un certificat de signature de code : créez un certificat** de signature et autorisez l'utilisateur à signer les mises à jour du microprogramme.
1. **Configurez l'authentification Amazon Cognito :** créez un fournisseur d'informations d'identification, un groupe d'utilisateurs et un accès des applications au groupe d'utilisateurs.
1. **Configurer FreeRTOS** : configurez Bluetooth Low Energy, les informations d'identification du client et le certificat public de signature de code.
1. **Configuration d'une application Android : configurez** le fournisseur d'informations d'identification, le groupe d'utilisateurs et déployez l'application sur un appareil Android.
1. **Exécutez le script de mise à jour OTA :** pour lancer une mise à jour OTA, utilisez le script de mise à jour OTA.
Pour plus d'informations sur le fonctionnement des mises à jour, consultez[Mises à jour de FreeRTOS Over-the-Air](freertos-ota-dev.md). Pour plus d'informations sur la configuration de la fonctionnalité du proxy Bluetooth Low Energy MQTT, consultez l'article [Utilisation du Bluetooth Low Energy avec FreeRTOS sur ESP32](https://aws.amazon.com/blogs/iot/using-bluetooth-low-energy-with-amazon-freertos-on-espressif-esp32/) Espressif de Richard Kang.
## Conditions préalables
Pour effectuer les étapes de ce didacticiel, vous avez besoin des ressources suivantes :
+ Un conseil ESP32 de développement.
+ Un câble microUSB vers USB A.
+ Un AWS compte (le niveau gratuit est suffisant).
+ Un téléphone Android doté d'Android version 6.0 ou ultérieure et de Bluetooth version 4.2 ou ultérieure.
Sur votre ordinateur de développement, vous devez :
+ Espace disque suffisant (\$1500 Mo) pour la chaîne d'outils Xtensa, le code source FreeRTOS et des exemples.
+ Android Studio est installé.
+ L'[AWS CLI](https://aws.amazon.com/cli/)installé.
+ Python3 installé.
+ Le [kit de développement AWS logiciel (SDK) boto3 pour Python](https://github.com/boto/boto3).
Les étapes de ce didacticiel supposent que la chaîne d'outils Xtensa, l'ESP-IDF et le code FreeRTOS sont installés dans le répertoire de votre répertoire personnel. `/esp` Vous devez ajouter des `~/esp/xtensa-esp32-elf/bin` éléments à votre `$PATH` variable.
## Étape 1 : Configuration du stockage
1. [Créez un compartiment Amazon S3 pour stocker votre mise à jour](dg-ota-bucket.md)avec la gestion des versions activée pour conserver les images du microprogramme.
1. [Créer un rôle de service de mise à jour OTA](create-service-role.md)et ajoutez les politiques gérées suivantes au rôle :
+ AWSIotJournalisation
+ AWSIotRuleActions
+ AWSIotThingsRegistration
+ AWSFreeRTOSOTAUpdate
1. [Créez un utilisateur capable d'](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html)effectuer des mises à jour OTA. Cet utilisateur peut signer et déployer des mises à jour du microprogramme sur les appareils IoT du compte, et a accès aux mises à jour OTA sur tous les appareils. L'accès doit être limité aux entités de confiance.
1. Suivez les étapes pour [Créer une stratégie utilisateur OTA](create-ota-user-policy.md) le joindre à votre utilisateur.
## Étape 2 : Création du certificat de signature de code
1. Créez un compartiment Amazon S3 avec la gestion des versions activée pour contenir les images du microprogramme.
1. Créez un certificat de signature de code qui peut être utilisé pour signer le microprogramme. Notez le certificat Amazon Resource Name (ARN) lorsque le certificat est importé.
```
aws acm import-certificate --profile=ota-update-user --certificate file://ecdsasigner.crt --private-key file://ecdsasigner.key
```
Exemple de sortie :
```
{
"CertificateArn": "arn:aws:acm:us-east-1::certificate/"
}
```
Vous utiliserez l'ARN ultérieurement pour créer un profil de signature. Si vous le souhaitez, vous pouvez créer le profil dès maintenant à l'aide de la commande suivante :
```
aws signer put-signing-profile --profile=ota-update-user --profile-name esp32Profile --signing-material certificateArn=arn:aws:acm:us-east-1:account:certificate/certid --platform AmazonFreeRTOS-Default --signing-parameters certname=/cert.pem
```
Exemple de sortie :
```
{
"arn": "arn:aws:signer:::/signing-profiles/esp32Profile"
}
```
## Étape 3 : configuration de l'authentification Amazon Cognito
**Création d'une AWS IoT politique**
1. Connectez-vous à la [console AWS IoT](https://console.aws.amazon.com/iot/).
1. Dans le coin supérieur droit de la console, sélectionnez **Mon** compte. Dans **Paramètres du compte**, notez votre identifiant de compte à 12 chiffres.
1. Dans le panneau de navigation de gauche, choisissez **Paramètres**. Dans Point de **terminaison des données de l'appareil**, notez la valeur du point de terminaison. Le point de terminaison doit être quelque chose comme`xxxxxxxxxxxxxx.iot.us-west-2.amazonaws.com`. Dans cet exemple, la AWS région est « us-west-2 ».
1. Dans le volet de navigation de gauche, choisissez **Secure**, **Policies**, puis **Create**. Si aucune politique n'est associée à votre compte, le message « Vous n'avez pas encore de politique » s'affichera et vous pourrez choisir **Créer une politique**.
1. Entrez un nom pour votre politique, par exemple « esp32\$1mqtt\$1proxy\$1iot\$1policy ».
1. Dans la section **Ajouter des instructions**, choisissez **Mode avancé**. Copiez et collez le code JSON suivant dans la fenêtre de l'éditeur de stratégie. `aws-account-id`Remplacez-le par votre numéro de compte et `aws-region` par votre région (par exemple, « us-west-2 »).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:*"
},
{
"Effect": "Allow",
"Action": "iot:Publish",
"Resource": "arn:aws:iot:us-east-1:123456789012:*"
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": "arn:aws:iot:us-east-1:123456789012:*"
},
{
"Effect": "Allow",
"Action": "iot:Receive",
"Resource": "arn:aws:iot:us-east-1:123456789012:*"
}
]
}
```
------
1. Choisissez **Créer**.
**Créez n'importe quel AWS IoT objet**
1. Connectez-vous à la [console AWS IoT](https://console.aws.amazon.com/iot/).
1. Dans le volet de navigation de gauche, choisissez **Gérer**, puis **Objets**.
1. Dans le coin supérieur droit, choisissez **Create**. Si aucun élément n'est enregistré dans votre compte, le message « Vous n'avez rien encore » s'affiche et vous pouvez choisir **Enregistrer un objet**.
1. Sur la page **Création d' AWS IoT objets**, choisissez **Créer un objet unique**.
1. Sur la page **Ajouter votre appareil au registre** des objets, saisissez un nom pour votre objet (par exemple, « esp32-ble »). Seuls les caractères alphanumériques, les tirets (-) et les traits de soulignement (\$1) sont autorisés. Choisissez **Suivant**.
1. Sur la page **Ajouter un certificat pour votre objet**, sous **Ignorer le certificat et créer un objet**, choisissez **Créer un objet sans certificat**. Comme nous utilisons l'application mobile proxy BLE qui utilise un identifiant Amazon Cognito pour l'authentification et l'autorisation, aucun certificat d'appareil n'est requis.
**Création d'un client d'application Amazon Cognito**
1. Connectez-vous à la [console Amazon Cognito](https://console.aws.amazon.com/cognito/users/).
1. Dans le bandeau de navigation en haut à droite, choisissez **Créer un groupe d'utilisateurs.**
1. Entrez le nom du pool (par exemple, « esp32\$1mqtt\$1proxy\$1user\$1pool »).
1. Sélectionnez **Review defaults**.
1. Dans **App Clients**, choisissez **Ajouter un client d'application**, puis choisissez **Ajouter un client d'application**.
1. Entrez le nom du client de l'application (par exemple « mqtt\$1app\$1client »).
1. Assurez-vous que l'option **Générer le secret du client** est sélectionnée.
1. Choisissez **Créer un client d’application**.
1. Sélectionnez **Revenir aux détails du groupe**.
1. Sur la page de **révision** du groupe d'utilisateurs, choisissez **Create pool**. Vous devriez voir un message indiquant « Votre groupe d'utilisateurs a été créé avec succès ». Notez l'ID du pool.
1. Dans le volet de navigation, sélectionnez **App clients**.
1. Choisissez **Afficher les détails**. Notez l'ID du client de l'application et le secret du client de l'application.
**Créer un groupe d’identités Amazon Cognito**
1. Connectez-vous à la [console Amazon Cognito](https://console.aws.amazon.com/cognito/federated).
1. Sélectionnez **Create new identity pool**.
1. Entrez un nom pour le pool d'identités (par exemple, « mqtt\$1proxy\$1identity\$1pool »).
1. Développez les **fournisseurs d'authentification**.
1. Choisissez l'onglet **Cognito**.
1. Entrez l'ID du groupe d'utilisateurs et l'ID du client de l'application que vous avez indiqués lors des étapes précédentes.
1. Sélectionnez **Créer une réserve**.
1. **Sur la page suivante, pour créer de nouveaux rôles pour les identités authentifiées et non authentifiées, choisissez Autoriser.**
1. Notez l'ID du pool d'identités, qui est au format`us-east-1:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`.
**Associer une politique IAM à l'identité authentifiée**
1. Ouvrez la [console Amazon Cognito](https://console.aws.amazon.com/cognito/federated).
1. Sélectionnez le pool d'identités que vous venez de créer (par exemple, « mqtt\$1proxy\$1identity\$1pool »).
1. Choisissez **Edit identity groupe (Modifier le groupe d'identités)**.
1. Notez le rôle IAM attribué au rôle authentifié (par exemple, « Cognito\$1MQTT\$1Proxy\$1Identity\$1PoolAuth\$1Role »).
1. Ouvrez la [console IAM](https://console.aws.amazon.com/iam/home).
1. Dans le panneau de navigation, choisissez **Rôles**.
1. Recherchez le rôle attribué (par exemple, « Cognito\$1MQTT\$1Proxy\$1Identity\$1PoolAuth\$1Role »), puis sélectionnez-le.
1. Choisissez **Ajouter une politique intégrée**, puis choisissez **JSON**.
1. Saisissez la politique suivante :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:AttachPolicy",
"iot:AttachPrincipalPolicy",
"iot:Connect",
"iot:Publish",
"iot:Subscribe"
],
"Resource": "*"
}]
}
```
------
1. Choisissez **Review Policy (Examiner une stratégie)**.
1. Entrez un nom de politique (par exemple, « mqttProxyCognito Politique »).
1. Choisissez **Create Policy** (Créer une politique).
## Étape 4 : Configuration d'Amazon FreeRTOS
1. [Téléchargez la dernière version du code Amazon FreeRTOS depuis le dépôt FreeRTOS. GitHub ](https://github.com/aws/amazon-freertos)
1. Pour activer la démo de mise à jour OTA, suivez les étapes décrites dans[Commencer à utiliser l'Espressif ESP32 - DevKit C et le ESP-WROVER-KIT](getting_started_espressif.md).
1. Apportez ces modifications supplémentaires dans les fichiers suivants :
1. Ouvrez `vendors/espressif/boards/esp32/aws_demos/config_files/aws_demo_config.h` et définissez`CONFIG_OTA_UPDATE_DEMO_ENABLED`.
1. Ouvrez `vendors/espressif/boards/esp32/aws_demos/common/config_files/aws_demo_config.h` et remplacez `democonfigNETWORK_TYPES` par`AWSIOT_NETWORK_TYPE_BLE`.
1. Ouvrez `demos/include/aws_clientcredential.h` et entrez l'URL de votre point de terminaison pour`clientcredentialMQTT_BROKER_ENDPOINT`.
Entrez le nom de votre objet pour `clientcredentialIOT_THING_NAME` (par exemple, « esp32-ble »). Il n'est pas nécessaire d'ajouter des certificats lorsque vous utilisez les informations d'identification Amazon Cognito.
1. Ouvrir`vendors/espressif/boards/esp32/aws_demos/config_files/aws_iot_network_config.h`, modifier `configSUPPORTED_NETWORKS` et `configENABLED_NETWORKS` inclure uniquement`AWSIOT_NETWORK_TYPE_BLE`.
1. Ouvrez le `vendors/vendor/boards/board/aws_demos/config_files/ota_demo_config.h` fichier et entrez votre certificat.
```
#define otapalconfigCODE_SIGNING_CERTIFICATE [] = "your-certificate-key";
```
L'application doit démarrer et imprimer la version de démonstration :
```
11 13498 [iot_thread] [INFO ][DEMO][134980] Successfully initialized the demo. Network type for the demo: 2
12 13498 [iot_thread] [INFO ][MQTT][134980] MQTT library successfully initialized.
13 13498 [iot_thread] OTA demo version 0.9.20
14 13498 [iot_thread] Creating MQTT Client...
```
## Étape 5 : Configuration d'une application Android
1. Téléchargez le SDK Bluetooth Low Energy pour Android et un exemple d'application depuis le dépôt [amazon-freertos-ble-android GitHub -sdk](https://github.com/aws/amazon-freertos-ble-android-sdk).
1. Ouvrez le fichier `app/src/main/res/raw/awsconfiguration.json` et renseignez l'ID du pool AppClientId, la région et AppClientSecret suivez les instructions de l'exemple JSON suivant.
```
{
"UserAgent": "MobileHub/1.0",
"Version": "1.0",
"CredentialsProvider": {
"CognitoIdentity": {
"Default": {
"PoolId": "Cognito->Manage Identity Pools->Federated Identities->mqtt_proxy_identity_pool->Edit Identity Pool->Identity Pool ID",
"Region": "Your region (for example us-east-1)"
}
}
},
"IdentityManager": {
"Default": {}
},
"CognitoUserPool": {
"Default": {
"PoolId": "Cognito-> Manage User Pools -> esp32_mqtt_proxy_user_pool -> General Settings -> PoolId",
"AppClientId": "Cognito-> Manage User Pools -> esp32_mqtt_proxy_user_pool -> General Settings -> App clients ->Show Details",
"AppClientSecret": "Cognito-> Manage User Pools -> esp32_mqtt_proxy_user_pool -> General Settings -> App clients ->Show Details",
"Region": "Your region (for example us-east-1)"
}
}
}
```
1. Ouvrez `app/src/main/java/software/amazon/freertos/DemoConstants.java` et entrez le nom de la politique que vous avez créé précédemment (par exemple,*esp32\$1mqtt\$1proxy\$1iot\$1policy*) ainsi que la région (par exemple,*us-east-1*).
1. Créez et installez l'application de démonstration.
1. Dans Android Studio, choisissez **Build**, puis **Make Module app**.
1. Choisissez **Exécuter**, puis **Exécuter l'application**. Vous pouvez accéder au volet de la fenêtre Logcat d'Android Studio pour surveiller les messages du journal.
1. Sur l'appareil Android, créez un compte à partir de l'écran de connexion.
1. Créez un utilisateur. Si un utilisateur existe déjà, entrez ses informations d'identification.
1. Autorisez la démo Amazon FreeRTOS à accéder à la position de l'appareil.
1. Recherchez les appareils Bluetooth Low Energy.
1. Déplacez le curseur de l'appareil trouvé **sur** Activé.
1. Appuyez sur **y** sur la console de débogage du port série pour le ESP32.
1. Choisissez **Pair & Connect**.
1. Le **plus...** le lien devient actif une fois la connexion établie. L'état de connexion doit passer à « BLE\$1CONNECTED » dans le logcat de l'appareil Android lorsque la connexion est terminée :
```
2019-06-06 20:11:32.160 23484-23497/software.amazon.freertos.demo I/FRD: BLE connection state changed: 0; new state: BLE_CONNECTED
```
1. Avant que les messages puissent être transmis, l'appareil Amazon FreeRTOS et l'appareil Android négocient le MTU. Vous devriez voir le résultat suivant dans logcat :
```
2019-06-06 20:11:46.720 23484-23497/software.amazon.freertos.demo I/FRD: onMTUChanged : 512 status: Success
```
1. L'appareil se connecte à l'application et commence à envoyer des messages MQTT à l'aide du proxy MQTT. Pour confirmer que le périphérique peut communiquer, assurez-vous que la valeur des données caractéristiques MQTT\$1CONTROL passe à 01 :
```
2019-06-06 20:12:28.752 23484-23496/software.amazon.freertos.demo D/FRD: <-<-<- Writing to characteristic: MQTT_CONTROL with data: 01
2019-06-06 20:12:28.839 23484-23496/software.amazon.freertos.demo D/FRD: onCharacteristicWrite for: MQTT_CONTROL; status: Success; value: 01
```
1. Lorsque les appareils sont couplés, un message s'affiche sur la ESP32 console. Pour activer BLE, appuyez sur **y.** La démo ne fonctionnera pas tant que vous n'aurez pas effectué cette étape.
```
E (135538) BT_GATT: GATT_INSUF_AUTHENTICATION: MITM Required
W (135638) BT_L2CAP: l2cble_start_conn_update, the last connection update command still pending.
E (135908) BT_SMP: Value for numeric comparison = 391840
15 13588 [InputTask] Numeric comparison:391840
16 13589 [InputTask] Press 'y' to confirm
17 14078 [InputTask] Key accepted
W (146348) BT_SMP: FOR LE SC LTK IS USED INSTEAD OF STK
18 16298 [iot_thread] Connecting to broker...
19 16298 [iot_thread] [INFO ][MQTT][162980] Establishing new MQTT connection.
20 16298 [iot_thread] [INFO ][MQTT][162980] (MQTT connection 0x3ffd5754, CONNECT operation 0x3ffd586c) Waiting for operation completion.
21 16446 [iot_thread] [INFO ][MQTT][164450] (MQTT connection 0x3ffd5754, CONNECT operation 0x3ffd586c) Wait complete with result SUCCESS.
22 16446 [iot_thread] [INFO ][MQTT][164460] New MQTT connection 0x3ffc0ccc established.
23 16446 [iot_thread] Connected to broker.
```
## Étape 6 : Exécuter le script de mise à jour OTA
1. Pour installer les prérequis, exécutez les commandes suivantes :
```
pip3 install boto3
```
```
pip3 install pathlib
```
1. Incrémentez la version de l'application FreeRTOS en. `demos/include/aws_application_version.h`
1. Créez un nouveau fichier .bin.
1. Téléchargez le script python [start\$1ota.py](https://github.com/aws-samples/amazon-freertos-ota-scripts/blob/master/scripts/start_ota.py). Pour consulter le contenu de l'aide du script, exécutez la commande suivante dans une fenêtre de terminal :
```
python3 start_ota.py -h
```
Vous devriez voir quelque chose comme ceci :
```
usage: start_ota.py [-h] --profile PROFILE [--region REGION]
[--account ACCOUNT] [--devicetype DEVICETYPE] --name NAME
--role ROLE --s3bucket S3BUCKET --otasigningprofile
OTASIGNINGPROFILE --signingcertificateid
SIGNINGCERTIFICATEID [--codelocation CODELOCATION]
Script to start OTA update
optional arguments:
-h, --help show this help message and exit
--profile PROFILE Profile name created using aws configure
--region REGION Region
--account ACCOUNT Account ID
--devicetype DEVICETYPE thing|group
--name NAME Name of thing/group
--role ROLE Role for OTA updates
--s3bucket S3BUCKET S3 bucket to store firmware updates
--otasigningprofile OTASIGNINGPROFILE
Signing profile to be created or used
--signingcertificateid SIGNINGCERTIFICATEID
certificate id (not arn) to be used
--codelocation CODELOCATION
base folder location (can be relative)
```
1. Si vous avez utilisé le CloudFormation modèle fourni pour créer des ressources, exécutez la commande suivante :
```
python3 start_ota_stream.py --profile otausercf --name esp32-ble --role ota_ble_iot_role-sample --s3bucket afr-ble-ota-update-bucket-sample --otasigningprofile abcd --signingcertificateid certificateid
```
Vous devriez voir la mise à jour démarrer dans la console de ESP32 débogage :
```
38 2462 [OTA Task] [prvParseJobDoc] Job was accepted. Attempting to start transfer.
---
49 2867 [OTA Task] [prvIngestDataBlock] Received file block 1, size 1024
50 2867 [OTA Task] [prvIngestDataBlock] Remaining: 1290
51 2894 [OTA Task] [prvIngestDataBlock] Received file block 2, size 1024
52 2894 [OTA Task] [prvIngestDataBlock] Remaining: 1289
53 2921 [OTA Task] [prvIngestDataBlock] Received file block 3, size 1024
54 2921 [OTA Task] [prvIngestDataBlock] Remaining: 1288
55 2952 [OTA Task] [prvIngestDataBlock] Received file block 4, size 1024
56 2953 [OTA Task] [prvIngestDataBlock] Remaining: 1287
57 2959 [iot_thread] State: Active Received: 5 Queued: 5 Processed: 5 Dropped: 0
```
1. Lorsque la mise à jour OTA est terminée, l'appareil redémarre conformément au processus de mise à jour OTA. Il essaie ensuite de se connecter à l'aide du microprogramme mis à jour. Si la mise à niveau est réussie, le microprogramme mis à jour est marqué comme actif et vous devriez voir la version mise à jour dans la console :
```
13 13498 [iot_thread] OTA demo version 0.9.21
```
# AWS IoT Application de démonstration Device Shadow
**Important**
Cette démo est hébergée sur le référentiel Amazon-FreeRTOS 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
## Introduction
Cette démo montre comment utiliser la bibliothèque AWS IoT Device Shadow pour se connecter au [service AWS Device Shadow](https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html). Il utilise le [bibliothèque CoreMQTT](coremqtt.md) pour établir une connexion MQTT avec TLS (authentification mutuelle) avec le courtier AWS IoT MQTT et l'analyseur de bibliothèque CoreJSON pour analyser les documents cachés reçus du service Shadow. AWS La démo montre les opérations de base du fantôme, telles que la mise à jour d'un document fantôme et la procédure de suppression d'un document fantôme. La démo montre également comment enregistrer une fonction de rappel dans la bibliothèque CoreMQTT pour gérer des messages tels que le shadow `/update` et les `/update/delta` messages envoyés depuis le service Device Shadow AWS IoT .
Cette démonstration est conçue comme un exercice d'apprentissage uniquement car la demande de mise à jour du document fantôme (état) et la réponse de mise à jour sont effectuées par la même application. Dans un scénario de production réaliste, une application externe demanderait une mise à jour de l'état de l'appareil à distance, même si celui-ci n'est pas connecté actuellement. L'appareil accusera réception de la demande de mise à jour lorsqu'il sera connecté.
**Note**
Pour configurer et exécuter les démos de FreeRTOS, suivez les étapes décrites dans. [Commencez avec FreeRTOS](freertos-getting-started.md)
## Fonctionnalité
La démonstration crée une tâche d'application unique qui passe en revue un ensemble d'exemples illustrant le shadow `/update` et les `/update/delta` rappels pour simuler le basculement de l'état d'un appareil distant. Il envoie une mise à jour instantanée avec le nouvel `desired` état et attend que l'appareil change d'`reported`état en réponse au nouvel `desired` état. De plus, un `/update` rappel des ombres est utilisé pour imprimer les états changeants des ombres. Cette démonstration utilise également une connexion MQTT sécurisée avec le courtier AWS IoT MQTT et suppose qu'il existe un `powerOn` état dans l'ombre du périphérique.
La démo effectue les opérations suivantes :
1. Établissez une connexion MQTT à l'aide des fonctions d'assistance dans. `shadow_demo_helpers.c`
1. Assemblez des chaînes thématiques MQTT pour les opérations d'ombrage des appareils, à l'aide de macros définies par la bibliothèque AWS IoT Device Shadow.
1. Publiez dans la rubrique MQTT utilisée pour supprimer une ombre d'appareil afin de supprimer toute ombre de périphérique existante.
1. Abonnez-vous aux rubriques MQTT relatives aux fonctions `/update/delta` d'assistance `/update/accepted` et `/update/rejected` à leur utilisation dans. `shadow_demo_helpers.c`
1. Publiez l'état souhaité d'`powerOn`utilisation des fonctions d'assistance dans`shadow_demo_helpers.c`. Cela provoquera l'envoi d'un `/update/delta` message à l'appareil.
1. Gérez les messages MQTT entrants et déterminez s'ils sont liés à l'ombre du périphérique à l'aide d'une fonction définie par la bibliothèque AWS IoT Device Shadow (`Shadow_MatchTopic`). `prvEventCallback` S'il s'agit d'un `/update/delta` message invisible sur l'appareil, la fonction de démonstration principale publiera un deuxième message pour mettre à jour l'état signalé`powerOn`. Si un `/update/accepted` message est reçu, vérifiez qu'il contient le même `clientToken` que celui publié précédemment dans le message de mise à jour. Cela marquera la fin de la démo.
![\[sortie du terminal de démonstration Shadow\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/shadow-demo-output.png)
La démo se trouve dans le fichier `freertos/demos/device_shadow_for_aws/shadow_demo_main.c` ou sur [ GitHub](https://github.com/aws/amazon-freertos/blob/main/demos/device_shadow_for_aws/shadow_demo_main.c).
La capture d'écran suivante montre le résultat attendu en cas de réussite de la démonstration.
![\[sortie du terminal de démonstration Shadow indiquant le succès\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/shadow-demo-screenshot.png)
## Connectez-vous au broker AWS IoT MQTT
Pour nous connecter au broker AWS IoT MQTT, nous utilisons la même méthode que `MQTT_Connect()` dans le[Démo de l'authentification mutuelle CoreMQTT](mqtt-demo-ma.md).
## Supprimer le document fantôme
Pour supprimer le document fantôme, appelez `xPublishToTopic` avec un message vide, en utilisant les macros définies par la bibliothèque AWS IoT Device Shadow. Cela permet `MQTT_Publish` de publier sur le `/delete` sujet. La section de code suivante montre comment cela est effectué dans la fonction`prvShadowDemoTask`.
```
/* First of all, try to delete any Shadow document in the cloud. */
returnStatus = PublishToTopic( SHADOW_TOPIC_STRING_DELETE( THING_NAME ),
SHADOW_TOPIC_LENGTH_DELETE( THING_NAME_LENGTH ),
pcUpdateDocument,
0U );
```
## Abonnez-vous aux sujets parallèles
Abonnez-vous aux rubriques Device Shadow pour recevoir des notifications du AWS IoT broker concernant les modifications apportées aux Shadow. Les rubriques Device Shadow sont assemblées par des macros définies dans la bibliothèque Device Shadow. La section de code suivante montre comment cela est effectué dans la `prvShadowDemoTask` fonction.
```
/* Then try to subscribe shadow topics. */
if( returnStatus == EXIT_SUCCESS )
{
returnStatus = SubscribeToTopic(
SHADOW_TOPIC_STRING_UPDATE_DELTA( THING_NAME ),
SHADOW_TOPIC_LENGTH_UPDATE_DELTA( THING_NAME_LENGTH ) );
}
if( returnStatus == EXIT_SUCCESS )
{
returnStatus = SubscribeToTopic(
SHADOW_TOPIC_STRING_UPDATE_ACCEPTED( THING_NAME ),
SHADOW_TOPIC_LENGTH_UPDATE_ACCEPTED( THING_NAME_LENGTH ) );
}
if( returnStatus == EXIT_SUCCESS )
{
returnStatus = SubscribeToTopic(
SHADOW_TOPIC_STRING_UPDATE_REJECTED( THING_NAME ),
SHADOW_TOPIC_LENGTH_UPDATE_REJECTED( THING_NAME_LENGTH ) );
}
```
## Envoyer des mises à jour sur Sh
Pour envoyer une mise à jour instantanée, la démo appelle `xPublishToTopic` avec un message au format JSON, à l'aide de macros définies par la bibliothèque Device Shadow. Cela permet `MQTT_Publish` de publier sur le `/delete` sujet. La section de code suivante montre comment cela est effectué dans la `prvShadowDemoTask` fonction.
```
#define SHADOW_REPORTED_JSON \
"{" \
"\"state\":{" \
"\"reported\":{" \
"\"powerOn\":%01d" \
"}" \
"}," \
"\"clientToken\":\"%06lu\"" \
"}"
snprintf( pcUpdateDocument,
SHADOW_REPORTED_JSON_LENGTH + 1,
SHADOW_REPORTED_JSON,
( int ) ulCurrentPowerOnState,
( long unsigned ) ulClientToken );
xPublishToTopic( SHADOW_TOPIC_STRING_UPDATE( THING_NAME ),
SHADOW_TOPIC_LENGTH_UPDATE( THING_NAME_LENGTH ),
pcUpdateDocument,
( SHADOW_DESIRED_JSON_LENGTH + 1 ) );
```
## Gérer les messages Shadow Delta et les messages Shadow Update
La fonction de rappel utilisateur, qui a été enregistrée dans la [bibliothèque cliente CoreMQTT](https://www.freertos.org/iot-device-shadow/device-shadow-demo.html#handle-shadow-messages) à l'aide de cette `MQTT_Init` fonction, nous informera d'un événement de paquet entrant. Voir la fonction de rappel [ prvEventCallback](https://github.com/aws/amazon-freertos/blob/main/demos/device_shadow_for_aws/shadow_demo_main.c#L671-L753)activée. GitHub
La fonction de rappel confirme le type `MQTT_PACKET_TYPE_PUBLISH` du paquet entrant et utilise l'API Device Shadow Library `Shadow_MatchTopic` pour confirmer que le message entrant est un message fantôme.
Si le message entrant est un message fantôme de type`ShadowMessageTypeUpdateDelta`, nous appelons [ prvUpdateDeltaHandler](https://github.com/aws/amazon-freertos/blob/main/demos/device_shadow_for_aws/shadow_demo_main.c#L464-L580) pour gérer ce message. Le gestionnaire `prvUpdateDeltaHandler` utilise la bibliothèque CoreJSON pour analyser le message afin d'obtenir la valeur delta de l'`powerOn`état et la compare à l'état actuel du périphérique maintenu localement. S'ils sont différents, l'état du périphérique local est mis à jour pour refléter la nouvelle valeur de l'`powerOn`état figurant dans le document fantôme.
Si le message entrant est un message fantôme de type`ShadowMessageTypeUpdateAccepted`, nous appelons [ prvUpdateAcceptedHandler](https://github.com/aws/amazon-freertos/blob/main/demos/device_shadow_for_aws/shadow_demo_main.c#L584-L667) pour gérer ce message. Le gestionnaire `prvUpdateAcceptedHandler` analyse le message à l'aide de la bibliothèque CoreJSON pour en extraire le `clientToken` contenu. Cette fonction de gestion vérifie que le jeton client du message JSON correspond au jeton client utilisé par l'application. S'il ne correspond pas, la fonction enregistre un message d'avertissement.
# Démonstration du client Secure Sockets Echo
**Important**
Cette démo est hébergée sur le référentiel Amazon-FreeRTOS, 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 Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
L'exemple suivant utilise une seule tâche RTOS. Le code source de cet exemple se trouve sur `demos/tcp/aws_tcp_echo_client_single_task.c`.
Avant de commencer, vérifiez que vous avez téléchargé FreeRTOS sur votre microcontrôleur et que vous avez créé et exécuté les projets de démonstration de FreeRTOS. Vous pouvez cloner ou télécharger FreeRTOS depuis. [GitHub](https://github.com/aws/amazon-freertos) Consultez le fichier [README.md](https://github.com/aws/amazon-freertos/blob/main/README.md) pour obtenir des instructions.
**Pour exécuter la démonstration**
**Note**
Pour configurer et exécuter les démos de FreeRTOS, suivez les étapes décrites dans. [Commencez avec FreeRTOS](freertos-getting-started.md)
Les démos du serveur TCP et du client ne sont actuellement pas prises en charge sur les kits de développement Cypress CYW9439 07 AEVAL1 F et CYW9549 07 AEVAL1 F.
1. Suivez les instructions de la section [Configuration du serveur TLS Echo](https://docs.aws.amazon.com/freertos/latest/portingguide/tls-echo-server.html) dans le guide de portage de FreeRTOS.
Un TLS Echo Server doit être en cours d'exécution et à l'écoute sur le port 9000.
Pendant la configuration, vous devez avoir généré quatre fichiers :
+ `client.pem` (certificat de client)
+ `client.key` (clé privée du client)
+ `server.pem` (certificat de serveur)
+ `server.key` (clé privée du serveur)
1. Utilisez l'outil `tools/certificate_configuration/CertificateConfigurator.html` pour copier le certificat client (`client.pem`) et la clé privée du client (`client.key`) dans `aws_clientcredential_keys.h`.
1. Ouvrez le fichier `FreeRTOSConfig.h`.
1. Définissez les variables `configECHO_SERVER_ADDR0`, `configECHO_SERVER_ADDR1`, `configECHO_SERVER_ADDR2` et `configECHO_SERVER_ADDR3` pour les quatre nombres entiers qui constituent l'adresse IP à laquelle l'instance TLS Echo Server est exécutée.
1. Définissez la variable `configTCP_ECHO_CLIENT_PORT` sur `9000`, qui correspond au port où l'instance TLS Echo Server est à l'écoute.
1. Définissez la variable `configTCP_ECHO_TASKS_SINGLE_TASK_TLS_ENABLED` sur `1`.
1. Utilisez l'outil `tools/certificate_configuration/PEMfileToCString.html` pour copier le certificat de serveur (`server.pem`) dans `cTlsECHO_SERVER_CERTIFICATE_PEM` dans le fichier `aws_tcp_echo_client_single_task.c`.
1. Ouvrez`freertos/vendors/vendor/boards/board/aws_demos/config_files/aws_demo_config.h`, commentez `#define CONFIG_CORE_MQTT_MUTUAL_AUTH_DEMO_ENABLED` et définissez `CONFIG_OTA_MQTT_UPDATE_DEMO_ENABLED` ou`CONFIG_OTA_HTTP_UPDATE_DEMO_ENABLED`.
Le microcontrôleur et l'instance TLS Echo Server doivent être sur le même réseau. Lorsque la démonstration démarre (`main.c`), vous devez voir un message de journal qui indique `Received correct string from echo server`.