Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Tutorial: Führen Sie OTA-Updates auf Espressif ESP32 mit FreeRTOS Bluetooth Low Energy durch
**Wichtig**
Diese Referenzintegration wird im Amazon-FreeRTOS-Repository gehostet, das veraltet ist. Wir empfehlen, dass Sie [hier beginnen](freertos-getting-started-modular.md), wenn Sie ein neues Projekt erstellen. Wenn Sie bereits ein vorhandenes FreeRTOS-Projekt haben, das auf dem inzwischen veralteten Amazon-FreeRTOS-Repository basiert, finden Sie weitere Informationen unter. [Leitfaden zur Migration des Amazon-FreerTOS Github-Repositorys](github-repo-migration.md)
Dieses Tutorial zeigt Ihnen, wie Sie einen ESP32 Espressif-Mikrocontroller aktualisieren, der mit einem MQTT Bluetooth Low Energy-Proxy auf einem Android-Gerät verbunden ist. Es aktualisiert das Gerät mithilfe von AWS IoT Over-the-air (OTA-) Aktualisierungsjobs. Das Gerät stellt AWS IoT mithilfe der Amazon Cognito Cognito-Anmeldeinformationen, die in der Android-Demo-App eingegeben wurden, eine Verbindung her. Ein autorisierter Betreiber initiiert das OTA-Update von der Cloud aus. Wenn das Gerät über die Android-Demo-App eine Verbindung herstellt, wird das OTA-Update initiiert und die Firmware auf dem Gerät aktualisiert.
FreeRTOS-Versionen 2019.06.00 Major und höher beinhalten Bluetooth Low Energy MQTT-Proxyunterstützung, die für die Wi-Fi-Bereitstellung und sichere Verbindungen zu Diensten verwendet werden kann. AWS IoT Mithilfe der Bluetooth Low Energy-Funktion können Sie Geräte mit geringem Stromverbrauch erstellen, die zur Konnektivität mit einem Mobilgerät gekoppelt werden können, ohne dass WLAN erforderlich ist. Geräte können mithilfe von MQTT kommunizieren, indem sie sich über Android oder iOS Bluetooth Low Energy verbinden SDKs , die Generic Access Profile (GAP) und Generic Attributes (GATT) -Profile verwenden.
Hier sind die Schritte, die wir befolgen werden, um OTA-Updates über Bluetooth Low Energy zuzulassen:
1. **Speicher konfigurieren:** Erstellen Sie einen Amazon S3 S3-Bucket und Richtlinien und konfigurieren Sie einen Benutzer, der Updates durchführen kann.
1. **Erstellen Sie ein Codesignaturzertifikat:** Erstellen Sie ein Signaturzertifikat und ermöglichen Sie es dem Benutzer, Firmware-Updates zu signieren.
1. **Amazon Cognito Cognito-Authentifizierung konfigurieren:** Erstellen Sie einen Anmeldeinformationsanbieter, einen Benutzerpool und Anwendungszugriff auf den Benutzerpool.
1. **FreeRTOS konfigurieren:** Bluetooth Low Energy, Client-Anmeldeinformationen und das öffentliche Code-Signing-Zertifikat einrichten.
1. **Eine Android-App konfigurieren:** Richten Sie einen Anbieter für Anmeldeinformationen und einen Benutzerpool ein und stellen Sie die Anwendung auf einem Android-Gerät bereit.
1. **Führen Sie das OTA-Aktualisierungsskript aus:** Verwenden Sie das OTA-Aktualisierungsskript, um ein OTA-Update zu initiieren.
Weitere Informationen zur Funktionsweise der Updates finden Sie unter[FreeRTOS RTOS-Updates Over-the-Air](freertos-ota-dev.md). Weitere Informationen zur Einrichtung der Bluetooth Low Energy MQTT-Proxyfunktion finden Sie im Beitrag [Using Bluetooth Low Energy with FreeRTOS on ESP32 Espressif](https://aws.amazon.com/blogs/iot/using-bluetooth-low-energy-with-amazon-freertos-on-espressif-esp32/) von Richard Kang.
## Voraussetzungen
Um die Schritte in diesem Tutorial durchzuführen, benötigen Sie die folgenden Ressourcen:
+ Ein ESP32 Entwicklungsboard.
+ Ein MicroUSB-zu-USB-A-Kabel.
+ Ein AWS Konto (das kostenlose Kontingent ist ausreichend).
+ Ein Android-Telefon mit Android v 6.0 oder höher und Bluetooth-Version 4.2 oder höher.
Auf Ihrem Entwicklungscomputer benötigen Sie:
+ Ausreichender Festplattenspeicher (\~500 MB) für die Xtensa-Toolchain und den FreeRTOS-Quellcode und Beispiele.
+ Android Studio ist installiert.
+ Das [AWS CLI](https://aws.amazon.com/cli/)installierte.
+ Python3 installiert.
+ Das [boto3 AWS Software Developer Kit (SDK) für Python](https://github.com/boto/boto3).
Bei den Schritten in diesem Tutorial wird davon ausgegangen, dass die Xtensa-Toolchain, ESP-IDF und FreeRTOS-Code im Verzeichnis in Ihrem Home-Verzeichnis installiert sind. `/esp` Sie müssen zu Ihrer Variablen etwas hinzufügen. `~/esp/xtensa-esp32-elf/bin` `$PATH`
## Schritt 1: Speicher konfigurieren
1. [Erstellen Sie einen Amazon S3 S3-Bucket, um Ihr Update zu speichern](dg-ota-bucket.md)mit aktivierter Versionierung zum Speichern der Firmware-Images.
1. [Erstellen einer OTA-Update-Servicerolle](create-service-role.md)und fügen Sie der Rolle die folgenden verwalteten Richtlinien hinzu:
+ AWSIotProtokollierung
+ AWSIotRuleActions
+ AWSIotThingsRegistration
+ AWSFreeRTOSOTAUpdate
1. [Erstellen Sie einen Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html), der OTA-Updates durchführen kann. Dieser Benutzer kann Firmware-Updates für IoT-Geräte im Konto signieren und bereitstellen und hat Zugriff auf OTA-Updates auf allen Geräten. Der Zugriff sollte auf vertrauenswürdige Entitäten beschränkt sein.
1. Folgen Sie den Schritten [Erstellen einer OTA-Benutzerrichtlinie](create-ota-user-policy.md) und hängen Sie es an Ihren Benutzer an.
## Schritt 2: Erstellen Sie das Codesignaturzertifikat
1. Erstellen Sie einen Amazon S3 S3-Bucket mit aktivierter Versionierung, um die Firmware-Images zu speichern.
1. Erstellen Sie ein Codesignaturzertifikat, das zum Signieren der Firmware verwendet werden kann. Notieren Sie sich das Zertifikat Amazon Resource Name (ARN), wenn das Zertifikat importiert wird.
```
aws acm import-certificate --profile=ota-update-user --certificate file://ecdsasigner.crt --private-key file://ecdsasigner.key
```
Beispielausgabe:
```
{
"CertificateArn": "arn:aws:acm:us-east-1::certificate/"
}
```
Sie werden den ARN später verwenden, um ein Signaturprofil zu erstellen. Wenn Sie möchten, können Sie das Profil jetzt mit dem folgenden Befehl erstellen:
```
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
```
Beispielausgabe:
```
{
"arn": "arn:aws:signer:::/signing-profiles/esp32Profile"
}
```
## Schritt 3: Amazon Cognito Cognito-Authentifizierungskonfiguration
**Erstellen Sie eine Richtlinie AWS IoT**
1. Melden Sie sich bei der [AWS IoT -Konsole](https://console.aws.amazon.com/iot/) an.
1. Wählen Sie in der oberen rechten Ecke der Konsole **Mein** Konto aus. Notieren Sie sich unter **Kontoeinstellungen** Ihre 12-stellige Konto-ID.
1. Wählen Sie im linken Navigationsbereich die Option **Einstellungen** aus. Notieren Sie sich unter **Gerätedatenendpunkt** den Endpunktwert. Der Endpunkt sollte ungefähr so lauten`xxxxxxxxxxxxxx.iot.us-west-2.amazonaws.com`. In diesem Beispiel ist die AWS Region „us-west-2".
1. **Wählen Sie im linken Navigationsbereich **Secure**, dann **Policies** und anschließend Create aus.** Wenn Sie in Ihrem Konto keine Richtlinien haben, wird die Meldung „Sie haben noch keine Richtlinien“ **angezeigt, und Sie können „Richtlinie erstellen**“ auswählen.
1. Geben Sie einen Namen für Ihre Richtlinie ein, zum Beispiel „esp32\_mqtt\_proxy\_iot\_policy“.
1. Wählen Sie im Abschnitt **Anweisungen hinzufügen** die Option **Erweiterter Modus** aus. Kopieren Sie die folgende JSON und fügen Sie sie in das Fenster des Richtlinien-Editors ein. Ersetze es `aws-account-id` durch deine Konto-ID und `aws-region` durch deine Region (z. B. „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. Wählen Sie **Erstellen** aus.
**Erstelle ein Ding AWS IoT**
1. Melden Sie sich bei der [AWS IoT -Konsole](https://console.aws.amazon.com/iot/) an.
1. Wählen Sie im linken Navigationsbereich **Manage (Verwalten)** und dann **Things (Objekte)**.
1. Wählen Sie in der oberen rechten Ecke die Option **Erstellen** aus. Wenn Sie in Ihrem Konto keine Dinge registriert haben, wird die Meldung „Sie haben noch keine Dinge“ angezeigt und Sie können „**Etwas registrieren**“ auswählen.
1. Wählen Sie auf der Seite „** AWS IoT Dinge erstellen**“ die Option „**Eine einzelne Sache erstellen**“ aus.
1. Geben Sie auf der Seite **Gerät zur Registrierung von Dingen hinzufügen** einen Namen für Ihr Ding ein (z. B. „esp32-ble“). Nur alphanumerische Zeichen, Bindestriche (-) und Unterstriche (\_) sind zulässig. Wählen Sie **Weiter** aus.
1. Wählen Sie auf der Seite **Zertifikat für Ihr Ding hinzufügen** unter **Zertifikat überspringen und Sache erstellen die Option Ding** ohne Zertifikat **erstellen** aus. Da wir die mobile BLE-Proxy-App verwenden, die Amazon Cognito Cognito-Anmeldeinformationen für die Authentifizierung und Autorisierung verwendet, ist kein Gerätezertifikat erforderlich.
**Erstellen Sie einen Amazon Cognito App-Client**
1. Melden Sie sich bei der [Amazon Cognito-Konsole](https://console.aws.amazon.com/cognito/users/) an.
1. Wählen Sie im Navigationsbanner oben rechts die Option **Benutzerpool erstellen** aus.
1. Geben Sie den Poolnamen ein (z. B. „esp32\_mqtt\_proxy\_user\_pool“).
1. Wählen Sie **Review defaults**.
1. **Wählen Sie unter **App-Clients die Option App-Client** hinzufügen und anschließend App-Client **hinzufügen** aus.**
1. Geben Sie einen Namen für den App-Client ein (zum Beispiel „mqtt\_app\_client“).
1. Stellen Sie sicher, dass die Option Clientgeheimnis **generieren ausgewählt** ist.
1. Wählen Sie **Create app client**.
1. Wählen Sie **Return to pool details (Zurück zu den Pool-Details)**.
1. Wählen Sie auf der Seite **„Überprüfen**“ des Benutzerpools die Option **Pool erstellen** aus. Sie sollten die Meldung „Ihr Benutzerpool wurde erfolgreich erstellt“ sehen. Notieren Sie sich die Pool-ID.
1. Wählen Sie im Navigationsbereich **App-Clients** aus.
1. Wählen Sie „**Details anzeigen**“. Notieren Sie sich die App-Client-ID und das App-Client-Geheimnis.
**Amazon-Cognito-Identitätspool erstellen**
1. Melden Sie sich bei der [Amazon Cognito-Konsole](https://console.aws.amazon.com/cognito/federated) an.
1. Wählen Sie **Neuen Identitätspool erstellen**.
1. Geben Sie einen Namen für den Identitätspool ein (z. B. „mqtt\_proxy\_identity\_pool“).
1. **Erweitern** Sie Authentifizierungsanbieter.
1. Wählen Sie den Tab **Cognito**.
1. Geben Sie die Benutzerpool-ID und die App-Client-ID ein, die Sie sich in den vorherigen Schritten notiert haben.
1. Wählen Sie **Pool erstellen**.
1. **Wählen Sie auf der nächsten Seite Allow aus, um neue Rollen für authentifizierte und nicht authentifizierte Identitäten zu erstellen.**
1. Notieren Sie sich die Identitätspool-ID, die im folgenden Format vorliegt. `us-east-1:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`
**Fügen Sie der authentifizierten Identität eine IAM-Richtlinie hinzu**
1. Öffnen Sie die [Amazon-Cognito-Konsole](https://console.aws.amazon.com/cognito/federated).
1. Wählen Sie den Identitätspool aus, den Sie gerade erstellt haben (z. B. „mqtt\_proxy\_identity\_pool“).
1. Wählen Sie **Edit identity pool (Identitäten-Pool bearbeiten)**.
1. Notieren Sie sich die der authentifizierten Rolle zugewiesene IAM-Rolle (z. B. „Cognito\_MQTT\_Proxy\_Identity\_PoolAuth\_Role“).
1. Öffnen Sie die [IAM-Konsole](https://console.aws.amazon.com/iam/home).
1. Wählen Sie im Navigationsbereich **Roles** aus.
1. Suchen Sie nach der zugewiesenen Rolle (z. B. „Cognito\_MQTT\_Proxy\_Identity\_PoolAuth\_Role“) und wählen Sie sie dann aus.
1. **Wählen** **Sie Inline-Richtlinie hinzufügen und anschließend JSON aus.**
1. Geben Sie die folgende Richtlinie ein:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:AttachPolicy",
"iot:AttachPrincipalPolicy",
"iot:Connect",
"iot:Publish",
"iot:Subscribe"
],
"Resource": "*"
}]
}
```
------
1. Wählen Sie **Review policy** (Richtlinie überprüfen) aus.
1. Geben Sie einen Richtliniennamen ein (z. B. „mqttProxyCognitoRichtlinie“).
1. Wählen Sie **Richtlinie erstellen** aus.
## Schritt 4: Amazon FreeRTOS konfigurieren
1. Laden Sie die neueste Version des Amazon FreeRTOS FreeRTOS-Codes aus dem [ GitHub FreeRTOS-Repo](https://github.com/aws/amazon-freertos) herunter.
1. Um die OTA-Update-Demo zu aktivieren, folgen Sie den Schritten unter. [Erste Schritte mit dem Espressif ESP32 - DevKit C und dem ESP-WROVER-KIT](getting_started_espressif.md)
1. Nehmen Sie diese zusätzlichen Änderungen in den folgenden Dateien vor:
1. Öffnen `vendors/espressif/boards/esp32/aws_demos/config_files/aws_demo_config.h` und definieren`CONFIG_OTA_UPDATE_DEMO_ENABLED`.
1. Öffnen `vendors/espressif/boards/esp32/aws_demos/common/config_files/aws_demo_config.h` und wechseln `democonfigNETWORK_TYPES` zu`AWSIOT_NETWORK_TYPE_BLE`.
1. Öffnen Sie `demos/include/aws_clientcredential.h` und geben Sie Ihre Endpunkt-URL für ein`clientcredentialMQTT_BROKER_ENDPOINT`.
Geben Sie den Namen Ihres Dings für ein `clientcredentialIOT_THING_NAME` (zum Beispiel „esp32-ble“). Zertifikate müssen nicht hinzugefügt werden, wenn Sie Amazon Cognito Cognito-Anmeldeinformationen verwenden.
1. Öffnen `vendors/espressif/boards/esp32/aws_demos/config_files/aws_iot_network_config.h` und ändern `configSUPPORTED_NETWORKS` und nur `configENABLED_NETWORKS` `AWSIOT_NETWORK_TYPE_BLE` zum Einbeziehen.
1. Öffnen Sie die `vendors/{{vendor}}/boards/{{board}}/aws_demos/config_files/ota_demo_config.h` Datei und geben Sie Ihr Zertifikat ein.
```
#define otapalconfigCODE_SIGNING_CERTIFICATE [] = "{{your-certificate-key}}";
```
Die Anwendung sollte starten und die Demoversion drucken:
```
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...
```
## Schritt 5: Konfigurieren Sie eine Android-App
1. Laden Sie das Android Bluetooth Low Energy SDK und eine Beispiel-App aus dem [amazon-freertos-ble-android GitHub -sdk-Repo](https://github.com/aws/amazon-freertos-ble-android-sdk) herunter.
1. Öffnen Sie die Datei `app/src/main/res/raw/awsconfiguration.json` und geben Sie die Pool-ID, die Region und AppClientSecret die Anweisungen im folgenden JSON-Beispiel ein. AppClientId
```
{
"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. Öffnen Sie den zuvor erstellten Richtliniennamen (z. B.{{esp32\_mqtt\_proxy\_iot\_policy}}) `app/src/main/java/software/amazon/freertos/DemoConstants.java` und geben Sie auch die Region (z. B.{{us-east-1}}) ein.
1. Erstellen und installieren Sie die Demo-App.
1. Wählen Sie in Android Studio **Build** und dann **Make Module App** aus.
1. Wählen Sie „**Ausführen**“ und dann „**App ausführen**“. Sie können in Android Studio zum Logcat-Fenster wechseln, um Protokollnachrichten zu überwachen.
1. Erstellen Sie auf dem Android-Gerät über den Anmeldebildschirm ein Konto.
1. Erstellen eines Benutzers. Wenn ein Benutzer bereits existiert, geben Sie die Anmeldeinformationen ein.
1. Erlauben Sie der Amazon FreeRTOS-Demo, auf den Standort des Geräts zuzugreifen.
1. Suchen Sie nach Bluetooth Low Energy-Geräten.
1. Stellen Sie den Schieberegler für das gefundene Gerät **auf Ein**.
1. Drücken Sie **Y** an der Debug-Konsole für die ESP32 serielle Schnittstelle.
1. Wählen Sie **Pair & Connect**.
1. Je **mehr...** Der Link wird aktiv, nachdem die Verbindung hergestellt wurde. Der Verbindungsstatus sollte sich im Logcat des Android-Geräts auf „BLE\_CONNECTED“ ändern, wenn die Verbindung hergestellt ist:
```
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. Bevor die Nachrichten übertragen werden können, handeln das Amazon FreeRTOS FreeRTOS-Gerät und das Android-Gerät die MTU aus. Sie sollten die folgende Ausgabe in Logcat sehen:
```
2019-06-06 20:11:46.720 23484-23497/software.amazon.freertos.demo I/FRD: onMTUChanged : 512 status: Success
```
1. Das Gerät stellt eine Verbindung zur App her und beginnt, MQTT-Nachrichten über den MQTT-Proxy zu senden. Um zu bestätigen, dass das Gerät kommunizieren kann, stellen Sie sicher, dass sich der Wert der charakteristischen Daten von MQTT\_CONTROL auf 01 ändert:
```
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. Wenn die Geräte gekoppelt sind, wird auf der Konsole eine Aufforderung angezeigt. ESP32 Um BLE zu aktivieren, drücken Sie **Y.** Die Demo funktioniert erst, wenn Sie diesen Schritt ausführen.
```
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.
```
## Schritt 6: Führen Sie das OTA-Aktualisierungsskript aus
1. Führen Sie die folgenden Befehle aus, um die Voraussetzungen zu installieren:
```
pip3 install boto3
```
```
pip3 install pathlib
```
1. Inkrementieren Sie die FreeRTOS-Anwendungsversion in. `demos/include/aws_application_version.h`
1. Erstellen Sie eine neue .bin-Datei.
1. Laden Sie das Python-Skript [start\_ota.py](https://github.com/aws-samples/amazon-freertos-ota-scripts/blob/master/scripts/start_ota.py) herunter. Um den Inhalt der Hilfe für das Skript zu sehen, führen Sie den folgenden Befehl in einem Terminalfenster aus:
```
python3 start_ota.py -h
```
Dies sollte etwa wie folgt aussehen:
```
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. Wenn Sie die bereitgestellte CloudFormation Vorlage zum Erstellen von Ressourcen verwendet haben, führen Sie den folgenden Befehl aus:
```
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}}
```
Sie sollten den Start des Updates in der ESP32 Debug-Konsole sehen:
```
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. Wenn das OTA-Update abgeschlossen ist, wird das Gerät gemäß den Anforderungen des OTA-Aktualisierungsvorgangs neu gestartet. Es versucht dann, mit der aktualisierten Firmware eine Verbindung herzustellen. Wenn das Upgrade erfolgreich war, ist die aktualisierte Firmware als aktiv markiert und Sie sollten die aktualisierte Version in der Konsole sehen:
```
13 13498 [iot_thread] OTA demo version 0.9.21
```