Conectando ESP8266 a la nube de Amazon(AWS) - Core IOT

Hola en esta entrada veremos como conectar nuestro dispositivo ESP8266 a la nube de AWS. Para ello haremos un código con el cual conectaremos el ESP a nuestra red wifi, además lo comunicaremos con un arduino UNO el cual realizara la lectura de estado en un sensor ON/OFF y lo enviaremos al ESP por medio de los pines RX/TX, finalmente subiremos dicha data a la nube de AWS. Pero antes configuraremos arduino IDE para utilizar nuestro ESP. Empecemos ...

Materiales a usar

ESP 8266

Arduino UNO

JUMPERS

Empezando con AWS

Primero crearemos una cuenta en AWS dando click AQUI , y damos en el botón de Crear una cuenta de AWS.

(Damos click en el botón remarcado en rojo)

A continuación llenamos nuestros datos hasta terminar el registro, como vemos se nos brinda acceso gratuito por 1 año a los servicios disponibles de AWS.

Una vez terminado nuestro registro ingresamos a la plataforma y veremos una interfaz como esta:

(Pantalla de inicio de la plataforma).

Ahora empecemos la configuración de nuestra plataforma para IoT. Nos dirigimos a Servicios y buscamos IOT Core.

(Damos click en IoT Core como se muestra)

Dentro de IoT Core primero iremos a crear una nueva política, para eso vamos a Seguridad > Políticas>Crear

Asignamos un nombre a la política, vamos a modo avanzado y llenamos los datos como se muestra en la siguiente imagen y damos click en crear para finalizar:

(Llenamos el recuadro de texto como se muestra,  Action: "*",Resource:"*" )

Finzalida la creacion de nuestra politica ahora vamos a Administración > Objetos>Crear 

(Damos click en Crear como se muestra)

Para este ejemplo damos click en Crear un solo objeto y continuamos con la asignación de las características para nuestro dispositivo. En la primero pantalla solo asignaremos el nombre y damos siguiente.

(Imagen de la primera pantalla de creacion de objeto)

En la siguiente pagina crearemos un certificado para nuestro objeto, con la finalidad de establecer una conexión segura a nuestro endpoint en la nube desde nuestra red, damos click en Crear Certificado y se nos mostrara una pantalla con el certificado, las llaves publicas y privada que acabamos de generar, descargamos dichos archivos y ahora descargaremos la certificación CA dando click en descargar, como se muestra en la siguiente imagen: 

(Descargamos las llaves y el certificado y  damos click en Descargar como se indica en el cuadro rojo)

Ahora vamos a RSA 2048 bit key y damos click derecho sobre Amazon Root CA1 y ponemos guardar enlace como. Guardamos el archivo.

(Guardamos el enlace de Amazon Root CA 1)

Volvemos a AWS IoT y ahora damos click en Asociar Politica

(Damos click en asociar una politica)

Seleccionamos nuestra política y damos click en registrar objeto. Y listo ya terminamos con la creación de nuestro objeto.

Para finalizar nos dirigimos a Seguridad > Certificados y verificamos que nuestro certificado este activo, en caso contrario le damos en los 3 puntos y seleccionamos Activar.

(Vemos que el certificado que creamos se encuentra Activo)

Con esto terminamos de configurar en AWS, pero antes de continuar iremos a configuración y guardamos nuestro Punto de enlace (Esto es importante ya que hace referencia a nuestra instancia en la nube),

Configurando nuestro ESP8266 con Arduino IDE

Para poder escribir el código que conectara nuestro ESP8266 con la nube primero tenemos que realizar algunas configuraciones, la primera es la que realizaremos a la interfaz de arduino para poder conectarlo y subir nuestro programa al ESP. 

Primero abrimos arduino IDE y damos click en Archivo > Preferencias, y nos dirigimos al Gestor de URLs Adicionales de Tarjetas y copiamos lo siguiente: 

https://arduino.esp8266.com/stable/package_esp8266com_index.json

Damos OK y continuamos, tal como se muestra a continuación:

(Copiamos y damos OK para continuar)

Continuamos dando click en Herramientas > Placa > Gestor de Tarjetas , buscamos ESP8266 e instalamos la librería.

(Instalamos la librería)

Terminada la instalación cerramos arduino IDE y vamos a el siguiente enlace en github. Entra al enlace AQUI. En la pagina descargamos el archivo ZIP. 

Volvemos al arduino IDE, entramos en Archivo > Preferencias, revisamos la ruta que aparece en Localización de Proyecto y nos dirigimos hacia ella. Dentro de la carpeta de proyecto copiamos el archivo ZIP que descargamos antes y lo descomprimimos. Volvemos a cerrar y abrir nuestro Arduino IDE. 

(Nos debe quedar la carpeta tools)

De vuelta en nuestro arduino IDE ahora nos debe aparecer en Herramientas una nueva opción > ESP8266 Sketch Data Upload. Terminado estos pasos, ya tenemos listo el entorno de arduino para trabajar el ESP8266.

Empecemos con el código

Empezaremos haciendo el programa de nuestro ESP8266, en dicho programa cubriremos conexión con arduino, wifi y con la nube. Veamos el código a continuación:

//Se declara SPIFFS para utilzar la flash de sistema
#include "FS.h"
//Se declara WiFi
#include 
#include 
#include 
#include 

// Nombre de nuestra red wifi
const char* ssid = "NombreDeTuRed";
// Contraseña de nuestra red wifi
const char* pass = "TuContraseñaWifi";
// EndPoint de AWS
const char* AWS_endpoint("XXXXXXXXXXXXXXXXX-ats.iot.us-west-1.amazonaws.com");
char msg[50];
// 
WiFiClientSecure espClient;

// Variable del servidor de la hora del sistema(ESP-8266)
WiFiUDP ntpUDP;
// Cliente que se conecta al server NTP
NTPClient timeClient(ntpUDP, "pool.ntp.org");

void retorno(char* topic, byte* payload, unsigned int length) {
  Serial.print("Mensaje recibido [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();
}

PubSubClient client(AWS_endpoint, 8883, retorno, espClient); 

//Metodo de conexion a wifi
void conectarWIFI(){
 
  delay(10);
  //Establece el esp en modo de conexion a una red 
  WiFi.mode(WIFI_STA);
  //Estblaece la conexion con la red
  WiFi.begin(ssid,pass);

  //Bucle de espera para la conexion
  while(WiFi.status() != WL_CONNECTED){
    delay(500);
    Serial.print('.');
  }

  //Mensaje cuando se establece la conexion wifi
  Serial.println();
  Serial.print("Conectado a: ");Serial.println(WiFi.SSID());
  // Muestra la direccion IP asignada
  //Serial.println(WiFi.localIP());

   timeClient.begin();
   while (!timeClient.update()) {
      timeClient.forceUpdate();
   }

  espClient.setX509Time(timeClient.getEpochTime());
}

void cargarCertificados(){
  
  if (!SPIFFS.begin()) {
    Serial.println("Failed to mount file system");
    return;
  }

  // Cargamos el certificado
  File cert = SPIFFS.open("/cert.der", "r");
  if (!cert) {
    Serial.println("Fallo al abrir el cerficado");
  }
  else
    Serial.println("Certificado abierto con exito");

  delay(1000);

  if (espClient.loadCertificate(cert))
    Serial.println("certificado cargado");
  else
    Serial.println("Fallo en cargar el archivo");

  // Load private key file
  File private_key = SPIFFS.open("/private.der", "r"); 
  if (!private_key) {
    Serial.println("Fallo al abrir la llave privada");
  }
  else
    Serial.println("Llave privada abierta con exito");

  delay(1000);

  if (espClient.loadPrivateKey(private_key))
    Serial.println("Llave privada cargada");
  else
    Serial.println("No se pudo cargar la llave privada");

  // Load CA file
  File ca = SPIFFS.open("/ca.der", "r"); 
  if (!ca) {
    Serial.println("Fallo al abrir el archivo ca ");
  }
  else
    Serial.println("Archivo ca abierto con exito");

  delay(1000);

  if (espClient.loadCACert(ca))
    Serial.println("ca cargado");
  else
    Serial.println("ca fallo al abrir");
}

//Conexion con la nube
void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Estableciendo conexion MQTT...");
    // Attempt to connect
    if (client.connect("ESPthing")) {
      Serial.println("Conectado");
      // Once connected, publish an announcement...
      client.publish("outTopic", "Hola mundo");
      // ... and resubscribe
      client.subscribe("inTopic");
    } else {
      Serial.print("Fallo, error=");
      Serial.print(client.state());
      Serial.println("Intentando nuevamente en 5 segundos");

      char buf[256];
      espClient.getLastSSLError(buf, 256);
      Serial.print("WiFiClientSecure SSL error: ");
      Serial.println(buf);

      // Espera 5 segundos
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  conectarWIFI();
  cargarCertificados();
}

void loop() {

  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  if(Serial.available()){
    char a = Serial.read();
    Serial.println(a);
    if (a == 76){
      snprintf (msg, 75,"{Sensor INACTIVO}");
    }

    if (a == 72){
      snprintf (msg, 75,"{Sensor ACTIVO}");
    }

    Serial.print("Publish message: ");
    Serial.println(msg);
    //Envia el topic con el mensaje correspondiente a la nube
    client.publish("outTopic", msg);
    delay(1000);
  }
}

Nota: En la variable AWS_endpoint debemos copiar nuestro endpoint de amazon el cual obtuvimos en el IoT Core en configuración y Puerta de enlace.

Ahora cargaremos los certificados que descargamos a la memoria flash. Realizamos los siguientes pasos:

1° Descargamos el software OpenSSL. El cual puedes bajar en .ZIP haciendo click AQUI .

2° Descargado el zip lo descomprimimos y abrimos la carpeta bin, ahí encontraremos el archivo openssl.exe lo copiamos al escritorio, también copiamos los certificados de AWS que descargamos antes.

3° Ejecutamos openssl.exe y escribimos los siguientes comandos cambiando por los nombres de nuestros archivos:

x509 -in a65dea06a6-certificate.pem.crt -out cert.der -outform DER

rsa -in c6969200b1-private.pem.key -out private.der -outform DER

x509 - AmazonRootCA1.pem -out ca.der -outform DER

Nota: El primer comando corresponde al certificado, el 2do a la llave privada y el 3ero al CA

4° Se nos generaran 3 archivos con extension .der

5° Vamos a la carpeta de nuestro proyecto (Donde estamos escribiendo el codigo) y creamos una carpeta de nombre Data y copiamos los archivos .der en esa carpeta

6° volvemos al arduino IDE y damos click en Herramientas > Placa y seleccionamos nuestro modelo de ESP en mi caso selecciono el genérico.

7° Ahora damos en Herramientas > ESP8266 Data Upload y esperamos que cargue los certificados a la flash.

8° Una vez terminamos de subir los certificados ya podemos subir nuestro programa al ESP pero primero configuramos los parametros. Vamos a Herramientas > Flash size y asignamos el tamaño de flash dependiendo de la version, en mi caso en V3 uso 4MB.

9° Finalizamos subiendo nuestro programa al ESP.

Ahora haremos un pequeño codigo para leer un pin digital y enviar datos del arduino al ESP, el código es el siguiente:

//Este codigo envia una 'H' si el sensor fue activado

// Y una 'L' si el sensor permanece sin activarse

void setup() {
  Serial.begin(115200);
  pinMode(8,OUTPUT);
}

void loop() {
  int a = digitalRead(8);

  if(a == 1){

    //Envia un caracter 'H'
    Serial.write(72);
  }else{

    //Envia un caracter 'L'
    Serial.write(76);
  }
  delay(100);
  }

Subimos nuestro código al arduino y continuamos con la conexión según la tabla que se muestra a continuación:

                     

Ahora alimentamos nuestros dispositivos y conectamos el ESP a la computadora, abrimos el monitor serie de arduino IDE y vemos como procede el programa:

De la imagen vemos que primero conectamos con nuestra red wifi, luego cargamos los certificados, establecemos conexion con la nube(Protocolo MQTT) y empezamos a mandar publish a nuestro endpoint. 

Ahora vamos a IoT Core > Prueba y en Tema de suscripción ponemos el nombre de nuestro tópico en este caso outTopic y damos en Publicar en tema

(Imagen de outTopic recibiendo datos)

Como vemos nos aparecen los mensaje enviados desde nuestro ESP en la plataforma de AWS, con esto ya estamos enviando data a nuestro servicio en la nube, ahora podemos enlazarlo con otros servicios que brinda Amazon, En el futuro haremos una variante a este programa para comunicarlo con DynamoDB una base de datos de Amazon y tambien el envio de comandos desde IoT Core a nuestro ESP.

Muchas Gracias por leer.

Si quieres descargar los programas que hemos usado haz click en la imagen de Descargar

Cualquier consulta por favor escribir a : sstechnologyrp@gmail.com

REFERENCIA:

https://electronicsinnovation.com/how-to-connect-nodemcu-esp8266-with-aws-iot-core-using-arduino-ide-mqtt/