Sistema de Riego Automatizado

// Riego por tiempo: una electroválvula, controlada por un relé, se abre
// durante un rato para regar y luego se cierra durante un rato más largo,
// en un ciclo que se repite para siempre. No hay sensores todavía: el
// riego depende solo del reloj interno (los delay).
//
// SEGURIDAD: agua y electricidad no se llevan bien. Todas las conexiones
// eléctricas van fuera y POR ENCIMA del nivel del agua. La electroválvula
// del original es de lavarropas (220 V): en el aula se usa una válvula de
// baja tensión (12 V) o se simula la carga, y la conexión a 220 V queda
// reservada al docente o a una instalación supervisada, nunca sobre la
// protoboard (desvío pedagógico acordado).
//
// Plataforma: Arduino UNO.
// Conexión (la del esquema original): entrada "S" del módulo relé de la
// electroválvula → pin 2.
//
// Basado en: Fragmentos de código 1 y 2 — Sistema de Riego Automatizado,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: se reemplazó el código generado por mBlock3 (_delay,
// _loop) por C++ idiomático de Arduino con constantes nombradas.
//
// Nota pedagógica: la ficha de insumos del PDF menciona un "módulo reloj"
// (RTC), pero el código del original NO lo usa: temporiza con delay. Un
// RTC sería la evolución natural (regar a horas fijas del día, no cada X
// tiempo desde el encendido), pero queda fuera del alcance de este nivel.

// Relé que controla la electroválvula de entrada de agua.
const int PIN_RELE_VALVULA = 2;

// Módulo relé activo-alto, como en el original (HIGH = válvula abierta,
// pasa el agua). Si tu módulo es activo-bajo, invertí solo estas dos.
const int VALVULA_ABIERTA = HIGH; // riega
const int VALVULA_CERRADA = LOW;  // corta el agua

// Tiempos del ejemplo del original (Fragmento 2): riega 2 minutos y luego
// espera 1 hora. OJO en el aula: una hora es una eternidad para probar;
// bajá estos valores a segundos (por ejemplo 5000 y 10000) mientras
// verificás el circuito, y recién después poné los tiempos reales de tu
// huerta. En el nivel intermedio, el higrómetro reemplaza este reloj fijo.
const unsigned long DURACION_RIEGO_MS  = 120000UL;  // 2 minutos regando
const unsigned long DURACION_ESPERA_MS = 3600000UL; // 1 hora sin regar

void setup() {
  pinMode(PIN_RELE_VALVULA, OUTPUT);
}

void loop() {
  // delay() detiene todo el programa: en este nivel es la herramienta que
  // ya conocemos y hace que el código se lea igual que la secuencia real.
  digitalWrite(PIN_RELE_VALVULA, VALVULA_ABIERTA);
  delay(DURACION_RIEGO_MS);
  digitalWrite(PIN_RELE_VALVULA, VALVULA_CERRADA);
  delay(DURACION_ESPERA_MS);
}

// Riego por tiempo: una electroválvula, controlada por un relé, se abre
// durante un rato para regar y luego se cierra durante un rato más largo,
// en un ciclo que se repite para siempre. No hay sensores todavía: el
// riego depende solo del reloj interno (los delay).
//
// SEGURIDAD: agua y electricidad no se llevan bien. Todas las conexiones
// eléctricas van fuera y POR ENCIMA del nivel del agua. La electroválvula
// del original es de lavarropas (220 V): en el aula se usa una válvula de
// baja tensión (12 V) o se simula la carga, y la conexión a 220 V queda
// reservada al docente o a una instalación supervisada, nunca sobre la
// protoboard (desvío pedagógico acordado).
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: entrada "S" del módulo relé de la electroválvula → GPIO 16.
// Nota eléctrica: el ESP32 trabaja a 3,3 V (no 5 V como el UNO). Elegí un
// módulo relé cuya entrada acepte señal de 3,3 V (la mayoría la aceptan
// aunque se alimenten con 5 V) y nunca inyectes 5 V en un GPIO.
//
// Basado en: Fragmentos de código 1 y 2 — Sistema de Riego Automatizado,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: se reemplazó el código generado por mBlock3 (_delay,
// _loop) por C++ idiomático con constantes nombradas, y se portó a ESP32
// con un GPIO seguro (el original usaba el pin 2 del UNO).
//
// Nota pedagógica: la ficha de insumos del PDF menciona un "módulo reloj"
// (RTC), pero el código del original NO lo usa: temporiza con delay. Un
// RTC sería la evolución natural (regar a horas fijas del día), pero queda
// fuera del alcance de este nivel.

// Relé que controla la electroválvula de entrada de agua.
const int PIN_RELE_VALVULA = 16;

// Módulo relé activo-alto, como en el original (HIGH = válvula abierta,
// pasa el agua). Si tu módulo es activo-bajo, invertí solo estas dos.
const int VALVULA_ABIERTA = HIGH; // riega
const int VALVULA_CERRADA = LOW;  // corta el agua

// Tiempos del ejemplo del original (Fragmento 2): riega 2 minutos y luego
// espera 1 hora. OJO en el aula: una hora es una eternidad para probar;
// bajá estos valores a segundos (por ejemplo 5000 y 10000) mientras
// verificás el circuito, y recién después poné los tiempos reales de tu
// huerta. En el nivel intermedio, el higrómetro reemplaza este reloj fijo.
const unsigned long DURACION_RIEGO_MS  = 120000UL;  // 2 minutos regando
const unsigned long DURACION_ESPERA_MS = 3600000UL; // 1 hora sin regar

void setup() {
  pinMode(PIN_RELE_VALVULA, OUTPUT);
}

void loop() {
  // delay() detiene todo el programa: en este nivel es la herramienta que
  // ya conocemos y hace que el código se lea igual que la secuencia real.
  digitalWrite(PIN_RELE_VALVULA, VALVULA_ABIERTA);
  delay(DURACION_RIEGO_MS);
  digitalWrite(PIN_RELE_VALVULA, VALVULA_CERRADA);
  delay(DURACION_ESPERA_MS);
}

// Riego por humedad: un higrómetro de suelo (FC-28) mide qué tan seca está
// la tierra y el programa abre o cierra la electroválvula en función de eso.
// El higrómetro también se imprime por la consola serial para poder
// calibrar los umbrales observando valores reales.
//
// CONVENCIÓN DEL HIGRÓMETRO (¡importante!): en estos módulos resistivos,
// MAYOR lectura = tierra MÁS SECA (más resistencia, menos agua conduciendo).
// Por eso "seco" es el umbral ALTO y "húmedo" el umbral BAJO. El original
// lo confirma: "mayor a 750 => demasiado seco; menor a 380 => húmedo".
//
// HISTÉRESIS NATURAL DEL ORIGINAL (se preserva tal cual): son dos ifs
// independientes con DOS umbrales distintos. Por encima de 750 abre; por
// debajo de 380 cierra; en la franja intermedia (380 a 750) NINGUNO de los
// dos se cumple, así que la válvula conserva su estado anterior. Esa banda
// muerta evita que la válvula traquetee cuando la lectura baila cerca de un
// único umbral: es una solución elegante que ya venía en el original.
//
// SEGURIDAD: agua y electricidad no se llevan bien. Conexiones eléctricas
// fuera y por encima del agua. Electroválvula de baja tensión (12 V) o
// simulación en el aula; 220 V solo docente/instalación supervisada, nunca
// sobre la protoboard (desvío pedagógico acordado).
//
// Plataforma: Arduino UNO.
// Conexión (la del esquema original): señal analógica del higrómetro → A0;
// entrada "S" del módulo relé de la electroválvula → pin 2.
//
// Basado en: Fragmento de código 5 — Sistema de Riego Automatizado,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: constantes nombradas en lugar del C de mBlock3; el
// original llamaba a analogRead(A0) tres veces por vuelta (una para
// imprimir y una por cada if), lo que podía dar tres valores distintos;
// acá se lee UNA vez a una variable y esa misma lectura se imprime y se
// compara. Es más correcto y hace evidente que se decide sobre un único dato.

const int PIN_HIGROMETRO   = A0;
const int PIN_RELE_VALVULA = 2;

// Módulo relé activo-alto, como en el original (HIGH = válvula abierta).
// Si tu módulo es activo-bajo, invertí solo estas dos constantes.
const int VALVULA_ABIERTA = HIGH;
const int VALVULA_CERRADA = LOW;

// Umbrales del original (escala del UNO: 0 a 1023). NO son mágicos: salen
// de medir muestras de tierra con distintos grados de humedad y anotar los
// valores por la consola (Paso 4 del original). Ajustalos a TU suelo.
const int UMBRAL_SECO   = 750; // por encima: tierra demasiado seca → regar
const int UMBRAL_HUMEDO = 380; // por debajo: tierra húmeda → cortar

const long VELOCIDAD_SERIAL = 115200; // la del original

// El original medía una vez por segundo (_delay(1)).
const unsigned long INTERVALO_MEDICION_MS = 1000;

void setup() {
  pinMode(PIN_HIGROMETRO, INPUT);
  pinMode(PIN_RELE_VALVULA, OUTPUT);
  // Estado inicial SEGURO: arrancamos con la válvula cerrada. Sin esta línea
  // el pin queda en LOW por defecto; si invertís las constantes para un módulo
  // activo-bajo, ese LOW pasaría a ser "abierta" y, si al encender la lectura
  // cae en la banda muerta (entre 380 y 750), la válvula regaría sin control.
  // Regla de oro: dejá SIEMPRE el actuador en estado seguro antes del loop.
  digitalWrite(PIN_RELE_VALVULA, VALVULA_CERRADA);
  Serial.begin(VELOCIDAD_SERIAL);
}

void loop() {
  int humedad = analogRead(PIN_HIGROMETRO);

  // Publicamos la lectura por consola: sirve para calibrar los umbrales
  // y para ver en vivo qué "piensa" el sistema del suelo.
  Serial.println(humedad);

  // Histéresis del original: dos ifs independientes, dos umbrales.
  if (humedad > UMBRAL_SECO) {
    // Tierra demasiado seca: abrir la válvula para regar.
    digitalWrite(PIN_RELE_VALVULA, VALVULA_ABIERTA);
  }
  if (humedad < UMBRAL_HUMEDO) {
    // Tierra suficientemente húmeda: cerrar la válvula.
    digitalWrite(PIN_RELE_VALVULA, VALVULA_CERRADA);
  }
  // Entre 380 y 750 no se cumple ninguno: la válvula queda como estaba.

  delay(INTERVALO_MEDICION_MS);
}

// Riego por humedad: un higrómetro de suelo (FC-28) mide qué tan seca está
// la tierra y el programa abre o cierra la electroválvula en función de eso.
// El higrómetro también se imprime por la consola serial para poder
// calibrar los umbrales observando valores reales.
//
// CONVENCIÓN DEL HIGRÓMETRO (¡importante!): en estos módulos resistivos,
// MAYOR lectura = tierra MÁS SECA (más resistencia, menos agua conduciendo).
// Por eso "seco" es el umbral ALTO y "húmedo" el umbral BAJO. El original
// lo confirma: "mayor a 750 => demasiado seco; menor a 380 => húmedo".
//
// HISTÉRESIS NATURAL DEL ORIGINAL (se preserva tal cual): son dos ifs
// independientes con DOS umbrales distintos. Por encima del umbral seco
// abre; por debajo del húmedo cierra; en la franja intermedia NINGUNO de
// los dos se cumple, así que la válvula conserva su estado anterior. Esa
// banda muerta evita que la válvula traquetee cuando la lectura baila
// cerca de un único umbral: es una solución elegante que ya venía en el
// original.
//
// DIFERENCIA DE ADC (didáctica): el conversor del ESP32 es de 12 bits, así
// que analogRead() devuelve 0 a 4095 (3,3 V), NO el 0 a 1023 (10 bits, 5 V)
// del UNO. Los umbrales del original (750 y 380) se reescalan en la misma
// proporción: 750/1023 ≈ 3000/4095 y 380/1023 ≈ 1520/4095. Mismo fenómeno,
// distinta "regla de medir".
//
// SEGURIDAD: agua y electricidad no se llevan bien. Conexiones eléctricas
// fuera y por encima del agua. Electroválvula de baja tensión (12 V) o
// simulación en el aula; 220 V solo docente/instalación supervisada, nunca
// sobre la protoboard (desvío pedagógico acordado).
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: señal analógica del higrómetro → GPIO 34; relé de la
// electroválvula → GPIO 16.
// Nota eléctrica: el ESP32 trabaja a 3,3 V. El GPIO 34 es de SOLO ENTRADA
// y pertenece al ADC1 (sigue midiendo con WiFi activo, a diferencia del
// ADC2). El módulo higrómetro de 3 pines ya entrega una señal analógica
// lista para el pin; alimentalo con 3,3 V para que su salida no supere ese
// nivel.
//
// Basado en: Fragmento de código 5 — Sistema de Riego Automatizado,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: constantes nombradas y portado a ESP32 (el original usaba
// A0 y el pin 2 del UNO); umbrales reescalados al ADC de 12 bits; el
// original llamaba a analogRead tres veces por vuelta (una para imprimir y
// una por cada if), lo que podía dar tres valores distintos; acá se lee UNA
// vez a una variable y esa misma lectura se imprime y se compara.

const int PIN_HIGROMETRO   = 34;
const int PIN_RELE_VALVULA = 16;

// Módulo relé activo-alto, como en el original (HIGH = válvula abierta).
// Si tu módulo es activo-bajo, invertí solo estas dos constantes.
const int VALVULA_ABIERTA = HIGH;
const int VALVULA_CERRADA = LOW;

// Umbrales del original reescalados al ADC de 12 bits del ESP32.
// Ajustalos a TU suelo midiendo con la consola (Paso 4 del original).
const int UMBRAL_SECO   = 3000; // por encima: tierra seca → regar   (750 en UNO)
const int UMBRAL_HUMEDO = 1520; // por debajo: tierra húmeda → cortar (380 en UNO)

const long VELOCIDAD_SERIAL = 115200; // la del original

// El original medía una vez por segundo (_delay(1)).
const unsigned long INTERVALO_MEDICION_MS = 1000;

void setup() {
  pinMode(PIN_HIGROMETRO, INPUT);
  pinMode(PIN_RELE_VALVULA, OUTPUT);
  // Estado inicial SEGURO: arrancamos con la válvula cerrada. Sin esta línea
  // el pin queda en LOW por defecto; si invertís las constantes para un módulo
  // activo-bajo, ese LOW pasaría a ser "abierta" y, si al encender la lectura
  // cae en la banda muerta (entre 1520 y 3000), la válvula regaría sin control.
  // Regla de oro: dejá SIEMPRE el actuador en estado seguro antes del loop.
  digitalWrite(PIN_RELE_VALVULA, VALVULA_CERRADA);
  Serial.begin(VELOCIDAD_SERIAL);
}

void loop() {
  int humedad = analogRead(PIN_HIGROMETRO);

  // Publicamos la lectura por consola: sirve para calibrar los umbrales
  // y para ver en vivo qué "piensa" el sistema del suelo.
  Serial.println(humedad);

  // Histéresis del original: dos ifs independientes, dos umbrales.
  if (humedad > UMBRAL_SECO) {
    // Tierra demasiado seca: abrir la válvula para regar.
    digitalWrite(PIN_RELE_VALVULA, VALVULA_ABIERTA);
  }
  if (humedad < UMBRAL_HUMEDO) {
    // Tierra suficientemente húmeda: cerrar la válvula.
    digitalWrite(PIN_RELE_VALVULA, VALVULA_CERRADA);
  }
  // Entre el umbral húmedo y el seco no se cumple ninguno: la válvula
  // queda como estaba.

  delay(INTERVALO_MEDICION_MS);
}

// Riego por humedad SIN delay(): la misma lógica del nivel intermedio
// (higrómetro que abre o cierra la electroválvula), pero no bloqueante.
// En vez de detener el programa un segundo entre mediciones, cada vuelta
// de loop() pregunta con millis() si ya pasó el intervalo; el resto del
// tiempo el procesador queda libre. Esta es la base que en ESP32 permite
// sumar IoT en riego-iot.ino sin que el riego se "cuelgue".
//
// CONVENCIÓN DEL HIGRÓMETRO: MAYOR lectura = tierra MÁS SECA (módulo
// resistivo). Por eso "seco" es el umbral alto (750) y "húmedo" el bajo
// (380), igual que en el nivel intermedio.
//
// HISTÉRESIS NATURAL DEL ORIGINAL (se preserva tal cual): dos ifs con dos
// umbrales; en la franja 380 a 750 la válvula conserva su estado, lo que
// evita el traqueteo cuando la lectura baila cerca de un borde.
//
// SEGURIDAD: agua y electricidad no se llevan bien. Conexiones eléctricas
// fuera y por encima del agua. Electroválvula de baja tensión (12 V) o
// simulación en el aula; 220 V solo docente/instalación supervisada, nunca
// sobre la protoboard (desvío pedagógico acordado).
//
// Plataforma: Arduino UNO.
// Conexión (la del esquema original): higrómetro → A0; relé de la
// electroválvula → pin 2.
//
// Basado en: Fragmentos de código 6 (patrón millis) y 7 (medición y
// control cada segundo, sin la parte IoT) — Sistema de Riego Automatizado,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: constantes nombradas; millisAnterior como unsigned long
// (el long del original desborda la cuenta); una sola lectura del
// higrómetro por ciclo, reutilizada para imprimir y comparar.

const int PIN_HIGROMETRO   = A0;
const int PIN_RELE_VALVULA = 2;

// Módulo relé activo-alto, como en el original (HIGH = válvula abierta).
// Si tu módulo es activo-bajo, invertí solo estas dos constantes.
const int VALVULA_ABIERTA = HIGH;
const int VALVULA_CERRADA = LOW;

// Umbrales del original (escala del UNO: 0 a 1023). Ajustalos a TU suelo.
const int UMBRAL_SECO   = 750; // por encima: tierra seca → regar
const int UMBRAL_HUMEDO = 380; // por debajo: tierra húmeda → cortar

const long VELOCIDAD_SERIAL = 115200; // la del original

// El Fragmento de código 7 del original mide una vez por segundo.
const unsigned long INTERVALO_MEDICION_MS = 1000;

// Momento (ms desde el arranque) de la última medición.
unsigned long millisAnterior = 0;

void setup() {
  pinMode(PIN_HIGROMETRO, INPUT);
  pinMode(PIN_RELE_VALVULA, OUTPUT);
  // Estado inicial SEGURO: arrancamos con la válvula cerrada. Sin esta línea
  // el pin queda en LOW por defecto; si invertís las constantes para un módulo
  // activo-bajo, ese LOW pasaría a ser "abierta" y, si al encender la lectura
  // cae en la banda muerta (entre 380 y 750), la válvula regaría sin control.
  // Regla de oro: dejá SIEMPRE el actuador en estado seguro antes del loop.
  digitalWrite(PIN_RELE_VALVULA, VALVULA_CERRADA);
  Serial.begin(VELOCIDAD_SERIAL);
}

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;

    int humedad = analogRead(PIN_HIGROMETRO);
    Serial.println(humedad);

    // Histéresis del original: dos ifs independientes, dos umbrales.
    if (humedad > UMBRAL_SECO) {
      // Tierra demasiado seca: abrir la válvula para regar.
      digitalWrite(PIN_RELE_VALVULA, VALVULA_ABIERTA);
    }
    if (humedad < UMBRAL_HUMEDO) {
      // Tierra suficientemente húmeda: cerrar la válvula.
      digitalWrite(PIN_RELE_VALVULA, VALVULA_CERRADA);
    }
    // Entre 380 y 750 la válvula queda como estaba.
  }

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

// Riego por humedad SIN delay(): la misma lógica del nivel intermedio
// (higrómetro que abre o cierra la electroválvula), pero no bloqueante.
// En vez de detener el programa un segundo entre mediciones, cada vuelta
// de loop() pregunta con millis() si ya pasó el intervalo; el resto del
// tiempo el procesador queda libre. Este programa es la base directa de
// riego-iot.ino: sin código bloqueante, el ESP32 puede mantener el WiFi y
// publicar por MQTT sin desatender el riego.
//
// CONVENCIÓN DEL HIGRÓMETRO: MAYOR lectura = tierra MÁS SECA (módulo
// resistivo). Por eso "seco" es el umbral alto y "húmedo" el bajo.
//
// HISTÉRESIS NATURAL DEL ORIGINAL (se preserva tal cual): dos ifs con dos
// umbrales; en la franja intermedia la válvula conserva su estado, lo que
// evita el traqueteo cuando la lectura baila cerca de un borde.
//
// DIFERENCIA DE ADC (didáctica): el ESP32 mide 0 a 4095 (12 bits, 3,3 V),
// no 0 a 1023 (10 bits, 5 V) del UNO; los umbrales del original se
// reescalan en la misma proporción (750→3000, 380→1520).
//
// SEGURIDAD: agua y electricidad no se llevan bien. Conexiones eléctricas
// fuera y por encima del agua. Electroválvula de baja tensión (12 V) o
// simulación en el aula; 220 V solo docente/instalación supervisada, nunca
// sobre la protoboard (desvío pedagógico acordado).
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: higrómetro → GPIO 34 (ADC1, solo entrada); relé de la
// electroválvula → GPIO 16. Nota eléctrica: el ESP32 trabaja a 3,3 V;
// alimentá el higrómetro con 3,3 V y nunca inyectes 5 V en un GPIO.
//
// Basado en: Fragmentos de código 6 (patrón millis) y 7 (medición y
// control cada segundo, sin la parte IoT) — Sistema de Riego Automatizado,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: constantes nombradas; millisAnterior como unsigned long
// (el long del original desborda la cuenta); portado a ESP32 con umbrales
// reescalados; una sola lectura del higrómetro por ciclo, reutilizada para
// imprimir y comparar.

const int PIN_HIGROMETRO   = 34;
const int PIN_RELE_VALVULA = 16;

// Módulo relé activo-alto, como en el original (HIGH = válvula abierta).
// Si tu módulo es activo-bajo, invertí solo estas dos constantes.
const int VALVULA_ABIERTA = HIGH;
const int VALVULA_CERRADA = LOW;

// Umbrales del original reescalados al ADC de 12 bits del ESP32.
const int UMBRAL_SECO   = 3000; // por encima: tierra seca → regar   (750 en UNO)
const int UMBRAL_HUMEDO = 1520; // por debajo: tierra húmeda → cortar (380 en UNO)

const long VELOCIDAD_SERIAL = 115200; // la del original

// El Fragmento de código 7 del original mide una vez por segundo.
const unsigned long INTERVALO_MEDICION_MS = 1000;

// Momento (ms desde el arranque) de la última medición.
unsigned long millisAnterior = 0;

void setup() {
  pinMode(PIN_HIGROMETRO, INPUT);
  pinMode(PIN_RELE_VALVULA, OUTPUT);
  // Estado inicial SEGURO: arrancamos con la válvula cerrada. Sin esta línea
  // el pin queda en LOW por defecto; si invertís las constantes para un módulo
  // activo-bajo, ese LOW pasaría a ser "abierta" y, si al encender la lectura
  // cae en la banda muerta (entre 1520 y 3000), la válvula regaría sin control.
  // Regla de oro: dejá SIEMPRE el actuador en estado seguro antes del loop.
  digitalWrite(PIN_RELE_VALVULA, VALVULA_CERRADA);
  Serial.begin(VELOCIDAD_SERIAL);
}

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;

    int humedad = analogRead(PIN_HIGROMETRO);
    Serial.println(humedad);

    // Histéresis del original: dos ifs independientes, dos umbrales.
    if (humedad > UMBRAL_SECO) {
      // Tierra demasiado seca: abrir la válvula para regar.
      digitalWrite(PIN_RELE_VALVULA, VALVULA_ABIERTA);
    }
    if (humedad < UMBRAL_HUMEDO) {
      // Tierra suficientemente húmeda: cerrar la válvula.
      digitalWrite(PIN_RELE_VALVULA, VALVULA_CERRADA);
    }
    // Entre el umbral húmedo y el seco la válvula queda como estaba.
  }

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

// Riego por humedad con monitoreo IoT vía Adafruit IO (MQTT).
// La lógica no bloqueante de riego-no-bloqueante.ino sigue controlando la
// electroválvula según el higrómetro; además se publican dos feeds para
// verlos desde el Panel de Control de Adafruit (como en la guía):
//
//   "humedad": lectura cruda del higrómetro (número más alto = más seco).
//   "valvula": 0 = cerrada, 1 = abierta.
//
// CONVENCIÓN DEL HIGRÓMETRO: MAYOR lectura = tierra MÁS SECA (módulo
// resistivo). Por eso "seco" es el umbral alto y "húmedo" el bajo.
//
// HISTÉRESIS NATURAL DEL ORIGINAL (se preserva tal cual): dos ifs con dos
// umbrales; en la franja intermedia la válvula conserva su estado.
//
// DIFERENCIA DE ADC (didáctica): el ESP32 mide 0 a 4095 (12 bits, 3,3 V),
// no 0 a 1023 del UNO; los umbrales se reescalan (750→3000, 380→1520).
//
// SEGURIDAD: agua y electricidad no se llevan bien. Conexiones eléctricas
// fuera y por encima del agua. Electroválvula de baja tensión (12 V) o
// simulación en el aula; 220 V solo docente/instalación supervisada, nunca
// sobre la protoboard (desvío pedagógico acordado).
//
// Plataforma: ESP32 (DevKit v1) — usa su WiFi integrado.
// Conexión: higrómetro → GPIO 34 (ADC1, solo entrada); relé de la
// electroválvula → GPIO 16. Nota eléctrica: el ESP32 trabaja a 3,3 V;
// alimentá el higrómetro con 3,3 V y nunca inyectes 5 V en un GPIO.
//
// Librería requerida (Library Manager del IDE de Arduino):
//   "Adafruit MQTT Library" (de Adafruit) — la misma elección que en los
//   demás proyectos: cada feed es un objeto y publish() acepta números
//   directamente, igual que el olq.publish() del original.
//
// Basado en: Fragmento de código 7 — Sistema de Riego Automatizado,
// 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 "humedad" en CADA
// medición (cada 1 s = 60 publicaciones por minuto, el doble del límite
// gratuito de Adafruit IO de 30/min); acá se publica solo cuando algo
// cambia: la válvula al conmutar y la humedad cuando difiere 50 o más del
// último valor publicado. (3) Umbrales reescalados al ADC de 12 bits.

#include <WiFi.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;

const int PIN_HIGROMETRO   = 34;
const int PIN_RELE_VALVULA = 16;

// Módulo relé activo-alto, como en el original (HIGH = válvula abierta).
// Si tu módulo es activo-bajo, invertí solo estas dos constantes.
const int VALVULA_ABIERTA = HIGH;
const int VALVULA_CERRADA = LOW;

// Umbrales del original reescalados al ADC de 12 bits del ESP32.
const int UMBRAL_SECO   = 3000; // por encima: tierra seca → regar   (750 en UNO)
const int UMBRAL_HUMEDO = 1520; // por debajo: tierra húmeda → cortar (380 en UNO)

// La humedad se re-publica solo si difiere en 50 o más (sobre 0-4095) del
// último valor publicado: los saltitos de ruido entre medición y medición
// no le aportan nada a la central y consumen el cupo gratuito de Adafruit.
const int UMBRAL_PUBLICACION = 50;

const long VELOCIDAD_SERIAL = 115200;

// El original mide una vez por segundo.
const unsigned long INTERVALO_MEDICION_MS = 1000;

// Si se cae la conexión MQTT, reintentamos cada tanto SIN bloquear:
// el riego debe seguir funcionando aunque no haya internet.
const unsigned long INTERVALO_REINTENTO_MQTT_MS = 5000;

// Cliente MQTT sobre el WiFi del ESP32, y un objeto por feed.
WiFiClient clienteWifi;
Adafruit_MQTT_Client mqtt(&clienteWifi, SERVIDOR_MQTT, PUERTO_MQTT,
                          IO_USERNAME, IO_KEY);
Adafruit_MQTT_Publish feedHumedad(&mqtt, IO_USERNAME "/feeds/humedad");
Adafruit_MQTT_Publish feedValvula(&mqtt, IO_USERNAME "/feeds/valvula");

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

// Todavía no se midió: no hay que publicar humedad inventada si la
// conexión MQTT llega antes que la primera medición.
bool hayMedicion = false;

// Estado actual (lo que muestran la válvula y el higrómetro)...
int estadoValvula = 0; // 0 = cerrada, 1 = abierta
int humedadActual = 0; // última lectura cruda del higrómetro

// ...y lo último que llegó a publicarse. Separarlos permite publicar solo
// los CAMBIOS y, si la conexión estaba caída, ponerse al día al volver.
int estadoValvulaPublicado = -1;    // -1 = todavía no se publicó nada
int humedadPublicada        = -1000; // imposible: fuerza la 1ª publicación

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

// Mantiene viva la conexión MQTT sin bloquear el riego: 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ó desde la última publicación exitosa
// (la humedad, solo si cambió 50 o más). Si publish() falla o no hay
// conexión, no se actualiza el registro: se reintenta en la próxima vuelta.
void publicarCambios() {
  if (!mqtt.connected() || !hayMedicion) {
    return; // sin internet o sin datos reales todavía: no se publica
  }

  if (estadoValvula != estadoValvulaPublicado
      && feedValvula.publish((int32_t)estadoValvula)) {
    estadoValvulaPublicado = estadoValvula;
  }

  if (diferenciaAbsoluta(humedadActual, humedadPublicada) >= UMBRAL_PUBLICACION
      && feedHumedad.publish((int32_t)humedadActual)) {
    humedadPublicada = humedadActual;
  }
}

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

  pinMode(PIN_HIGROMETRO, INPUT);
  pinMode(PIN_RELE_VALVULA, OUTPUT);

  // Estado inicial seguro: válvula cerrada hasta que la primera medición
  // diga otra cosa.
  digitalWrite(PIN_RELE_VALVULA, VALVULA_CERRADA);

  // Conexión WiFi. Esperar acá con delay() es aceptable porque el riego
  // 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 control, una vez por segundo (como el original) ---
  if (millisActual - millisAnterior >= INTERVALO_MEDICION_MS) {
    millisAnterior = millisActual;

    humedadActual = analogRead(PIN_HIGROMETRO);
    hayMedicion = true; // desde ahora, publicarCambios() tiene datos reales
    Serial.println(humedadActual);

    // Histéresis del original: dos ifs independientes, dos umbrales.
    if (humedadActual > UMBRAL_SECO) {
      // Tierra demasiado seca: abrir la válvula para regar.
      digitalWrite(PIN_RELE_VALVULA, VALVULA_ABIERTA);
      estadoValvula = 1;
    }
    if (humedadActual < UMBRAL_HUMEDO) {
      // Tierra suficientemente húmeda: cerrar la válvula.
      digitalWrite(PIN_RELE_VALVULA, VALVULA_CERRADA);
      estadoValvula = 0;
    }
    // Entre el umbral húmedo y el seco la válvula queda como estaba.
  }

  // --- Parte IoT ---
  // Gracias a que el control no bloquea, estas dos tareas se atienden en
  // CADA vuelta de loop(): esta es la razón de fondo por la que la guía
  // enseña a abandonar delay() antes de llegar a IoT.
  mantenerConexionMqtt();
  publicarCambios();
}