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.
# 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
```