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
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2021/10/SMELPRO-ESP32-PINOUT.jpg?resize=705%2C591&ssl=1)
- Sensor DHT11 Temperatura y Humedad Relativa
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2021/10/DHT11-PINOUT-1024x858.jpg?resize=512%2C429&ssl=1)
Entendido ya que pines poseen ambos componentes, realizamos el siguiente circuito.
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2021/10/ESP32-UBIDOTSDHT11_bb-1024x573.png?resize=768%2C430&ssl=1)
Procedemos a realizar las siguientes conexiones entre los dispositivos:
ESP32 DEVKIT V1 | SENSOR DHT11 |
PIN 3.3V | VCC |
PIN GND | GND |
PIN DIGITAL 23 | DATA |
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.
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2021/10/LIBRERIA-DHT11-SMELPRO-1.jpg?resize=785%2C440&ssl=1)
Ahora, procedemos a instalar la librería para la conexión con la plataforma, denominada “QubitroMqttClient.h”
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/LIB2COPIA-1024x577.png?resize=768%2C433&ssl=1)
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/
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/login-1024x493.png?resize=1024%2C493&ssl=1)
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.
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/PROYECTCOPIA-1024x465.png?resize=1024%2C465&ssl=1)
Una vez creado el proyecto, pasamos a crear un Dispositivo. Damos clic a la opción Add Device
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/adddevicecopia-1024x493.png?resize=1024%2C493&ssl=1)
Completamos la información que se requiere, de acuerdo a como se muestra la imagen a continuación.
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/completarcopia-1024x497.png?resize=1024%2C497&ssl=1)
Creado el dispositivo, pasamos a ir al inciso “Settings”
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/sewttingscopia-1024x495.png?resize=1024%2C495&ssl=1)
Verificamos que tenemos 2 credenciales: DeviceID y DeviceToken. Pasamos a copiar ambos, ya que los usaremos en nuestro código.
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/keyscopia-1-1024x460.png?resize=512%2C230&ssl=1)
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.
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/COD-1-1024x533.png?resize=1024%2C533&ssl=1)
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/ESP32COPPIA2-1-1024x858.png?resize=768%2C644&ssl=1)
HORA DE EJECUTAR EL PROYECTO
Una vez hecho el circuito y subido nuestro código, obtendremos los siguientes resultados.
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/serial-3.png?resize=688%2C508&ssl=1)
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.
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/dashb1copia-1024x491.png?resize=1024%2C491&ssl=1)
Ahora, damos clic en New Dashboard para poder crear la interfaz.
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/crearcopia-1024x504.png?resize=1024%2C504&ssl=1)
Se nos pedirá poner el nombre al Dashboard que queremos crear. Se puede usar el nombre que el usuario desee.
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/test.png?resize=392%2C209&ssl=1)
Una vez creado el Dashboard, pasamos a agregar los Widgets indicados para visualizar los datos.
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/widgetcopia-1024x493.png?resize=1024%2C493&ssl=1)
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.
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/elegir.png?resize=837%2C652&ssl=1)
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.
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/indicadores.png?resize=661%2C613&ssl=1)
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:
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/01/dash-1024x493.png?resize=1024%2C493&ssl=1)
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.
![](https://i0.wp.com/todomaker.com/wp-content/uploads/2022/09/introduccion-al-esp32-portada-1024x576.jpg?resize=1024%2C576&ssl=1)
Te invitamos a tomar el curso de Introducción al ESP32: Introducción al ESP32 | TodoMaker’s School