Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Tutorial: Realice actualizaciones OTA en Espressif utilizando ESP32 FreeRTOS Bluetooth Low Energy
**importante**
Esta integración de referencia está alojada en el repositorio de Amazon-FreeRTOS, que está en desuso. Recomendamos [empezar por aquí](freertos-getting-started-modular.md) al crear un nuevo proyecto. Si ya tiene un proyecto FreeRTOS existente basado en el repositorio Amazon FreeRTOS, ahora obsoleto, consulte [Guía de migración del repositorio Github de Amazon-FreeRTOS](github-repo-migration.md).
Este tutorial le muestra cómo actualizar un ESP32 microcontrolador Espressif que está conectado a un proxy Bluetooth de bajo consumo de energía MQTT en un dispositivo Android. Actualiza el dispositivo mediante tareas de actualización AWS IoT Over-the-air (OTA). El dispositivo se conecta AWS IoT mediante las credenciales de Amazon Cognito introducidas en la aplicación de demostración de Android. Un operador autorizado inicia la actualización OTA desde la nube. Cuando el dispositivo se conecta a través de la aplicación de demostración de Android, se inicia la actualización OTA y se actualiza el firmware del dispositivo.
Las versiones 2019.06.00 Major y posteriores de FreeRTOS incluyen compatibilidad con proxy MQTT Bluetooth de bajo consumo que se puede utilizar para el aprovisionamiento de Wi-Fi y las conexiones seguras a los servicios. AWS IoT Al usar la característica Bluetooth de bajo consumo, puede crear dispositivos de bajo consumo que se pueden emparejar a un dispositivo móvil para tener conectividad sin necesidad de Wi-Fi. Los dispositivos pueden comunicarse mediante MQTT conectándose a través de Bluetooth Low Energy de Android o iOS SDKs que utilizan perfiles de perfil de acceso genérico (GAP) y atributos genéricos (GATT).
Estos son los pasos que seguiremos para permitir las actualizaciones OTA a través de Bluetooth de bajo consumo:
1. **Configurar el almacenamiento:** cree un bucket y políticas de Amazon S3 y configure un usuario que pueda realizar actualizaciones.
1. **Crear un certificado de firma de código:** cree un certificado de firma y permita al usuario firmar las actualizaciones del firmware.
1. **Configurar la autenticación de Amazon Cognito:** cree un proveedor de credenciales, un grupo de usuarios y un acceso de aplicaciones al grupo de usuarios.
1. **Configurar FreeRTOS:** configure Bluetooth de bajo consumo, las credenciales del cliente y el certificado público de firma de código.
1. **Configurar una aplicación para Android:** configure el proveedor de credenciales, el grupo de usuarios e implemente la aplicación en un dispositivo Android.
1. **Ejecutar el script de actualización OTA:** para iniciar una actualización OTA, utilice el script de actualización OTA.
Para obtener más información sobre cómo funcionan las actualizaciones, consulte [Actualizaciones gratuitas de FreRTOS Over-the-Air](freertos-ota-dev.md). Para obtener información adicional sobre cómo configurar la funcionalidad de proxy MQTT de Bluetooth de bajo consumo, consulte la publicación [Uso de Bluetooth de bajo consumo con Freertos en ESP32](https://aws.amazon.com/blogs/iot/using-bluetooth-low-energy-with-amazon-freertos-on-espressif-esp32/) Espressif de Richard Kang.
## Requisitos previos
Para realizar los pasos de este tutorial necesitará los siguientes recursos:
+ Una placa de desarrollo. ESP32
+ Un cable microUSB a USB A.
+ Una AWS cuenta (el nivel gratuito es suficiente).
+ Un teléfono Android con Android v 6.0 o posterior y Bluetooth versión 4.2 o posterior.
En su equipo de desarrollo necesita:
+ Espacio en disco suficiente (\$1500 Mb) para la cadena de herramientas de Xtensa y el código fuente y ejemplos de FreeRTOS.
+ Android Studio instalado.
+ La [AWS CLI](https://aws.amazon.com/cli/) instalada.
+ Python3 instalado.
+ El [kit de desarrollo de AWS software (SDK) boto3 para Python](https://github.com/boto/boto3).
En los pasos de este tutorial se supone que la cadena de herramientas de Xtensa, el código ESP-IDF y el código FreeRTOS están instalados en el directorio `/esp` de su directorio principal. Debe añadir `~/esp/xtensa-esp32-elf/bin` a la variable `$PATH`.
## Paso 1: Configurar almacenamiento
1. [Creación de un bucket de Amazon S3 para almacenar la actualización](dg-ota-bucket.md) con el control de versiones activado para almacenar las imágenes del firmware.
1. [Crear un rol de servicio de actualizaciones OTA](create-service-role.md) y añada las siguientes políticas administradas al rol:
+ AWSIotRegistro
+ AWSIotRuleActions
+ AWSIotThingsRegistration
+ AWSFreeRTOSOTAUpdate
1. [Cree un usuario](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html) que pueda realizar actualizaciones OTA. Este usuario puede firmar e implementar actualizaciones de firmware en los dispositivos de IoT de la cuenta y tiene acceso para realizar actualizaciones OTA en todos los dispositivos. El acceso debe estar limitado a entidades de confianza.
1. Siga los pasos para [Crear una política de usuario de OTA](create-ota-user-policy.md) y asóciela a su usuario.
## Paso 2: Crear el certificado de firma de código
1. Cree un bucket de Amazon S3 con el control de versiones habilitado para almacenar las imágenes del firmware.
1. Cree un certificado de firma de código que pueda usarse para firmar el firmware. Anote el Nombre de recurso de Amazon (ARN) del certificado cuando se importe.
```
aws acm import-certificate --profile=ota-update-user --certificate file://ecdsasigner.crt --private-key file://ecdsasigner.key
```
Ejemplo de código de salida:
```
{
"CertificateArn": "arn:aws:acm:us-east-1::certificate/"
}
```
Utilizará el ARN más adelante para crear un perfil de firma. Si lo desea, puede crear el perfil ahora con el siguiente 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
```
Ejemplo de código de salida:
```
{
"arn": "arn:aws:signer:::/signing-profiles/esp32Profile"
}
```
## Paso 3: Configuración de autenticación de Amazon Cognito
**Crea una AWS IoT política**
1. Inicie sesión en la [consola de AWS IoT](https://console.aws.amazon.com/iot/).
1. En la esquina superior derecha de la consola, elija **Mi cuenta**. En **Configuración de la cuenta**, anote el ID de 12 dígitos de la cuenta.
1. En el panel de navegación izquierdo, elija **Configuración**. En **Punto de enlace de datos de dispositivo**, anote el valor del punto de conexión. El punto de conexión debería ser similar a `xxxxxxxxxxxxxx.iot.us-west-2.amazonaws.com`. En este ejemplo, la región de AWS es “us-west-2”.
1. En el panel de navegación izquierdo, elija **Seguridad**, **Políticas** y, a continuación, **Crear**. Si no tiene ninguna política en su cuenta, verá el mensaje “Aún no tiene ninguna política” y podrá elegir **Crear una política**.
1. Introduzca un nombre para la política, por ejemplo, “esp32\$1mqtt\$1proxy\$1iot\$1policy”.
1. En la sección **Añadir declaraciones**, elija **Modo avanzado**. Copie y pegue la siguiente política JSON en la ventana del editor de políticas. Sustituya `aws-account-id` por su ID de cuenta de `aws-region` y por su región (por ejemplo, “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. Seleccione **Crear**.
**Crea cualquier AWS IoT cosa**
1. Inicie sesión en la [consola de AWS IoT](https://console.aws.amazon.com/iot/).
1. En el panel de navegación de la izquierda, elija **Manage (Administrar)** y, a continuación, **Things (Objetos)**.
1. En la esquina superior derecha, elija **Crear**. Si no tiene ningún objeto registrado en su cuenta, aparecerá el mensaje “Aún no tiene ningún objeto” y podrá seleccionar **Registrar un objeto**.
1. En la página **Crear AWS IoT cosas**, selecciona **Crear una sola cosa**.
1. En la página **Añadir su dispositivo al registro de objetos**, escriba un nombre para el objeto (por ejemplo, “esp32-ble”). Se permiten caracteres alfanuméricos, guiones (-) y guiones bajos (\$1). Elija **Siguiente**.
1. En la página **Añadir un certificado para el objeto**, en **Omitir certificado y crear objeto**, elija **Crear un objeto sin certificado**. Como utilizamos la aplicación móvil proxy BLE que utiliza una credencial de Amazon Cognito para la autenticación y la autorización, no se requiere ningún certificado de dispositivo.
**Creación de un cliente de aplicación de Amazon Cognito**
1. Inicie sesión en la [consola de Amazon Cognito](https://console.aws.amazon.com/cognito/users/).
1. En el banner de navegación de la parte superior derecha, seleccione **Crear un grupo de usuarios**.
1. Introduzca el nombre del grupo (por ejemplo, “esp32\$1mqtt\$1proxy\$1user\$1pool”).
1. Elija **Revisar los valores predeterminados**.
1. En **Clientes de aplicación**, elija **Agregar cliente de aplicación** y, a continuación, elija **Agregar un cliente de aplicación**.
1. Introduzca un nombre de cliente de aplicación (por ejemplo, “mqtt\$1app\$1client”).
1. Asegúrese de que esté seleccionada la opción **Generar secreto de cliente**.
1. Elija **Create app client** (Crear cliente de aplicación).
1. Elija **Return to pool details** (Volver a los detalles del grupo).
1. En la página **Revisar** del grupo de usuarios, elija **Crear grupo**. Debería ver un mensaje que indica: “El grupo de usuarios se ha creado correctamente”. Anote el ID del grupo.
1. En el panel de navegación, elija **Clientes de aplicación**.
1. Elija **Mostrar detalles**. Anote el ID y el secreto del cliente de aplicación.
**Creación de un grupo de identidades en Amazon Cognito**
1. Inicie sesión en la [consola de Amazon Cognito](https://console.aws.amazon.com/cognito/federated).
1. Elija **Crear nuevo grupo de identidades**.
1. Introduzca un nombre para el grupo de identidades (por ejemplo, “mqtt\$1proxy\$1identity\$1pool”).
1. Amplíe **Proveedores de autenticación**.
1. Seleccione la pestaña **Cognito**.
1. Introduzca el ID del grupo de usuarios y el ID de cliente de la aplicación que anotó en los pasos anteriores.
1. Elija **Crear grupo**.
1. En la página siguiente, para crear roles nuevos para las identidades autenticadas y no autenticadas, elija **Permitir**.
1. Anote el ID del grupo de identidades, que tiene el formato `us-east-1:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`.
**Asociación de una política de IAM a la identidad autenticada**
1. Abra la [consola de Amazon Cognito](https://console.aws.amazon.com/cognito/federated).
1. Seleccione el grupo de identidades que acaba de crear (por ejemplo, “mqtt\$1proxy\$1identity\$1pool”).
1. Elija **Edit identity pool** (Editar grupo de identidades).
1. Anote el rol de IAM asignado al rol autenticado (por ejemplo, “Cognito\$1mqtt\$1proxy\$1identity\$1poolAuth\$1Role”).
1. Abra la [consola de IAM](https://console.aws.amazon.com/iam/home).
1. Seleccione **Roles** en el panel de navegación.
1. Busque el rol asignado (por ejemplo, “Cognito\$1mqtt\$1proxy\$1identity\$1poolAuth\$1Role”) y selecciónelo.
1. Elija **Añadir política en línea** y, a continuación, seleccione la pestaña **JSON**.
1. Escriba la siguiente política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:AttachPolicy",
"iot:AttachPrincipalPolicy",
"iot:Connect",
"iot:Publish",
"iot:Subscribe"
],
"Resource": "*"
}]
}
```
------
1. Elija **Revisar la política**.
1. Introduce el nombre de una política (por ejemplo, «mqttProxyCognitoPolítica»).
1. Elija **Crear política**.
## Paso 4: Configurar Amazon FreeRTOS
1. [Descargue la última versión del código de Amazon FreeRTOS del repositorio de FreeRTOS. GitHub ](https://github.com/aws/amazon-freertos)
1. Para activar la demostración de la actualización OTA, siga los pasos que se indican en [Cómo empezar con el Espressif ESP32 - DevKit C y el ESP-WROVER-KIT](getting_started_espressif.md).
1. Realice estas modificaciones adicionales en los siguientes archivos:
1. Abra `vendors/espressif/boards/esp32/aws_demos/config_files/aws_demo_config.h` y defina `CONFIG_OTA_UPDATE_DEMO_ENABLED`.
1. Abra `vendors/espressif/boards/esp32/aws_demos/common/config_files/aws_demo_config.h` y cambie `democonfigNETWORK_TYPES` a `AWSIOT_NETWORK_TYPE_BLE`.
1. Abra `demos/include/aws_clientcredential.h` e introduzca la URL de su punto de conexión para `clientcredentialMQTT_BROKER_ENDPOINT`.
Introduzca el nombre del objeto para `clientcredentialIOT_THING_NAME` (por ejemplo, “esp32-ble”). No es necesario añadir certificados cuando se utilizan las credenciales de Amazon Cognito.
1. Abra `vendors/espressif/boards/esp32/aws_demos/config_files/aws_iot_network_config.h` y cambie `configSUPPORTED_NETWORKS` y `configENABLED_NETWORKS` para que solo incluya `AWSIOT_NETWORK_TYPE_BLE`.
1. Abra el archivo `vendors/vendor/boards/board/aws_demos/config_files/ota_demo_config.h` e introduzca su certificado.
```
#define otapalconfigCODE_SIGNING_CERTIFICATE [] = "your-certificate-key";
```
La aplicación debería iniciarse e imprimir la versión de demostración:
```
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...
```
## Paso 5: Configurar una aplicación para Android
1. [Descargue el SDK Bluetooth Low Energy para Android y una aplicación de muestra del amazon-freertos-ble-android repositorio -sdk.](https://github.com/aws/amazon-freertos-ble-android-sdk) GitHub
1. Abre el archivo `app/src/main/res/raw/awsconfiguration.json` e introduce el ID del grupo AppClientId, la región y sigue las AppClientSecret instrucciones del siguiente ejemplo de JSON.
```
{
"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. Abra `app/src/main/java/software/amazon/freertos/DemoConstants.java` e introduzca el nombre de la política que creó anteriormente (por ejemplo,*esp32\$1mqtt\$1proxy\$1iot\$1policy*) y también la región (por ejemplo,*us-east-1*).
1. Cree e instale la aplicación de demostración.
1. En Android Studio, seleccione **Crear** y, luego, **Crear aplicación de módulo**.
1. Elija **Ejecutar** y, a continuación, **Ejecutar aplicación**. Puede ir al panel de la ventana de logcat en Android Studio para monitorear los mensajes de registro.
1. En el dispositivo Android, crea una cuenta desde la pantalla de inicio de sesión.
1. Crear un usuario. Si ya existe un usuario, introduzca las credenciales.
1. Permita que la demostración de Amazon FreeRTOS acceda a la ubicación del dispositivo.
1. Busque dispositivos Bluetooth de bajo consumo.
1. Mueva el control deslizante del dispositivo que se encuentra a **Activado**.
1. Pulse **y** en la consola de depuración del ESP32 puerto serie para.
1. Elija **Emparejar y conectar**.
1. El enlace **Más…** se activa una vez establecida la conexión. El estado de la conexión debería cambiar a “BLE\$1CONNECTED” en el logcat del dispositivo Android cuando se complete la conexión:
```
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. Antes de poder transmitir los mensajes, el dispositivo Amazon FreeRTOS y el dispositivo Android negocian la MTU. Debería ver la siguiente salida en logcat:
```
2019-06-06 20:11:46.720 23484-23497/software.amazon.freertos.demo I/FRD: onMTUChanged : 512 status: Success
```
1. El dispositivo se conecta a la aplicación y comienza a enviar mensajes MQTT mediante el proxy MQTT. Para confirmar que el dispositivo puede comunicarse, asegúrese de que el valor de los datos de característica de MQTT\$1CONTROL cambie a 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. Cuando los dispositivos estén emparejados, aparecerá un mensaje en la ESP32 consola. Para activar BLE, pulse **y**. La demostración no funcionará hasta que realice este paso.
```
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.
```
## Paso 6: Ejecutar el script de actualización OTA
1. Para instalar los requisitos previos, ejecute los siguientes comandos:
```
pip3 install boto3
```
```
pip3 install pathlib
```
1. Aumente la versión de la aplicación FreeRTOS en `demos/include/aws_application_version.h`.
1. Cree un nuevo archivo .bin.
1. Descargue el script de python [ start\$1ota.py](https://github.com/aws-samples/amazon-freertos-ota-scripts/blob/master/scripts/start_ota.py). Para ver el contenido de ayuda del script, ejecute el siguiente comando en una ventana del terminal:
```
python3 start_ota.py -h
```
Debería ver algo parecido a lo siguiente:
```
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 usó la CloudFormation plantilla proporcionada para crear recursos, ejecute el siguiente comando:
```
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
```
Deberías ver el inicio de la actualización en la consola de ESP32 depuración:
```
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. Cuando finalice la actualización OTA, el dispositivo se reiniciará según lo requiera el proceso de actualización OTA. A continuación, intenta conectarse mediante el firmware actualizado. Si la actualización se ha realizado correctamente, el firmware actualizado se marca como activo y debería ver la versión actualizada en la consola:
```
13 13498 [iot_thread] OTA demo version 0.9.21
```