Saltar al contenido
Nivel avanzado

Monitorear la calefacción con Internet de las Cosas

Introducción a Internet de las Cosas (IoT)

Internet de las Cosas (en inglés Internet of Things, abreviado IoT) es un concepto que refiere a la interconexión digital de objetos cotidianos con internet. Por ejemplo, monitorear la temperatura de un ambiente enviando los datos de un sensor a una central donde se recopile la información, para visualizarla desde un dispositivo móvil: la temperatura de un laboratorio, de un invernadero o de la habitación que estamos calefaccionando.

Para poder incorporar IoT a nuestro proyecto es necesario:

  1. Un dispositivo capaz de conectarse a internet.
  2. Un servidor que reciba y aloje los datos.

Existen diversas formas de registrar y almacenar los datos. En este caso, se detallará cómo hacerlo con el WiFi integrado de la placa ESP32 y con los servidores de Adafruit IO.

El material original de 2019 resolvía este punto agregando al Arduino UNO un módulo externo llamado OBLOQ, un adaptador WiFi-serie de DFRobot hoy discontinuado (igual que su biblioteca ObloqAdafruit). Como el UNO clásico no tiene conectividad propia, en esta reedición la práctica de IoT se realiza con la variante ESP32 del proyecto: podés seguir este nivel de manera conceptual con tu UNO (el paso 3, sobre código no bloqueante, funciona perfectamente en él) y cambiar al ESP32 con el selector de plataforma para la parte práctica de conexión, que es idéntica en lo didáctico y más simple en el circuito.

El ESP32 cumple los dos roles a la vez: es el microcontrolador que ya está midiendo la temperatura y comandando el radiador, y, además, trae radio WiFi integrada. No hace falta ningún módulo adicional ni cableado extra: la conexión a internet se resuelve por completo desde el código.

Crear un panel de control en Adafruit IO

Primero se explicará cómo crear un panel de control en Adafruit IO, una plataforma online con posibilidad de uso gratuito, orientada al uso educativo, que centraliza la información que reportan los dispositivos. Empezamos creando una cuenta de usuario en io.adafruit.com.

Una vez que ingresamos, el trabajo tiene dos partes: crear los feeds donde se publicarán los datos y armar el panel que los muestre.

Un feed es una fuente de datos en la que uno puede publicar, así como también suscribirse para recibir sus datos. Desde la sección Feeds creamos dos, con estos nombres exactos (sin tildes, porque forman parte de la dirección con la que se publica):

  • temperatura: recibirá el valor de temperatura en grados Celsius.
  • humedad: recibirá el valor de humedad relativa del aire, en porcentaje.

Luego, desde la sección Dashboards, creamos un nuevo panel con el nombre y la descripción que quieras. Dentro del panel agregamos, tal como propone el original, dos bloques del tipo Line Chart (gráfico de línea), uno por feed: nos permiten ver el historial de los cambios en la temperatura y en la humedad a lo largo del tiempo. Al finalizar, el panel replicará a distancia la evolución de las condiciones de la habitación.

Por último, necesitamos las credenciales que le permitirán a nuestro dispositivo publicar en la cuenta: en Adafruit IO, tocá el ícono de la llave (API Key). Vas a ver dos datos, el nombre de usuario (Username) y la clave (Active Key): anotalos, porque los vamos a copiar dentro del código en el paso 4. La clave es secreta: cualquiera que la tenga puede publicar en tus feeds.

Programar sin código bloqueante

Antes de usar IoT debemos hacer una aclaración sobre la función delay() que venimos usando (nuestro programa espera unos segundos entre medición y medición). Esta función brinda un tiempo de espera al sistema y suele usarse bastante en las primeras aproximaciones a la programación, porque su comportamiento es fácil de comprender y no requiere más que una línea de código.

Sin embargo, delay() genera un código bloqueante: cuando el programa entra en esa función, se detiene todo el procesamiento hasta que se cumple el tiempo indicado. En otras palabras, el programa queda “colgado” durante ese período.

Al utilizar IoT, el código bloqueante es un problema: mientras el procesamiento está detenido, el sistema no puede realizar otras operaciones que funcionan en simultáneo, como las tareas de publicación y el mantenimiento constante de la conexión a internet.

Para evitarlo, usamos una alternativa no bloqueante, la función millis(). Esta función devuelve un conteo de tiempo (en milisegundos) desde que se inició el sistema: funciona como un cronómetro que, cada vez que se lo consulta, informa en cuánto va. Con eso podemos preguntarle al sistema cuánto tiempo pasó desde la última medición, sin detener todo lo demás.

La receta tiene tres ingredientes, que vas a reconocer en el código: una variable millisAnterior, que guarda cuándo fue la última medición (arranca en cero); la consulta del valor actual con millis() en cada vuelta de loop(); y la comparación entre ambos contra el INTERVALO_MEDICION_MS. Si ya pasó el intervalo, el programa mide, actualiza y anota el nuevo valor en millisAnterior, para que la cuenta arranque de cero otra vez. Si todavía no pasó el tiempo, no espera: sigue de largo, con el procesador libre para otras tareas.

Este nivel introduce, además, un cambio para probar con seguridad: como en el original, reemplazamos el relé por un LED que enciende cuando el radiador debería estar calentando, así verificamos toda la lógica sin cablear 220 V. La programación del LED es exactamente igual a la del relé, de modo que una vez comprobado se podría volver a conectar el relé. El LED queda encendido fijo mientras la calefacción está activa (temperatura por debajo del objetivo) y apagado cuando la habitación ya alcanzó la temperatura deseada.

Ver el código completo · calefaccion-no-bloqueante.ino
calefaccion-no-bloqueante.ino Arduino UNO 
// Calefaccion SIN delay(): el DHT11 mide la temperatura, el LCD 16x2 la
// muestra y el radiador se enciende mientras haga frio (temperatura por
// debajo del objetivo). Todo con millis() en lugar de delay(): cada vuelta de
// loop() pregunta si ya paso el intervalo y, si no, deja el procesador libre.
// Esta es la base directa de la version IoT (solo ESP32): sin codigo
// bloqueante, el micro puede sumar WiFi y MQTT sin desatender el sensor.
//
// !! PRUEBA SIN 220V !!  Como en el original, en este nivel REEMPLAZAMOS el
// rele por un LED conectado al pin 13 para probar la logica sin cablear los
// 220V. La programacion del LED es identica a la del rele: cuando el LED se
// enciende, el radiador real se prenderia. Una vez verificado, se vuelve a
// conectar el rele (pin 3) con las precauciones de 220V del README.
//
// Plataforma: Arduino UNO.
// Conexion: dato del DHT11 -> pin 2; LED de prueba -> pin 13 (el UNO ademas
// tiene el LED integrado en ese pin); display LCD Keypad Shield en modo
// paralelo por los pines 8, 9, 4, 5, 6, 7.
//
// Nota del original: en el LCD no usar tildes ni la letra Ñ.
//
// Basado en: Fragmento de codigo del Nivel Avanzado (Paso 5, patron millis,
// LED por if/else, sin la parte IoT) - Sistema de Calefaccion Automatico,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernizacion: (1) constantes nombradas; millisAnterior como unsigned long
// (el long del original desborda la cuenta). (2) DHT de Adafruit con
// dht.begin(). (3) Se ignora una lectura fallida del DHT11 (isnan).
// CORRECCION DE LOGICA (ver README): el codigo original de este paso encendia
// el LED cuando la temperatura SUPERABA los 22 grados (texto y codigo heredados
// del proyecto de invernadero, donde el LED significaba "ventilar"). Para un
// sistema de CALEFACCION eso esta invertido: aca el radiador se enciende
// cuando la temperatura esta POR DEBAJO del objetivo (hace frio), coherente
// con el termostato del nivel intermedio.

#include "DHT.h"
#include <LiquidCrystal.h>

// Pin de datos del sensor y tipo de sensor (DHT11).
const int PIN_DHT = 2;
#define DHTTYPE DHT11

// En el avanzado, el original reemplaza el rele por un LED en el pin 13 para
// probar sin 220V. Encendido = el radiador se prenderia. Para el sistema real,
// volvé a poner el rele del pin 3 (la programacion es la misma).
const int PIN_LED = 13;

// Temperatura objetivo fija del original (22 grados). Por debajo de este
// valor hace frio y se enciende el radiador.
const float TEMP_OBJETIVO_C = 22.0;

// El DHT11 no admite mas de una lectura por segundo; medimos cada 2 s.
const unsigned long INTERVALO_MEDICION_MS = 2000;

// Objeto del sensor y display paralelo (RS, E, D4, D5, D6, D7).
DHT dht(PIN_DHT, DHTTYPE);
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

// Momento (ms desde el arranque) de la ultima medicion.
unsigned long millisAnterior = 0;

void setup() {
  pinMode(PIN_LED, OUTPUT);
  dht.begin();
  lcd.begin(16, 2);
  lcd.clear();
}

void loop() {
  unsigned long millisActual = millis();

  // ¿Ya paso el intervalo desde la ultima medicion? Si no, no hacemos nada y
  // loop() vuelve a empezar: eso es NO bloquear.
  if (millisActual - millisAnterior >= INTERVALO_MEDICION_MS) {
    millisAnterior = millisActual;

    float temperatura = dht.readTemperature(); // grados Celsius

    // Una lectura fallida del DHT11 devuelve "no numerico": la salteamos.
    if (!isnan(temperatura)) {
      // Logica de calefaccion: encender si hace frio (por debajo del objetivo).
      if (temperatura < TEMP_OBJETIVO_C) {
        digitalWrite(PIN_LED, HIGH);
      } else {
        digitalWrite(PIN_LED, LOW);
      }

      // Mostramos la temperatura actual. Sin tildes ni Ñ (limitacion LCD).
      lcd.setCursor(0, 0);
      lcd.print("Temp Act: ");
      lcd.print(temperatura);
    }
  }

  // En este punto el procesador queda libre para realizar otras tareas (en la
  // version IoT del ESP32, aca se atiende la conexion WiFi/MQTT).
}
calefaccion-no-bloqueante.ino ESP32 
// Calefaccion SIN delay(): el DHT11 mide la temperatura, el LCD 16x2 (I2C) la
// muestra y el radiador se enciende mientras haga frio (temperatura por
// debajo del objetivo). Todo con millis() en lugar de delay(): cada vuelta de
// loop() pregunta si ya paso el intervalo y, si no, deja el procesador libre.
// Esta es la base directa de calefaccion-iot.ino: sin codigo bloqueante, el
// ESP32 puede sumar WiFi y MQTT sin desatender el sensor.
//
// !! PRUEBA SIN 220V !!  Como en el original, en este nivel REEMPLAZAMOS el
// rele por un LED (aca en GPIO 16) para probar la logica sin cablear los 220V.
// La programacion del LED es identica a la del rele: cuando el LED se
// enciende, el radiador real se prenderia. Una vez verificado, se vuelve a
// conectar el rele (GPIO 25) con las precauciones de 220V del README.
//
// Plataforma: ESP32 (DevKit v1).
// Conexion: dato del DHT11 -> GPIO 4; LED de prueba externo -> GPIO 16;
// display LCD 1602 por I2C: SDA -> GPIO 21, SCL -> GPIO 22.
//
// ADAPTACION DE PLATAFORMA (ver README): el original usa un LCD Keypad Shield
// paralelo (6 pines) que NO entra en un ESP32; aca usamos un LCD 1602 con
// modulo I2C (2 cables, libreria LiquidCrystal_I2C, direccion tipica 0x27;
// probá 0x3F si no muestra nada). Nota electrica: el ESP32 trabaja a 3,3 V.
//
// Nota del original: en el LCD no usar tildes ni la letra Ñ.
//
// Librerias requeridas (Library Manager): "DHT sensor library" (Adafruit) +
// "Adafruit Unified Sensor", y "LiquidCrystal_I2C".
//
// Basado en: Fragmento de codigo del Nivel Avanzado (Paso 5, patron millis,
// LED por if/else, sin la parte IoT) - Sistema de Calefaccion Automatico,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernizacion: constantes nombradas; millisAnterior como unsigned long; DHT
// de Adafruit con dht.begin(); LCD paralelo del original adaptado a I2C; se
// ignora la lectura fallida del DHT11 (isnan).
// CORRECCION DE LOGICA (ver README): el codigo original encendia el LED cuando
// la temperatura SUPERABA los 22 grados (texto heredado del proyecto de
// invernadero, donde el LED significaba "ventilar"). Para un sistema de
// CALEFACCION eso esta invertido: aca el radiador se enciende cuando la
// temperatura esta POR DEBAJO del objetivo (hace frio).

#include "DHT.h"
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Pin de datos del sensor y tipo de sensor (DHT11).
const int PIN_DHT = 4;
#define DHTTYPE DHT11

// En el avanzado se reemplaza el rele por un LED (GPIO 16) para probar sin
// 220V. Encendido = el radiador se prenderia. Para el sistema real, volvé a
// poner el rele del GPIO 25 (la programacion es la misma).
const int PIN_LED = 16;

// Direccion I2C y tamaño del display (16 columnas x 2 filas).
const uint8_t LCD_DIRECCION_I2C = 0x27;
const uint8_t LCD_COLUMNAS      = 16;
const uint8_t LCD_FILAS         = 2;

// Temperatura objetivo fija del original (22 grados). Por debajo de este
// valor hace frio y se enciende el radiador.
const float TEMP_OBJETIVO_C = 22.0;

// El DHT11 no admite mas de una lectura por segundo; medimos cada 2 s.
const unsigned long INTERVALO_MEDICION_MS = 2000;

// Objeto del sensor y display por I2C.
DHT dht(PIN_DHT, DHTTYPE);
LiquidCrystal_I2C lcd(LCD_DIRECCION_I2C, LCD_COLUMNAS, LCD_FILAS);

// Momento (ms desde el arranque) de la ultima medicion.
unsigned long millisAnterior = 0;

void setup() {
  pinMode(PIN_LED, OUTPUT);
  dht.begin();
  lcd.init();
  lcd.backlight();
  lcd.clear();
}

void loop() {
  unsigned long millisActual = millis();

  // ¿Ya paso el intervalo desde la ultima medicion? Si no, no hacemos nada y
  // loop() vuelve a empezar: eso es NO bloquear.
  if (millisActual - millisAnterior >= INTERVALO_MEDICION_MS) {
    millisAnterior = millisActual;

    float temperatura = dht.readTemperature(); // grados Celsius

    // Una lectura fallida del DHT11 devuelve "no numerico": la salteamos.
    if (!isnan(temperatura)) {
      // Logica de calefaccion: encender si hace frio (por debajo del objetivo).
      if (temperatura < TEMP_OBJETIVO_C) {
        digitalWrite(PIN_LED, HIGH);
      } else {
        digitalWrite(PIN_LED, LOW);
      }

      // Mostramos la temperatura actual. Sin tildes ni Ñ (limitacion LCD).
      lcd.setCursor(0, 0);
      lcd.print("Temp Act: ");
      lcd.print(temperatura);
    }
  }

  // En este punto el procesador queda libre para realizar otras tareas (en
  // calefaccion-iot.ino, aca se atiende la conexion WiFi/MQTT).
}
El mismo termostato del nivel intermedio, ahora sin delay(): el programa consulta millis() y solo mide cuando pasó el intervalo. Para probar sin 220 V, el aviso se muestra con un LED encendido fijo (encendido = el radiador está calentando).

En el Arduino UNO el LED de prueba es el del pin 13 (la constante PIN_LED del código), que ya está integrado en la placa: no hace falta cablear nada para verlo.

En el ESP32 usamos un LED externo en el GPIO 16 (la constante PIN_LED del código), un pin de salida seguro. No usamos el LED integrado del DevKit, que está en el GPIO 2, un strapping pin que interviene en el arranque de la placa y conviene dejar libre.

Teniendo un programa con código no bloqueante (es decir, sin delay()) estamos en condiciones de incorporar IoT.

Programar IoT

Con el panel listo y el código ya libre de bloqueos, falta el último eslabón: que el sistema publique la temperatura y la humedad en Adafruit IO.

Esta parte práctica corresponde a la variante ESP32: el Arduino UNO clásico no tiene WiFi (el original lo resolvía con el módulo OBLOQ, hoy discontinuado). Cambiá la plataforma a ESP32 con el selector para ver el código y las instrucciones de conexión. Todo lo conceptual —qué se publica en cada feed, el porqué del código no bloqueante— ya lo tenés resuelto con tu UNO en los pasos anteriores.

El programa final integra tres cosas que ya conocés: el control no bloqueante del paso 3, la conexión WiFi nativa del ESP32 y la publicación en Adafruit IO (mediante el protocolo MQTT, usando la Adafruit MQTT Library, que se instala desde el gestor de bibliotecas del Arduino IDE; reemplaza a la biblioteca ObloqAdafruit del original, discontinuada junto con su módulo).

Antes de subirlo, tenés que completar cuatro datos al comienzo del código: el nombre (SSID) y la contraseña de tu red WiFi, y el usuario y la clave que copiaste de Adafruit IO en el paso 2.

La publicación se engancha en el tiempo que el paso 3 le dejó libre al procesador: en cada vuelta de loop(), además de medir cuando toca, el programa mantiene viva la conexión con el servidor y publica los cambios. Para no gastar el cupo de la cuenta gratuita de Adafruit IO (30 publicaciones por minuto), un valor se re-publica solo si cambió lo suficiente respecto del último enviado: al menos 0,5 °C la temperatura y al menos 1 % la humedad. El original publicaba en cada medición; como el DHT11 tiene resolución de 1 °C y 1 %, en la práctica se publica ante cualquier cambio real (el desvío está documentado en la ficha). Por esto es importante que el código no sea bloqueante: si el programa quedara colgado en un delay(), la conexión no podría atenderse y las publicaciones se perderían.

Un detalle que corregimos del original: su programa IoT publicaba en el feed humedad una variable humedad que nunca leía del sensor (no estaba declarada). En esta reedición leemos la humedad real con dht.readHumidity() y publicamos ese valor, aprovechando que el DHT11 mide humedad y temperatura a la vez.

Ver el código completo · calefaccion-iot.ino

Nota: Este código está disponible para ESP32. Cambiá la plataforma con el selector del encabezado para verlo y practicarlo.

calefaccion-iot.ino ESP32 
// Calefaccion con monitoreo IoT via Adafruit IO (MQTT).
// La logica no bloqueante de calefaccion-no-bloqueante.ino sigue midiendo con
// el DHT11, mostrando en el LCD (I2C) y accionando el radiador (aca, el LED de
// prueba) segun la temperatura; ademas publica dos feeds para ver el ambiente
// desde el Panel de Control de Adafruit (como en la guia):
//
//   "temperatura": grados Celsius.
//   "humedad": humedad relativa en % (aprovechando que el DHT11 tambien la mide).
//
// !! PRUEBA SIN 220V !!  Igual que en el nivel avanzado, se REEMPLAZA el rele
// por un LED (GPIO 16) para probar sin cablear los 220V. Encendido = el
// radiador real se prenderia. Para el sistema real, volvé a poner el rele
// (GPIO 25) con las precauciones de 220V del README.
//
// Plataforma: ESP32 (DevKit v1) - usa su WiFi integrado.
// Conexion: dato del DHT11 -> GPIO 4; LED de prueba externo -> GPIO 16;
// display LCD 1602 por I2C: SDA -> GPIO 21, SCL -> GPIO 22.
//
// ADAPTACION DE PLATAFORMA (ver README): el original usa un LCD Keypad Shield
// paralelo (6 pines) que no entra en un ESP32; aca usamos un LCD 1602 con
// modulo I2C (2 cables, libreria LiquidCrystal_I2C, direccion tipica 0x27;
// probá 0x3F si no muestra nada). Nota electrica: el ESP32 trabaja a 3,3 V.
//
// Nota del original: en el LCD no usar tildes ni la letra Ñ.
//
// Librerias requeridas (Library Manager): "DHT sensor library" (Adafruit) +
// "Adafruit Unified Sensor", "LiquidCrystal_I2C" y "Adafruit MQTT Library".
//
// Basado en: Fragmento de codigo del Nivel Avanzado (Paso 6, IoT) - Sistema de
// Calefaccion Automatico, Saberes Digitales (INET/EDUCAR 2019)
// Modernizacion: (1) el modulo OBLOQ y la libreria ObloqAdafruit quedaron
// discontinuados; se reemplazan por el WiFi nativo del ESP32 (WiFi.h) y MQTT
// contra io.adafruit.com. (2) BUG DEL ORIGINAL CORREGIDO: el original publicaba
// olq.publish("humedad", humedad) pero la variable "humedad" NUNCA se leia del
// sensor (no compilaba / publicaba basura); aca se lee humedad de verdad con
// dht.readHumidity() y se publica ese valor real. (3) El original publicaba
// temperatura y humedad en CADA medicion (1 s = 120 publicaciones/min, muy por
// encima del limite gratuito de Adafruit IO de 30/min); aca se publican SOLO
// cuando cambian de forma apreciable (temperatura >= 0,5 grados; humedad >= 1 %)
// respecto de lo ultimo publicado. (4) Se ignora una lectura fallida del DHT11
// (isnan). (5) El LCD paralelo del original se adapta a I2C.
// CORRECCION DE LOGICA (ver README): el original encendia el LED cuando la
// temperatura SUPERABA los 22 grados (herencia del proyecto de invernadero,
// "ventilar"); para una CALEFACCION eso esta invertido, asi que aca el radiador
// se enciende cuando la temperatura esta POR DEBAJO del objetivo (hace frio).

#include <WiFi.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include "DHT.h"
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"

// ---------------------------------------------------------------------------
// Credenciales: reemplazar los cuatro valores por los propios.
// El usuario y la key de Adafruit se copian desde io.adafruit.com haciendo
// clic en el icono de la "llave" (igual que en la guia original).
// ---------------------------------------------------------------------------
#define WIFI_SSID     "TU_SSID"
#define WIFI_PASSWORD "TU_PASSWORD"
#define IO_USERNAME   "TU_USUARIO_ADAFRUIT"
#define IO_KEY        "TU_KEY_ADAFRUIT"

// Servidor MQTT de Adafruit IO.
const char SERVIDOR_MQTT[] = "io.adafruit.com";
const int  PUERTO_MQTT     = 1883;

// Pin de datos del sensor y tipo de sensor (DHT11).
const int PIN_DHT = 4;
#define DHTTYPE DHT11

// LED de prueba que reemplaza al rele para trabajar sin 220V (ver encabezado).
const int PIN_LED = 16;

// Direccion I2C y tamaño del display (16 columnas x 2 filas).
const uint8_t LCD_DIRECCION_I2C = 0x27;
const uint8_t LCD_COLUMNAS      = 16;
const uint8_t LCD_FILAS         = 2;

// Temperatura objetivo fija del original (22 grados): por debajo hace frio y
// se enciende el radiador.
const float TEMP_OBJETIVO_C = 22.0;

// El DHT11 no admite mas de una lectura por segundo; medimos cada 2 s.
const unsigned long INTERVALO_MEDICION_MS = 2000;

// Un valor se re-publica solo si cambio al menos esto respecto del ultimo
// publicado: evita gastar el cupo gratuito de Adafruit IO (30 pub/min).
const float UMBRAL_PUBLICACION_TEMP_C = 0.5;
const float UMBRAL_PUBLICACION_HUM    = 1.0;

// Si se cae la conexion MQTT, reintentamos cada tanto SIN bloquear.
const unsigned long INTERVALO_REINTENTO_MQTT_MS = 5000;

// Objetos de sensor, display, WiFi y MQTT.
DHT dht(PIN_DHT, DHTTYPE);
LiquidCrystal_I2C lcd(LCD_DIRECCION_I2C, LCD_COLUMNAS, LCD_FILAS);
WiFiClient clienteWifi;
Adafruit_MQTT_Client mqtt(&clienteWifi, SERVIDOR_MQTT, PUERTO_MQTT,
                          IO_USERNAME, IO_KEY);
Adafruit_MQTT_Publish feedTemperatura(&mqtt, IO_USERNAME "/feeds/temperatura");
Adafruit_MQTT_Publish feedHumedad(&mqtt, IO_USERNAME "/feeds/humedad");

// Momento (ms) de la ultima medicion y del ultimo intento de conexion MQTT.
unsigned long millisAnterior = 0;
unsigned long millisUltimoIntentoMqtt = 0;

// Ultimo valor que llego a publicarse de cada feed. Separarlo de la medicion
// permite publicar solo los cambios y ponerse al dia tras una desconexion.
// Se arranca con valores imposibles para forzar la primera publicacion.
float temperaturaPublicada = -1000.0;
float humedadPublicada     = -1000.0;
bool  hayMedicion          = false;

// Diferencia sin signo entre dos numeros (para comparar contra el umbral).
float diferenciaAbsoluta(float a, float b) {
  if (a > b) {
    return a - b;
  }
  return b - a;
}

// Mantiene viva la conexion MQTT sin bloquear el sensor: si esta caida,
// reintenta como mucho una vez cada 5 segundos.
void mantenerConexionMqtt() {
  if (mqtt.connected()) {
    return;
  }

  unsigned long millisActual = millis();
  if (millisActual - millisUltimoIntentoMqtt < INTERVALO_REINTENTO_MQTT_MS) {
    return; // todavia no toca reintentar
  }
  millisUltimoIntentoMqtt = millisActual;

  Serial.print("Conectando a Adafruit IO... ");
  int8_t resultado = mqtt.connect(); // 0 = conexion exitosa
  if (resultado == 0) {
    Serial.println("conectado.");
  } else {
    Serial.println(mqtt.connectErrorString(resultado));
    mqtt.disconnect(); // deja el socket limpio para el proximo intento
  }
}

// Publica cada feed SOLO si cambio lo suficiente desde la ultima publicacion
// exitosa. Si publish() falla o no hay conexion, no se actualiza el registro:
// se reintenta en la proxima vuelta.
void publicarCambios(float temperatura, float humedad) {
  if (!mqtt.connected() || !hayMedicion) {
    return; // sin internet o sin datos reales todavia: no se publica
  }

  if (diferenciaAbsoluta(temperatura, temperaturaPublicada)
        >= UMBRAL_PUBLICACION_TEMP_C
      && feedTemperatura.publish(temperatura)) {
    temperaturaPublicada = temperatura;
  }

  if (diferenciaAbsoluta(humedad, humedadPublicada) >= UMBRAL_PUBLICACION_HUM
      && feedHumedad.publish(humedad)) {
    humedadPublicada = humedad;
  }
}

void setup() {
  Serial.begin(115200);

  pinMode(PIN_LED, OUTPUT);
  dht.begin();
  lcd.init();
  lcd.backlight();
  lcd.clear();

  // Conexion WiFi. Esperar aca con delay() es aceptable porque el ciclo de
  // medicion todavia no arranco; una vez dentro de loop(), nada bloquea.
  Serial.print("Conectando a la red WiFi");
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("WiFi conectado, IP: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  unsigned long millisActual = millis();

  // --- Medicion, control del radiador y display, cada 2 s (respeta el DHT11) ---
  if (millisActual - millisAnterior >= INTERVALO_MEDICION_MS) {
    millisAnterior = millisActual;

    float temperatura = dht.readTemperature(); // grados Celsius
    float humedad     = dht.readHumidity();    // humedad relativa en %

    // Una lectura fallida del DHT11 devuelve "no numerico": la salteamos para
    // no mostrar ni publicar basura.
    if (!isnan(temperatura) && !isnan(humedad)) {
      hayMedicion = true;

      // Logica de calefaccion: encender si hace frio (por debajo del objetivo).
      if (temperatura < TEMP_OBJETIVO_C) {
        digitalWrite(PIN_LED, HIGH);
      } else {
        digitalWrite(PIN_LED, LOW);
      }

      // Fila 0: temperatura. Fila 1: humedad. Sin tildes ni Ñ (limitacion LCD).
      lcd.setCursor(0, 0);
      lcd.print("Temp Act: ");
      lcd.print(temperatura);
      lcd.setCursor(0, 1);
      lcd.print("Hum.: ");
      lcd.print(humedad);

      // Publicamos temperatura y humedad (solo si cambiaron lo suficiente).
      publicarCambios(temperatura, humedad);
    }
  }

  // --- Mantenimiento de la conexion IoT, en cada vuelta ---
  // Gracias a que la medicion no bloquea, esto se atiende continuamente: esta
  // es la razon de fondo por la que la guia abandona delay() antes de IoT.
  mantenerConexionMqtt();
}
La calefacción IoT completa: control no bloqueante + WiFi del ESP32 + publicación de la temperatura y la humedad (leída de verdad del DHT11) en Adafruit IO, solo cuando cambian.

Así queda funcionando el tablero que permite monitorear la calefacción a distancia. Podés ver el sistema completo —el sensor midiendo, el aviso y el panel reflejando cada publicación— en el simulador:

Simulación del comportamiento

La misma máquina de estados del firmware, portada a TypeScript, maneja el comportamiento del dispositivo. No se ejecuta el binario real: la ejecución del .hex con avr8js está en el roadmap.

Simulación lista. Presioná «Iniciar» para arrancar la secuencia.

Cierre del nivel

Al terminar este nivel, la calefacción de Martina dejó de ser solo un dispositivo local: es un dispositivo IoT. El programa funciona con millis(), sin ningún delay() que lo cuelgue; sabés explicar por qué eso es imprescindible cuando hay que atender internet en simultáneo; y el panel de Adafruit IO muestra desde cualquier dispositivo la temperatura y la humedad de la habitación. Con esto queda completo el recorrido del proyecto. Si el grupo quiere seguir, en la ficha del proyecto están las extensiones sugeridas: controlar el radiador a distancia por IoT, sumar un sistema de humidificación, o combinarlo con el proyecto “Sistema Lumínico Automático” para seguir trabajando el uso eficiente de la energía.

Evidencia de cierre

Al terminar este nivel, esto tiene que estar funcionando:

  • El sistema funciona con código no bloqueante basado en millis(): no queda ningún delay() que detenga el programa entre mediciones, y para probar sin 220 V el aviso se muestra con un LED encendido fijo (pin 13 en el UNO, GPIO 16 en el ESP32) en lugar del relé.
  • Podés explicar con tus palabras por qué el código bloqueante es un problema cuando el dispositivo tiene que atender internet en simultáneo.
  • El panel de Adafruit IO muestra la temperatura y la humedad del ambiente publicadas por el dispositivo (variante ESP32), con la humedad leída de verdad del DHT11.