ENVÍO DE DATOS A THINGSBOARD USANDO ESP32

INTRODUCCIÓN

En el mundo del Internet de las Cosas, hay que tener en cuenta un punto muy importante, como lo es la elección de la plataforma a la cual se enviarán los datos medidos. Existen muchísimas opciones en la web, y en esta oportunidad veremos la conexión a ThingsBoard, una plataforma SaaS para IoT que permite un rápido desarrollo, gestión y escalado de proyectos de IoT. Su principal objetivo es proporcionar la solución local o en la nube de IoT lista para usar que habilitará la infraestructura del lado del servidor para sus aplicaciones de IoT. Se realizará un circuito sencillo, y con las credenciales necesarias, podremos hacer una conexión hacia ThingSpeak para enviar los datos de nuestro sensor DHT11, para medición de temperatura y humedad.

Las plataformas SaaS IoT ofrecen conectividad y funcionalidad de recopilación de datos en su núcleo. Si deseas conocer un poco más de este tipo de plataformas, puedes visitar este sitio: https://kryptonsolid.com/las-plataformas-saas-iot-impulsan-el-desarrollo-de-aplicaciones-iot/

Si desea conocer más acerca de esta plataforma, puede visitar el siguiente sitio web: https://thingsboard.io/docs/getting-started-guides/what-is-thingsboard/

MOMENTO DE REALIZAR NUESTRO CIRCUITO

Para la realización de este proyecto, vamos a necesitar los siguientes componentes:

  • ESP32 DevKit V1
  • Sensor de Temperatura y Humedad DHT11
  • Cable USB-Micro USB
  • Cables Jumper Male-Male
  • Protoboard

Ahora, procedemos a revisar el diagrama de PinOut del ESP32 DevKit v1 y del sensor DHT11 para realizar las conexiones.

  • ESP32 DevKit V1

  • Sensor DHT11 – Temperatura y Humedad Relativa
  • Entendido ya que pines poseen ambos componentes, realizamos el siguiente circuito.

    Procedemos a realizar las siguientes conexiones entre los dispositivos:

    ESP32 DEVKIT V1SENSOR DHT11
    PIN 3.3VVCC
    PIN GNDGND
    PIN DIGITAL 23DATA

    ANTES DE PROGRAMAR..

    Tenemos que tener instalado la librería para usar el sensor DHT11, y la librería para hacer la conexión hacia la plataforma ThingsBoard.

    Instalamos primero, la librería del sensor DHT11.

    Ahora, procedemos a instalar la librería de ThingsBoard a usar con el ESP32 DevKit.

    Como último paso previo, debemos ingresar a la plataforma ThingsBoard utilizando este enlace: https://demo.thingsboard.io/login ; se debe realizar un registro para ingresar a la misma, la cual debe ser completada con información del usuario. Cabe mencionar que para motivos de este ejercicio, usaremos la plataforma de ThingsBoard para envío de datos usado para DEMOS.

    Una vez dentro de la plataforma de ThingsBoard, nos mostrará la siguiente interfaz. Nosotros nos dirigimos al inciso Devices.

    Se nos mostrará una interfaz como la que se ve en la imagen. Procedemos a dar clic al ícono “+” para agregar un nuevo dispositivo.

    Se nos pedirá completar varios campos. Por motivos de este ejercicio, se procedieron a completar dichos campos como se muestra a continuación.

    • Se utilizó el nombre “TEST-TODOMAKER” y se seleccionó como Device-profile “default”. Para continuar con la creación, se presiona “Next”
    • En el segundo cuadro que nos aparece, procedemos a dejarlo por defecto. Presionamos “Next” para continuar con la creación.
    • Aquí, seleccionamos la opción de Customer como “Customer A”. Presionamos la opción “Add” para que finalice la creación del Device.

    Una vez creado el dispositivo, se nos mostrará la interfaz con el dispositivo creado llamado “TEST-TODOMAKER”. Entramos a ver sus detalles, dando doble clic sobre el nombre del dispositivo.

    Aparecerá el siguiente menú. Damos clic a “Copiar el Access Token”, ya que esta credencial es importante para el envío de datos a la plataforma, por lo que procedemos a guardarlo en un archivo .txt

    Nos dirigimos a “Last Telemetry”, y dejamos la pestaña en dicho inciso, para poder visualizar luego los datos que llegan desde el sensor hacia la plataforma.

    Obtenido ya el Access Token del dispositivo, procedemos a realizar el código en el IDE de Arduino.

    REALIZAMOS NUESTRO CÓDIGO

    Para realizar la programación del microcontrolador, usaremos el Arduino IDE, por la facilidad y lo sencillo que es programar con dicho programa.

    El código a cargar en ESP32 DevKit es el siguiente:

    /*
     * El ejemplo de esta semana es una conexión hacia la plataforma ThingsBoard para proyectos 
     * de Internet de las Cosas (IoT)
     * Realizado por: Sebastian Carranza - Equipo TodoMaker
     * Propiedad y Derechos: Equipo TodoMaker
     * Para esta semana, necesitamos lo siguiente:
     * ESP32 Dev Kit
     * Sensor DHT11
     * Cables Jumper Male - Female
     * Cable USB a MicroUSB
     * Una red WiFi existente en nuestro hogar, lugar de trabajo, etc.
     * 
     * No habrá una conexión física con algún componente extra.
     */
    /*Incluimos primero las librerías*/
    #include "ThingsBoard.h"
    #include <WiFi.h>
    #include "DHT.h"
    /*Definimos que el Pin de Datos del sensor estará conectado al pin 23 del ESP32DevKit*/
    #define DHTPIN  23      
    /*Definimos que el tipo de sensor que estamos utilizando es un DHT11*/
    #define DHTTYPE DHT11     // DHT 11
    /*Se actualizan algunos parámetros del DHT11 con los puntos definidos anteriormente*/ 
    DHT dht(DHTPIN, DHTTYPE);
    
    /*Definimos el nombre y contraseña de la Red WiFi a utilizar*/
    #define WIFI_AP             "SSID_WIFI"
    #define WIFI_PASSWORD       "PASSWORD-WIFI"
    
    /*Definimos 2 variables, el Access Token obtenido de la plataforma, y el servidor al cual se enviarán los datos*/
    #define TOKEN               "ACCESS_TOKEN"
    #define THINGSBOARD_SERVER  "demo.thingsboard.io"
    
    /*Definimos la velocidad del terminal Serial a una velocidad de 115200*/
    #define SERIAL_DEBUG_BAUD   115200
    /*Definimos el cliente WiFi que usaremos*/
    WiFiClient espClient;
    /*Definimos que el cliente MQTT a utilizar para la conexión a la plataforma, es la que definimos líneas arriba*/
    ThingsBoard tb(espClient);
    /*Incluimos el status del radio WiFi*/
    int status = WL_IDLE_STATUS;
    /*Iniciamos la función Setup()*/
    void setup() {
      /*Iniciamos el terminal Serial a una velocidad de 115200*/
      Serial.begin(SERIAL_DEBUG_BAUD);
      /*Iniciamos la conexión Wifi, con las credenciales*/
      WiFi.begin(WIFI_AP, WIFI_PASSWORD);
      /*Incluimos un retardo de 1 segundo e iniciamos nuestro sensor DHT junto a la función de incio WiFi*/
      delay(1000);
      dht.begin();
      InitWiFi();
    }
    
    /*Iniciamos la función Loop()*/
    void loop() {
      /*Usamos un retardo de 1 segundo, y agregamos una condicional donde se resalta que, si no se conecta a la red, se pasa a usar la funcion Reconnect()*/
      delay(1000);
      if (WiFi.status() != WL_CONNECTED) {
        reconnect();
      }
      /*Usamos una condicional donde resalta que si no se realiza la conexión, se pasa a usar las credenciales para lograr la conexión a la plataforma*/
      if (!tb.connected()) {
        // Connect to the ThingsBoard
        Serial.print("Connecting to: ");
        Serial.print(THINGSBOARD_SERVER);
        Serial.print(" with token ");
        Serial.println(TOKEN);
        /*Si no se realiza la conexión usando las credenciales, se procede a imprimir la frase de error de conexión*/
        if (!tb.connect(THINGSBOARD_SERVER, TOKEN)) {
          Serial.println("Failed to connect");
          return;
        }
      }
      /*Una vez realizada la conexión, se procede a imprimir la frase que indica el inicio del envío de datos*/
      Serial.println("Sending data...");
    
      /*Se procede a realizar la lectura de los valores del sensor*/
      float h = dht.readHumidity();       // Lectura de humedad
      float t = dht.readTemperature();     // Lectura de temperatura
      Serial.println("Temperatura: ");
      Serial.println(t);
      Serial.println("Humedad: ");
      Serial.println(h);
      /*Se procede a hacer el envío de los datos del sensor DHT con el respectivo nombre del valor*/
      tb.sendTelemetryInt("Temperatura", t);
      tb.sendTelemetryFloat("Humedad", h);
      /*Agregamos un retardo de 5 segundos e iniciamos un bucle*/
      delay(5000);
      tb.loop();
    }
    /*Mostramos la función InitWifi, para el inicio de la conexión a la red WiFi*/
    void InitWiFi()
    {
      /*Imprimimos la frase, para indicar el inicio de la conexión*/
      Serial.println("Connecting to AP ...");
      /*Iniciamos la conexión a la red, y se muestran caracteres indicando el tiempo que tarda en realizar la conexión*/
      WiFi.begin(WIFI_AP, WIFI_PASSWORD);
      while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
      }
      /*Una vez realizada la conexión, se mostrará la siguiente frase*/
      Serial.println("Connected to AP");
    }
    /*Definimos la función Reconnect(), para realizar la conexión a la red*/
    void reconnect() {
      /*Se indica una condicional donde, si no se realiza la conexión, se imprimirán caracteres indicando el tiempo que tarda en realizar la conexión*/
      status = WiFi.status();
      if ( status != WL_CONNECTED) {
        WiFi.begin(WIFI_AP, WIFI_PASSWORD);
        while (WiFi.status() != WL_CONNECTED) {
          delay(500);
          Serial.print(".");
        }
        /*Una vez realizada la conexión a la red, se procede a imprimir una frase*/
        Serial.println("Connected to AP");
      }
    }

    La explicación del código se muestra a continuación:

  • Como primer paso (y muy importante, por cierto), debemos llamar a las librerías WiFi.h, ThingsBoard.h y DHT.h, instaladas en los incisos anteriores.
  • /*Incluimos primero las librerías*/
    #include "ThingsBoard.h"
    #include <WiFi.h>
    #include "DHT.h"

  • Ahora definimos que el pin de Datos del sensor estará conectado al pin digital 23 del ESP32 DevKit V1, y que además, estamos usando el sensor DHT11.
  • /*Definimos que el Pin de Datos del sensor estará conectado al pin 23 del ESP32DevKit*/
    #define DHTPIN  23      
    /*Definimos que el tipo de sensor que estamos utilizando es un DHT11*/
    #define DHTTYPE DHT11     // DHT 11
    /*Se actualizan algunos parámetros del DHT11 con los puntos definidos anteriormente*/ 
    DHT dht(DHTPIN, DHTTYPE);
    • Definimos nuestras credenciales de la red WiFi a la cual se conectará la tarjeta ESP32 DevKit V1, con variables de nombre WIFI_AP y WIFI_PASSWORD
    /*Definimos el nombre y contraseña de la Red WiFi a utilizar*/
    #define WIFI_AP             "SSID_WIFI"
    #define WIFI_PASSWORD       "PASSWORD-WIFI"
    • Ahora, definimos primero el Access Token que obtuvimos de la plataforma ThingsBoard incisos atrás, y además definimos el servidor al cual se apunta a enviar los datos desde nuestro microcontrolador.
    /*Definimos 2 variables, el Access Token obtenido de la plataforma, y el servidor al cual se enviarán los datos*/
    #define TOKEN               "ACCESS_TOKEN"
    #define THINGSBOARD_SERVER  "demo.thingsboard.io"
    • Definimos la velocidad que usaremos en el terminal Serial, que será de 115200. Además, definimos el cliente WiFi que usaremos, el cual denominaremos espClient.
    /*Definimos la velocidad del terminal Serial a una velocidad de 115200*/
    #define SERIAL_DEBUG_BAUD   115200
    /*Definimos el cliente WiFi que usaremos*/
    WiFiClient espClient;
    • Indicamos que el cliente MQTT a utilizar para la conexión, es el cliente WiFi definido en líneas anteriores.
    /*Definimos que el cliente MQTT a utilizar para la conexión a la plataforma, es la que definimos líneas arriba*/
    ThingsBoard tb(espClient);
    /*Incluimos el status del radio WiFi*/
    int status = WL_IDLE_STATUS;
    • En la función Setup(), iniciamos el terminal Serial con la velocidad definida anteriormente, e iniciamos la conexión a la red WiFi usando las credenciales también definidas anteriormente.
    /*Iniciamos la función Setup()*/
    void setup() {
      /*Iniciamos el terminal Serial a una velocidad de 115200*/
      Serial.begin(SERIAL_DEBUG_BAUD);
      /*Iniciamos la conexión Wifi, con las credenciales*/
      WiFi.begin(WIFI_AP, WIFI_PASSWORD);
    • Incluimos un retardo de 1 segundo, iniciamos la lectura del sensor DHT y llamamos a la función InitWiFi, para indicar el inicio de la conexión a la red.
    /*Incluimos un retardo de 1 segundo e iniciamos nuestro sensor DHT junto a la función de incio WiFi*/
      delay(1000);
      dht.begin();
      InitWiFi();
    }
    • En la función Loop(), indicamos un retardo de 1 segundo e indicamos que si no se realiza la conexión, se procede a usar la función Reconnect().
    /*Iniciamos la función Loop()*/
    void loop() {
      /*Usamos un retardo de 1 segundo, y agregamos una condicional donde se resalta que, si no se conecta a la red, se pasa a usar la funcion Reconnect()*/
      delay(1000);
      if (WiFi.status() != WL_CONNECTED) {
        reconnect();
      }
    • Se indica una condicional que indica que si no se realiza la conexión, se usan las credenciales para poder tener una conexión con la plataforma. Eso sí, si este no llegase a realizarse, se procede a imprimir una frase indicando la conexión fallida.
     /*Usamos una condicional donde resalta que si no se realiza la conexión, se pasa a usar las credenciales para lograr la conexión a la plataforma*/
      if (!tb.connected()) {
        // Connect to the ThingsBoard
        Serial.print("Connecting to: ");
        Serial.print(THINGSBOARD_SERVER);
        Serial.print(" with token ");
        Serial.println(TOKEN);
        /*Si no se realiza la conexión usando las credenciales, se procede a imprimir la frase de error de conexión*/
        if (!tb.connect(THINGSBOARD_SERVER, TOKEN)) {
          Serial.println("Failed to connect");
          return;
        }
      }
    • Una vez puesta en marcha la conexión con la plataforma, se procede a indicar el envío con una frase.
    /*Una vez realizada la conexión, se procede a imprimir la frase que indica el inicio del envío de datos*/
      Serial.println("Sending data...");
    
    • Se procede a realizar una lectura de Temperatura y Humedad del sensor. Como tal, imprimimos los valores en el terminal Serial y los enviamos a la plataforma en valor Float o decimal. Como tal, agregamos un retardo de 5 segundos y reiniciamos el bucle de la librería de la plataforma.
     /*Se procede a realizar la lectura de los valores del sensor*/
      float h = dht.readHumidity();       // Lectura de humedad
      float t = dht.readTemperature();     // Lectura de temperatura
      Serial.println("Temperatura: ");
      Serial.println(t);
      Serial.println("Humedad: ");
      Serial.println(h);
      /*Se procede a hacer el envío de los datos del sensor DHT con el respectivo nombre del valor*/
      tb.sendTelemetryFloat("Temperatura", t);
      tb.sendTelemetryFloat("Humedad", h);
      /*Agregamos un retardo de 5 segundos e iniciamos un bucle*/
      delay(5000);
      tb.loop();
    }
    • La función InitWiFi inicia con la frase de indicación de conexión a la plataforma.
    /*Mostramos la función InitWifi, para el inicio de la conexión a la red WiFi*/
    void InitWiFi()
    {
      /*Imprimimos la frase, para indicar el inicio de la conexión*/
      Serial.println("Connecting to AP ...");
    • Como tal, iniciamos la conexión a la red, y mientras esto tome tiempo, se procederá a imprimir caracteres cada 0.5 segundos. Una vez conectado a la red, procedemos a imprimir una frase.
    /*Iniciamos la conexión a la red, y se muestran caracteres indicando el tiempo que tarda en realizar la conexión*/
      WiFi.begin(WIFI_AP, WIFI_PASSWORD);
      while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
      }
      /*Una vez realizada la conexión, se mostrará la siguiente frase*/
      Serial.println("Connected to AP");
    • La función Reconnect está definida para indicar que, si no se realiza la conexión (utilizando una condicional), se imprimirán caracteres al igual que el paso anterior. Una vez conectado a la red, se procederá a imprimir una frase. Si no se realiza la conexión, se seguirán imprimiendo caracteres.
    /*Definimos la función Reconnect(), para realizar la conexión a la red*/
    void reconnect() {
      /*Se indica una condicional donde, si no se realiza la conexión, se imprimirán caracteres indicando el tiempo que tarda en realizar la conexión*/
      status = WiFi.status();
      if ( status != WL_CONNECTED) {
        WiFi.begin(WIFI_AP, WIFI_PASSWORD);
        while (WiFi.status() != WL_CONNECTED) {
          delay(500);
          Serial.print(".");
        }
        /*Una vez realizada la conexión a la red, se procede a imprimir una frase*/
        Serial.println("Connected to AP");
      }
    }

    HORA DE PROBAR EL CIRCUITO

    Se muestra a continuación imágenes del código en el IDE de Arduino, como del circuito realizado.

    HORA DE EJECUTAR EL PROYECTO

    Una vez hecho el circuito y subido nuestro código, obtendremos los siguientes resultados.

    CONCLUSIONES

    Una vez finalizado el ejercicio y con el envío de datos realizándose de forma continua, podemos llegar a la conclusión de que el envío de datos a las plataformas de Internet de las Cosas, es un ejercicio bastante interesante y práctico, por lo que a manera de que vayamos realizando más ejercicios y el uso constante de plataformas, el panorama para proyectos se ampliará y tendremos mucho más experiencia al momento de decidir por la plataforma a utilizar al momento de desarrollar un MVP, un ejercicio, etc.

    Te invitamos a tomar el curso de Introducción al ESP32: Introducción al ESP32 | TodoMaker’s School

    Previous Post
    Next Post

    Comments

    Mario

    Dan asesoría.

    Soporte

    Hola Mario, si porfavor escríbenos al correo hola@todomaker.com, nos envías tu necesidad y tu número de celular para poder contactarte.