ENVÍO DE DATOS A QUBITRO USANDO ESP32

  2. ESP32
  3. ENVÍO DE DATOS A QUBITRO USANDO ESP32
ENVÍO DE DATOS A QUBITRO 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 Qubitro, una plataforma SaaS para IoT definida para el envío y recepción de datos; esta plataforma permite que los dispositivos se conecten a través de los principales protocolos de comunicación de IoT.

Si desea conocer más acerca de la plataforma mencionada, puede visitar el sitio oficial de Qubitro y su documentación: https://docs.qubitro.com/

En esta oportunidad, se pasará a realizar un circuito sencillo, y con las credenciales necesarias, podremos hacer una conexión hacia Qubitro para enviar los datos de nuestro sensor DHT11, para medición de temperatura y humedad.

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 Qubitro.

Instalamos primero, la librería del sensor DHT11.

Ahora, procedemos a instalar la librería para la conexión con la plataforma, denominada “QubitroMqttClient.h”

Procedemos ahora a crear nuestra cuenta en la plataforma Qubitro usando este enlace: https://portal.qubitro.com/login ; mencionar que la plataforma nos da la facilidad de obtener una cuenta gratuita con ciertas restricciones. Para revisar las mismas, puede ingresar al siguiente enlace: https://www.qubitro.com/pricing/

Ahora, procedemos a ir a lado izquierdo de la interfaz y dar clic a “New Project”. Ahí completaremos los campos de nombre del Proyecto como la descripción del mismo, en caso se desee.

Una vez creado el proyecto, pasamos a crear un Dispositivo. Damos clic a la opción Add Device

Completamos la información que se requiere, de acuerdo a como se muestra la imagen a continuación.

Creado el dispositivo, pasamos a ir al inciso “Settings”

Verificamos que tenemos 2 credenciales: DeviceID y DeviceToken. Pasamos a copiar ambos, ya que los usaremos en nuestro código.

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 Qubitro 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 <QubitroMqttClient.h>
#include <WiFi.h>
#include "DHT.h"
/*Definimos el cliente WiFi que usaremos*/
WiFiClient wifiClient;
/*Definimos que el Pin de Datos del sensor estará conectado al pin 2 del Arduino UNO*/
#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 que el cliente MQTT a utilizar es el definimo líneas arriba*/
QubitroMqttClient mqttClient(wifiClient);

/*Definimos 2 variables char, donde están puestas las claves de conexión a la plataforma*/
char deviceID[] = "DEVICE_ID";
char deviceToken[] = "DEVICE_TOKEN";

/*Definimos el nombre y contraseña de la Red WiFi a utilizar*/
const char* ssid = "SSID_WIFI";
const char* password = "PASSWORD_WIFI";

/*Iniciamos la función Setup()*/
void setup() {
  /*En la función Setup() están incluídas funciones adicionales*/
  /*Iniciamos nuestro terminal Serial y nuestro sensor con la función Serial_init*/
  serial_init();
  /*Iniciamos la conexión a la red WiFi con la función WiFi_Init()*/
  wifi_init();
  /*Iniciamos la conexión y el envío de datos a la plataforma, usando la función qubitro_init()*/
  qubitro_init();
}

/*Iniciamos la función Loop()*/
void loop() {
  /*Hacemos la medición de la Temperatura y Humedad del sensor*/
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  /*Hacemos el cambio de variable Float (decimal) a variable String*/
  String Temperature = String(t);
  String Humidity = String(h);
  /*Imprimimos en el terminal Serial, los valores la Temperatura y Humedad*/
  Serial.print("Temperatura: ");
  Serial.println(Temperature);
  Serial.print("Humedad: ");
  Serial.println(Humidity);

  /*Definimos una variable String que ocupe los valores del sensor, y así fuera enviado*/
  String payload = "{\"Temperatura\":" + String(Temperature)
    + ",\"Humedad\":" + String(Humidity) + "}";
  /*Usamos las siguientes comandos para hacer el envío de datos a Qubitro*/
  mqttClient.poll();
  mqttClient.beginMessage(deviceID);
  mqttClient.print(payload);
  mqttClient.endMessage();
  /*Imprimimos los datos en el Terminal Serial para verificar que exactamente estaría llegando a la plataforma*/
  Serial.print(payload);

  /*Hacemos un retardo de 3 segundos*/
  delay(30 * 1000);
}

/*Iniciamos la función Serial_Init*/
void serial_init() {
  /*Iniciamos el terminal Serial a una velocidad de 115200*/
  Serial.begin(115200);
  /*Incluimos un retardo de 200 milisegundos e iniciamos nuestro sensor DHT*/
  delay(200);
  dht.begin();
}

/*Iniciamos la función WiFi_init()*/
void wifi_init() {
  /*Configuramos el modo WiFi como modo Estación*/
  WiFi.mode(WIFI_STA);
  /*Desconectamos el modo WiFi para luego encenderlo, junto a un retardo de 100*/
  WiFi.disconnect();
  delay(100);
  /*Iniciamos la conexión Wifi, con las credenciales*/
  WiFi.begin(ssid, password);
  /*Imprimimos una frase que nos indica la conexión a la red*/
  Serial.print("Connecting to WiFi...");
  /*Se imprimirán caracteres, significando que se está realizando la conexión a la red*/
  while(true)
  {
    delay(1000);
    Serial.print(".");
    if (WiFi.status() == WL_CONNECTED)
    {
      Serial.println("");
      /*una vez conectado, imprimimos la frase WiFi Connected, y unos datos adicionales respecto a la conexión del dispositivo con la red*/
      Serial.println("WiFi Connected.");
      Serial.print("Local IP: ");
      Serial.println(WiFi.localIP());
      Serial.print("RSSI: ");
      Serial.println(WiFi.RSSI());
      break;
    }
  }
}
/*Iniciamos la función Qubitro_Init*/
void qubitro_init() {
  /*Indicamos en una variables Char, el broker al cual debemos apuntar, junto al puerto a utilizar*/
  char host[] = "broker.qubitro.com";
  int port = 1883;
  /*Utilizamos el deviceID y el deviceToken, a utilizar para realizar la conexión e imprimimos una frase*/
  mqttClient.setId(deviceID);
  mqttClient.setDeviceIdToken(deviceID, deviceToken);
  Serial.println("Connecting to Qubitro...");
  /*Definimos una condicional, que indican las acciones a realizar si no se hace la conexión a la plataforma */
  if (!mqttClient.connect(host, port))
  {
    Serial.print("Connection failed. Error code: ");
    Serial.println(mqttClient.connectError());
    Serial.println("Visit docs.qubitro.com or create a new issue on github.com/qubitro");
  }
  /*Una vez realizada la conexión, imprimimos la frase Conectado a Qubitro, y realizamos la subscripcion a la plataforma para los mensajes de Retorno*/
  Serial.println("Connected to Qubitro.");
  mqttClient.subscribe(deviceID);
}

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, QubitroMqttClient.h y DHT.h, instaladas en los incisos anteriores. Además indicamos el cliente WiFi que se usará en el ejercicio.
/*Incluimos primero las librerías*/
#include <QubitroMqttClient.h>
#include <WiFi.h>
#include "DHT.h"
/*Definimos el cliente WiFi que usaremos*/
WiFiClient wifiClient;
  • 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 2 del Arduino UNO*/
#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 al cliente MQTT a utilizar, que sería el cliente WiFi definido líneas arriba. Además, definimos como constantes char a las credenciales que obtuvimos de la plataforma Qubitro. Es ahí donde deben insertarse para poder usarse en el código.
/*Definimos que el cliente MQTT a utilizar es el definimos líneas arriba*/
QubitroMqttClient mqttClient(wifiClient);

/*Definimos 2 variables char, donde están puestas las claves de conexión a la plataforma*/
char deviceID[] = "DEVICE_ID";
char deviceToken[] = "DEVICE_TOKEN";
  • Definimos como constantes char nuestras credenciales de la red WiFi a la cual se conectará la tarjeta ESP32 DevKit V1.
/*Definimos el nombre y contraseña de la Red WiFi a utilizar*/
const char* ssid = "SSID_WIFI";
const char* password = "PASSWORD_WIFI";
  • Iniciando la función Setup, podemos visualizar que tiene 3 funciones incorporadas, las cuales serán explicadas líneas abajo.
/*Iniciamos la función Setup()*/
void setup() {
  /*En la función Setup() están incluídas funciones adicionales*/
  /*Iniciamos nuestro terminal Serial y nuestro sensor con la función Serial_init*/
  serial_init();
  /*Iniciamos la conexión a la red WiFi con la función WiFi_Init()*/
  wifi_init();
  /*Iniciamos la conexión y el envío de datos a la plataforma, usando la función qubitro_init()*/
  qubitro_init();
}
  • En la función Loop(), procedemos a hacer la lectura de los valores del sensor en Temperatura y Humedad.
/*Iniciamos la función Loop()*/
void loop() {
  /*Hacemos la medición de la Temperatura y Humedad del sensor*/
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  • Hacemos el cambio de variable de Float a String.
/*Hacemos el cambio de variable Float (decimal) a variable String*/
  String Temperature = String(t);
  String Humidity = String(h);
  • Imprimimos los valores obtenidos en el terminal Serial, de Temperatura y Humedad.
/*Imprimimos en el terminal Serial, los valores la Temperatura y Humedad*/
  Serial.print("Temperatura: ");
  Serial.println(Temperature);
  Serial.print("Humedad: ");
  Serial.println(Humidity);
  • Hacemos una variable String, donde incorporaremos los valores a enviar a la plataforma.
/*Definimos una variable String que ocupe los valores del sensor, y así fuera enviado*/
  String payload = "{\"Temperatura\":" + String(Temperature)
    + ",\"Humedad\":" + String(Humidity) + "}";
  • Para el envío de los datos, se pasa a usar los siguientes comandos para el envío de datos a la plataforma.
/*Usamos las siguientes comandos para hacer el envío de datos a Qubitro*/
  mqttClient.poll();
  mqttClient.beginMessage(deviceID);
  mqttClient.print(payload);
  mqttClient.endMessage();
  • Imprimimos una frase en el terminal Serial, para verificar el envío de datos a la plataforma. Agregamos además un retardo de 3 segundos.
/*Imprimimos los datos en el Terminal Serial para verificar que exactamente estaría llegando a la plataforma*/
  Serial.println("Enviando a Qubitro: ");
  Serial.print(payload);
  /*Hacemos un retardo de 3 segundos*/
  delay(30 * 1000);
}
  • En la función Serial_Init(), pasamos a iniciar el terminal Serial a 115200, agregamos un pequeño retardo e iniciamos nuestro sensor DHT.
/*Iniciamos la función Serial_Init*/
void serial_init() {
  /*Iniciamos el terminal Serial a una velocidad de 115200*/
  Serial.begin(115200);
  /*Incluimos un retardo de 200 milisegundos e iniciamos nuestro sensor DHT*/
  delay(200);
  dht.begin();
}
  • En la función Wifi_init(), se procede a configurar el Wifi en modo estación, para proceder a desconectarlo y seguir con un retardo de 100 ms.
/*Iniciamos la función WiFi_init()*/
void wifi_init() {
  /*Configuramos el modo WiFi como modo Estación*/
  WiFi.mode(WIFI_STA);
  /*Desconectamos el modo WiFi para luego encenderlo, junto a un retardo de 100*/
  WiFi.disconnect();
  delay(100);
  • Iniciamos la conexión a la red WiFi, con las credenciales indicadas anteriormente, e imprimimos una frase.
/*Iniciamos la conexión Wifi, con las credenciales*/
  WiFi.begin(ssid, password);
  /*Imprimimos una frase que nos indica la conexión a la red*/
  Serial.print("Connecting to WiFi...");
  • Aquí, agregamos un condicional que diga que mientras se conecta a la red, se procede a imprimir caracteres hasta que este resulte. Como tal, cuando la conexión sea exitosa, se imprimirán frases indicando la conexión como la IP asignada al dispositivo y su RSSI.
/*Se imprimirán caracteres, significando que se está realizando la conexión a la red*/
  while(true)
  {
    delay(1000);
    Serial.print(".");
    if (WiFi.status() == WL_CONNECTED)
    {
      Serial.println("");
      /*una vez conectado, imprimimos la frase WiFi Connected, y unos datos adicionales respecto a la conexión del dispositivo con la red*/
      Serial.println("WiFi Connected.");
      Serial.print("Local IP: ");
      Serial.println(WiFi.localIP());
      Serial.print("RSSI: ");
      Serial.println(WiFi.RSSI());
      break;
    }
  }
}
  • En la función Qubitro_init(), definimos el broker al cual debemos apuntar para el envío de datos como el puerto al cual debemos enviar.
/*Iniciamos la función Qubitro_Init*/
void qubitro_init() {
  /*Indicamos en una variables Char, el broker al cual debemos apuntar, junto al puerto a utilizar*/
  char host[] = "broker.qubitro.com";
  int port = 1883;
  • En esta parte, se procede a usar el deviceID y el deviceToken para realizar la conexión a la plataforma. Luego, imprimimos una frase indicando la conexión a la plataforma.
/*Utilizamos el deviceID y el deviceToken, a utilizar para realizar la conexión e imprimimos una frase*/
  mqttClient.setId(deviceID);
  mqttClient.setDeviceIdToken(deviceID, deviceToken);
  Serial.println("Connecting to Qubitro...");
  • Si es que no se realiza la conexión, se procederá a imprimir una frase de error, junto a información a seguir para hacer la conexión a la plataforma.
/*Definimos una condicional, que indican las acciones a realizar si no se hace la conexión a la plataforma */
  if (!mqttClient.connect(host, port))
  {
    Serial.print("Connection failed. Error code: ");
    Serial.println(mqttClient.connectError());
    Serial.println("Visit docs.qubitro.com or create a new issue on github.com/qubitro");
  }
  • Una vez realizada la conexión, se imprimirá una frase y se pasará a suscribir a la plataforma, por si habría mensajes de retorno de la plataforma al dispositivo.
/*Una vez realizada la conexión, imprimimos la frase Conectado a Qubitro, y realizamos la subscripcion a la plataforma para los mensajes de Retorno*/
  Serial.println("Connected to Qubitro.");
  mqttClient.subscribe(deviceID);
}

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.

Procedemos a dirigirnos a la plataforma Qubitro, para crear un pequeño Dashboard donde se vean los datos. Para eso, nos dirigimos a lado izquierdo de la plataforma.

Ahora, damos clic en New Dashboard para poder crear la interfaz.

Se nos pedirá poner el nombre al Dashboard que queremos crear. Se puede usar el nombre que el usuario desee.

Una vez creado el Dashboard, pasamos a agregar los Widgets indicados para visualizar los datos.

Podemos hacer la elección del tipo de Widget que queremos usar, y debemos especificar el proyecto y el equipo del cual se usarán sus datos.

Como tal, procedemos ahora a escoger los datos, y la configuración de la parte estética del Dashboard. Una vez realizado, se pueden agregar más Widgets para ver los demás datos. Ejem: Gráficos lineales, etc.

Los datos enviados aparecerán en el Dashboard creado hace un momento, se mostrarán los datos dentro de los Widgets, de la siguiente manera:

Podremos visualizar los datos que llegan a la plataforma en el Dashboard creado, y con esto cerramos el ejercicio de esta semana.

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

10/01/2022
ESP32

Sebastian Carranza

Equipo TodoMaker.
Ingeniería de Telecomunicaciones.
Experiencia en Proyectos de Internet de las Cosas (IoT)

Previous Post
Next Post