As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Tutorial: Execute atualizações OTA no Espressif usando ESP32 FreeRTOS Bluetooth Low Energy
**Importante**
Essa integração de referência está hospedada no repositório Amazon-FreeRTOS, que está preterido. Recomendamos [começar aqui](freertos-getting-started-modular.md) ao criar um novo projeto. Se você já tem um projeto FreeRTOS existente baseado no repositório Amazon-FreeRTOS que está preterido, consulte o [Guia de migração do repositório Github do Amazon FreeRTOS](github-repo-migration.md).
Este tutorial mostra como atualizar um ESP32 microcontrolador Espressif conectado a um proxy MQTT Bluetooth Low Energy em um dispositivo Android. Ele atualiza o dispositivo usando trabalhos de atualização AWS IoT Over-the-air (OTA). O dispositivo se conecta AWS IoT usando as credenciais do Amazon Cognito inseridas no aplicativo de demonstração do Android. Um operador autorizado inicia a atualização OTA a partir da nuvem. Quando o dispositivo se conecta por meio da aplicação de demonstração do Android, a atualização OTA é iniciada e o firmware é atualizado no dispositivo.
As versões principais e posteriores do FreeRTOS 2019.06.00 incluem suporte a proxy Bluetooth Low Energy MQTT que pode ser usado para provisionamento de Wi-Fi e conexões seguras a serviços. AWS IoT Ao usar o recurso Bluetooth Low Energy, você pode criar dispositivos de baixo consumo de energia que podem ser emparelhados com um dispositivo móvel para conectividade sem precisar de Wi-Fi. Os dispositivos podem se comunicar usando o MQTT conectando-se por meio de Bluetooth Low Energy para Android ou iOS SDKs que usam perfis genéricos de acesso (GAP) e atributos genéricos (GATT).
Confira as etapas que seguiremos para permitir atualizações OTA via Bluetooth Low Energy:
1. **Configurar o armazenamento:** crie um bucket e políticas do Amazon S3 e configure um usuário que possa realizar atualizações.
1. **Criar um certificado de assinatura de código:** crie um certificado de assinatura e permita que o usuário assine atualizações de firmware.
1. **Configurar a autenticação do Amazon Cognito:** crie um provedor de credenciais, um grupo de usuários e acesso de aplicações ao grupo de usuários.
1. **Configurar o FreeRTOS**: configure o Bluetooth Low Energy, as credenciais do cliente e o certificado público de assinatura de código.
1. **Configurar uma aplicação Android:** configure o provedor de credenciais, o grupo de usuários e implante a aplicação em um dispositivo Android.
1. **Executar o script de atualização OTA:** para iniciar uma atualização OTA, use o script de atualização OTA.
Para obter mais informações sobre como as atualizações funcionam, consulte [Atualizações do FreeRTOS Over-the-Air](freertos-ota-dev.md). Para obter informações adicionais sobre como configurar a funcionalidade de proxy MQTT Bluetooth Low Energy, consulte o post [Usando Bluetooth Low Energy com FreeRTOS no ESP32 Espressif, de Richard](https://aws.amazon.com/blogs/iot/using-bluetooth-low-energy-with-amazon-freertos-on-espressif-esp32/) Kang.
## Pré-requisitos
Para executar as etapas neste tutorial, você precisa dos seguintes recursos:
+ Uma placa ESP32 de desenvolvimento.
+ Um cabo microUSB para USB A.
+ Uma AWS conta (o nível gratuito é suficiente).
+ Um telefone Android com Android v 6.0 ou posterior e Bluetooth versão 4.2 ou posterior.
No seu computador de desenvolvimento, você precisa:
+ Espaço em disco suficiente (\$1 500 Mb) para a cadeia de ferramentas Xtensa e o código-fonte e exemplos do FreeRTOS.
+ Android Studio instalado.
+ A [AWS CLI](https://aws.amazon.com/cli/) instalada.
+ Python3 instalado.
+ O [kit de desenvolvimento de AWS software (SDK) boto3 para Python](https://github.com/boto/boto3).
As etapas deste tutorial consideram que a cadeia de ferramentas Xtensa, o ESP-IDF e o código FreeRTOS estão instalados no diretório inicial `/esp`. Você deve adicionar `~/esp/xtensa-esp32-elf/bin` à sua variável `$PATH`.
## Etapa 1: configurar o armazenamento
1. [Criação de um bucket do Amazon S3 para armazenar a atualização](dg-ota-bucket.md) com o versionamento ativado para armazenar as imagens do firmware.
1. [Criação de uma função de serviço de atualização de OTA](create-service-role.md) e adicione as políticas gerenciadas a seguir ao perfil:
+ AWSIotRegistro
+ AWSIotRuleActions
+ AWSIotThingsRegistration
+ AWSFreeRTOSOTAUpdate
1. [Criar um usuário](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html) que possa realizar atualizações OTA. Esse usuário pode assinar e implantar atualizações de firmware em dispositivos IoT na conta e tem acesso para fazer atualizações OTA em todos os dispositivos. O acesso deve ser limitado a entidades confiáveis.
1. Siga as etapas em [Criação de uma política de usuário de OTA](create-ota-user-policy.md) e anexe-o ao seu usuário.
## Etapa 2: criar o certificado de assinatura de código
1. Crie um bucket do Amazon S3 com o versionamento habilitado para armazenar as imagens de firmware.
1. Crie um certificado de assinatura de código que possa ser usado para assinar o firmware. Observe o nome do recurso da Amazon (ARN) do certificado quando o certificado for importado.
```
aws acm import-certificate --profile=ota-update-user --certificate file://ecdsasigner.crt --private-key file://ecdsasigner.key
```
Resultado do exemplo:
```
{
"CertificateArn": "arn:aws:acm:us-east-1::certificate/"
}
```
Você usará o ARN mais tarde para criar um perfil de assinatura. Se desejar, você pode criar o perfil agora com o seguinte 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
```
Resultado do exemplo:
```
{
"arn": "arn:aws:signer:::/signing-profiles/esp32Profile"
}
```
## Etapa 3: configuração da autenticação do Amazon Cognito
**Crie uma AWS IoT política**
1. Faça login no [console do AWS IoT](https://console.aws.amazon.com/iot/).
1. No canto superior direito do console, escolha **Minha conta**. Em **Configurações da conta**, anote o ID de conta de 12 dígitos.
1. No painel de navegação à esquerda, escolha **Configurações**. Em **Endpoint de dados do dispositivo**, anote o valor do endpoint. O endpoint deve ser algo com `xxxxxxxxxxxxxx.iot.us-west-2.amazonaws.com`. Neste exemplo, a região da AWS é definida como "us-west-2".
1. No painel de navegação, escolha **Segurança**, **Políticas** e **Criar**. Se você não tiver nenhuma política em sua conta, verá a mensagem "Você ainda não tem nenhuma política" e poderá escolher **Criar uma política**.
1. Insira um nome para a sua política, por exemplo, "esp32\$1mqtt\$1proxy\$1iot\$1policy".
1. Na seção **Add statements (Adicionar instruções)**, escolha **Advanced mode (Modo avançado)**. Copie e cole o seguinte JSON na janela do editor de política. Substitua `aws-account-id` pelo ID da sua conta e `aws-region` pela sua região (por exemplo, "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. Escolha **Criar**.
**Crie qualquer AWS IoT coisa**
1. Faça login no [console do AWS IoT](https://console.aws.amazon.com/iot/).
1. No painel de navegação à esquerda, escolha **Manage (Gerenciar)** e, depois, **Things (Coisas)**.
1. No canto superior direito, escolha **Criar**. Se você não tiver coisas registradas em sua conta, a mensagem "Você ainda não tem coisas registradas" é exibida e você poderá escolher **Registrar uma coisa**.
1. Na página **Criando AWS IoT coisas**, escolha **Criar uma única coisa**.
1. Na página **Adicionar o dispositivo ao registro de coisa**, insira um nome para a coisa (por exemplo, "esp32-ble"). São permitidos somente caracteres alfanuméricos, hífen (-) e sublinhados (\$1). Escolha **Próximo**.
1. Na página **Adicionar um certificado para a coisa**, em **Ignorar certificado e criar coisa**, escolha **Criar uma coisa sem certificado**. Como usamos a aplicação móvel proxy BLE que usa uma credencial do Amazon Cognito para autenticação e autorização, certificado de dispositivo é necessário.
**Criação de um cliente de aplicação do Amazon Cognito**
1. Faça login no [console do Amazon Cognito](https://console.aws.amazon.com/cognito/users/).
1. No banner de navegação superior direito, escolha **Criar um grupo de usuários**.
1. Insira o nome do grupo (por exemplo, "esp32\$1mqtt\$1proxy\$1user\$1pool").
1. Escolha **Revisar padrões**.
1. Em **Clientes de aplicação**, escolha **Adicionar cliente de aplicação** e, em seguida, escolha **Adicionar um cliente de aplicação**.
1. Insira um nome de cliente de aplicação (por exemplo, "mqtt\$1app\$1client").
1. Verifique se a opção **Gerar segredo do cliente** está selecionada.
1. Escolha **Criar cliente da aplicação**.
1. Escolha **Return to pool details** (Retornar aos detalhes do grupo).
1. Na página **Revisar** do grupo de usuários, selecione **Criar grupo**. Você receberá uma mensagem dizendo: "O grupo de usuários foi criado com êxito". Anote o ID do grupo.
1. No painel de navegação à esquerda, escolha **Clientes de aplicação**.
1. Escolha **Mostrar detalhes**. Anote o ID e o segredo do cliente de aplicação.
**Como criar um banco de identidades do Amazon Cognito**
1. Faça login no [console do Amazon Cognito](https://console.aws.amazon.com/cognito/federated).
1. Escolha **Criar novo banco de identidades**.
1. Insira um nome para o banco de identidades (por exemplo, "mqtt\$1proxy\$1identity\$1pool").
1. Expanda os **Provedores de autenticação**.
1. Escolha a guia **Cognito**.
1. Insira o ID do grupo de usuários e do cliente de aplicação que você anotou nas etapas anteriores.
1. Selecione **Criar grupo**.
1. Na próxima página, para criar os perfis para identidades autenticadas e não autenticadas , escolha **Permitir**.
1. Anote o ID do banco de identidades, que está no formato `us-east-1:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`.
**Anexar uma política do IAM à identidade autenticada**
1. Abra o [console do Amazon Cognito](https://console.aws.amazon.com/cognito/federated).
1. Selecione o banco de identidades que você acabou de criar (por exemplo, "mqtt\$1proxy\$1identity\$1pool").
1. Escolha **Edit identity pool** (Editar grupo de identidades).
1. Anote o perfil do IAM atribuído ao perfil autenticada (por exemplo, "Cognito\$1MQTT\$1Proxy\$1Identity\$1PoolAuth\$1Role").
1. Abra o [console do IAM](https://console.aws.amazon.com/iam/home).
1. No painel de navegação, escolha **Perfis**.
1. Pesquise o perfil atribuído (por exemplo, "Cognito\$1MQTT\$1Proxy\$1Identity\$1PoolAuth\$1Role") e selecione-o.
1. Escolha **Adicionar política em linha** e, em seguida, **JSON**.
1. Insira a seguinte política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:AttachPolicy",
"iot:AttachPrincipalPolicy",
"iot:Connect",
"iot:Publish",
"iot:Subscribe"
],
"Resource": "*"
}]
}
```
------
1. Escolha **Revisar política**.
1. Insira um nome de política (por exemplo, "mqttProxyCognitoPolítica”).
1. Selecione **Criar política**.
## Etapa 4: configurar o Amazon FreeRTOS
1. [Baixe a versão mais recente do código do Amazon FreeRTOS no repositório do FreeRTOS. GitHub ](https://github.com/aws/amazon-freertos)
1. Para habilitar a demonstração da atualização OTA, siga as etapas em [Começando com o Espressif ESP32 - DevKit C e o ESP-WROVER-KIT](getting_started_espressif.md).
1. Faça essas modificações adicionais nos seguintes arquivos:
1. Abra `vendors/espressif/boards/esp32/aws_demos/config_files/aws_demo_config.h` e defina `CONFIG_OTA_UPDATE_DEMO_ENABLED`.
1. Abra `vendors/espressif/boards/esp32/aws_demos/common/config_files/aws_demo_config.h` e mude `democonfigNETWORK_TYPES` para `AWSIOT_NETWORK_TYPE_BLE`.
1. Abra `demos/include/aws_clientcredential.h` e insira o URL do endpoint para `clientcredentialMQTT_BROKER_ENDPOINT`.
Insira o nome do item para `clientcredentialIOT_THING_NAME` (por exemplo, "esp32-ble"). Os certificados não precisam ser adicionados quando você usa as credenciais do Amazon Cognito.
1. Abra `vendors/espressif/boards/esp32/aws_demos/config_files/aws_iot_network_config.h`, altere `configSUPPORTED_NETWORKS` e `configENABLED_NETWORKS` para incluir somente `AWSIOT_NETWORK_TYPE_BLE`.
1. Abra o arquivo `vendors/vendor/boards/board/aws_demos/config_files/ota_demo_config.h` e insira seu certificado.
```
#define otapalconfigCODE_SIGNING_CERTIFICATE [] = "your-certificate-key";
```
A aplicação deve iniciar e imprimir a versão de demonstração:
```
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...
```
## Etapa 5: configurar uma aplicação para Android
1. Baixe o SDK Bluetooth Low Energy para Android e um aplicativo de amostra do repositório [amazon-freertos-ble-android GitHub -sdk](https://github.com/aws/amazon-freertos-ble-android-sdk).
1. Abra o arquivo `app/src/main/res/raw/awsconfiguration.json` e preencha o ID do pool, a região e AppClientSecret use as instruções no exemplo de JSON a seguir. 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. Abra `app/src/main/java/software/amazon/freertos/DemoConstants.java` e insira o nome da política que você criou anteriormente (por exemplo,*esp32\$1mqtt\$1proxy\$1iot\$1policy*) e também a Região (por exemplo,*us-east-1*).
1. Compilar e instalar a aplicação de demonstração.
1. No Android Studio, escolha **Compilar** e, em seguida, **aplicação Make Module**.
1. Selecione **Executar** > **Executar aplicação**. Você pode acessar o painel da janela do Logcat no Android Studio para monitorar as mensagens de log.
1. No dispositivo Android, crie uma conta na tela de login.
1. Criar um usuário. Se já existe um usuário, insira as credenciais.
1. Permita que a demonstração do Amazon FreeRTOS acesse a localização do dispositivo.
1. Verificar dispositivos Bluetooth Low Energy.
1. Mova o controle deslizante do dispositivo encontrado para **Ativado.**
1. Pressione **y** no console de depuração da porta serial para o. ESP32
1. Escolha **Emparelhar e conectar**.
1. O link **Mais...** ficará ativo depois que a conexão for estabelecida. O estado da conexão deverá mudar para "BLE\$1CONNECTED" no logcat do dispositivo Android quando a conexão for concluída:
```
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 que as mensagens possam ser transmitidas, o dispositivo Amazon FreeRTOS e o dispositivo Android negociam a MTU. A seguinte saída deverá ser mostrada no logcat:
```
2019-06-06 20:11:46.720 23484-23497/software.amazon.freertos.demo I/FRD: onMTUChanged : 512 status: Success
```
1. O dispositivo se conecta à aplicação e começa a enviar mensagens MQTT usando o proxy MQTT. Para confirmar se o dispositivo pode se comunicar, verifique se o valor dos dados característicos do MQTT\$1CONTROL mudam para 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. Quando os dispositivos estiverem emparelhados, você verá um aviso no ESP32 console. Para ativar o BLE, pressione **S**. A demonstração não funcionará até que você realize essa etapa.
```
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.
```
## Etapa 6: executar o script de atualização OTA
1. Para instalar os pré-requisitos, execute os seguintes comandos:
```
pip3 install boto3
```
```
pip3 install pathlib
```
1. Incremente a versão da aplicação FreeRTOS em `demos/include/aws_application_version.h`.
1. Compile um arquivo.bin novo.
1. Baixe o script python [ start\$1ota.py](https://github.com/aws-samples/amazon-freertos-ota-scripts/blob/master/scripts/start_ota.py). Para visualizar o conteúdo da ajuda do script, execute o seguinte comando em uma janela de terminal:
```
python3 start_ota.py -h
```
Você deve ver algo parecido com o exemplo a seguir:
```
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. Se você usou o CloudFormation modelo fornecido para criar recursos, execute o seguinte 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
```
Você deve ver o início da atualização no console de ESP32 depuração:
```
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. Quando a atualização do OTA for concluída, o dispositivo será reiniciado conforme exigido pelo processo de atualização OTA. Em seguida, ele tenta se conectar usando o firmware atualizado. Se a atualização for bem-sucedida, o firmware atualizado será marcado como ativo e você deverá ver a versão atualizada no console:
```
13 13498 [iot_thread] OTA demo version 0.9.21
```