Prerequisiti Fase 1: Configurare l'archiviazione Fase 2: Creare il certificato di firma del codice Fase 3: configurazione dell'autenticazione di Amazon Cognito Fase 4: Configurazione di Amazon FreerTOS Passaggio 5: configura un'app per Android Passaggio 6: Esegui lo script di aggiornamento OTA

Tutorial: esegui gli aggiornamenti OTA su Espressif utilizzando ESP32 FreerTOS Bluetooth Low Energy

Importante

Questa integrazione di riferimento è ospitata nel repository Amazon-FreeRTOS che è obsoleto. Ti consigliamo di iniziare da qui quando crei un nuovo progetto. Se disponi già di un progetto FreeRTOS esistente basato sull'ormai obsoleto repository Amazon-FreerTOS, consulta il. Guida alla migrazione del repository Github di Amazon-FreeRTOS

Questo tutorial mostra come aggiornare un ESP32 microcontrollore Espressif collegato a un proxy Bluetooth Low Energy MQTT su un dispositivo Android. Aggiorna il dispositivo utilizzando i processi di aggiornamento AWS IoT Over-the-air (OTA). Il dispositivo si connette AWS IoT utilizzando le credenziali di Amazon Cognito inserite nell'app demo Android. Un operatore autorizzato avvia l'aggiornamento OTA dal cloud. Quando il dispositivo si connette tramite l'app demo Android, viene avviato l'aggiornamento OTA e il firmware viene aggiornato sul dispositivo.

Le versioni FreerTOS 2019.06.00 Major e successive includono il supporto proxy Bluetooth Low Energy MQTT che può essere utilizzato per il provisioning Wi-Fi e le connessioni sicure ai servizi. AWS IoT Utilizzando la funzione Bluetooth Low Energy, è possibile creare dispositivi a basso consumo che possono essere associati a un dispositivo mobile per la connettività senza richiedere il Wi-Fi. I dispositivi possono comunicare tramite MQTT connettendosi tramite Bluetooth Low Energy Android o iOS SDKs che utilizzano profili di accesso generico (GAP) e attributi generici (GATT).

Ecco i passaggi che seguiremo per consentire gli aggiornamenti OTA tramite Bluetooth Low Energy:

Configurazione dello storage: crea un bucket Amazon S3 e policy e configura un utente in grado di eseguire gli aggiornamenti.
Crea un certificato di firma con codice: crea un certificato di firma e consenti all'utente di firmare gli aggiornamenti del firmware.
Configura l'autenticazione Amazon Cognito: crea un provider di credenziali, un pool di utenti e l'accesso delle applicazioni al pool di utenti.
Configura FreerTOS: configura Bluetooth Low Energy, le credenziali del client e il certificato pubblico di firma del codice.
Configura un'app Android: configura il provider di credenziali, il pool di utenti e distribuisci l'applicazione su un dispositivo Android.
Esegui lo script di aggiornamento OTA: per avviare un aggiornamento OTA, utilizza lo script di aggiornamento OTA.

Per ulteriori informazioni su come funzionano gli aggiornamenti, vedereAggiornamenti FreerTOS Over-the-Air. Per ulteriori informazioni su come configurare la funzionalità proxy Bluetooth Low Energy MQTT, consulta il post Utilizzo di Bluetooth Low Energy con FreerTOS su ESP32 Espressif di Richard Kang.

Prerequisiti

Per eseguire i passaggi di questo tutorial, sono necessarie le seguenti risorse:

Una scheda di ESP32 sviluppo.
Un cavo da microUSB a USB A.
Un AWS account (il piano gratuito è sufficiente).
Un telefono Android con Android v 6.0 o versione successiva e Bluetooth versione 4.2 o successiva.

Sul tuo computer di sviluppo hai bisogno di:

Spazio su disco sufficiente (~500 Mb) per la toolchain Xtensa, il codice sorgente e gli esempi di FreerTOS.
Android Studio installato.
L'AWS CLIinstallato.
Python3 installato.
Il boto3 AWS Software Developer Kit (SDK) per Python.

I passaggi di questo tutorial presuppongono che il codice Xtensa toolchain, ESP-IDF e FreerTOS siano installati nella directory della home directory. /esp ~/esp/xtensa-esp32-elf/bin$PATHÈ necessario aggiungere alla variabile.

Fase 1: Configurare l'archiviazione

Crea un bucket Amazon S3 per archiviare l'aggiornamentocon il controllo delle versioni abilitato per contenere le immagini del firmware.
Creazione di un ruolo del servizio per gli aggiornamenti OTAe aggiungi le seguenti politiche gestite al ruolo:
- AWSIotRegistrazione
- AWSIotRuleActions
- AWSIotThingsRegistration
- AWSFreeRTOSOTAUpdate
Crea un utente in grado di eseguire gli aggiornamenti OTA. Questo utente può firmare e distribuire gli aggiornamenti del firmware sui dispositivi IoT nell'account e ha accesso agli aggiornamenti OTA su tutti i dispositivi. L'accesso deve essere limitato alle entità attendibili.
Segui i passaggi per Creazione di una policy utente OTA allegarlo al tuo utente.

Fase 2: Creare il certificato di firma del codice

Crea un bucket Amazon S3 con il controllo delle versioni abilitato per contenere le immagini del firmware.

Crea un certificato di firma del codice che può essere utilizzato per firmare il firmware. Prendi nota del certificato Amazon Resource Name (ARN) quando il certificato viene importato.


aws acm import-certificate --profile=ota-update-user --certificate file://ecdsasigner.crt --private-key file://ecdsasigner.key

Output di esempio:


{
"CertificateArn": "arn:aws:acm:us-east-1:<account>:certificate/<certid>"
}

In seguito utilizzerai l'ARN per creare un profilo di firma. Se lo desideri, puoi creare subito il profilo con il seguente comando:


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

Output di esempio:


{
"arn": "arn:aws:signer::<account>:/signing-profiles/esp32Profile"
}

Fase 3: configurazione dell'autenticazione di Amazon Cognito

Crea una policy AWS IoT

Accedere alla console AWS IoT.
Nell'angolo in alto a destra della console, scegli Il mio account. In Impostazioni account, prendi nota dell'ID del tuo account a 12 cifre.
Nel riquadro di navigazione a sinistra scegliere Impostazioni. In Device Data Endpoint, prendi nota del valore dell'endpoint. L'endpoint dovrebbe essere qualcosa del genere. xxxxxxxxxxxxxx.iot.us-west-2.amazonaws.com In questo esempio, la AWS regione è «us-west-2".
Nel riquadro di navigazione a sinistra, scegli Sicuro, scegli Politiche, quindi scegli Crea. Se non hai alcuna politica nel tuo account, vedrai il messaggio «Non hai ancora alcuna politica» e potrai scegliere Crea una politica.
Inserisci un nome per la tua politica, ad esempio «esp32_mqtt_proxy_iot_policy».

Nella sezione Add statements (Aggiungi istruzioni), scegliere Advanced mode (Modalità avanzata). Copiare e incollare il seguente JSON nella finestra dell'editor policy. Sostituiscilo aws-account-id con l'ID del tuo account e aws-region con la tua regione (ad esempio, «us-west-2").


{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "iot:Connect",
      "Resource": "arn:aws:iot:aws-region:aws-account-id:*"
    },
    {
      "Effect": "Allow",
      "Action": "iot:Publish",
      "Resource": "arn:aws:iot:aws-region:aws-account-id:*"
    },
    {
      "Effect": "Allow",
      "Action": "iot:Subscribe",
      "Resource": "arn:aws:iot:aws-region:aws-account-id:*"
    },
    {
      "Effect": "Allow",
      "Action": "iot:Receive",
      "Resource": "arn:aws:iot:aws-region:aws-account-id:*"
    }
  ]
}

Scegli Create (Crea) .

Crea qualsiasi cosa AWS IoT

Accedere alla console AWS IoT.
Nel riquadro di navigazione a sinistra nel pannello di controllo scegliere Manage (Gestisci), quindi Things (Oggetti).
Nell'angolo in alto a destra, scegli Crea. Se non hai ancora nulla registrato nel tuo account, viene visualizzato il messaggio «Non hai ancora nulla» e puoi scegliere Registra un oggetto.
Nella pagina Creazione di AWS IoT oggetti, scegli Crea una singola cosa.
Nella pagina Aggiungi il tuo dispositivo al registro degli oggetti, inserisci un nome per il tuo oggetto (ad esempio, «esp32-ble»). Sono consentiti solo caratteri alfanumerici, trattini (-) e caratteri di sottolineatura (_). Scegli Next (Successivo).
Nella pagina Aggiungi un certificato per il tuo oggetto, in Ignora certificato e crea oggetto, scegli Crea oggetto senza certificato. Poiché utilizziamo l'app mobile proxy BLE che utilizza una credenziale Amazon Cognito per l'autenticazione e l'autorizzazione, non è richiesto alcun certificato del dispositivo.

Crea un client per l'app Amazon Cognito

Accedi alla console Amazon Cognito.
Nel banner di navigazione in alto a destra, scegli Crea un pool di utenti.
Inserisci il nome del pool (ad esempio, «esp32_mqtt_proxy_user_pool»).
Scegli Review defaults (Esamina impostazioni predefinite).
In App Client, scegli Aggiungi app client, quindi scegli Aggiungi un app client.
Inserisci il nome di un client per l'app (ad esempio «mqtt_app_client»).
Assicurati che l'opzione Genera client secret sia selezionata.
Scegli Create app client (Crea client dell'app).
Scegli Return to pool details (Torna ai dettagli del pool).
Nella pagina di revisione del pool di utenti, scegli Crea pool. Dovresti vedere un messaggio che dice «Il tuo pool di utenti è stato creato con successo». Prendi nota dell'ID del pool.
Nel riquadro di navigazione, scegli App client.
Scegli Mostra dettagli. Prendi nota dell'ID del client dell'app e del segreto del client dell'app.

Creazione di un pool di identità in Amazon Cognito

Accedi alla console Amazon Cognito.
Scegli Create new identity pool (Crea un nuovo pool di identità).
Immettete un nome per il pool di identità (ad esempio, «mqtt_proxy_identity_pool»).
Espandi i provider di autenticazione.
Scegli la scheda Cognito.
Inserisci l'ID del pool di utenti e l'ID client dell'app che hai annotato nei passaggi precedenti.
Seleziona Create Pool (Crea pool).
Nella pagina successiva, per creare nuovi ruoli per identità autenticate e non autenticate, scegli Consenti.
Prendi nota dell'ID del pool di identità, che è nel formato. us-east-1:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

Allega una policy IAM all'identità autenticata

Apri la console Amazon Cognito.
Seleziona il pool di identità che hai appena creato (ad esempio, «mqtt_proxy_identity_pool»).
Scegli Modifica pool di identità.
Prendi nota del ruolo IAM assegnato al ruolo autenticato (ad esempio, «COGNITO_MQTT_PROXY_IDENTITY_POOLAUTH_ROLE»).
Aprire la console IAM.
Nel pannello di navigazione, selezionare Ruoli.
Cerca il ruolo assegnato (ad esempio, «COGNITO_MQTT_Proxy_Identity_PoolAuth_Role»), quindi selezionalo.
Scegli Aggiungi politica in linea, quindi scegli JSON.

Immettere la seguente policy:


{
       "Version": "2012-10-17",
       "Statement": [
       {
          "Effect": "Allow",
          "Action": [
             "iot:AttachPolicy",
             "iot:AttachPrincipalPolicy",
             "iot:Connect",
             "iot:Publish",
             "iot:Subscribe"
          ],
          "Resource": "*"
       }]
    }

Scegli Esamina la policy.
Inserisci il nome di una politica (ad esempio, "mqttProxyCognitoPolicy»).
Scegli Create Policy (Crea policy).

Fase 4: Configurazione di Amazon FreerTOS

Scarica l'ultima versione del codice Amazon FreerTOS dal repository FreerTOS. GitHub
Per abilitare la demo di aggiornamento OTA, segui i passaggi indicati. Guida introduttiva all'Espressif ESP32 - DevKit C e al ESP-WROVER-KIT
Apporta queste modifiche aggiuntive nei seguenti file:
1. Apri vendors/espressif/boards/esp32/aws_demos/config_files/aws_demo_config.h e definisciCONFIG_OTA_UPDATE_DEMO_ENABLED.
2. Apri vendors/espressif/boards/esp32/aws_demos/common/config_files/aws_demo_config.h e cambia democonfigNETWORK_TYPES inAWSIOT_NETWORK_TYPE_BLE.
3. Apri demos/include/aws_clientcredential.h e inserisci l'URL dell'endpoint perclientcredentialMQTT_BROKER_ENDPOINT.
  
  Inserisci il nome dell'oggetto per clientcredentialIOT_THING_NAME (ad esempio, «esp32-ble»). Non è necessario aggiungere certificati quando utilizzi le credenziali di Amazon Cognito.
4. Apri vendors/espressif/boards/esp32/aws_demos/config_files/aws_iot_network_config.h e modifica configSUPPORTED_NETWORKS e solo configENABLED_NETWORKS per includere. AWSIOT_NETWORK_TYPE_BLE
5. Apri il vendors/vendor/boards/board/aws_demos/config_files/ota_demo_config.h file e inserisci il certificato.
```
#define otapalconfigCODE_SIGNING_CERTIFICATE [] = "your-certificate-key";
```
L'applicazione dovrebbe avviarsi e stampare la versione demo:
```
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...
```

Passaggio 5: configura un'app per Android

Scarica l'SDK Bluetooth Low Energy per Android e un'app di esempio dal repository amazon-freertos-ble-android GitHub -sdk.

Apri il file app/src/main/res/raw/awsconfiguration.json e inserisci l'ID del pool, la regione e AppClientSecret utilizza le istruzioni nel seguente esempio JSON. 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)"
    }
  }
}

Apri app/src/main/java/software/amazon/freertos/DemoConstants.java e inserisci il nome della policy che hai creato in precedenza (ad esempio,esp32_mqtt_proxy_iot_policy) e anche la regione (ad esempio,us-east-1).
Crea e installa l'app demo.
1. In Android Studio, scegli Build, quindi l'app Make Module.
2. Scegli Esegui, quindi Esegui app. Puoi andare al riquadro della finestra logcat in Android Studio per monitorare i messaggi di registro.
3. Sul dispositivo Android, crea un account dalla schermata di accesso.
4. Creare un utente. Se esiste già un utente, inserisci le credenziali.
5. Consenti alla demo di Amazon FreerTOS di accedere alla posizione del dispositivo.
6. Cerca dispositivi Bluetooth Low Energy.
7. Sposta il cursore del dispositivo trovato su Attivato.
8. Premi y sulla console di debug della porta seriale per. ESP32
9. Scegli Pair & Connect.
Il Altro... il collegamento diventa attivo dopo aver stabilito la connessione. Lo stato della connessione dovrebbe cambiare in «BLE_CONNECTED» nel logcat del dispositivo Android quando la connessione è completa:
```
2019-06-06 20:11:32.160 23484-23497/software.amazon.freertos.demo I/FRD: BLE connection state changed: 0; new state: BLE_CONNECTED
```
Prima che i messaggi possano essere trasmessi, il dispositivo Amazon FreerTOS e il dispositivo Android negoziano l'MTU. Dovresti vedere il seguente output in logcat:
```
2019-06-06 20:11:46.720 23484-23497/software.amazon.freertos.demo I/FRD: onMTUChanged : 512 status: Success
```

Il dispositivo si connette all'app e inizia a inviare messaggi MQTT utilizzando il proxy MQTT. Per confermare che il dispositivo è in grado di comunicare, assicuratevi che il valore dei dati caratteristici MQTT_CONTROL sia impostato su 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

Quando i dispositivi sono associati, verrà visualizzato un messaggio sulla console. ESP32 Per abilitare BLE, premi y. La demo non funzionerà finché non eseguirai questo passaggio.


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.

Passaggio 6: Esegui lo script di aggiornamento OTA

Per installare i prerequisiti, esegui i seguenti comandi:
```
pip3 install boto3
```
```
pip3 install pathlib
```
Incrementa la versione dell'applicazione FreerTOS in. demos/include/aws_application_version.h
Crea un nuovo file.bin.

Scarica lo script python start_ota.py. Per vedere il contenuto della guida dello script, esegui il seguente comando in una finestra di terminale:


python3 start_ota.py -h

Viene visualizzato quanto segue:


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)

Se hai utilizzato il AWS CloudFormation modello fornito per creare risorse, esegui il comando seguente:


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

Dovresti vedere l'avvio dell'aggiornamento nella console di ESP32 debug:


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

Una volta completato l'aggiornamento OTA, il dispositivo si riavvia come richiesto dal processo di aggiornamento OTA. Quindi tenta di connettersi utilizzando il firmware aggiornato. Se l'aggiornamento è riuscito, il firmware aggiornato viene contrassegnato come attivo e la versione aggiornata dovrebbe essere visualizzata nella console:
```
13 13498 [iot_thread] OTA demo version 0.9.21
```

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Renesas N RX65

AWS IoT Device Shadow