ESP8266 - AWS IoT
Este tutorial ensina você a usar o ESP8266 com o AWS IoT Core. Especificamente, vamos abordar os seguintes tópicos em detalhes:
- Estabelecer a conexão entre o ESP8266 e o AWS IoT Core.
- Programar o ESP8266 para transmitir dados ao AWS IoT Core.
- Programar o ESP8266 para receber dados do AWS IoT Core.
Seguindo estes passos, você terá uma compreensão completa de como integrar o ESP8266 ao AWS IoT Core para uma comunicação sem falhas.
Hardware Necessário
Or you can buy the following kits:
| 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 ESP8266 e o AWS IoT
O ESP8266 estabelece uma conexão com o AWS IoT Core por meio do protocolo MQTT. Embora existam bibliotecas que simplificam essa conexão, ela é mais complexa do que conectar a um broker MQTT local, como o Mosquitto no seu PC. Essa complexidade surge das rigorosas medidas de segurança do AWS IoT Core, que exigem etapas de configuração para obter as credenciais de autenticação e a autorização a serem integradas ao código do ESP8266. Em essência, o processo envolve dois passos principais:
- Configurar o AWS IoT Core: Este passo configura o AWS IoT Core para gerar as credenciais de autenticação necessárias, que depois serão incorporadas ao código do ESP8266.
- Escrever o Código do ESP8266: Depois de obter as credenciais de autenticação do AWS IoT Core, o passo seguinte é escrever o código do ESP8266. Esse código integra os protocolos essenciais de autenticação e comunicação necessários para uma interação sem falhas com o AWS IoT Core.
Vamos analisar cada passo de perto para entendê-lo melhor.
Configurando o AWS IoT Core para uso com o ESP8266
Os objetivos deste passo incluem:
- Criar uma representação do dispositivo ESP8266 no AWS IoT Core, chamada de "Thing."
- Configurar a autorização necessária para permitir que o dispositivo ESP8266 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 ESP8266.
Abaixo estão as instruções para configurar o AWS IoT Core para uso com o ESP8266 por meio do AWS IoT Console. Observe que, embora a Interface do Usuário possa mudar com o tempo, o processo deve continuar semelhante às instruções fornecidas abaixo:
- Faça login 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, ESP8266-thing e clique no botão Next na parte inferior 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, ESP8266-policy e clique no botão JSON.
- Copie o conteúdo da policy JSON abaixo e cole-o na área Policy document:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "*",
"Resource": "*"
}
]
}
- Clique no botão Create na parte inferior 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 ESP8266-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 e guarde-os em um local seguro no seu PC, mantendo-os em sigilo.
- Em seguida, clique no botão Done.
Entre os arquivos baixados, há três arquivos que serão usados no código do ESP8266 nos próximos passos:
- 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 ESP8266 para se conectar ao AWS IoT Core
/*
* Este código de ESP8266 NodeMCU foi desenvolvido por pt.newbiely.com
* Este código de ESP8266 NodeMCU é disponibilizado ao público sem nenhuma restrição.
* Para tutoriais completos e diagramas de ligação, visite:
* https://pt.newbiely.com/tutorials/esp8266/esp8266-aws-iot
*/
#include "secrets.h"
#include <ESP8266WiFi.h>
#include <MQTTClient.h>
#include <ArduinoJson.h>
// The MQTT topics that this device should publish/subscribe
#define AWS_IOT_PUBLISH_TOPIC "esp8266/esp8266-to-aws"
#define AWS_IOT_SUBSCRIBE_TOPIC "esp8266/aws-to-esp8266"
#define PUBLISH_INTERVAL 5000 // 5 seconds
BearSSL::WiFiClientSecure network;
MQTTClient client = MQTTClient(256);
unsigned long lastPublishTime = 0;
void setup() {
Serial.begin(9600);
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
Serial.println("Connecting");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("Connected to WiFi network with IP Address: ");
Serial.println(WiFi.localIP());
setClock();
connectToAWS();
}
void loop() {
client.loop();
if (millis() - lastPublishTime > PUBLISH_INTERVAL) {
sendToAWS();
lastPublishTime = millis();
}
}
// Set time via NTP, as required for x.509 validation
void setClock() {
configTime(3 * 3600, 0, "pool.ntp.org", "time.nist.gov");
Serial.print("Waiting for NTP time sync: ");
time_t now = time(nullptr);
while (now < 8 * 3600 * 2) {
delay(500);
Serial.print(".");
now = time(nullptr);
}
Serial.println("");
struct tm timeinfo;
gmtime_r(&now, &timeinfo);
Serial.print("Current time: ");
Serial.print(asctime(&timeinfo));
}
void connectToAWS() {
// Configure the AWS IoT device credentials
network.setTrustAnchors(new BearSSL::X509List(AWS_CERT_CA));
network.setClientRSACert(new BearSSL::X509List(AWS_CERT_CRT), new BearSSL::PrivateKey(AWS_CERT_PRIVATE));
// Connect to the MQTT broker on the AWS endpoint we defined earlier
client.begin(AWS_IOT_ENDPOINT, 8883, network);
// Create a handler for incoming messages
client.onMessage(messageHandler);
Serial.print("ESP8266 connecting to AWS IOT");
while (!client.connect(THINGNAME)) {
Serial.print(".");
delay(100);
}
Serial.println();
if (!client.connected()) {
Serial.println("ESP8266 - AWS IoT Timeout!");
return;
}
// Subscribe to a topic, the incoming messages are processed by messageHandler() function
client.subscribe(AWS_IOT_SUBSCRIBE_TOPIC);
Serial.println("ESP8266 - 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
Para começar com o ESP8266 no Arduino IDE, siga estes passos:
- Confira o tutorial como configurar o ambiente para o ESP8266 no Arduino IDE se for a primeira vez que você usa o ESP8266.
- Conecte a placa ESP8266 ao seu computador usando um cabo USB.
- Abra o Arduino IDE no seu computador.
- Escolha a placa ESP8266 correta, como (por exemplo, NodeMCU 1.0 (ESP-12E Module)), e a respectiva porta COM.
- 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-o no Arduino IDE.
- Crie o arquivo secrets.h no Arduino IDE:
- Clique no botão logo abaixo do ícone do Serial Monitor e escolha New Tab, ou use as teclas Ctrl+Shift+N.
- Dê ao arquivo o nome secrets.h e clique no botão OK
- Copie o código abaixo e cole-o 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 no passo anterior.
- O AWS_IOT_ENDPOINT. Essa informação pode ser encontrada no AWS IoT Console, indo em Setting, como na imagem abaixo:
- Compile e faça o upload do código para a placa ESP8266 clicando no botão Upload no Arduino IDE
#include <pgmspace.h>
#define SECRET
#define THINGNAME "ESP8266-thing"
const char WIFI_SSID[] = ""; // CHANGE IT TO MATCH YOUR OWN NETWORK CREDENTIALS
const char WIFI_PASSWORD[] = ""; // CHANGE IT TO MATCH YOUR OWN NETWORK CREDENTIALS
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 ESP8266 para o AWS IoT
O código do ESP8266 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, verá o log como abaixo:
8
Serial.println("Hello World!");
Message (Enter to send message to 'Nodemcu 1.0 (ESP-12E Module)' on 'COM15')
New Line
9600 baud
ESP8266 connecting to AWS IOT.
ESP8266 - AWS IoT Connected!
sent:
- topic: esp8266/esp8266-to-aws
- payload:{"timestamp":12743,"data":0}
sent:
- topic: esp8266/esp8266-to-aws
- payload:{"timestamp":16745,"data":130}
Para verificar se os dados foram recebidos pelo AWS IoT, siga estes passos:
- No AWS IoT Console, navegue até Test MQTT Test Client
- Clique no botão Subcribe to a topic.
- Digite esp8266/esp8266-to-aws no Topic filter. Você pode mudar o tópico, mas ele DEVE ser igual ao tópico no código do ESP8266.
- Clique no botão Subcribe.
- Você poderá ver os dados enviados pelo ESP8266 no AWS IoT Console.
Enviando dados do AWS IoT para o ESP8266
Você pode enviar dados do AWS IoT Console para o ESP8266 seguindo estes passos:
- No Arduino IDE, abra o Serial Monitor
- No AWS IoT Console, navegue até Test MQTT Test Client
- Clique no botão Publish to a topic.
- Digite esp8266/aws-to-esp8266 no Topic name. Você pode mudar o tópico, mas ele DEVE ser igual ao tópico no código do ESP8266.
- Opcionalmente, você pode alterar o payload da mensagem ou simplesmente mantê-lo como padrão.
- Clique no botão Publish.
- Veja o Serial Monitor no Arduino IDE e você verá a mensagem enviada pelo AWS IoT Console.
8
Serial.println("Hello World!");
Message (Enter to send message to 'Nodemcu 1.0 (ESP-12E Module)' on 'COM15')
New Line
9600 baud
received:
- topic: esp8266/aws-to-esp8266
- payload:
{
"message": "Hello from AWS IoT console"
}
Faça mais com a AWS
Agora, você pode estabelecer uma comunicação bidirecional entre o ESP8266 e o AWS IoT Core. Isso significa que você pode enviar dados do ESP8266 para o AWS IoT Core e receber dados do AWS IoT Core no ESP8266. Além disso, você pode configurar IoTRules, permitindo que o ESP8266 se conecte perfeitamente 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 ESP8266, possibilitando uma ampla variedade de aplicações e integrações IoT.