Sistema de Calefacción Automático

// Calefaccion temporizada: un modulo rele enciende y apaga un radiador
// electrico siguiendo tiempos fijos, sin sensores. Es el prototipo mas
// simple del sistema: "prender 10 min, apagar 15 min", como un temporizador.
//
// !! SEGURIDAD 220V !!  El radiador es una carga de 220V conmutada por el
// rele. En el aula, usar una carga de BAJA TENSION (o directamente el LED de
// prueba del pin 13) para ver el ciclo sin riesgo. La conexion real a 220V
// queda reservada al docente o a una instalacion supervisada, y el rele con
// su cableado de 220V van SIEMPRE fuera de la protoboard (ver README).
//
// Plataforma: Arduino UNO.
// Conexion (la del esquema original): senal del modulo rele -> pin 3 (con su
// alimentacion de 5V y GND). El rele se comporta como el interruptor del
// radiador.
//
// Basado en: Fragmento de codigo del Nivel Inicial (Paso 4) - Sistema de
// Calefaccion Automatico, Saberes Digitales (INET/EDUCAR 2019)
// Modernizacion: se reemplaza el C generado por mBlock3 (_delay, _loop) por
// C++ idiomatico con constantes nombradas; los tiempos quedan como constantes
// claras en milisegundos, y el estado del rele por constantes invertibles.

// Pin de la senal del modulo rele.
const int PIN_RELE = 3;

// El modulo rele de la guia es ACTIVO-ALTO: HIGH cierra el contacto y el
// radiador se enciende. Muchos modulos comerciales son activo-bajo: si el
// tuyo enciende al reves, invertí estas dos constantes (ENCENDIDO = LOW /
// APAGADO = HIGH) y el resto del programa no cambia.
const int RELE_ENCENDIDO = HIGH;
const int RELE_APAGADO   = LOW;

// Tiempos del ejemplo original: 10 minutos encendido, 15 minutos apagado
// (600 s y 900 s en el PDF, aca expresados en milisegundos).
// NOTA PARA EL AULA: 10 y 15 minutos hacen la demostracion muy lenta. Para
// ver el ciclo en clase, bajá estos valores a algo corto, por ejemplo
// 5000UL / 5000UL (5 s encendido / 5 s apagado); una vez entendido el
// comportamiento, volvé a los tiempos reales.
const unsigned long TIEMPO_ENCENDIDO_MS = 600000UL; // 10 min
const unsigned long TIEMPO_APAGADO_MS   = 900000UL; // 15 min

void setup() {
  pinMode(PIN_RELE, OUTPUT);
  // Arrancamos con el radiador apagado.
  digitalWrite(PIN_RELE, RELE_APAGADO);
}

void loop() {
  // Encender el radiador y esperar el tiempo de encendido.
  digitalWrite(PIN_RELE, RELE_ENCENDIDO);
  delay(TIEMPO_ENCENDIDO_MS);

  // Apagar el radiador y esperar el tiempo de apagado. 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.
  digitalWrite(PIN_RELE, RELE_APAGADO);
  delay(TIEMPO_APAGADO_MS);
}

// Calefaccion temporizada: un modulo rele enciende y apaga un radiador
// electrico siguiendo tiempos fijos, sin sensores. Es el prototipo mas
// simple del sistema: "prender 10 min, apagar 15 min", como un temporizador.
//
// !! SEGURIDAD 220V !!  El radiador es una carga de 220V conmutada por el
// rele. En el aula, usar una carga de BAJA TENSION (o directamente un LED de
// prueba) para ver el ciclo sin riesgo. La conexion real a 220V queda
// reservada al docente o a una instalacion supervisada, y el rele con su
// cableado de 220V van SIEMPRE fuera de la protoboard (ver README).
//
// Plataforma: ESP32 (DevKit v1).
// Conexion: senal del modulo rele -> GPIO 25. Nota electrica: el ESP32
// trabaja a 3,3 V; usar un modulo rele con entrada compatible con 3,3 V (o
// con optoacoplador) para que conmute de forma confiable.
//
// Basado en: Fragmento de codigo del Nivel Inicial (Paso 4) - Sistema de
// Calefaccion Automatico, Saberes Digitales (INET/EDUCAR 2019)
// Modernizacion: se reemplaza el C generado por mBlock3 (_delay, _loop) por
// C++ idiomatico con constantes nombradas; los tiempos quedan como constantes
// claras en milisegundos, y el estado del rele por constantes invertibles.

// Pin de la senal del modulo rele (GPIO seguro del contrato ESP32).
const int PIN_RELE = 25;

// El modulo rele de la guia es ACTIVO-ALTO: HIGH cierra el contacto y el
// radiador se enciende. Muchos modulos comerciales son activo-bajo: si el
// tuyo enciende al reves, invertí estas dos constantes (ENCENDIDO = LOW /
// APAGADO = HIGH) y el resto del programa no cambia.
const int RELE_ENCENDIDO = HIGH;
const int RELE_APAGADO   = LOW;

// Tiempos del ejemplo original: 10 minutos encendido, 15 minutos apagado
// (600 s y 900 s en el PDF, aca expresados en milisegundos).
// NOTA PARA EL AULA: 10 y 15 minutos hacen la demostracion muy lenta. Para
// ver el ciclo en clase, bajá estos valores a algo corto, por ejemplo
// 5000UL / 5000UL (5 s encendido / 5 s apagado); una vez entendido el
// comportamiento, volvé a los tiempos reales.
const unsigned long TIEMPO_ENCENDIDO_MS = 600000UL; // 10 min
const unsigned long TIEMPO_APAGADO_MS   = 900000UL; // 15 min

void setup() {
  pinMode(PIN_RELE, OUTPUT);
  // Arrancamos con el radiador apagado.
  digitalWrite(PIN_RELE, RELE_APAGADO);
}

void loop() {
  // Encender el radiador y esperar el tiempo de encendido.
  digitalWrite(PIN_RELE, RELE_ENCENDIDO);
  delay(TIEMPO_ENCENDIDO_MS);

  // Apagar el radiador y esperar el tiempo de apagado. 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.
  digitalWrite(PIN_RELE, RELE_APAGADO);
  delay(TIEMPO_APAGADO_MS);
}

// Termostato con display: el sensor DHT11 mide la temperatura del ambiente y
// un potenciometro fija la temperatura OBJETIVO. Si hace frio (temperatura
// por debajo del objetivo) el rele enciende el radiador; si ya se alcanzo el
// objetivo, lo apaga. El LCD 16x2 muestra la temperatura actual y la objetivo.
//
// !! SEGURIDAD 220V !!  El radiador es una carga de 220V conmutada por el
// rele. En el aula, usar una carga de BAJA TENSION (o el LED de prueba del
// pin 13) para probar sin riesgo. La conexion real a 220V queda reservada al
// docente o a una instalacion supervisada, y el rele con su cableado de 220V
// van SIEMPRE fuera de la protoboard (ver README).
//
// Plataforma: Arduino UNO.
// Conexion (la del esquema original): dato del DHT11 -> pin 2; senal del rele
// -> pin 3; potenciometro (cursor) -> A1; display LCD Keypad Shield en modo
// paralelo por los pines 8, 9, 4, 5, 6, 7. El shield se apila sobre el UNO;
// su preset RP1 ajusta el contraste si no se lee el texto.
//
// Nota del original: en el LCD no usar tildes ni la letra Ñ.
//
// Basado en: Fragmento de codigo del Nivel Intermedio (Paso 14, codigo
// completo) - Sistema de Calefaccion Automatico, Saberes Digitales
// (INET/EDUCAR 2019)
// Modernizacion: (1) constantes nombradas en vez del C de mBlock3. (2)
// Libreria "DHT sensor library" de Adafruit (instalar desde el Library
// Manager; arrastra "Adafruit Unified Sensor"), con dht.begin() en setup().
// (3) La temperatura se lee UNA vez por vuelta a una variable y ese valor se
// usa para el rele y para el display. (4) Se ignora una lectura fallida del
// DHT11 (isnan) para no accionar el radiador con un valor no numerico.

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

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

// Senal del modulo rele del radiador.
const int PIN_RELE = 3;

// Cursor del potenciometro que fija la temperatura objetivo (entrada analogica).
const int PIN_POTENCIOMETRO = A1;

// El modulo rele es ACTIVO-ALTO: HIGH enciende el radiador. Si tu modulo es
// activo-bajo, invertí estas dos constantes (ENCENDIDO = LOW / APAGADO = HIGH).
const int RELE_ENCENDIDO = HIGH;
const int RELE_APAGADO   = LOW;

// El potenciometro fija la temperatura objetivo. La entrada analogica del UNO
// lee 0..1023 (10 bits); la mapeamos a 0..30 grados con una regla de tres,
// tal como el original (potenciometro en 0 -> 0 grados; en el maximo -> 30).
const float TEMP_OBJETIVO_MAX_C = 30.0;
const int   ADC_MAX             = 1023;

// El DHT11 no admite mas de una lectura por segundo; medimos cada 2 s (el
// original pedia 1 s, pero 2 s es el valor honesto para este sensor y la
// libreria de Adafruit ademas cachea la lectura).
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_RELE, OUTPUT);
  digitalWrite(PIN_RELE, RELE_APAGADO); // arranca apagado
  pinMode(PIN_POTENCIOMETRO, INPUT);
  dht.begin();
  lcd.begin(16, 2);
  lcd.clear();
}

void loop() {
  // Temperatura actual del ambiente (grados Celsius).
  float temperatura = dht.readTemperature();

  // Temperatura objetivo fijada a mano con el potenciometro (0..30 grados).
  float objetivo = (float)analogRead(PIN_POTENCIOMETRO) * TEMP_OBJETIVO_MAX_C / ADC_MAX;

  // Una lectura fallida del DHT11 devuelve "no numerico": la salteamos para
  // no accionar el radiador con basura (el rele conserva su ultimo estado).
  if (!isnan(temperatura)) {
    // Termostato: si la temperatura esta por debajo del objetivo, hace frio y
    // encendemos el radiador; si ya se alcanzo el objetivo, lo apagamos.
    if (temperatura < objetivo) {
      digitalWrite(PIN_RELE, RELE_ENCENDIDO);
    } else {
      digitalWrite(PIN_RELE, RELE_APAGADO);
    }
  }

  // Fila 0: temperatura actual. Fila 1: temperatura objetivo. Sin tildes ni Ñ.
  lcd.setCursor(0, 0);
  lcd.print("Temp Act: ");
  lcd.print(temperatura);
  lcd.setCursor(0, 1);
  lcd.print("Temp Set: ");
  lcd.print(objetivo);

  delay(INTERVALO_MEDICION_MS);
}

// Termostato con display: el sensor DHT11 mide la temperatura del ambiente y
// un potenciometro fija la temperatura OBJETIVO. Si hace frio (temperatura
// por debajo del objetivo) el rele enciende el radiador; si ya se alcanzo el
// objetivo, lo apaga. El LCD 16x2 muestra la temperatura actual y la objetivo.
//
// !! SEGURIDAD 220V !!  El radiador es una carga de 220V conmutada por el
// rele. En el aula, usar una carga de BAJA TENSION (o un LED de prueba) para
// probar sin riesgo. La conexion real a 220V queda reservada al docente o a
// una instalacion supervisada, y el rele con su cableado de 220V van SIEMPRE
// fuera de la protoboard (ver README).
//
// Plataforma: ESP32 (DevKit v1).
// Conexion: dato del DHT11 -> GPIO 4; senal del rele -> GPIO 25; cursor del
// potenciometro -> GPIO 34 (entrada del ADC1, solo entrada); 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: 8, 9, 4, 5, 6, 7) que NO entra en un ESP32. Aca usamos un
// LCD 1602 con modulo I2C: solo DOS cables de senal (SDA y SCL) y la libreria
// LiquidCrystal_I2C. La direccion I2C tipica es 0x27 (algunos son 0x3F: si la
// pantalla no muestra nada, probá 0x3F o escaneá el bus I2C).
//
// ADAPTACION DEL ADC (¡importante!): el ADC del ESP32 es de 12 bits
// (0..4095), no de 10 bits (0..1023) como el UNO. Por eso ADC_MAX = 4095 al
// mapear el potenciometro a 0..30 grados. GPIO 34 es solo-entrada y pertenece
// al ADC1 (el unico usable con WiFi encendido).
// Nota electrica: el ESP32 trabaja a 3,3 V; DHT11 y el modulo I2C funcionan a
// 3,3 V, y el potenciometro se alimenta entre 3,3 V y GND.
//
// 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 Intermedio (Paso 14, codigo
// completo) - Sistema de Calefaccion Automatico, Saberes Digitales
// (INET/EDUCAR 2019)
// Modernizacion: constantes nombradas; DHT de Adafruit con dht.begin(); LCD
// paralelo del original adaptado a I2C para ESP32; ADC de 12 bits; una sola
// lectura por vuelta reutilizada para el rele y el display; se ignora la
// lectura fallida del DHT11 (isnan).

#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

// Senal del modulo rele del radiador (GPIO seguro del contrato ESP32).
const int PIN_RELE = 25;

// Cursor del potenciometro que fija la temperatura objetivo (ADC1, GPIO 34).
const int PIN_POTENCIOMETRO = 34;

// El modulo rele es ACTIVO-ALTO: HIGH enciende el radiador. Si tu modulo es
// activo-bajo, invertí estas dos constantes (ENCENDIDO = LOW / APAGADO = HIGH).
const int RELE_ENCENDIDO = HIGH;
const int RELE_APAGADO   = LOW;

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

// El potenciometro fija la temperatura objetivo. El ADC del ESP32 lee 0..4095
// (12 bits); lo mapeamos a 0..30 grados con una regla de tres.
const float TEMP_OBJETIVO_MAX_C = 30.0;
const int   ADC_MAX             = 4095;

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

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

void loop() {
  // Temperatura actual del ambiente (grados Celsius).
  float temperatura = dht.readTemperature();

  // Temperatura objetivo fijada a mano con el potenciometro (0..30 grados).
  float objetivo = (float)analogRead(PIN_POTENCIOMETRO) * TEMP_OBJETIVO_MAX_C / ADC_MAX;

  // Una lectura fallida del DHT11 devuelve "no numerico": la salteamos para
  // no accionar el radiador con basura (el rele conserva su ultimo estado).
  if (!isnan(temperatura)) {
    // Termostato: si la temperatura esta por debajo del objetivo, hace frio y
    // encendemos el radiador; si ya se alcanzo el objetivo, lo apagamos.
    if (temperatura < objetivo) {
      digitalWrite(PIN_RELE, RELE_ENCENDIDO);
    } else {
      digitalWrite(PIN_RELE, RELE_APAGADO);
    }
  }

  // Fila 0: temperatura actual. Fila 1: temperatura objetivo. Sin tildes ni Ñ.
  lcd.setCursor(0, 0);
  lcd.print("Temp Act: ");
  lcd.print(temperatura);
  lcd.setCursor(0, 1);
  lcd.print("Temp Set: ");
  lcd.print(objetivo);

  delay(INTERVALO_MEDICION_MS);
}

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

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