ESP32 - AWS IoT
Este tutorial explica cómo usar ESP32 con AWS IoT Core. En detalle, aprenderemos:
- Cómo conectar el ESP32 a AWS IoT Core.
- Cómo programar el ESP32 para enviar los datos a AWS IoT Core.
- Cómo programar el ESP32 para recibir los datos de AWS IoT Core.
Hardware Requerido
Or you can buy the following kits:
| 1 | × | DIYables ESP32 Starter Kit (ESP32 included) | |
| 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 ESP32 y AWS IoT
El ESP32 se conecta a AWS IoT Core mediante el protocolo MQTT. Aunque existen bibliotecas disponibles para facilitar esta conexión, no es tan sencillo como conectarse a un broker MQTT local como Mosquitto en tu PC. Esto se debe a que AWS IoT Core tiene medidas de seguridad estrictas, lo que requiere pasos de configuración para obtener credenciales de autenticación y autorización antes de integrarlas en el código del ESP32. En resumen, el proceso implica dos pasos principales:
- Paso 1: Configuración de AWS IoT Core - Esto implica configurar AWS IoT Core para generar las credenciales de autenticación necesarias, las cuales se utilizarán posteriormente en el código ESP32.
- Paso 2: Escribir el código ESP32 - Una vez obtenidas las credenciales de autenticación de AWS IoT Core, el siguiente paso es escribir el código ESP32, integrando los protocolos de autenticación y comunicación necesarios.
Vamos a echar un vistazo más de cerca a cada paso para entenderlo mejor.
Configurando AWS IoT Core para su uso con ESP32
Los objetivos de este paso incluyen:
- Crear una representación del dispositivo ESP32 en AWS IoT Core, conocida como "Thing".
- Configurar la autorización necesaria para permitir que el dispositivo ESP32 se conecte, publique y se suscriba a AWS IoT Core, conocida como una "Policy".
- Generar las credenciales de AWS necesarias para la autenticación, conocidas como "Certificates". Estas credenciales se descargarán e integrarán en el código de Arduino para ESP32.
A continuación se presentan instrucciones para configurar AWS IoT Core para su uso con ESP32 a través de la Consola de AWS IoT. Tenga en cuenta que, aunque la interfaz de usuario puede 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 y ve a Gestionar Todos los dispositivos Things
- Haz clic en el botón Crear cosas.
- Selecciona Crear una sola cosa y haz clic en el Siguiente botón.
- Especifica el Nombre de la cosa, por ejemplo, ESP32-thing y haz clic en el botón Siguiente al final de la página.
- Generar las credenciales al seleccionar la opción Generar automáticamente 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, ESP32-policy y haga clic en el botón JSON.
- Copie el contenido de la política JSON a continuación y péguelo en el área de documento de la política:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "*",
"Resource": "*"
}
]
}
- Haz clic en el botón Crear 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 regresa a la página del dispositivo.
- Ver la ESP32-policy y haz clic en el botón Crear dispositivo para crear el dispositivo.
- Aparece una ventana emergente que te permite descargar los archivos de credenciales. Descarga todos los archivos y guárdalos en una ubicación segura de tu PC y manténlos confidenciales.
- Luego, haga clic en el Hecho botón.
Entre los archivos descargados, hay tres archivos que se utilizarán en el código ESP32 en los próximos pasos:
- AmazonRootCA1.pem
- xxxxxxxxxx-certificate.pem.crt
- xxxxxxxxxx-private.pem.key
Estos archivos pueden abrirse con cualquier editor de texto, como Notepad o Notepad++.
Escribiendo el código ESP32 para conectarse a AWS IoT Core
/*
* Este código de ESP32 fue desarrollado por es.newbiely.com
* Este código de ESP32 se proporciona al público sin ninguna restricción.
* Para tutoriales completos y diagramas de cableado, visite:
* https://es.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"];
*/
}
Pasos R\u00e1pidos
- Si es la primera vez que usas ESP32, consulta cómo configurar el entorno para ESP32 en Arduino IDE.
- 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 el cuadro 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 la caja de búsqueda, luego busca la biblioteca ArduinoJson de Benoit Blanchon.
- Haz clic en el botón Instalar para instalar la biblioteca ArduinoJson.
- Copie el código anterior y péguelo en el IDE de Arduino.
- Cree el archivo secrets.h en el IDE de Arduino mediante:
- Haga clic en el botón justo debajo del icono del monitor serie y elija Nueva pestaña, o use las teclas Ctrl+Shift+N.
- Ingrese el nombre del archivo secrets.h y haga clic en el botón Aceptar
- Copia el código de abajo y pégalo en el archivo secrets.h creado.
- Actualice la siguiente información en el secrets.h
- El WIFI_SSID y 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 accediendo a Ajustes como se muestra en la imagen a continuación:
- Compilar y subir código a la placa ESP32 haciendo clic en el botón Subir del IDE de Arduino
#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 datos desde ESP32 a AWS IoT
El código ESP32 anterior lee periódicamente datos de un pin analógico y los envía a AWS IoT cada cuatro segundos. Si abres el Monitor Serial en el IDE de Arduino, verás un registro como el que se muestra a continuación:
COM6
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}
Autoscroll
Clear output
9600 baud
Newline
Para verificar si AWS IoT recibe los datos 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 Suscríbete a un tema.
- Escribe esp32/esp32-to-aws en el Filtro de tema. Puedes cambiar el tema, pero DEBE coincidir con el tema del código ESP32.
- Haz clic en el botón Suscríbete.
- Podrás ver los datos enviados desde ESP32 en la Consola de AWS IoT.
Enviando datos desde AWS IoT al ESP32
Es posible enviar los datos desde la consola de AWS IoT al ESP32 siguiendo los siguientes pasos:
- En el IDE de Arduino, abra el Monitor Serial
- En la consola de AWS IoT, navegue a Prueba Cliente MQTT de Prueba
- Haz clic en el botón Publicar en un tema.
- Escribe esp32/aws-to-esp32 en el Nombre del tema. Puedes cambiar el tema, pero DEBE coincidir con el tema en el código del ESP32.
- Opcionalmente, puedes cambiar la carga útil del mensaje, o simplemente dejarla como predeterminada.
- Haz clic en el botón Publicar.
- Abre el Monitor Serial en el IDE de Arduino, verás el mensaje enviado desde la Consola de AWS IoT.
COM6
received:
- topic: esp32/aws-to-esp32
- payload:
{
"message": "Hello from AWS IoT console"
}
Autoscroll
Clear output
9600 baud
Newline
Haz más con AWS
Ahora, puedes establecer una comunicación bidireccional entre el ESP32 y AWS IoT Core. Esto significa que puedes enviar datos desde el ESP32 a AWS IoT Core y recibir datos de AWS IoT Core en el ESP32. Además, tienes la capacidad de configurar IoTRules, lo que permite que el ESP32 se conecte sin problemas con otros servicios de AWS como Lambda, DynamoDB, Amplify y RDS. Con IoTRules, puedes automatizar acciones basadas en los datos recibidos desde el ESP32, lo que permite una amplia gama de aplicaciones e integraciones de IoT.