ESP8266 - AWS IoT
Este tutorial te enseña cómo usar ESP8266 con AWS IoT Core. Específicamente, cubriremos en detalle los siguientes temas:
- Estableciendo la conexión entre el ESP8266 y AWS IoT Core.
- Programando el ESP8266 para transmitir datos a AWS IoT Core.
- Programando el ESP8266 para recibir datos de AWS IoT Core.
Al seguir estos pasos, obtendrás una comprensión integral de la integración del ESP8266 con AWS IoT Core para una comunicación fluida.
Hardware Requerido
Or you can buy the following kits:
| 1 | × | DIYables Sensor Kit (30 sensors/displays) | |
| 1 | × | DIYables Sensor Kit (18 sensors/displays) |
Divulgación: Algunos de los enlaces proporcionados en esta sección son enlaces de afiliado de Amazon. Podemos recibir una comisión por las compras realizadas a través de estos enlaces sin costo adicional para usted. Apreciamos su apoyo.
Acerca de ESP8266 y AWS IoT
El ESP8266 establece una conexión con AWS IoT Core a través del protocolo MQTT. Aunque existen bibliotecas disponibles para simplificar esta conexión, es más complejo que conectarse a un broker MQTT local como Mosquitto en tu PC. Esta complejidad surge de las medidas de seguridad estrictas de AWS IoT Core, que requieren pasos de configuración para obtener credenciales de autenticación y autorización para la integración en el código del ESP8266. En esencia, el proceso implica dos pasos principales:
- Configurar AWS IoT Core: Este paso configura AWS IoT Core para generar las credenciales de autenticación requeridas, las cuales se incorporarán posteriormente al código ESP8266.
- Escribir el código ESP8266: Después de obtener las credenciales de autenticación de AWS IoT Core, el siguiente paso implica escribir el código ESP8266. Este código integra los protocolos de autenticación y comunicación necesarios para una interacción sin problemas con AWS IoT Core.
Echemos un vistazo más de cerca a cada paso para entenderlo mejor.
Configuración de AWS IoT Core para su uso con ESP8266
Los objetivos de este paso incluyen:
- Creación de una representación del dispositivo ESP8266 en AWS IoT Core, conocida como 'Thing'.
- Configuración de la autorización necesaria para permitir que el dispositivo ESP8266 se conecte, publique y se suscriba a AWS IoT Core, conocida como 'Policy'.
- Generación de las credenciales de AWS necesarias para la autenticación, conocidas como 'Certificados'. Estas credenciales se descargarán e integrarán en el código de Arduino ESP8266.
A continuación se presentan instrucciones para configurar AWS IoT Core para su uso con ESP8266 a través de la consola de AWS IoT. Tenga en cuenta que, aunque la interfaz de usuario pueda cambiar con el tiempo, el proceso debería permanecer similar a las instrucciones proporcionadas a continuación:
- Inicia sesión en la Consola de AWS IoT
- Crea un Thing accediendo a Gestionar Todos los dispositivos Things
- Haz clic en el botón Crear cosas.
- Selecciona Crear cosas individuales y haz clic en el botón Siguiente.
- Especifique el Nombre del dispositivo, por ejemplo, ESP8266-thing y haga clic en el botón Siguiente en la parte inferior de la página.
- Genera las credenciales al seleccionar la opción Autogenerar un nuevo certificado, y haz clic en el botón Siguiente.
- Ahora, se crea un Certificado y se vincula al Objeto.
- Crear una política haciendo clic en el botón Crear política.
- Se abrirá una nueva pestaña.
- Especifique el Nombre de la política, por ejemplo, ESP8266-policy y haga clic en el botón JSON.
- Copie el contenido de la política en formato JSON que se muestra a continuación y péguelo en el área documento de la política.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "*",
"Resource": "*"
}
]
}
- Haz clic en el Crear botón en la parte inferior de la página para crear la política.
- Ahora, se crea una Política y se adjunta al Certificado. Cierra esa página y vuelve a la página del Dispositivo.
- Ver la ESP8266-policy y haz clic en el Crear objeto para crear el Dispositivo.
- Aparece una ventana emergente que te permite descargar los archivos de credenciales. Descarga todos los archivos y guárdalos en un lugar seguro de tu PC y mantén su confidencialidad.
- Luego, haga clic en el botón Hecho.
Entre los archivos descargados, hay tres archivos que se utilizarán en el código ESP8266 en los próximos pasos:
- AmazonRootCA1.pem
- xxxxxxxxxx-certificate.pem.crt
- xxxxxxxxxx-private.pem.key
Estos archivos se pueden abrir con cualquier editor de texto, como Notepad o Notepad++.
Escribiendo el código ESP8266 para conectarse a AWS IoT Core
/*
* Este código de ESP8266 NodeMCU fue desarrollado por es.newbiely.com
* Este código de ESP8266 NodeMCU se proporciona al público sin ninguna restricción.
* Para tutoriales completos y diagramas de cableado, visite:
* https://es.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"];
*/
}
Pasos R\u00e1pidos
Para empezar con ESP8266 en el IDE de Arduino, siga estos pasos:
- Consulta el cómo configurar el entorno para ESP8266 en Arduino IDE tutorial si es la primera vez que usas ESP8266.
- Conecta la placa ESP8266 a tu computadora usando un cable USB.
- Abre Arduino IDE en tu computadora.
- Elige la placa ESP8266 correcta, como (p. ej. NodeMCU 1.0 (ESP-12E Module)), y su puerto COM respectivo.
- Abre el Administrador de Bibliotecas haciendo clic en el icono Administrador de Bibliotecas en la barra de navegación izquierda de Arduino IDE.
- Escribe MQTT en la caja de búsqueda, luego busca la biblioteca MQTT de Joel Gaehwiler.
- Haz clic en el botón Instalar para instalar la biblioteca MQTT.
- Escribe ArduinoJson en el cuadro de búsqueda, luego busca la biblioteca ArduinoJson de Benoit Blanchon.
- Haz clic en el botón Instalar para instalar la biblioteca ArduinoJson.
- Copia el código anterior y pégalo en el IDE de Arduino.
- Crea el archivo secrets.h en el IDE de Arduino mediante:
- Haz clic en el botón justo debajo del icono del monitor serie y elige Nueva pestaña, o usa las teclas Ctrl+Shift+N.
- Escribe el nombre del archivo secrets.h y haz clic en el botón Aceptar
- Copie el código de abajo y péguelo en el archivo creado secrets.h.
- Actualice la siguiente información en el secrets.h
- El WIFI_SSID y el WIFI_PASSWORD de su red WiFi
- El AWS_CERT_CA, AWS_CERT_CRT y AWS_CERT_PRIVATE. Esta información se encuentra en los archivos que descargó en el paso anterior.
- El AWS_IOT_ENDPOINT. Esta información se puede encontrar en la Consola de AWS IoT yendo a Configuración como se muestra en la imagen a continuación:
- Compila y carga el código en la placa ESP8266 haciendo clic en el botón Cargar en el IDE de Arduino
#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 datos desde ESP8266 a AWS IoT
El código ESP8266 anterior lee periódicamente datos de un pin analógico y los envía a AWS IoT cada 4 segundos. Si abres el Monitor Serial en el IDE de Arduino, verás el registro como el siguiente:
COM6
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}
Autoscroll
Clear output
9600 baud
Newline
Para verificar si los datos son recibidos por AWS IoT o no, siga los siguientes pasos:
- En la consola de AWS IoT, navegue a Prueba Cliente de Prueba MQTT
- Haz clic en el botón Suscribirse a un tema.
- Escribe esp8266/esp8266-to-aws en el Filtro de temas. Puedes cambiar el tema pero DEBE coincidir con el tema en el código ESP8266.
- Haz clic en el botón Suscribirse.
- Podrás ver los datos enviados desde ESP8266 en la Consola de AWS IoT.
Enviando datos de AWS IoT a ESP8266
Es posible enviar los datos desde la Consola de AWS IoT al ESP8266 siguiendo los siguientes pasos:
- En el IDE de Arduino, abra el Monitor Serial
- En la Consola de AWS IoT, navegue a Prueba Cliente de Prueba MQTT
- Haz clic en el botón Publicar en un tema.
- Escribe esp8266/aws-to-esp8266 en el Nombre del tema. Puedes cambiar el tema, pero DEBE coincidir con el tema del código ESP8266.
- Opcionalmente, puedes cambiar la carga útil del mensaje, o simplemente dejarla como predeterminada.
- Haz clic en el Publicar botón.
- Abre el Monitor Serial en el IDE de Arduino; verás el mensaje enviado desde AWS IoT Console.
COM6
received:
- topic: esp8266/aws-to-esp8266
- payload:
{
"message": "Hello from AWS IoT console"
}
Autoscroll
Clear output
9600 baud
Newline
Haz más con AWS
Ahora, ya puedes establecer una comunicación bidireccional entre el ESP8266 y AWS IoT Core. Esto significa que puedes enviar datos desde el ESP8266 a AWS IoT Core y recibir datos de AWS IoT Core en el ESP8266. Además, tienes la capacidad de configurar IoTRules, lo que permite que el ESP8266 se conecte sin problemas con otros servicios de AWS como Lambda, DynamoDB, Amplify y RDS. Con IoTRules, puedes automatizar acciones basadas en datos recibidos desde el ESP8266, lo que posibilita una amplia gama de aplicaciones e integraciones de IoT.