ESP32 - AWS IoT
Este tutorial ensina como usar o ESP32 com o AWS IoT Core. Em detalhes, vamos aprender:
- Como conectar o ESP32 ao AWS IoT Core.
- Como programar o ESP32 para enviar dados ao AWS IoT Core.
- Como programar o ESP32 para receber dados do AWS IoT Core.
Hardware Necessário
Or you can buy the following kits:
| 1 | × | DIYables ESP32 Starter Kit (ESP32 included) | |
| 1 | × | DIYables ESP32 S3 Starter Kit (ESP32 S3 included) | |
| 1 | × | DIYables Sensor Kit (18 sensors/displays) |
Divulgação: Alguns dos links desta seção são links de afiliado da Amazon. Podemos receber uma comissão pelas compras feitas por meio desses links, sem custo adicional para você. Agradecemos o seu apoio.
Sobre o ESP32 e o AWS IoT
O ESP32 se conecta ao AWS IoT Core usando o protocolo MQTT. Embora existam bibliotecas para facilitar essa conexão, não é tão simples quanto conectar a um broker MQTT local como o Mosquitto no seu PC. Isso acontece porque o AWS IoT Core tem medidas de segurança rigorosas, exigindo etapas de configuração para obter credenciais de autenticação e autorização antes de integrá-las ao código do ESP32. Em resumo, o processo envolve duas etapas principais:
- Etapa 1: Configurar o AWS IoT Core - Isso envolve configurar o AWS IoT Core para gerar as credenciais de autenticação necessárias, que serão usadas depois no código do ESP32.
- Etapa 2: Escrever o Código do ESP32 - Depois de obter as credenciais de autenticação do AWS IoT Core, o próximo passo é escrever o código do ESP32, integrando os protocolos de autenticação e comunicação necessários.
Vamos olhar cada etapa mais de perto para entendê-la melhor.
Configurando o AWS IoT Core para usar com o ESP32
Os objetivos desta etapa incluem:
- Criar uma representação do dispositivo ESP32 no AWS IoT Core, chamada de "Thing".
- Configurar a autorização necessária para permitir que o dispositivo ESP32 se conecte, publique e assine tópicos do/no AWS IoT Core, conhecida como "Policy".
- Gerar as credenciais da AWS necessárias para a autenticação, conhecidas como "Certificates". Essas credenciais serão baixadas e integradas ao código Arduino do ESP32.
Abaixo estão as instruções para configurar o AWS IoT Core para uso com o ESP32 pelo AWS IoT Console. Observe que, embora a Interface do Usuário possa mudar com o tempo, o processo deve continuar parecido com as instruções abaixo:
- Entre no AWS IoT Console
- Crie uma Thing indo em Manage All devices Things
- Clique no botão Create things.
- Selecione Create single things e clique no botão Next.
- Especifique o Thing name, por exemplo, ESP32-thing e clique no botão Next no final da página.
- Gere as credenciais selecionando a opção Auto-generate a new certificate e clique no botão Next.
- Agora, um Certificate é criado e vinculado à Thing.
- Crie uma policy clicando no botão Create policy.
- Uma nova aba será aberta
- Especifique o Policy name, por exemplo, ESP32-policy e clique no botão JSON.
- Copie o conteúdo da policy JSON abaixo e cole na área Policy document:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "*",
"Resource": "*"
}
]
}
- Clique no botão Create no final da página para criar a policy.
- Agora, uma Policy é criada e anexada ao Certificate. Feche essa página e volte para a página da Thing.
- Marque a ESP32-policy e clique no botão Create thing para criar a Thing.
- Uma janela popup aparece permitindo que você baixe os arquivos de credenciais. Baixe todos os arquivos, guarde-os em um local seguro no seu PC e mantenha-os em sigilo.
- Depois, clique no botão Done.
Entre os arquivos baixados, três serão usados no código do ESP32 nas próximas etapas:
- AmazonRootCA1.pem
- xxxxxxxxxx-certificate.pem.crt
- xxxxxxxxxx-private.pem.key
Esses arquivos podem ser abertos por qualquer editor de texto, como o Bloco de Notas ou o Notepad++
Escrevendo o código do ESP32 para conectar ao AWS IoT Core
/*
* Este código de ESP32 foi desenvolvido por pt.newbiely.com
* Este código de ESP32 é disponibilizado ao público sem nenhuma restrição.
* Para tutoriais completos e diagramas de ligação, visite:
* https://pt.newbiely.com/tutorials/esp32/esp32-aws-iot
*/
#include "secrets.h"
#include <WiFiClientSecure.h>
#include <MQTTClient.h>
#include <ArduinoJson.h>
#include "WiFi.h"
// The MQTT topics that this device should publish/subscribe
#define AWS_IOT_PUBLISH_TOPIC "esp32/esp32-to-aws"
#define AWS_IOT_SUBSCRIBE_TOPIC "esp32/aws-to-esp32"
#define PUBLISH_INTERVAL 4000 // 4 seconds
WiFiClientSecure net = WiFiClientSecure();
MQTTClient client = MQTTClient(256);
unsigned long lastPublishTime = 0;
void setup() {
Serial.begin(9600);
// set the ADC attenuation to 11 dB (up to ~3.3V input)
analogSetAttenuation(ADC_11db);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
Serial.println("ESP32 connecting to Wi-Fi");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
connectToAWS();
}
void loop() {
client.loop();
if (millis() - lastPublishTime > PUBLISH_INTERVAL) {
sendToAWS();
lastPublishTime = millis();
}
}
void connectToAWS() {
// Configure WiFiClientSecure to use the AWS IoT device credentials
net.setCACert(AWS_CERT_CA);
net.setCertificate(AWS_CERT_CRT);
net.setPrivateKey(AWS_CERT_PRIVATE);
// Connect to the MQTT broker on the AWS endpoint we defined earlier
client.begin(AWS_IOT_ENDPOINT, 8883, net);
// Create a handler for incoming messages
client.onMessage(messageHandler);
Serial.print("ESP32 connecting to AWS IOT");
while (!client.connect(THINGNAME)) {
Serial.print(".");
delay(100);
}
Serial.println();
if (!client.connected()) {
Serial.println("ESP32 - AWS IoT Timeout!");
return;
}
// Subscribe to a topic, the incoming messages are processed by messageHandler() function
client.subscribe(AWS_IOT_SUBSCRIBE_TOPIC);
Serial.println("ESP32 - AWS IoT Connected!");
}
void sendToAWS() {
StaticJsonDocument<200> message;
message["timestamp"] = millis();
message["data"] = analogRead(0); // Or you can read data from other sensors
char messageBuffer[512];
serializeJson(message, messageBuffer); // print to client
client.publish(AWS_IOT_PUBLISH_TOPIC, messageBuffer);
Serial.println("sent:");
Serial.print("- topic: ");
Serial.println(AWS_IOT_PUBLISH_TOPIC);
Serial.print("- payload:");
Serial.println(messageBuffer);
}
void messageHandler(String &topic, String &payload) {
Serial.println("received:");
Serial.println("- topic: " + topic);
Serial.println("- payload:");
Serial.println(payload);
// You can process the incoming data as json object, then control something
/*
StaticJsonDocument<200> doc;
deserializeJson(doc, payload);
const char* message = doc["message"];
*/
}
Passos Rápidos
- Se esta é a primeira vez que você usa o ESP32, veja como configurar o ambiente do ESP32 no Arduino IDE.
- Abra o Library Manager clicando no ícone Library Manager na barra de navegação à esquerda do Arduino IDE
- Digite MQTT na caixa de pesquisa e procure a biblioteca MQTT de Joel Gaehwiler.
- Clique no botão Install para instalar a biblioteca MQTT.
- Digite ArduinoJson na caixa de pesquisa e procure a biblioteca ArduinoJson de Benoit Blanchon.
- Clique no botão Install para instalar a biblioteca ArduinoJson.
- Copie o código acima e cole no Arduino IDE.
- Crie o arquivo secrets.h no Arduino IDE assim:
- Clique no botão logo abaixo do ícone do serial monitor e escolha New Tab, ou use as teclas Ctrl+Shift+N.
- Dê o nome secrets.h ao arquivo e clique no botão OK
- Copie o código abaixo e cole no arquivo secrets.h criado.
- Atualize as seguintes informações no secrets.h
- O WIFI_SSID e o WIFI_PASSWORD da sua rede WiFi
- O AWS_CERT_CA, o AWS_CERT_CRT e o AWS_CERT_PRIVATE. Essas informações estão nos arquivos que você baixou na etapa anterior.
- O AWS_IOT_ENDPOINT. Essa informação pode ser encontrada no AWS IoT Console indo em Setting, como na imagem abaixo:
- Compile e carregue o código na placa ESP32 clicando no botão Upload no Arduino IDE
#include <pgmspace.h>
#define SECRET
#define THINGNAME "ESP32-thing"
const char WIFI_SSID[] = "";
const char WIFI_PASSWORD[] = "";
const char AWS_IOT_ENDPOINT[] = "xxxxx.amazonaws.com";
// Amazon Root CA 1
static const char AWS_CERT_CA[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
-----END CERTIFICATE-----
)EOF";
// Device Certificate
static const char AWS_CERT_CRT[] PROGMEM = R"KEY(
-----BEGIN CERTIFICATE-----
-----END CERTIFICATE-----
)KEY";
// Device Private Key
static const char AWS_CERT_PRIVATE[] PROGMEM = R"KEY(
-----BEGIN RSA PRIVATE KEY-----
-----END RSA PRIVATE KEY-----
)KEY";
Enviando dados do ESP32 para o AWS IoT
O código ESP32 acima lê periodicamente dados de um pino analógico e os envia ao AWS IoT a cada 4 segundos. Se você abrir o Serial Monitor no Arduino IDE, vai ver o log como abaixo:
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32 Dev Module' on 'COM15')
New Line
9600 baud
ESP32 connecting to AWS IOT.
ESP32 - AWS IoT Connected!
sent:
- topic: esp32/esp32-to-aws
- payload:{"timestamp":12743,"data":0}
sent:
- topic: esp32/esp32-to-aws
- payload:{"timestamp":16745,"data":130}
Para verificar se os dados foram recebidos pelo AWS IoT ou não, siga estes passos:
- No AWS IoT Console, vá em Test MQTT Test Client
- Clique no botão Subcribe to a topic.
- Digite esp32/esp32-to-aws no Topic filter. Você pode mudar o tópico, mas ele DEVE corresponder ao tópico do código do ESP32.
- Clique no botão Subcribe.
- Você vai poder ver os dados enviados pelo ESP32 no AWS IoT Console.
Enviando dados do AWS IoT para o ESP32
Você pode enviar dados do AWS IoT Console para o ESP32 seguindo estes passos:
- No Arduino IDE, abra o Serial Monitor
- No AWS IoT Console, vá em Test MQTT Test Client
- Clique no botão Publish to a topic.
- Digite esp32/aws-to-esp32 no Topic name. Você pode mudar o tópico, mas ele DEVE corresponder ao tópico do código do ESP32.
- Opcionalmente, você pode mudar o payload da mensagem, ou apenas mantê-lo como padrão.
- Clique no botão Publish.
- Confira o Serial Monitor no Arduino IDE, você vai ver a mensagem enviada pelo AWS IoT Console.
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32 Dev Module' on 'COM15')
New Line
9600 baud
received:
- topic: esp32/aws-to-esp32
- payload:
{
"message": "Hello from AWS IoT console"
}
Faça mais com a AWS
Agora, você pode estabelecer comunicação bidirecional entre o ESP32 e o AWS IoT Core. Isso significa que você pode enviar dados do ESP32 para o AWS IoT Core e receber dados do AWS IoT Core no ESP32. Além disso, você pode configurar IoTRules, permitindo que o ESP32 se conecte sem problemas a outros serviços da AWS, como Lambda, DynamoDB, Amplify e RDS. Com as IoTRules, você pode automatizar ações com base nos dados recebidos do ESP32, possibilitando uma ampla gama de aplicações e integrações IoT.