Resumen
¿Te imaginas poder monitorear la temperatura de distintos puntos en tiempo real desde tu celular, estés donde estés? En esta guía aprenderás a crear tu propio Sistema de Temperatura Múltiple IoT utilizando una ESP32 DevKit V1, tres sensores DS18B20 y la potente plataforma Blynk.
Este proyecto combina electrónica y conectividad WiFi para medir temperatura en tres zonas diferentes usando sensores digitales de alta precisión. Gracias al protocolo OneWire, los tres sensores pueden conectarse a un solo pin de la ESP32, simplificando el cableado y manteniendo el sistema ordenado y eficiente.
Introducción
Antes de enseñarte como poner en marcha este sistema, debemos tener bien definido las herramientas que usaremos, y cómo funcionan, esto ayudará a si se requiere hacer modificaciones o mejoras incluso, recordemos que la base de todo proyecto es saber que usar para obtener los mejores resultados.
Blynk IoT ¿Qué es?
Blynk es una plataforma IoT (Internet de las Cosas) de bajo código que permite conectar hardware como Arduino, Raspberry Pi o ESP32 a la nube para crear aplicaciones móviles y web personalizadas. Permite monitorear y controlar dispositivos de forma remota, ideal para prototipos rápidos y productos comerciales, con funciones de arrastrar y soltar widgets.
Características
- Interfaz fácil de usar: Permite diseñar interfaces móviles ricas en funciones en minutos sin necesidad de programación compleja.
- Compatibilidad amplia: Funciona con más de 400 tarjetas de desarrollo y microcontroladores, incluyendo ESP32 y Arduino.
- Conectividad: Se comunica con la nube de Blynk mediante WiFi, Ethernet, 2G, 3G o 4G.
- Control y Monitoreo: Permite encender/apagar dispositivos o visualizar datos de sensores en tiempo real desde cualquier lugar.
- Personalización: Ofrece widgets como botones, deslizadores, gráficos, displays y notificaciones.
- Uso: Ideal para proyectos caseros (domótica) hasta soluciones profesionales de IoT.
Herramientas
- Blynk App: Aplicación móvil para Android/iOS para crear la interfaz.
- Blynk Cloud: Servidor donde se gestionan los datos y la comunicación.
- Blynk Library: Código necesario para que el hardware se conecte a la plataforma.
DS18B20 ¿Cómo funciona?
El DS18B20 es un sensor de temperatura digital de alta precisión (±0.5°C). Se caracteriza por utilizar el protocolo 1-Wire (solo requiere un pin de datos) y medir entre -55°C y +125°C. Es muy popular en proyectos de IoT y con Arduino (o ESP32) gracias a su formato robusto y estanco.
Características
- Protocolo 1-Wire: Permite conectar múltiples sensores a un solo pin de datos.
- Identificación única: Cada sensor tiene una dirección de 64 bits grabada de fábrica, lo que permite identificarlos individualmente en una red.
- Resolución: Programable de 9 a 12 bits.
- Voltaje de operación: 3.0V a 5.5V.
Protocolo de Comunicación One Wire.
El protocolo 1-Wire es una via de comunicaciones en serie diseñado por Dallas Semiconductor. Está basado en un bus, un maestro y varios esclavos de una sola línea de datos en la que se alimentan. Por supuesto, necesita una referencia a tierra común a todos los dispositivos.
La línea de datos/alimentación requiere una resistencia de pull-up conectada a la alimentación y que le proporciona ésta.
Funcionamiento
Se mantiene la señal de datos a 0 voltios durante 480 microsegundos. Se reinician todos los dispositivos conectados al bus (les retira la alimentación). Los dispositivos reiniciados indican su presencia manteniendo la señal de datos a 0 voltios durante 60 microsegundos.
Para enviar un bit a 1 el maestro se lleva a 0 voltios la línea de datos durante 1-15 microsegundos. Para enviar un bit a 0 el maestro se lleva a 0 voltios la línea de datos durante 60 microsegundos. Los dispositivos esclavos leen el bit aproximadamente a los 30 microsegundos después del flanco de bajada de cada bit.
Cuando el maestro lee los datos del dispositivo esclavo pone 0 voltios durante 1-15 microsegundos en la línea de datos y a partir de ese momento el esclavo no hace nada (la señal se mantiene en 5 voltios) si quiere enviar un 1 lógico o mantiene la señal en 0 voltios hasta los 60 microsegundos si quiere enviar un 0 lógico.
Los datos se envían o reciben en grupos de 8 bits. Para iniciar una comunicación se reinicia el bus.
Como en el bus puede haber muchos dispositivos el protocolo incluye el direccionamiento de estos empleando un código único de 64 bits de los cuales el byte más significativo indica el tipo de dispositivo, y el último es un código de detección de errores (CRC) de 8 bits.
Ahora que tenemos las bases principales de este sistema, se puede pasar al desarrollo de este, ahora bien, si tienes dudas de la ESP32, cómo funciona o sus principales características, puedes visitar alguna de las entradas que tenemos en nuestro blog o en nuestra biblioteca.
Materiales
- ESP32 DEVKIT V1 30 Pines USB-C.
- UNIT Tarjeta de Expansión para ESP32 30 Pines.
- DS18B20 Sensor de temperatura Digital x3.
- Cable USB Tipo C.
- Protoboard.
- Jumpers.
- Resistencia 4.7KΩ.
- PC / Ordenador.
- Arduino IDE.
- Aplicación Blynk.
Diagrama de Conexión
Te dejo el diagrama de conexión para este sistema, es realmente sencillo y muy rápido de realizar solo ten cuidado con la posición del sensor DS18B20, es muy común equivocarse.
Requerimientos Previos
Para el sistema se usarán solo dos softwares, uno es el clásico IDE de Arduino y el otro es Blynk, este lo usaremos desde un navegador, pero también desde el celular para un monitoreo a distancia.
Instalar Arduino IDE
Para la instalación de Arduino IDE se puede hacer desde su página oficial, dando solo click en “Descargar”, verificando que sea su sistema operativo el seleccionado, se ejecuta como administrador, y se dará en siguiente a todas las ventanas.
La otra opción más sencilla es abrir la “Microsoft Store” y buscar Arduino IDE, se tendrá la siguiente imagen:
Se dará click en “Obtener” y listo se tendrá instalado, cualquiera de las dos formas funcionará.
Instalar Librerías
Un punto sumamente es la correcta instalación de librerías, ya que si se descargan las incorrectas el código no funcionará de forma adecuada. Abriremos el IDE de Arduino y nos dirigiremos a “Library Manager”, posteriormente buscaremos “OneWire”, tendrá que salir la siguiente búsqueda:
Una vez encontrada, solo se dará clic en “Install”, hay que esperar a que termine, esto puede tardar un poco, pero no te desesperes; posteriormente buscaremos las siguientes librerías y haremos lo mismo:
Con las librerías ya instaladas, se podrá posteriormente compilar el código y cargarlo a nuestra tarjeta ESP32, ahora bien, si tienes dudas de como poder bajar los recursos para la programación puedes visitar la sección de Información Adicional, de la página del producto en nuestra página, ahí viene el paso a paso de como probarla de forma sencilla.
Instalación de Blynk
Primero accederemos a la página oficial de Blynk desde un navegador web, dentro de ella, solo daremos clic en “Get Started”, y ahí haremos los pasos necesarios para crear nuestra cuenta:
Ahora procederemos a buscarla desde la play store en cualquier dispositivo Android o también puede ser Mac, en ambos sistemas se en encuentra disponible:
Ya que esté instalada, vamos a abrirla, para iniciar sesión, daremos clic en “Acceso” y solo tendremos que ingresar el correo electrónico/contraseña que hayamos creados. Tenemos ambos softwares/aplicación para nuestro sistema IoT, así que pasemos al código de programación.
Código de Programación
Vamos a hablar un poco de este código; la ESP32 se conecta al WiFi con red 2.4 GHz, esto es muy importante ya que esta tarjeta no soporta 5 GHz; posteriormente se enlaza a los servidores de Blynk, una vez completado, empieza a enviar cada 2 segundos los valores de temperatura de los sensores.
En cuanto a las alertas se enviarán cuando alguno de los sensores supere los 28 °C, y se reiniciarán cuando la temperatura baje a 25 °C, así mismo el sistema detecta si algún sensor está desconectado, enviando igualmente una alerta.
Para la configuración del código debemos cambiar los #define (líneas 31 – 33), con los datos que nos de Blynk, esto lo veremos a detalle en el siguiente apartado; también se debe cambiar los char (líneas 40 y 41), por la información de nuestra red 2.4 GHz.
/*
========================================================================================================================
Nombre del archivo: CON_ALARMA.ino
Proyecto: UNIT Electronics Blog - Sistema de Temperatura Múltiple IoT con ESP32 y DS18B20
Área: Desarrollo
Autor: Gonzalo González
Fecha: 27/10/2025
========================================================================================================================
Descripción:
La ESP32 se conecta a internet a través de WiFi, con redes 2.4 GHz, y a su vez hace un enlace a Blynk, posteriormente envía
cada 2 segundos los valores de temperatura que tienen los sensores DS. Las alertas se envían cada vez que un sensor supera
los 28 °C, y esta se reinicia de nuevo cuando baja su temperatura a 25 °C, de igual manera si se encuentra un sensor des-
conectado enviará la alerta al sistema.
========================================================================================================================
Conexión de Hardware
DS18B20 a ESP32
VCC - 3.3V
SIN - GPIO 4
GND - GND
Resistencia 4.7kOhms - ESP32
GPIO 4 - R1 - VCC
========================================================================================================================
Desarrollado para UNIT Electronics / Desarrollo / Blog UNIT Electronics
========================================================================================================================
*/
#define BLYNK_TEMPLATE_ID "ID DE TU TEMPLATE"
#define BLYNK_TEMPLATE_NAME "NOMBRE DE TU TEMPLATE"
#define BLYNK_AUTH_TOKEN "TOKEN DE LA ESP32"
#include <WiFi.h>
#include <BlynkSimpleEsp32.h>
#include <OneWire.h>
#include <DallasTemperature.h>
char ssid[] = "NOMBRE DE TU RED";
char pass[] = "CONTRASEÑA DE TU RED";
#define ONE_WIRE_BUS 4
#define TEMP_MAX 28.0
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
BlynkTimer timer;
// Variables anti-spam
bool alertaT1 = false;
bool alertaT2 = false;
bool alertaT3 = false;
void checkAlerts(float t1, float t2, float t3) {
// SENSOR 1
if (t1 == -127.0) {
Blynk.logEvent("sensor_error", "Sensor 1 desconectado");
}
if (t1 > TEMP_MAX && !alertaT1) {
Blynk.logEvent("alta_t1", "Temperatura 1 ALTA");
alertaT1 = true;
}
if (t1 <= 25.0 ) {
alertaT1 = false;
}
// SENSOR 2
if (t2 == -127.0) {
Blynk.logEvent("sensor_error", "Sensor 2 desconectado");
}
if (t2 > TEMP_MAX && !alertaT2) {
Blynk.logEvent("alta_t2", "Temperatura 2 ALTA");
alertaT2 = true;
}
if (t2 <= 25.0) {
alertaT2 = false;
}
// SENSOR 3
if (t3 == -127.0) {
Blynk.logEvent("sensor_error", "Sensor 3 desconectado");
}
if (t3 > TEMP_MAX && !alertaT3) {
Blynk.logEvent("alta_t3", "Temperatura 3 ALTA");
alertaT3 = true;
}
if (t3 <= 25.0) {
alertaT3 = false;
}
}
void sendTemperatures() {
sensors.requestTemperatures();
float temp1 = sensors.getTempCByIndex(0);
float temp2 = sensors.getTempCByIndex(1);
float temp3 = sensors.getTempCByIndex(2);
Blynk.virtualWrite(V0, temp1);
Blynk.virtualWrite(V1, temp2);
Blynk.virtualWrite(V2, temp3);
checkAlerts(temp1, temp2, temp3);
}
void setup() {
Serial.begin(115200);
sensors.begin();
Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);
timer.setInterval(2000L, sendTemperatures);
}
void loop() {
Blynk.run();
timer.run();
}Funcionamiento
Con todo explicado y preparado, vamos a hacer que este sistema funcione, primero debemos configurar nuestro template en Blynk.
Template de Blynk
Al abrir Blynk, daremos clic en “Zona de desarrollador” que se encuentra en la columna izquierda:
En la sección de “Plantillas” daremos clic en “Nueva Plantilla” ahí configuraremos nuestro Template de la siguiente manera:
Podemos cambiar el nombre al que tú gustes al igual que la descripción, los campos que debemos llenar, así como aparece es el “Hardware” y “Tipo de Conexión”, de lo contrario no funcionará; una vez llenado, hay que dar clic en “Hecho”.
Flujo de Datos
Tendremos la ventana en donde nos dirán los pasos a realizar, pero no te preocupes yo te diré que hacer paso a paso, lo primero será “Configurar Flujo de Datos”, así que le daremos clic. Se abrirá otra ventana y ahí tendremos que seleccionar “+ Nuevo Flujo de Datos” y después en “Pin Virtual”. Cambiaremos el nombre, tipo de dato, unidades y los valores mínimos/máximos del flujo de datos:
Con los valores ya actualizados, solo daremos clic en “Crear”; este paso lo haremos tres veces, ya que serán los pines (sensores) que tendremos en nuestro Template, naturalmente lo que cambiará será el nombre a V1, V2, y si añadiéramos más, se formarían consecutivamente. Si hacemos todo correcto, se tendrá la siguiente lista de Flujo de Datos:
Panel Web
Ahora iremos al apartado de “Panel Web”:
Aquí haremos la interfaz gráfica de los sensores, seleccionaremos un “Indicador Radial” o puede ser solo “Indicador”:
Lo arrastraremos a la “Dashboard”, colocaremos el cursor sobre el indicador y aparecerá un engranaje de configuración, daremos clic ahí y abrirá la siguiente ventana:
Tendremos que configurar los parámetros como aparece, realmente sencillo; este indicador se vinculará con el flujo de datos que ya hicimos anteriormente; esto igual lo repetiremos 3 veces para los diferentes sensores que se tienen, igual solo cambiará el título y el flujo de forma consecutiva. Una vez terminado la Dashboard, se tendrá el siguiente resultado:
Eventos y Notificaciones
Ya casi terminamos, solo falta configurar “Eventos y notificaciones”, así que iremos a ese apartado:
Daremos clic en “+ Agregar Nuevo Evento”, se abrirá la siguiente ventana, donde configuraremos “General”, “Notificaciones” y “Configuración”:
Hay que cambiar esos parámetros, exceptuando la descripción, esa solo si tú lo deseas, todo lo demás debe quedar, así como se ve, ahora pasaremos a la siguiente pestaña “Notificaciones”:
En esta pestañada debemos activar esas opciones y configurar el correo electrónico y las notificaciones push, ahora pasemos a lo último en “Configuración”:
Dejaremos estos parámetros tal como están, sobre todo el límite, ya que, de lo contrario, solo pondrá enviar una alerta cada hora en vez de que sea inmediato, recuerda algo super importante DEBES GUARDAR TODO LOS CAMBIOS REALIZADOS, si no lo haces, tendrás que repetir todo.
El proceso de alerta se hará 3 veces para cada sensor, solo lo que cambia es el “Nombre del Evento” de forma consecutiva, en el caso de la alerta de desconexión del algún sensor, se debe configurar la primera pestaña de la siguiente manera:
Se cambiará el nombre del evento, el código, color y el tipo; todo lo contrario, quedará igual. Si hacemos todos los pasos de forma correcta, tendremos la siguiente lista:
Alta de Dispositivo ESP32
Con la “Zona de Desarrollador” totalmente configurada, pasemos al punto más importante de Blynk, dar de alta un dispositivo; para ello primero daremos clic a “Dispositivos” de la columna izquierda de la página web:
Haremos clic en “+ Nuevo Dispositivo”, y de ahí en el recuadro de “Desde Plantilla”:
Se abrirá una ventana en donde tendremos que escoger la “Plantilla” y el “Nombre del Dispositivo”, en este caso con ponerle ESP32 es suficiente:
Cuando le demos clic en “Crear”, se abrirá una ventana, pero OJO aquí en la esquina superior derecha saldrá un recuadro como este:
Esta información es la que cambiaremos en el código que les mencione anteriormente, ten mucho cuidado, así como está cópialo y pégalo, si haces un ligero cambio, aunque sea mínimo, no funcionará correctamente, y si en tu cabeza llegas a pensar en copiar los datos de la imagen, temo decirte que ese template será eliminado jaja. Ahora ya tenemos todo, así que pasemos a la configuración de la aplicación Android/Mac.
Configuración de App Blynk
Abriremos la aplicación desde nuestro celular, tendremos la siguiente vista:
Aquí daremos clic en el “ESP32”, abrirá una nueva ventana donde seleccionaremos el recuadro verde con la llave española, para configurar la parte visual del Template:
En esta vista, daremos clic en el círculo verde “+” para ir agregando los indicadores como lo hicimos en el navegador web:
Una vez que se pongamos un indicador en el “Dashboard”, hay que configurarlo, la diferencia es que es más sencillo en la app, solo tendremos que seleccionar el flujo de dato que queremos para ese indicador:
Obviamente tendremos que colocar 3 indicadores y a cada uno de esto asignar el pin virtual, que le corresponde:
Si hicimos todo bien, tendremos el dashboard de la siguiente manera:
Prueba Final
En el IDE de Arduino solo cargaremos el código con los cambios del Template y la red que tengas, recuerda, DEBE SER 2.4 GHz, SELECIONA BIEN EL COM Y TARJETA, de lo contrario nunca se conectará, una vez que hayas hecho ese paso, verás está información en el navegador:
El ESP32 cambiará su estado a Online, esto puede tardar alrededor de 5 minutos así que ten paciencia, ahora bien, en la imagen 36 puedes notar una temperatura elevada, así que enviará una alerta al celular:
Aquí se nota como la temperatura del sensor 3 paso del valor permitido; ahora bien, si desconectamos algún sensor, simulando un mal funcionamiento esta es la información que envía:
Envía la alerta de desconexión e indica también que sensor es el que fallo, también manda alertas a través del correo electrónico, estás no las enseñaremos por cuestiones de privacidad. De igual forma en la aplicación en el celular lo vas a poder monitorear en tiempo real:
Este sistema, se realizó a petición de un seguidor que nos comentó la idea y decidimos llevarla a cabo, y agradecemos de todo corazón que nos den ideas, comenten o incluso nos dejen sus dudas, así que, si tienes algún proyecto en mente, puedes dejar tu comentario, ten la seguridad de que lo leeremos.
Conclusión
El desarrollo del sistema de temperatura múltiple IoT demuestra cómo la integración de hardware y software puede dar como resultado una solución práctica, escalable y de fácil implementación. Mediante el uso de la ESP32 DevKit V1, los sensores DS18B20 y la plataforma Blynk, se logró crear un sistema capaz de monitorear en tiempo real tres zonas distintas de temperatura, enviar datos a la nube y generar alertas automáticas ante condiciones críticas o fallos de conexión.
El uso del protocolo OneWire permitió simplificar considerablemente el cableado al conectar múltiples sensores a un solo pin, manteniendo el sistema ordenado y eficiente. Además, la implementación de notificaciones con límites configurables y control anti-spam asegura una supervisión confiable sin saturar al usuario con avisos repetitivos.
Este proyecto no solo cumple con el objetivo de monitoreo remoto, sino que también sienta las bases para futuras ampliaciones, como la integración de más sensores, automatización de sistemas de ventilación o calefacción, o su aplicación en entornos domésticos, industriales o agrícolas. En definitiva, se trata de una solución didáctica y funcional que combina conectividad, programación y electrónica, demostrando el gran potencial del IoT cuando se aplican correctamente sus herramientas y recursos.
