Estación Meteorológica

// Estación meteorológica básica: mide temperatura y humedad del aire con un
// sensor DHT11 y detecta presencia de lluvia con un sensor digital, y muestra
// todo en un display LCD 16x2. Fila 0: temperatura y humedad. Fila 1: si
// llueve o no.
//
// CONVENCIÓN DEL SENSOR DE LLUVIA (¡importante!, activo-bajo): este módulo
// (tipo FC-37 / YL-83 con comparador LM393) cierra circuito cuando se moja.
// Su salida digital D0 vale BAJO (0 V) cuando DETECTA agua y ALTO (5 V)
// cuando está SECO. El original lo confirma: "al detectar agua... la salida
// digital D0 se debe encontrar en el estado BAJO (0V); cuando no se detecta
// lluvia... en el estado ALTO (5V)". Por eso comparamos contra LOW.
// La sensibilidad se calibra con el potenciómetro azul del módulo.
//
// Plataforma: Arduino UNO.
// Conexión (la del esquema original): dato del DHT11 → pin 2; salida digital
// D0 del sensor de lluvia → pin 3; display LCD Keypad Shield en modo paralelo
// por los pines 8, 9, 4, 5, 6, 7 (se apila sobre el UNO; su potenciómetro RP1
// ajusta el contraste).
//
// Nota del original: en el LCD no usar tildes ni la letra Ñ.
// Nota física: la placa de contactos del sensor de lluvia se moja a propósito,
// pero la electrónica (la placa Arduino y el módulo comparador) debe quedar
// protegida del agua. Es todo de baja tensión (5 V).
//
// Basado en: Fragmento de código del Nivel Inicial (Paso 4) — Estación
// Meteorológica Automatizada, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: (1) C++ idiomático con constantes nombradas en vez del C de
// mBlock3. (2) Librería "DHT sensor library" de Adafruit (instalar con su
// dependencia "Adafruit Unified Sensor"), que reemplaza la vieja "DHT.h" y
// requiere dht.begin(). (3) El original no pausaba el loop; acá medimos cada
// 2 s porque el DHT11 no admite más de una lectura por segundo.

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

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

// Salida digital D0 del sensor de lluvia.
const int PIN_LLUVIA = 3;

// Nivel de la salida del sensor cuando HAY lluvia (activo-bajo: ver encabezado).
const int LLUVIA_DETECTADA_NIVEL = LOW;

// 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 y display paralelo (RS, E, D4, D5, D6, D7).
DHT dht(PIN_DHT, DHTTYPE);
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

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

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

  // Fila 0: temperatura (col 0) y humedad (col 8). Sin tildes ni Ñ.
  lcd.setCursor(0, 0);
  lcd.print("T:");
  lcd.print(temperatura);
  lcd.setCursor(8, 0);
  lcd.print("H:");
  lcd.print(humedad);

  // Fila 1: estado de la lluvia. La salida en LOW significa agua detectada.
  lcd.setCursor(0, 1);
  if (digitalRead(PIN_LLUVIA) == LLUVIA_DETECTADA_NIVEL) {
    lcd.print("Lluvia:SI");
  } else {
    lcd.print("Lluvia:NO");
  }

  // 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);
}

// Estación meteorológica básica: mide temperatura y humedad del aire con un
// sensor DHT11 y detecta presencia de lluvia con un sensor digital, y muestra
// todo en un display LCD 16x2. Fila 0: temperatura y humedad. Fila 1: si
// llueve o no.
//
// CONVENCIÓN DEL SENSOR DE LLUVIA (¡importante!, activo-bajo): este módulo
// (tipo FC-37 / YL-83 con comparador LM393) cierra circuito cuando se moja.
// Su salida digital D0 vale BAJO (0 V) cuando DETECTA agua y ALTO cuando está
// SECO. El original lo confirma: "al detectar agua... la salida D0 en estado
// BAJO; cuando no se detecta lluvia... en ALTO". Por eso comparamos contra LOW.
// La sensibilidad se calibra con el potenciómetro azul del módulo.
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: dato del DHT11 → GPIO 4; salida digital D0 del sensor de lluvia →
// GPIO 14; 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; el DHT11 y el módulo I2C del LCD
// funcionan a 3,3 V. El módulo de lluvia se alimenta a 3,3 V para que su
// salida no supere ese nivel en el GPIO.
// Nota física: la placa de contactos del sensor de lluvia se moja a propósito,
// pero la electrónica (placa y módulo comparador) debe quedar protegida del
// agua. Es todo de baja tensión.
//
// Librerías requeridas (Library Manager): "DHT sensor library" (Adafruit) +
// "Adafruit Unified Sensor", y "LiquidCrystal_I2C".
//
// Basado en: Fragmento de código del Nivel Inicial (Paso 4) — Estación
// Meteorológica Automatizada, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: C++ idiomático con constantes nombradas; portado a ESP32;
// DHT de Adafruit con dht.begin(); LCD paralelo del original adaptado a I2C;
// pausa de 2 s (límite del DHT11; el original no pausaba el loop).

#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

// Salida digital D0 del sensor de lluvia.
const int PIN_LLUVIA = 14;

// Nivel de la salida del sensor cuando HAY lluvia (activo-bajo).
const int LLUVIA_DETECTADA_NIVEL = LOW;

// 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;

// 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_LLUVIA, INPUT);
  dht.begin();
  // Con I2C, primero arranca el display; backlight enciende la luz de fondo.
  lcd.init();
  lcd.backlight();
  lcd.clear();
}

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

  // Fila 0: temperatura (col 0) y humedad (col 8). Sin tildes ni Ñ.
  lcd.setCursor(0, 0);
  lcd.print("T:");
  lcd.print(temperatura);
  lcd.setCursor(8, 0);
  lcd.print("H:");
  lcd.print(humedad);

  // Fila 1: estado de la lluvia. La salida en LOW significa agua detectada.
  lcd.setCursor(0, 1);
  if (digitalRead(PIN_LLUVIA) == LLUVIA_DETECTADA_NIVEL) {
    lcd.print("Lluvia:SI");
  } else {
    lcd.print("Lluvia:NO");
  }

  delay(INTERVALO_MEDICION_MS);
}

// Estación meteorológica con presión: además de temperatura y humedad (DHT11)
// y presencia de lluvia (sensor digital), suma un sensor BMP180 que mide la
// presión atmosférica. Todo se muestra en el LCD 16x2. Fila 0: temperatura y
// humedad. Fila 1: estado de lluvia y presión (rótulo "P:").
//
// ¿Por qué importa la presión? El original lo explica: las bajas presiones
// suelen asociarse a tiempo inestable (y a veces lluvia) y las altas, a tiempo
// estable. Sumarla enriquece el pronóstico de la estación.
//
// CONVENCIÓN DEL SENSOR DE LLUVIA (activo-bajo): la salida digital D0 vale
// BAJO cuando DETECTA agua y ALTO cuando está SECO (ver detalle en el sketch
// del nivel inicial). Por eso comparamos contra LOW.
//
// Plataforma: Arduino UNO.
// Conexión (la del esquema original): dato del DHT11 → pin 2; lluvia D0 → pin
// 3; display LCD Keypad Shield paralelo por 8, 9, 4, 5, 6, 7; BMP180 por el bus
// I2C del UNO: SDA → A4, SCL → A5.
//
// 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 "Adafruit BMP085 Library" (sirve para BMP085 y
// BMP180, que son compatibles; es la que nombra el original).
//
// Basado en: Fragmento de código del Nivel Intermedio (Paso 3) — Estación
// Meteorológica Automatizada, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: constantes nombradas; DHT de Adafruit con dht.begin();
// pausa de 2 s (el DHT11 no admite más de una lectura por segundo; el original
// no pausaba el loop).

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

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

// Salida digital D0 del sensor de lluvia.
const int PIN_LLUVIA = 3;

// Nivel de la salida del sensor cuando HAY lluvia (activo-bajo).
const int LLUVIA_DETECTADA_NIVEL = LOW;

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

// Objetos de sensores y display. El BMP180 habla por I2C (A4/A5 en el UNO).
DHT dht(PIN_DHT, DHTTYPE);
Adafruit_BMP085 bmp;
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

void setup() {
  pinMode(PIN_LLUVIA, INPUT);
  dht.begin();
  bmp.begin(); // inicializa el sensor de presión por I2C
  lcd.begin(16, 2);
  lcd.clear();
}

void loop() {
  float temperatura = dht.readTemperature();      // grados Celsius
  float humedad     = dht.readHumidity();         // humedad relativa en %
  // readPressure() devuelve pascales (Pa); dividimos por 100 para tener
  // hectopascales (hPa), la unidad habitual del "1013 hPa" del clima.
  float presion     = bmp.readPressure() / 100.0;

  // Fila 0: temperatura (col 0) y humedad (col 8). Sin tildes ni Ñ.
  lcd.setCursor(0, 0);
  lcd.print("T:");
  lcd.print(temperatura);
  lcd.setCursor(8, 0);
  lcd.print("H:");
  lcd.print(humedad);

  // Fila 1: estado de la lluvia (col 0) y presión (col 10).
  lcd.setCursor(0, 1);
  if (digitalRead(PIN_LLUVIA) == LLUVIA_DETECTADA_NIVEL) {
    lcd.print("Lluvia:SI");
  } else {
    lcd.print("Lluvia:NO");
  }
  lcd.setCursor(10, 1);
  lcd.print("P:");
  lcd.print(presion);

  delay(INTERVALO_MEDICION_MS);
}

// Estación meteorológica con presión: además de temperatura y humedad (DHT11)
// y presencia de lluvia (sensor digital), suma un sensor BMP180 que mide la
// presión atmosférica. Todo se muestra en el LCD 16x2. Fila 0: temperatura y
// humedad. Fila 1: estado de lluvia y presión (rótulo "P:").
//
// ¿Por qué importa la presión? El original lo explica: las bajas presiones
// suelen asociarse a tiempo inestable (y a veces lluvia) y las altas, a tiempo
// estable.
//
// BUS I2C COMPARTIDO (¡buen punto didáctico!): en el ESP32, TANTO el LCD como
// el BMP180 se conectan al MISMO bus I2C (SDA GPIO 21, SCL GPIO 22). El I2C es
// un bus compartido: varios dispositivos conviven en los mismos dos cables
// porque cada uno tiene una DIRECCIÓN distinta. El LCD responde en 0x27 y el
// BMP180 en 0x77, así que no hay conflicto. Ambos cuelgan en paralelo de
// SDA/SCL.
//
// CONVENCIÓN DEL SENSOR DE LLUVIA (activo-bajo): la salida D0 vale BAJO cuando
// DETECTA agua y ALTO cuando está SECO (ver detalle en el nivel inicial).
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: DHT11 → GPIO 4; lluvia D0 → GPIO 14; LCD y BMP180 al bus I2C
// (SDA GPIO 21, SCL GPIO 22).
//
// ADAPTACIÓN DE PLATAFORMA (ver README): el original usa un LCD Keypad Shield
// paralelo que no entra en un ESP32; acá el LCD es 1602 I2C (LiquidCrystal_I2C,
// 0x27; probá 0x3F si no muestra nada).
// Nota eléctrica: el ESP32 trabaja a 3,3 V; DHT11, BMP180 y LCD I2C andan 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", "Adafruit BMP085 Library" (BMP085/BMP180) y
// "LiquidCrystal_I2C".
//
// Basado en: Fragmento de código del Nivel Intermedio (Paso 3) — Estación
// Meteorológica Automatizada, Saberes Digitales (INET/EDUCAR 2019)
// Modernización: constantes nombradas; portado a ESP32; DHT de Adafruit con
// dht.begin(); LCD adaptado a I2C (comparte bus con el BMP180); pausa de 2 s.

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

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

// Salida digital D0 del sensor de lluvia.
const int PIN_LLUVIA = 14;

// Nivel de la salida del sensor cuando HAY lluvia (activo-bajo).
const int LLUVIA_DETECTADA_NIVEL = LOW;

// 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;

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

// Objetos de sensores y display. LCD (0x27) y BMP180 (0x77) comparten el bus.
DHT dht(PIN_DHT, DHTTYPE);
Adafruit_BMP085 bmp;
LiquidCrystal_I2C lcd(LCD_DIRECCION_I2C, LCD_COLUMNAS, LCD_FILAS);

void setup() {
  pinMode(PIN_LLUVIA, INPUT);
  dht.begin();
  bmp.begin(); // el BMP180 se inicializa por el mismo bus I2C que el LCD
  lcd.init();
  lcd.backlight();
  lcd.clear();
}

void loop() {
  float temperatura = dht.readTemperature();      // grados Celsius
  float humedad     = dht.readHumidity();         // humedad relativa en %
  float presion     = bmp.readPressure() / 100.0; // Pa → hPa

  // Fila 0: temperatura (col 0) y humedad (col 8). Sin tildes ni Ñ.
  lcd.setCursor(0, 0);
  lcd.print("T:");
  lcd.print(temperatura);
  lcd.setCursor(8, 0);
  lcd.print("H:");
  lcd.print(humedad);

  // Fila 1: estado de la lluvia (col 0) y presión (col 10).
  lcd.setCursor(0, 1);
  if (digitalRead(PIN_LLUVIA) == LLUVIA_DETECTADA_NIVEL) {
    lcd.print("Lluvia:SI");
  } else {
    lcd.print("Lluvia:NO");
  }
  lcd.setCursor(10, 1);
  lcd.print("P:");
  lcd.print(presion);

  delay(INTERVALO_MEDICION_MS);
}

// Estación meteorológica completa SIN delay(): DHT11 (temperatura y humedad),
// sensor de lluvia y BMP180 (presión), mostrando todo en el LCD 16x2, pero
// con millis() en lugar de delay(). Cada vuelta de loop() pregunta si ya pasó
// el intervalo de medición y, si no, deja el procesador libre.
//
// Este programa es la base directa de estacion-iot.ino: sin código bloqueante,
// el ESP32 puede sumar WiFi y MQTT sin desatender los sensores.
//
// CONVENCIÓN DEL SENSOR DE LLUVIA (activo-bajo): la salida digital D0 vale
// BAJO cuando DETECTA agua y ALTO cuando está SECO (ver detalle en el sketch
// del nivel inicial). Por eso comparamos contra LOW.
//
// Plataforma: Arduino UNO.
// Conexión (la del esquema original): dato del DHT11 → pin 2; lluvia D0 → pin
// 3; display LCD Keypad Shield paralelo por 8, 9, 4, 5, 6, 7; BMP180 por I2C:
// SDA → A4, SCL → A5.
//
// 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 "Adafruit BMP085 Library" (BMP085/BMP180).
//
// Basado en: Fragmentos de código del Nivel Avanzado (patrón millis, sin la
// parte IoT) — Estación Meteorológica Automatizada, Saberes Digitales
// (INET/EDUCAR 2019)
// Modernización: constantes nombradas; millisAnterior como unsigned long (el
// long del original desborda la cuenta); DHT de Adafruit con dht.begin().

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

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

// Salida digital D0 del sensor de lluvia.
const int PIN_LLUVIA = 3;

// Nivel de la salida del sensor cuando HAY lluvia (activo-bajo).
const int LLUVIA_DETECTADA_NIVEL = LOW;

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

// Objetos de sensores y display.
DHT dht(PIN_DHT, DHTTYPE);
Adafruit_BMP085 bmp;
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_LLUVIA, INPUT);
  dht.begin();
  bmp.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 %
    float presion     = bmp.readPressure() / 100.0; // Pa → hPa

    // Fila 0: temperatura (col 0) y humedad (col 8). Sin tildes ni Ñ.
    lcd.setCursor(0, 0);
    lcd.print("T:");
    lcd.print(temperatura);
    lcd.setCursor(8, 0);
    lcd.print("H:");
    lcd.print(humedad);

    // Fila 1: estado de la lluvia (col 0) y presión (col 10).
    lcd.setCursor(0, 1);
    if (digitalRead(PIN_LLUVIA) == LLUVIA_DETECTADA_NIVEL) {
      lcd.print("Lluvia:SI");
    } else {
      lcd.print("Lluvia:NO");
    }
    lcd.setCursor(10, 1);
    lcd.print("P:");
    lcd.print(presion);
  }

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

// Estación meteorológica completa SIN delay(): DHT11 (temperatura y humedad),
// sensor de lluvia y BMP180 (presión), mostrando todo en el LCD 16x2 (I2C),
// pero con millis() en lugar de delay(). Cada vuelta de loop() pregunta si ya
// pasó el intervalo de medición y, si no, deja el procesador libre.
//
// Este programa es la base directa de estacion-iot.ino: sin código bloqueante,
// el ESP32 puede sumar WiFi y MQTT sin desatender los sensores.
//
// BUS I2C COMPARTIDO: el LCD (0x27) y el BMP180 (0x77) conviven en el mismo
// bus I2C (SDA GPIO 21, SCL GPIO 22): distintas direcciones, sin conflicto.
//
// CONVENCIÓN DEL SENSOR DE LLUVIA (activo-bajo): la salida D0 vale BAJO cuando
// DETECTA agua y ALTO cuando está SECO (ver detalle en el nivel inicial).
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: DHT11 → GPIO 4; lluvia D0 → GPIO 14; LCD y BMP180 al bus I2C
// (SDA GPIO 21, SCL GPIO 22).
//
// ADAPTACIÓN DE PLATAFORMA (ver README): LCD 1602 I2C (LiquidCrystal_I2C,
// 0x27; probá 0x3F si no muestra nada) en lugar del Keypad Shield paralelo
// del original.
// 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", "Adafruit BMP085 Library" y "LiquidCrystal_I2C".
//
// Basado en: Fragmentos de código del Nivel Avanzado (patrón millis, sin la
// parte IoT) — Estación Meteorológica Automatizada, Saberes Digitales
// (INET/EDUCAR 2019)
// Modernización: constantes nombradas; millisAnterior como unsigned long;
// portado a ESP32; DHT de Adafruit con dht.begin(); LCD adaptado a I2C.

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

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

// Salida digital D0 del sensor de lluvia.
const int PIN_LLUVIA = 14;

// Nivel de la salida del sensor cuando HAY lluvia (activo-bajo).
const int LLUVIA_DETECTADA_NIVEL = LOW;

// 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;

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

// Objetos de sensores y display por I2C.
DHT dht(PIN_DHT, DHTTYPE);
Adafruit_BMP085 bmp;
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_LLUVIA, INPUT);
  dht.begin();
  bmp.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 %
    float presion     = bmp.readPressure() / 100.0; // Pa → hPa

    // Fila 0: temperatura (col 0) y humedad (col 8). Sin tildes ni Ñ.
    lcd.setCursor(0, 0);
    lcd.print("T:");
    lcd.print(temperatura);
    lcd.setCursor(8, 0);
    lcd.print("H:");
    lcd.print(humedad);

    // Fila 1: estado de la lluvia (col 0) y presión (col 10).
    lcd.setCursor(0, 1);
    if (digitalRead(PIN_LLUVIA) == LLUVIA_DETECTADA_NIVEL) {
      lcd.print("Lluvia:SI");
    } else {
      lcd.print("Lluvia:NO");
    }
    lcd.setCursor(10, 1);
    lcd.print("P:");
    lcd.print(presion);
  }

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

// Estación meteorológica con monitoreo IoT vía Adafruit IO (MQTT).
// La lógica no bloqueante de estacion-no-bloqueante.ino sigue midiendo con el
// DHT11, el sensor de lluvia y el BMP180, y mostrando en el LCD (I2C); además
// publica cuatro feeds para verlos desde el Panel de Control de Adafruit:
//
//   "temperatura": grados Celsius.
//   "humedad": humedad relativa en %.
//   "presion": presión atmosférica en hPa.
//   "lluvia": 0 = seco, 1 = lloviendo.
//
// El original publicaba solo temperatura, humedad y presión. Acá se agrega el
// feed "lluvia" (extensión): el estado de lluvia ya se muestra en el LCD y es
// una variable meteorológica que también vale la pena monitorear a distancia.
//
// BUS I2C COMPARTIDO: el LCD (0x27) y el BMP180 (0x77) conviven en el mismo
// bus I2C (SDA GPIO 21, SCL GPIO 22): distintas direcciones, sin conflicto.
//
// CONVENCIÓN DEL SENSOR DE LLUVIA (activo-bajo): la salida D0 vale BAJO cuando
// DETECTA agua y ALTO cuando está SECO (ver detalle en el nivel inicial).
//
// Plataforma: ESP32 (DevKit v1) — usa su WiFi integrado.
// Conexión: DHT11 → GPIO 4; lluvia D0 → GPIO 14; LCD y BMP180 al bus I2C
// (SDA GPIO 21, SCL GPIO 22).
//
// ADAPTACIÓN DE PLATAFORMA (ver README): LCD 1602 I2C (0x27; probá 0x3F si no
// muestra nada) en lugar del Keypad Shield paralelo del original.
// 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", "Adafruit BMP085 Library", "LiquidCrystal_I2C" y
// "Adafruit MQTT Library".
//
// Basado en: Fragmento de código del Nivel Avanzado (Paso 4) — Estación
// Meteorológica Automatizada, 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 en cada medición (cada
// 10 s); acá se publica solo cuando un valor cambia de forma apreciable
// (temperatura ≥ 0,5 °C; humedad ≥ 1 %; presión ≥ 1 hPa; lluvia ante cualquier
// cambio de estado), para no gastar el cupo gratuito de Adafruit IO (30
// publicaciones/minuto). (3) Se ignora una lectura fallida del DHT11 (isnan).
// (4) LCD adaptado a I2C.

#include <WiFi.h>
#include <Wire.h>
#include <Adafruit_BMP085.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

// Salida digital D0 del sensor de lluvia.
const int PIN_LLUVIA = 14;

// Nivel de la salida del sensor cuando HAY lluvia (activo-bajo).
const int LLUVIA_DETECTADA_NIVEL = LOW;

// 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;

// 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;
const float UMBRAL_PUBLICACION_PRESION  = 1.0; // hPa

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

// Objetos de sensores, display, WiFi y MQTT.
DHT dht(PIN_DHT, DHTTYPE);
Adafruit_BMP085 bmp;
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");
Adafruit_MQTT_Publish feedPresion(&mqtt, IO_USERNAME "/feeds/presion");
Adafruit_MQTT_Publish feedLluvia(&mqtt, IO_USERNAME "/feeds/lluvia");

// Momento (ms) de la última medición y del último intento de conexión MQTT.
unsigned long millisAnterior = 0;
unsigned long millisUltimoIntentoMqtt = 0;

// Últimos valores publicados (arrancan imposibles para forzar la 1ª publicación).
float temperaturaPublicada = -1000.0;
float humedadPublicada     = -1000.0;
float presionPublicada     = -1000.0;
int   lluviaPublicada      = -1;
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 los sensores: 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, float presion, int lluvia) {
  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;
  }

  if (diferenciaAbsoluta(presion, presionPublicada) >= UMBRAL_PUBLICACION_PRESION
      && feedPresion.publish(presion)) {
    presionPublicada = presion;
  }

  if (lluvia != lluviaPublicada && feedLluvia.publish((int32_t)lluvia)) {
    lluviaPublicada = lluvia;
  }
}

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

  pinMode(PIN_LLUVIA, INPUT);
  dht.begin();
  bmp.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 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 %
    float presion     = bmp.readPressure() / 100.0; // Pa → hPa
    // 1 si la salida del sensor está en el nivel de "agua detectada", si no 0.
    int lluvia = (digitalRead(PIN_LLUVIA) == LLUVIA_DETECTADA_NIVEL) ? 1 : 0;

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

      // Fila 0: temperatura (col 0) y humedad (col 8). Sin tildes ni Ñ.
      lcd.setCursor(0, 0);
      lcd.print("T:");
      lcd.print(temperatura);
      lcd.setCursor(8, 0);
      lcd.print("H:");
      lcd.print(humedad);

      // Fila 1: estado de la lluvia (col 0) y presión (col 10).
      lcd.setCursor(0, 1);
      if (lluvia == 1) {
        lcd.print("Lluvia:SI");
      } else {
        lcd.print("Lluvia:NO");
      }
      lcd.setCursor(10, 1);
      lcd.print("P:");
      lcd.print(presion);

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

  // --- Mantenimiento de la conexión IoT, en cada vuelta ---
  mantenerConexionMqtt();
}