Domina el IoT desde cero: Controla una luz LED con ESP32 y AWS IoT Core

En este blog, te enseñaremos cómo encender y apagar una luz LED utilizando dos herramientas poderosas: AWS IOT Core y ESP32. AWS IoT Core ofrece una solución segura y escalable para la gestión de dispositivos IoT, y el ESP32 es un microcontrolador popular y accesible que proporciona una amplia gama de funcionalidades. Juntos, forman una poderosa pareja para desarrollar proyectos de IoT.

No te preocupes si no tienes experiencia previa, este proyecto es como el “Hola mundo” del ESP32 y AWS IoT Core. Aprenderemos todo desde cero y te guiaremos en cada paso del camino.

Estos son los materiales que necesitaras:

• 1 breadboard
• 1 ESP32
• 1 luz led
• 1 resistencia de 220 ohms
• 2 cables puente

Crear un dispositivo IoT Core

1. En la consola de AWS IoT elegimos a Manage, All devices y Create things.

2. En la pantalla Create Things hacemos clic en Next.

3. En la pantalla Specify thing properties ingresamos un nombre en Thing name para nuestro dispositivo y luego hacemos clic en Next.

4. En la pantalla Configure device certificate — optional dejamos seleccionada la opción Auto-generate a new certificate (recommended) y hacemos clic en Next.

5. En la pantalla Attach Policies to certificate — optional hacemos clic en la opción Create Policy.

6. En la pantalla Create Policy ingresamos un nombre para la política en el campo Policy Name. En la sección Policy Document seleccionamos JSON y pegamos la siguiente política.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "iot:Connect",
      "Resource": "*"
    },
    {
      "Effect": "Allow",
      "Action": "iot:Receive",
      "Resource": "*"
    },
    {
      "Effect": "Allow",
      "Action": "iot:Subscribe",
      "Resource": "*"
    },
    {
      "Effect": "Allow",
      "Action": "iot:Publish",
      "Resource": "*"
    }
  ]
}

7. Regresamos a la pantalla de creación del objeto, seleccionamos la política creada y hacemos clic en Create thing.

8. Nos aparecerá una pantalla para descargar los certificados. Necesitamos descargar el Device Certificate, Public key file, Private key file y ROOT CA Certificate.

Conectar el ESP32

En el breadboard, vamos a colocar el ESP32. Para comenzar, asegurémonos de conectar el pin de tierra (GND) del ESP32 al rail de tierra del breadboard. A continuación, colocaremos un cable puente desde el pin 32 del ESP32 hacia la fila 26 del breadboard.

Ahora, tomemos la resistencia de 220 ohmios y coloquémosla desde la fila 26 a la fila 29 en el breadboard. Por último, conectemos el ánodo de la luz LED en la fila 29 del breadboard y el cátodo (el pin más corto del LED) a la tierra del breadboard.

Después de seguir estos pasos, el breadboard debería verse similar a la imagen de abajo.

Configurando el Arduino IDE

Para poder programar el ESP32 necesitamos descargar y configurar el Arduino IDE.

1. Descarga el instalador de Arduino para tu sistema operativo.
2. Abre el Arduino IDE y ve a la ventana de Preferences.
3. En el campo Additional Board Manager URLs ingresa https://dl.espressif.com/dl/package_esp32_index.json
4. En Tools, Boards, Board Manager busca esp32 by Expressif e instala la última versión.
5. En Sketch, Include Library, Manage Libraries busca la libreria MQQT by Joel Gaehwiler y ArduinoJson e instala la última versión de ambas librerias.

Programando el ESP32

Necesitamos conectar el ESP32 mediante un cable USB a nuestra computadora. Con el Arduino IDE vamos a crear un nuevo sketch para trabajar en File, New sketch.

1. Creamos una nueva pestaña y la llamamos secrets.sh
2. Ingresa el siguiente código

#include <pgmspace.h>
#define SECRET
#define THINGNAME ""
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";

3. En THINGNAME pon el nombre del dispositivo. En nuestro caso fue ESP32.

4. Agrega el nombre de tu wifi y contraseña en los campos WIFI_SSID y WIFI_PASSWORD. El nombre de la red no debería de tener espacios o caracteres especiales.

5. En el campo AWS_IOT_ENDPOINT ingresa el endpoint que se encuentra en la pantalla de Settings de la consola de AWS IOT.

6. Copia el contenido de los archivos Amazon Root CA 1, Device Certificate y Device Private Key en los respectivos campos del archivo.

7. En el archivo principal del sketch pega el siguiente código.

#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_SUBSCRIBE_TOPIC "esp32/sub"
WiFiClientSecure net = WiFiClientSecure();
MQTTClient client = MQTTClient(256);
#define ledPin 32
void connectAWS()
{
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.println("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED){
    delay(500);
    Serial.print(".");
  }
  // 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 message handler
  client.onMessage(messageHandler);
  Serial.print("Connecting to AWS IOT");
  while (!client.connect(THINGNAME)) {
    Serial.print(".");
    delay(100);
  }
  if(!client.connected()){
    Serial.println("AWS IoT Timeout!");
    return;
  }
  // Subscribe to a topic
  client.subscribe(AWS_IOT_SUBSCRIBE_TOPIC);
  Serial.println("AWS IoT Connected!");
}
void messageHandler(String &topic, String &payload) {
  Serial.println("incoming: " + topic + " - " + payload);
  StaticJsonDocument<200> doc;
  deserializeJson(doc, payload);
  int message = doc["led"];
  Serial.println(message);
  if (message == 1)
  {
    digitalWrite(ledPin, HIGH);
    Serial.println("Turn on led");
  }
  else if (message == 0)
  {
    digitalWrite(ledPin, LOW);
    Serial.println("Turn off led");
  }
}
void setup() {
  Serial.begin(115200);
  connectAWS();
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
}
void loop() {
  client.loop();
}

8. En el Arduino selecciona Tools, Boards, esp32 y ESP32 Dev Module.

9. Haz clic en el botón Upload del Arduino IDE para cargar el código en ESP32. En la placa de ESP32 haz clic en el botón BOOT mientras se carga el sketch.

Encendiendo y apagando la luz led

Siguiendo estos pasos, podrás probar el encendido y apagado de la luz LED mediante el envío de mensajes a través del MQTT test client de AWS IoT Core.

1. Dirígete al al MQTT test client de la consola de AWS IoT Core
2. En el campo Topic name ingresamos esp32/sub
3. En el campo Message payload ingresamos el siguiente código:

{
  "led": "1"
}

Este mensaje indica al ESP32 que encienda la luz LED.

4. Hacemos clic en Publish. Con esto, la luz LED debería encenderse.

5. Para apagar la luz LED, modifica el Message payload con el siguiente código JSON:

{
  "led": "0"
}