Invernadero Inteligente

// Aviso de ventilación por temperatura: un sensor DHT11 mide la temperatura
// del aire del invernadero y, cuando supera el umbral, un LED PARPADEA para
// avisar que hay que ventilar. Mientras la temperatura esté por debajo del
// umbral, el LED queda apagado.
//
// ¿Por qué parpadea y no queda fijo? Así lo plantea el original: un LED que
// titila llama más la atención que uno encendido de forma continua. En el
// nivel avanzado, ya con pantalla y monitoreo, el aviso evoluciona a
// encendido fijo (encendido = ventilar / apagado = todo en orden).
//
// Plataforma: Arduino UNO.
// Conexión (la del esquema original): dato del DHT11 → pin 2; pata larga
// (positiva) del LED → pin 13, con su resistencia a GND. El pin 13 tiene
// además el LED integrado de la placa, útil para probar sin LED externo.
//
// Basado en: Fragmento de código del Nivel Inicial (Paso 6) — Invernadero
// Inteligente, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: (1) se reemplazó el C generado por mBlock3 (_delay, _loop)
// por C++ idiomático con constantes nombradas. (2) Se usa la librería "DHT
// sensor library" de Adafruit (instalar desde el Library Manager; arrastra
// como dependencia "Adafruit Unified Sensor"), que reemplaza a la vieja
// "DHT.h" genérica del original — ya no se consigue igual. Requiere
// dht.begin() en setup(), que el código viejo no llamaba.

#include "DHT.h"

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

// LED indicador de "hay que ventilar".
const int PIN_LED_VENTILACION = 13;

// Umbral del original: por encima de 25 °C hay que ventilar.
const float UMBRAL_TEMP_C = 25.0;

// Tiempos del parpadeo del aviso (medio segundo encendido, medio apagado),
// como en el original.
const unsigned long PARPADEO_ENCENDIDO_MS = 500;
const unsigned long PARPADEO_APAGADO_MS   = 500;

// El DHT11 no admite más de una lectura por segundo (es su límite físico).
// Medimos cada 2 s: margen seguro, y la librería de Adafruit además cachea
// la lectura durante 2 s. El original pedía 1 s; 2 s es el valor honesto
// para este sensor.
const unsigned long INTERVALO_MEDICION_MS = 2000;

// Creamos el objeto del sensor: pin de datos + tipo.
DHT dht(PIN_DHT, DHTTYPE);

void setup() {
  pinMode(PIN_LED_VENTILACION, OUTPUT);
  // La librería de Adafruit necesita esta inicialización (la vieja no).
  dht.begin();
}

void loop() {
  // readTemperature() devuelve la temperatura en grados Celsius.
  float temperatura = dht.readTemperature();

  if (temperatura > UMBRAL_TEMP_C) {
    // Demasiado calor: un parpadeo del LED para avisar que hay que ventilar.
    digitalWrite(PIN_LED_VENTILACION, HIGH);
    delay(PARPADEO_ENCENDIDO_MS);
    digitalWrite(PIN_LED_VENTILACION, LOW);
    delay(PARPADEO_APAGADO_MS);
  }
  // Si la temperatura no supera el umbral, el LED simplemente queda apagado
  // (no se toca, y quedó en LOW del parpadeo anterior o del arranque).

  // Espera entre mediciones (respeta el límite del DHT11). En este nivel
  // usamos delay(): es la herramienta que ya conocemos y hace que el
  // programa se lea de arriba hacia abajo igual que su comportamiento.
  delay(INTERVALO_MEDICION_MS);
}

// Aviso de ventilación por temperatura: un sensor DHT11 mide la temperatura
// del aire del invernadero y, cuando supera el umbral, un LED PARPADEA para
// avisar que hay que ventilar. Mientras la temperatura esté por debajo del
// umbral, el LED queda apagado.
//
// ¿Por qué parpadea y no queda fijo? Así lo plantea el original: un LED que
// titila llama más la atención. En el nivel avanzado el aviso evoluciona a
// encendido fijo.
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: dato del DHT11 → GPIO 4; pata larga (positiva) del LED → GPIO 16,
// con su resistencia a GND.
// Decisión de plataforma: se usa un LED EXTERNO en GPIO 16, no el LED
// integrado del DevKit (GPIO 2). Motivo: el GPIO 2 es un "strapping pin"
// (interviene en el arranque de la placa) y conviene dejarlo libre; además,
// el indicador de "ventilar" se ve mejor como un LED discreto montado en el
// invernadero. Documentado también en el README.
// Nota eléctrica: el ESP32 trabaja a 3,3 V (no 5 V como el UNO); el DHT11
// funciona bien a 3,3 V.
//
// Basado en: Fragmento de código del Nivel Inicial (Paso 6) — Invernadero
// Inteligente, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: (1) C++ idiomático con constantes nombradas en vez del C
// de mBlock3; portado a ESP32. (2) Librería "DHT sensor library" de Adafruit
// (instalar desde el Library Manager con su dependencia "Adafruit Unified
// Sensor"), que reemplaza la vieja "DHT.h" del original y requiere
// dht.begin() en setup().

#include "DHT.h"

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

// LED externo indicador de "hay que ventilar".
const int PIN_LED_VENTILACION = 16;

// Umbral del original: por encima de 25 °C hay que ventilar.
const float UMBRAL_TEMP_C = 25.0;

// Tiempos del parpadeo del aviso, como en el original.
const unsigned long PARPADEO_ENCENDIDO_MS = 500;
const unsigned long PARPADEO_APAGADO_MS   = 500;

// El DHT11 no admite más de una lectura por segundo; medimos cada 2 s
// (margen seguro; la librería de Adafruit además cachea 2 s).
const unsigned long INTERVALO_MEDICION_MS = 2000;

// Objeto del sensor: pin de datos + tipo.
DHT dht(PIN_DHT, DHTTYPE);

void setup() {
  pinMode(PIN_LED_VENTILACION, OUTPUT);
  dht.begin();
}

void loop() {
  // readTemperature() devuelve la temperatura en grados Celsius.
  float temperatura = dht.readTemperature();

  if (temperatura > UMBRAL_TEMP_C) {
    // Demasiado calor: un parpadeo del LED para avisar que hay que ventilar.
    digitalWrite(PIN_LED_VENTILACION, HIGH);
    delay(PARPADEO_ENCENDIDO_MS);
    digitalWrite(PIN_LED_VENTILACION, LOW);
    delay(PARPADEO_APAGADO_MS);
  }
  // Si la temperatura no supera el umbral, el LED queda apagado.

  // Espera entre mediciones (respeta el límite del DHT11).
  delay(INTERVALO_MEDICION_MS);
}

// Invernadero con display: el sensor DHT11 mide temperatura y humedad del
// aire, un LCD 16x2 las muestra en pantalla, y el LED de ventilación
// PARPADEA cuando la temperatura supera el umbral (igual que en el nivel
// inicial). Ahora, además del aviso, vemos los números exactos.
//
// Plataforma: Arduino UNO.
// Conexión (la del esquema original): dato del DHT11 → pin 2; LED → pin 13;
// display LCD Keypad Shield en modo paralelo por los pines 8, 9, 4, 5, 6, 7.
// El shield se apila directamente sobre el UNO; su potenciómetro RP1 ajusta
// el contraste si no se lee el texto.
//
// Nota del original: en el LCD no usar tildes ni la letra Ñ (el display no
// las representa bien). Por eso los rótulos van como "Temp." y "Hum.".
//
// Basado en: Fragmento de código del Nivel Intermedio (Paso 5) — Invernadero
// Inteligente, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: (1) constantes nombradas en vez del C de mBlock3. (2)
// Librería DHT de Adafruit (ver nivel inicial), con dht.begin(). (3) El
// original llamaba a readTemperature() y readHumidity() varias veces por
// vuelta; acá se leen UNA vez a variables y esos mismos valores se usan
// para el LED y para el display.

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

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

// LED indicador de "hay que ventilar".
const int PIN_LED_VENTILACION = 13;

// Umbral del original: por encima de 25 °C hay que ventilar.
const float UMBRAL_TEMP_C = 25.0;

// Tiempos del parpadeo del aviso, como en el original.
const unsigned long PARPADEO_ENCENDIDO_MS = 500;
const unsigned long PARPADEO_APAGADO_MS   = 500;

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

// Objeto del sensor: pin de datos + tipo.
DHT dht(PIN_DHT, DHTTYPE);

// Display LCD en modo paralelo. El orden de pines es el del LCD Keypad
// Shield: (RS, E, D4, D5, D6, D7) = (8, 9, 4, 5, 6, 7).
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

void setup() {
  pinMode(PIN_LED_VENTILACION, OUTPUT);
  dht.begin();
  // Inicializamos el display de 16 columnas por 2 filas y lo limpiamos.
  lcd.begin(16, 2);
  lcd.clear();
}

void loop() {
  // Leemos una sola vez y reutilizamos los valores. readTemperature() da
  // grados Celsius; readHumidity() da humedad relativa en %.
  float temperatura = dht.readTemperature();
  float humedad     = dht.readHumidity();

  if (temperatura > UMBRAL_TEMP_C) {
    // Demasiado calor: un parpadeo del LED para avisar que hay que ventilar.
    digitalWrite(PIN_LED_VENTILACION, HIGH);
    delay(PARPADEO_ENCENDIDO_MS);
    digitalWrite(PIN_LED_VENTILACION, LOW);
    delay(PARPADEO_APAGADO_MS);
  }

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

  delay(INTERVALO_MEDICION_MS);
}

// Invernadero con display: el sensor DHT11 mide temperatura y humedad del
// aire, un LCD 16x2 las muestra en pantalla, y el LED de ventilación
// PARPADEA cuando la temperatura supera el umbral (igual que en el inicial).
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: dato del DHT11 → GPIO 4; LED externo → GPIO 16; display LCD 1602
// por I2C: SDA → GPIO 21, SCL → GPIO 22 (los pines I2C por defecto del ESP32).
//
// ADAPTACIÓN DE PLATAFORMA (¡importante!, ver README): el original usa un
// LCD Keypad Shield, una placa con formato Arduino UNO que se apila sobre la
// placa y se maneja con LiquidCrystal en modo PARALELO (6 pines de datos:
// 8, 9, 4, 5, 6, 7). Ese shield NO se enchufa en un ESP32. Por eso en ESP32
// usamos un LCD 1602 con módulo I2C: solo DOS cables de señal (SDA y SCL) en
// lugar de seis, y la librería LiquidCrystal_I2C en lugar de LiquidCrystal.
// Es el estándar moderno y evita el problema del shield. La dirección I2C
// típica de estos módulos es 0x27 (algunos son 0x3F: si la pantalla no
// muestra nada, probá 0x3F o escaneá el bus I2C).
// Nota eléctrica: el ESP32 trabaja a 3,3 V; DHT11 y el módulo I2C del LCD
// funcionan a 3,3 V.
//
// Nota del original: en el LCD no usar tildes ni la letra Ñ.
//
// Librerías requeridas (Library Manager): "DHT sensor library" (Adafruit) +
// su dependencia "Adafruit Unified Sensor", y "LiquidCrystal_I2C".
//
// Basado en: Fragmento de código del Nivel Intermedio (Paso 5) — Invernadero
// Inteligente, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: constantes nombradas; DHT de Adafruit con dht.begin(); LCD
// paralelo del original adaptado a I2C para ESP32; una sola lectura por
// vuelta reutilizada para LED y display.

#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

// LED externo indicador de "hay que ventilar".
const int PIN_LED_VENTILACION = 16;

// Dirección 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;

// Umbral del original: por encima de 25 °C hay que ventilar.
const float UMBRAL_TEMP_C = 25.0;

// Tiempos del parpadeo del aviso, como en el original.
const unsigned long PARPADEO_ENCENDIDO_MS = 500;
const unsigned long PARPADEO_APAGADO_MS   = 500;

// El DHT11 no admite más 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);

void setup() {
  pinMode(PIN_LED_VENTILACION, OUTPUT);
  dht.begin();
  // Con I2C, primero arranca el bus y el display; backlight enciende la luz.
  lcd.init();
  lcd.backlight();
  lcd.clear();
}

void loop() {
  // Leemos una sola vez y reutilizamos los valores.
  float temperatura = dht.readTemperature(); // grados Celsius
  float humedad     = dht.readHumidity();    // humedad relativa en %

  if (temperatura > UMBRAL_TEMP_C) {
    // Demasiado calor: un parpadeo del LED para avisar que hay que ventilar.
    digitalWrite(PIN_LED_VENTILACION, HIGH);
    delay(PARPADEO_ENCENDIDO_MS);
    digitalWrite(PIN_LED_VENTILACION, LOW);
    delay(PARPADEO_APAGADO_MS);
  }

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

  delay(INTERVALO_MEDICION_MS);
}

// Invernadero SIN delay(): el DHT11 mide temperatura y humedad, el LCD 16x2
// las muestra y el LED de ventilación queda ENCENDIDO FIJO mientras la
// temperatura supera el umbral (apagado si está por debajo). Todo con
// millis() en lugar de delay(): cada vuelta de loop() pregunta si ya pasó
// el intervalo y, si no, deja el procesador libre.
//
// Cambio de comportamiento del LED respecto a los niveles anteriores: acá
// el aviso pasa de parpadeo a encendido fijo, tal como evoluciona el
// original al llegar al nivel avanzado (con pantalla y monitoreo, un estado
// estable se lee mejor que un titileo). Esta es además la base directa de
// invernadero-iot.ino: sin código bloqueante, el ESP32 puede sumar WiFi y
// MQTT sin desatender el sensor.
//
// Plataforma: Arduino UNO.
// Conexión (la del esquema original): dato del DHT11 → pin 2; LED → pin 13;
// 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: Fragmentos de código del Nivel Superior (Paso 5, patrón millis,
// con LED encendido/apagado por if/else y sin la parte IoT) — Invernadero
// Inteligente, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: constantes nombradas; millisAnterior como unsigned long
// (el long del original desborda la cuenta); librería DHT de Adafruit con
// dht.begin(); una sola lectura por ciclo reutilizada para LED y display.

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

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

// LED indicador de "hay que ventilar".
const int PIN_LED_VENTILACION = 13;

// Umbral del original: por encima de 25 °C hay que ventilar.
const float UMBRAL_TEMP_C = 25.0;

// El DHT11 no admite más 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 última medición.
unsigned long millisAnterior = 0;

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

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

  // ¿Ya pasó el intervalo desde la última medición? 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
    float humedad     = dht.readHumidity();    // humedad relativa en %

    // Aviso de ventilación como encendido fijo (if/else): encendido = hay
    // que ventilar, apagado = temperatura en orden.
    if (temperatura > UMBRAL_TEMP_C) {
      digitalWrite(PIN_LED_VENTILACION, HIGH);
    } else {
      digitalWrite(PIN_LED_VENTILACION, LOW);
    }

    // Fila 0: temperatura. Fila 1: humedad. Sin tildes ni Ñ (limitación LCD).
    lcd.setCursor(0, 0);
    lcd.print("Temp.: ");
    lcd.print(temperatura);
    lcd.setCursor(0, 1);
    lcd.print("Hum.: ");
    lcd.print(humedad);
  }

  // En este punto el procesador queda libre para realizar otras tareas.
}

// Invernadero SIN delay(): el DHT11 mide temperatura y humedad, el LCD 16x2
// (I2C) las muestra y el LED de ventilación queda ENCENDIDO FIJO mientras la
// temperatura supera el umbral (apagado si está por debajo). Todo con
// millis(): cada vuelta de loop() pregunta si ya pasó el intervalo y, si no,
// deja el procesador libre.
//
// El aviso pasa de parpadeo (niveles anteriores) a encendido fijo, como
// evoluciona el original. Este programa es la base directa de
// invernadero-iot.ino: sin código bloqueante, el ESP32 puede sumar WiFi y
// MQTT sin desatender el sensor.
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: dato del DHT11 → GPIO 4; LED externo → GPIO 16; display LCD 1602
// por I2C: SDA → GPIO 21, SCL → GPIO 22.
//
// ADAPTACIÓN DE PLATAFORMA (ver README): el original usa un LCD Keypad
// Shield paralelo (6 pines) que no entra en un ESP32; acá usamos un LCD 1602
// con módulo I2C (2 cables, librería LiquidCrystal_I2C, dirección típica
// 0x27; probá 0x3F si no muestra nada).
// Nota eléctrica: el ESP32 trabaja a 3,3 V.
//
// Nota del original: en el LCD no usar tildes ni la letra Ñ.
//
// Librerías requeridas (Library Manager): "DHT sensor library" (Adafruit) +
// "Adafruit Unified Sensor", y "LiquidCrystal_I2C".
//
// Basado en: Fragmentos de código del Nivel Superior (Paso 5, patrón millis,
// LED por if/else, sin la parte IoT) — Invernadero Inteligente, Saberes
// Digitales (INET/EDUCAR 2019)
// Modernización: constantes nombradas; millisAnterior como unsigned long;
// DHT de Adafruit con dht.begin(); LCD paralelo del original adaptado a I2C;
// una sola lectura por ciclo reutilizada para LED y display.

#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

// LED externo indicador de "hay que ventilar".
const int PIN_LED_VENTILACION = 16;

// Dirección 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;

// Umbral del original: por encima de 25 °C hay que ventilar.
const float UMBRAL_TEMP_C = 25.0;

// El DHT11 no admite más 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 última medición.
unsigned long millisAnterior = 0;

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

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

  // ¿Ya pasó el intervalo desde la última medición? 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
    float humedad     = dht.readHumidity();    // humedad relativa en %

    // Aviso de ventilación como encendido fijo (if/else).
    if (temperatura > UMBRAL_TEMP_C) {
      digitalWrite(PIN_LED_VENTILACION, HIGH);
    } else {
      digitalWrite(PIN_LED_VENTILACION, LOW);
    }

    // Fila 0: temperatura. Fila 1: humedad. Sin tildes ni Ñ (limitación LCD).
    lcd.setCursor(0, 0);
    lcd.print("Temp.: ");
    lcd.print(temperatura);
    lcd.setCursor(0, 1);
    lcd.print("Hum.: ");
    lcd.print(humedad);
  }

  // En este punto el procesador queda libre para realizar otras tareas
  // (en invernadero-iot.ino, acá se atiende la conexión WiFi/MQTT).
}

// Invernadero con monitoreo IoT vía Adafruit IO (MQTT).
// La lógica no bloqueante de invernadero-no-bloqueante.ino sigue midiendo
// con el DHT11, mostrando en el LCD (I2C) y encendiendo el LED de
// ventilación; además publica dos feeds para ver las condiciones del
// invernadero desde el Panel de Control de Adafruit (como en la guía):
//
//   "temperatura": grados Celsius.
//   "humedad": humedad relativa en %.
//
// Plataforma: ESP32 (DevKit v1) — usa su WiFi integrado.
// Conexión: dato del DHT11 → GPIO 4; LED externo → GPIO 16; display LCD 1602
// por I2C: SDA → GPIO 21, SCL → GPIO 22.
//
// ADAPTACIÓN DE PLATAFORMA (ver README): el original usa un LCD Keypad
// Shield paralelo (6 pines) que no entra en un ESP32; acá usamos un LCD 1602
// con módulo I2C (2 cables, librería LiquidCrystal_I2C, dirección típica
// 0x27; probá 0x3F si no muestra nada).
// Nota eléctrica: el ESP32 trabaja a 3,3 V.
//
// Nota del original: en el LCD no usar tildes ni la letra Ñ.
//
// Librerías requeridas (Library Manager): "DHT sensor library" (Adafruit) +
// "Adafruit Unified Sensor", "LiquidCrystal_I2C" y "Adafruit MQTT Library".
//
// Basado en: Fragmento de código del Nivel Superior (Paso 6) — Invernadero
// Inteligente, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: (1) el módulo OBLOQ y la librería ObloqAdafruit quedaron
// discontinuados; se reemplazan por el WiFi nativo del ESP32 (WiFi.h) y MQTT
// contra io.adafruit.com. (2) El original publicaba temperatura y humedad en
// CADA medición; acá se publican solo cuando cambian de forma apreciable
// (temperatura ≥ 0,5 °C; humedad ≥ 1 %) respecto de lo último publicado, para
// no gastar el cupo gratuito de Adafruit IO (30 publicaciones por minuto).
// Como el DHT11 tiene resolución de 1 °C y 1 %, en la práctica se publica
// ante cualquier cambio real de la medición. (3) Se ignora una lectura
// fallida del DHT11 (isnan): si el sensor devuelve "no numérico" (pasa cada
// tanto), se saltea el ciclo en vez de mostrar/publicar basura. (4) El LCD
// paralelo del original se adapta a I2C.

#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 ícono de la "llave" (igual que en la guía 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 externo indicador de "hay que ventilar".
const int PIN_LED_VENTILACION = 16;

// Dirección 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;

// Umbral del original: por encima de 25 °C hay que ventilar.
const float UMBRAL_TEMP_C = 25.0;

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

// Un valor se re-publica solo si cambió al menos esto respecto del último
// publicado: evita gastar el cupo gratuito de Adafruit IO con repeticiones.
const float UMBRAL_PUBLICACION_TEMP_C = 0.5;
const float UMBRAL_PUBLICACION_HUM    = 1.0;

// Si se cae la conexión 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 última medición y del último intento de conexión MQTT.
unsigned long millisAnterior = 0;
unsigned long millisUltimoIntentoMqtt = 0;

// Últimas mediciones válidas, y lo último que llegó a publicarse. Separarlos
// permite publicar solo los cambios y ponerse al día tras una desconexión.
// Se arranca con valores imposibles para forzar la primera publicación.
float temperaturaPublicada = -1000.0;
float humedadPublicada     = -1000.0;
bool  hayMedicion          = false;

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

// Mantiene viva la conexión MQTT sin bloquear el sensor: si está caída,
// 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; // todavía no toca reintentar
  }
  millisUltimoIntentoMqtt = millisActual;

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

// Publica cada feed SOLO si cambió lo suficiente desde la última publicación
// exitosa. Si publish() falla o no hay conexión, no se actualiza el registro:
// se reintenta en la próxima vuelta.
void publicarCambios(float temperatura, float humedad) {
  if (!mqtt.connected() || !hayMedicion) {
    return; // sin internet o sin datos reales todavía: 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_VENTILACION, OUTPUT);
  dht.begin();
  lcd.init();
  lcd.backlight();
  lcd.clear();

  // Conexión WiFi. Esperar acá con delay() es aceptable porque el ciclo de
  // medición todavía no arrancó; 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();

  // --- Medición, aviso 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 numérico": la salteamos
    // para no mostrar ni publicar basura.
    if (!isnan(temperatura) && !isnan(humedad)) {
      hayMedicion = true;

      // Aviso de ventilación como encendido fijo (if/else).
      if (temperatura > UMBRAL_TEMP_C) {
        digitalWrite(PIN_LED_VENTILACION, HIGH);
      } else {
        digitalWrite(PIN_LED_VENTILACION, LOW);
      }

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

      // Publicamos (solo si cambió lo suficiente).
      publicarCambios(temperatura, humedad);
    }
  }

  // --- Mantenimiento de la conexión IoT, en cada vuelta ---
  // Gracias a que la medición no bloquea, esto se atiende continuamente:
  // esta es la razón de fondo por la que la guía abandona delay() antes de IoT.
  mantenerConexionMqtt();
}