Sistema de Tanques

// Control de llenado de un tanque: el sensor ultrasónico HC-SR04 mide la
// distancia entre la tapa y la superficie del agua; cuando el agua llega
// a la altura de corte, un relé cierra la electroválvula de entrada.
// Menor distancia = tanque más lleno: el sensor mira al agua desde arriba.
//
// SEGURIDAD: agua y electricidad no se llevan bien. Todas las conexiones
// eléctricas van fuera y POR ENCIMA del nivel del agua, y el sensor no se
// debe mojar. La práctica se realiza con una electroválvula de baja
// tensión (12 V); la conexión a 220 V de la guía original queda reservada
// al docente o a una instalación supervisada, y nunca sobre la protoboard
// (desvío pedagógico acordado).
//
// Plataforma: Arduino UNO.
// Conexión (la del esquema original): TRIG del sensor → pin 8, ECHO → pin 9,
// entrada "S" del módulo relé de la válvula → pin 4.
//
// Basado en: Fragmento de código 1 — Sistema de Tanques,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: (1) se reemplazó el código generado por mBlock3 (_delay,
// _loop, pinMode dentro de la función de medición) por C++ idiomático con
// constantes nombradas y pinMode en setup(). (2) Se agregó una histéresis
// de 5 cm: el original abría y cerraba la válvula en el mismo valor exacto
// (40 cm), y el ruido de medición del HC-SR04 (±1 cm típico) haría
// traquetear el relé justo en el borde.

// Sensor ultrasónico del tanque (TRIG dispara el pulso, ECHO lo recibe).
const int PIN_TRIG1 = 8;
const int PIN_ECHO1 = 9;

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

// 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 RELE_ENCENDIDO = HIGH; // válvula abierta: entra agua
const int RELE_APAGADO   = LOW;  // válvula cerrada

// Altura de corte del original: si el agua queda a menos de 40 cm del
// sensor, el tanque está lleno. Este valor NO se inventa: sale de medir
// en tu maqueta la distancia entre el sensor y el nivel máximo deseado
// (5 a 10 cm por debajo del ingreso de agua, dice la guía).
const float DISTANCIA_MINIMA_CM = 40.0;

// Colchón de la histéresis: la válvula cierra a 40 cm pero recién vuelve
// a abrir cuando el agua baja más allá de 45 cm. Sin este margen, una
// medición que oscile entre 39.5 y 40.5 abriría y cerraría el relé sin
// parar (modernización, ver encabezado).
const float MARGEN_HISTERESIS_CM = 5.0;

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

// El eco tarda 58 microsegundos por cada centímetro de distancia (ida y
// vuelta del sonido a ~343 m/s). El timeout evita quedar esperando para
// siempre un eco que no llega.
const float MICROSEGUNDOS_POR_CM = 58.0;
const unsigned long TIMEOUT_ECO_US = 30000;

// Mide la distancia en cm entre el sensor y la superficie del agua.
// Si en 30 ms no llega el eco (sensor desconectado o fuera de rango),
// pulseIn devuelve 0 y la distancia da 0: el programa lo interpreta como
// "tanque lleno" y cierra la válvula. Es una falla SEGURA: ante la duda,
// que no entre agua.
float medirDistanciaCm(int pinTrig, int pinEcho) {
  digitalWrite(pinTrig, LOW);
  delayMicroseconds(2);
  digitalWrite(pinTrig, HIGH); // pulso de disparo de 10 microsegundos
  delayMicroseconds(10);
  digitalWrite(pinTrig, LOW);
  return pulseIn(pinEcho, HIGH, TIMEOUT_ECO_US) / MICROSEGUNDOS_POR_CM;
}

void setup() {
  pinMode(PIN_TRIG1, OUTPUT);
  pinMode(PIN_ECHO1, INPUT);
  pinMode(PIN_RELE_VALVULA, OUTPUT);

  // Arrancamos con la válvula cerrada hasta la primera medición:
  // el estado seguro de un tanque es "no entra agua".
  digitalWrite(PIN_RELE_VALVULA, RELE_APAGADO);
}

void loop() {
  float distancia = medirDistanciaCm(PIN_TRIG1, PIN_ECHO1);

  if (distancia < DISTANCIA_MINIMA_CM) {
    // El agua llegó a la altura de corte: cerrar la válvula.
    digitalWrite(PIN_RELE_VALVULA, RELE_APAGADO);
  } else if (distancia > DISTANCIA_MINIMA_CM + MARGEN_HISTERESIS_CM) {
    // Hay lugar de sobra: abrir la válvula para cargar el tanque.
    digitalWrite(PIN_RELE_VALVULA, RELE_ENCENDIDO);
  }
  // Entre 40 y 45 cm no escribimos nada: el relé conserva su último
  // estado. Esa franja "muerta" es la histéresis que evita el traqueteo.

  delay(INTERVALO_MEDICION_MS);
}

// Control de llenado de un tanque: el sensor ultrasónico HC-SR04 mide la
// distancia entre la tapa y la superficie del agua; cuando el agua llega
// a la altura de corte, un relé cierra la electroválvula de entrada.
// Menor distancia = tanque más lleno: el sensor mira al agua desde arriba.
//
// SEGURIDAD: agua y electricidad no se llevan bien. Todas las conexiones
// eléctricas van fuera y POR ENCIMA del nivel del agua, y el sensor no se
// debe mojar. La práctica se realiza con una electroválvula de baja
// tensión (12 V); la conexión a 220 V de la guía original queda reservada
// al docente o a una instalación supervisada, y nunca sobre la protoboard
// (desvío pedagógico acordado).
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: TRIG → GPIO 5, ECHO → GPIO 18 (¡leer nota!), relé de la
// válvula → GPIO 25.
// NOTA ELÉCTRICA (¡importante!): el ESP32 trabaja a 3,3 V. El HC-SR04
// clásico se alimenta con 5 V y su pin ECHO devuelve el eco a 5 V: eso
// dañaría el GPIO. Es OBLIGATORIO un divisor de tensión en ECHO
// (ECHO —1 kΩ— GPIO 18 —2 kΩ— GND), que baja los 5 V a ~3,3 V. Es la
// misma idea del divisor del LDR: dos resistencias que reparten la
// tensión. TRIG no necesita nada: los 3,3 V del GPIO alcanzan para
// dispararlo. Alternativa sin divisor: el modelo HC-SR04P, que puede
// alimentarse directamente con 3,3 V.
//
// Basado en: Fragmento de código 1 — Sistema de Tanques,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: (1) se reemplazó el código generado por mBlock3 (_delay,
// _loop, pinMode dentro de la función de medición) por C++ idiomático con
// constantes nombradas y pinMode en setup(); se portó a ESP32 (el original
// usaba los pines 8/9/4 del UNO). (2) Se agregó una histéresis de 5 cm:
// el original abría y cerraba la válvula en el mismo valor exacto (40 cm),
// y el ruido de medición del HC-SR04 (±1 cm típico) haría traquetear el
// relé justo en el borde.

// Sensor ultrasónico del tanque (TRIG dispara el pulso, ECHO lo recibe).
const int PIN_TRIG1 = 5;
const int PIN_ECHO1 = 18; // con divisor de tensión 1 kΩ / 2 kΩ (ver nota)

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

// 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 RELE_ENCENDIDO = HIGH; // válvula abierta: entra agua
const int RELE_APAGADO   = LOW;  // válvula cerrada

// Altura de corte del original: si el agua queda a menos de 40 cm del
// sensor, el tanque está lleno. Este valor NO se inventa: sale de medir
// en tu maqueta la distancia entre el sensor y el nivel máximo deseado
// (5 a 10 cm por debajo del ingreso de agua, dice la guía).
const float DISTANCIA_MINIMA_CM = 40.0;

// Colchón de la histéresis: la válvula cierra a 40 cm pero recién vuelve
// a abrir cuando el agua baja más allá de 45 cm. Sin este margen, una
// medición que oscile entre 39.5 y 40.5 abriría y cerraría el relé sin
// parar (modernización, ver encabezado).
const float MARGEN_HISTERESIS_CM = 5.0;

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

// El eco tarda 58 microsegundos por cada centímetro de distancia (ida y
// vuelta del sonido a ~343 m/s). El timeout evita quedar esperando para
// siempre un eco que no llega.
const float MICROSEGUNDOS_POR_CM = 58.0;
const unsigned long TIMEOUT_ECO_US = 30000;

// Mide la distancia en cm entre el sensor y la superficie del agua.
// Si en 30 ms no llega el eco (sensor desconectado o fuera de rango),
// pulseIn devuelve 0 y la distancia da 0: el programa lo interpreta como
// "tanque lleno" y cierra la válvula. Es una falla SEGURA: ante la duda,
// que no entre agua.
float medirDistanciaCm(int pinTrig, int pinEcho) {
  digitalWrite(pinTrig, LOW);
  delayMicroseconds(2);
  digitalWrite(pinTrig, HIGH); // pulso de disparo de 10 microsegundos
  delayMicroseconds(10);
  digitalWrite(pinTrig, LOW);
  return pulseIn(pinEcho, HIGH, TIMEOUT_ECO_US) / MICROSEGUNDOS_POR_CM;
}

void setup() {
  pinMode(PIN_TRIG1, OUTPUT);
  pinMode(PIN_ECHO1, INPUT);
  pinMode(PIN_RELE_VALVULA, OUTPUT);

  // Arrancamos con la válvula cerrada hasta la primera medición:
  // el estado seguro de un tanque es "no entra agua".
  digitalWrite(PIN_RELE_VALVULA, RELE_APAGADO);
}

void loop() {
  float distancia = medirDistanciaCm(PIN_TRIG1, PIN_ECHO1);

  if (distancia < DISTANCIA_MINIMA_CM) {
    // El agua llegó a la altura de corte: cerrar la válvula.
    digitalWrite(PIN_RELE_VALVULA, RELE_APAGADO);
  } else if (distancia > DISTANCIA_MINIMA_CM + MARGEN_HISTERESIS_CM) {
    // Hay lugar de sobra: abrir la válvula para cargar el tanque.
    digitalWrite(PIN_RELE_VALVULA, RELE_ENCENDIDO);
  }
  // Entre 40 y 45 cm no escribimos nada: el relé conserva su último
  // estado. Esa franja "muerta" es la histéresis que evita el traqueteo.

  delay(INTERVALO_MEDICION_MS);
}

// Sistema de dos tanques: cisterna (tanque 1) + tanque elevado (tanque 2).
// La electroválvula carga la cisterna desde la red; una bomba sumergible,
// ubicada dentro de la cisterna, sube el agua al tanque elevado.
// Cada tanque tiene su sensor ultrasónico mirando el agua desde arriba
// (menor distancia = tanque más lleno).
//
// Reglas (las del original):
//   - Válvula: cierra cuando la cisterna está llena; abre cuando hay lugar.
//   - Bomba: se apaga si el tanque elevado está lleno, O si la cisterna
//     está tan vacía que la bomba quedaría fuera del agua (una bomba
//     sumergible que trabaja en seco se arruina). Solo bombea si hay
//     lugar arriba Y agua suficiente abajo.
//
// SEGURIDAD: agua y electricidad no se llevan bien. Todas las conexiones
// eléctricas van fuera y POR ENCIMA del nivel del agua, los sensores no
// se deben mojar y la bomba sumergible solo se enciende estando bajo el
// agua. La práctica se realiza con válvula y bomba de baja tensión (12 V);
// la conexión a 220 V de la guía original queda reservada al docente o a
// una instalación supervisada, y nunca sobre la protoboard (desvío
// pedagógico acordado).
//
// Plataforma: Arduino UNO.
// Conexión (la del esquema original): sensor cisterna TRIG 8 / ECHO 9,
// relé de la válvula → pin 4; sensor tanque elevado TRIG 10 / ECHO 11,
// relé de la bomba → pin 5.
//
// Basado en: Fragmento de código 2 — Sistema de Tanques,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: (1) constantes nombradas y pinMode en setup() en lugar
// del C generado por mBlock3. (2) Histéresis de 5 cm en las tres
// comparaciones: el original conmutaba válvula y bomba en el valor exacto
// del umbral y el ruido del HC-SR04 haría traquetear los relés.

// Sensor del tanque 1 (cisterna) y relé de la electroválvula.
const int PIN_TRIG1        = 8;
const int PIN_ECHO1        = 9;
const int PIN_RELE_VALVULA = 4;

// Sensor del tanque 2 (elevado) y relé de la bomba sumergible.
const int PIN_TRIG2      = 10;
const int PIN_ECHO2      = 11;
const int PIN_RELE_BOMBA = 5;

// Módulos relé activo-alto, como en el original (HIGH = actuador andando).
// Si tu módulo es activo-bajo, invertí solo estas dos constantes.
const int RELE_ENCENDIDO = HIGH;
const int RELE_APAGADO   = LOW;

// Distancias del ejemplo original (se ajustan midiendo en TU maqueta):
// - MINIMA1: agua a menos de 40 cm del sensor 1 = cisterna llena.
// - MAXIMA1: agua a más de 140 cm del sensor 1 = cisterna casi vacía,
//   la bomba quedaría al aire.
// - MINIMA2: agua a menos de 40 cm del sensor 2 = tanque elevado lleno.
const float DISTANCIA_MINIMA1_CM = 40.0;
const float DISTANCIA_MAXIMA1_CM = 140.0;
const float DISTANCIA_MINIMA2_CM = 40.0;

// Colchón anti-traqueteo (modernización, ver encabezado): cada umbral
// tiene una franja de 5 cm en la que no se toca el relé.
const float MARGEN_HISTERESIS_CM = 5.0;

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

// 58 microsegundos de eco por cada cm de distancia; el timeout evita
// esperar para siempre un eco que no llega.
const float MICROSEGUNDOS_POR_CM = 58.0;
const unsigned long TIMEOUT_ECO_US = 30000;

// Mide la distancia en cm entre un sensor y la superficie del agua.
// Si no llega eco, pulseIn devuelve 0 y la distancia da 0: se interpreta
// como "tanque lleno" y todo se apaga. Falla segura.
float medirDistanciaCm(int pinTrig, int pinEcho) {
  digitalWrite(pinTrig, LOW);
  delayMicroseconds(2);
  digitalWrite(pinTrig, HIGH); // pulso de disparo de 10 microsegundos
  delayMicroseconds(10);
  digitalWrite(pinTrig, LOW);
  return pulseIn(pinEcho, HIGH, TIMEOUT_ECO_US) / MICROSEGUNDOS_POR_CM;
}

void setup() {
  pinMode(PIN_TRIG1, OUTPUT);
  pinMode(PIN_ECHO1, INPUT);
  pinMode(PIN_TRIG2, OUTPUT);
  pinMode(PIN_ECHO2, INPUT);
  pinMode(PIN_RELE_VALVULA, OUTPUT);
  pinMode(PIN_RELE_BOMBA, OUTPUT);

  // Estado inicial seguro: válvula cerrada y bomba apagada hasta que
  // las primeras mediciones digan otra cosa.
  digitalWrite(PIN_RELE_VALVULA, RELE_APAGADO);
  digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);
}

void loop() {
  float distancia1 = medirDistanciaCm(PIN_TRIG1, PIN_ECHO1); // cisterna
  float distancia2 = medirDistanciaCm(PIN_TRIG2, PIN_ECHO2); // elevado

  // --- Válvula de la cisterna (misma lógica del nivel inicial) ---
  if (distancia1 < DISTANCIA_MINIMA1_CM) {
    // Cisterna llena: cerrar la válvula.
    digitalWrite(PIN_RELE_VALVULA, RELE_APAGADO);
  } else if (distancia1 > DISTANCIA_MINIMA1_CM + MARGEN_HISTERESIS_CM) {
    // Hay lugar: abrir la válvula.
    digitalWrite(PIN_RELE_VALVULA, RELE_ENCENDIDO);
  }
  // En la franja intermedia el relé conserva su último estado (histéresis).

  // --- Bomba sumergible (el razonamiento escalonado del original) ---
  if (distancia2 < DISTANCIA_MINIMA2_CM) {
    // El tanque elevado está lleno: no hay que bombear más.
    digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);
  } else if (distancia1 > DISTANCIA_MAXIMA1_CM) {
    // La cisterna está casi vacía: apagar la bomba ANTES de que quede
    // fuera del agua. Esta condición protege al hardware y por eso se
    // evalúa aunque arriba haga falta agua.
    digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);
  } else if (distancia2 > DISTANCIA_MINIMA2_CM + MARGEN_HISTERESIS_CM
             && distancia1 < DISTANCIA_MAXIMA1_CM - MARGEN_HISTERESIS_CM) {
    // Hay lugar arriba Y agua suficiente abajo: bombear.
    digitalWrite(PIN_RELE_BOMBA, RELE_ENCENDIDO);
  }
  // En las franjas intermedias la bomba conserva su estado (histéresis).

  delay(INTERVALO_MEDICION_MS);
}

// Sistema de dos tanques: cisterna (tanque 1) + tanque elevado (tanque 2).
// La electroválvula carga la cisterna desde la red; una bomba sumergible,
// ubicada dentro de la cisterna, sube el agua al tanque elevado.
// Cada tanque tiene su sensor ultrasónico mirando el agua desde arriba
// (menor distancia = tanque más lleno).
//
// Reglas (las del original):
//   - Válvula: cierra cuando la cisterna está llena; abre cuando hay lugar.
//   - Bomba: se apaga si el tanque elevado está lleno, O si la cisterna
//     está tan vacía que la bomba quedaría fuera del agua (una bomba
//     sumergible que trabaja en seco se arruina). Solo bombea si hay
//     lugar arriba Y agua suficiente abajo.
//
// SEGURIDAD: agua y electricidad no se llevan bien. Todas las conexiones
// eléctricas van fuera y POR ENCIMA del nivel del agua, los sensores no
// se deben mojar y la bomba sumergible solo se enciende estando bajo el
// agua. La práctica se realiza con válvula y bomba de baja tensión (12 V);
// la conexión a 220 V de la guía original queda reservada al docente o a
// una instalación supervisada, y nunca sobre la protoboard (desvío
// pedagógico acordado).
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: sensor cisterna TRIG GPIO 5 / ECHO GPIO 18, relé de la
// válvula → GPIO 25; sensor elevado TRIG GPIO 19 / ECHO GPIO 21, relé de
// la bomba → GPIO 26.
// NOTA ELÉCTRICA (¡importante!): el ESP32 trabaja a 3,3 V. El HC-SR04
// clásico se alimenta con 5 V y su pin ECHO devuelve el eco a 5 V: eso
// dañaría el GPIO. Es OBLIGATORIO un divisor de tensión en CADA ECHO
// (ECHO —1 kΩ— GPIO —2 kΩ— GND), que baja los 5 V a ~3,3 V. TRIG no
// necesita nada: los 3,3 V del GPIO alcanzan para dispararlo.
// Alternativa sin divisores: el modelo HC-SR04P, que puede alimentarse
// directamente con 3,3 V.
//
// Basado en: Fragmento de código 2 — Sistema de Tanques,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: (1) constantes nombradas y pinMode en setup() en lugar
// del C generado por mBlock3; portado a ESP32 (el original usaba los
// pines 8/9/4 y 10/11/5 del UNO). (2) Histéresis de 5 cm en las tres
// comparaciones: el original conmutaba válvula y bomba en el valor exacto
// del umbral y el ruido del HC-SR04 haría traquetear los relés.

// Sensor del tanque 1 (cisterna) y relé de la electroválvula.
const int PIN_TRIG1        = 5;
const int PIN_ECHO1        = 18; // con divisor 1 kΩ / 2 kΩ (ver nota)
const int PIN_RELE_VALVULA = 25;

// Sensor del tanque 2 (elevado) y relé de la bomba sumergible.
const int PIN_TRIG2      = 19;
const int PIN_ECHO2      = 21;   // con divisor 1 kΩ / 2 kΩ (ver nota)
const int PIN_RELE_BOMBA = 26;

// Módulos relé activo-alto, como en el original (HIGH = actuador andando).
// Si tu módulo es activo-bajo, invertí solo estas dos constantes.
const int RELE_ENCENDIDO = HIGH;
const int RELE_APAGADO   = LOW;

// Distancias del ejemplo original (se ajustan midiendo en TU maqueta):
// - MINIMA1: agua a menos de 40 cm del sensor 1 = cisterna llena.
// - MAXIMA1: agua a más de 140 cm del sensor 1 = cisterna casi vacía,
//   la bomba quedaría al aire.
// - MINIMA2: agua a menos de 40 cm del sensor 2 = tanque elevado lleno.
const float DISTANCIA_MINIMA1_CM = 40.0;
const float DISTANCIA_MAXIMA1_CM = 140.0;
const float DISTANCIA_MINIMA2_CM = 40.0;

// Colchón anti-traqueteo (modernización, ver encabezado): cada umbral
// tiene una franja de 5 cm en la que no se toca el relé.
const float MARGEN_HISTERESIS_CM = 5.0;

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

// 58 microsegundos de eco por cada cm de distancia; el timeout evita
// esperar para siempre un eco que no llega.
const float MICROSEGUNDOS_POR_CM = 58.0;
const unsigned long TIMEOUT_ECO_US = 30000;

// Mide la distancia en cm entre un sensor y la superficie del agua.
// Si no llega eco, pulseIn devuelve 0 y la distancia da 0: se interpreta
// como "tanque lleno" y todo se apaga. Falla segura.
float medirDistanciaCm(int pinTrig, int pinEcho) {
  digitalWrite(pinTrig, LOW);
  delayMicroseconds(2);
  digitalWrite(pinTrig, HIGH); // pulso de disparo de 10 microsegundos
  delayMicroseconds(10);
  digitalWrite(pinTrig, LOW);
  return pulseIn(pinEcho, HIGH, TIMEOUT_ECO_US) / MICROSEGUNDOS_POR_CM;
}

void setup() {
  pinMode(PIN_TRIG1, OUTPUT);
  pinMode(PIN_ECHO1, INPUT);
  pinMode(PIN_TRIG2, OUTPUT);
  pinMode(PIN_ECHO2, INPUT);
  pinMode(PIN_RELE_VALVULA, OUTPUT);
  pinMode(PIN_RELE_BOMBA, OUTPUT);

  // Estado inicial seguro: válvula cerrada y bomba apagada hasta que
  // las primeras mediciones digan otra cosa.
  digitalWrite(PIN_RELE_VALVULA, RELE_APAGADO);
  digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);
}

void loop() {
  float distancia1 = medirDistanciaCm(PIN_TRIG1, PIN_ECHO1); // cisterna
  float distancia2 = medirDistanciaCm(PIN_TRIG2, PIN_ECHO2); // elevado

  // --- Válvula de la cisterna (misma lógica del nivel inicial) ---
  if (distancia1 < DISTANCIA_MINIMA1_CM) {
    // Cisterna llena: cerrar la válvula.
    digitalWrite(PIN_RELE_VALVULA, RELE_APAGADO);
  } else if (distancia1 > DISTANCIA_MINIMA1_CM + MARGEN_HISTERESIS_CM) {
    // Hay lugar: abrir la válvula.
    digitalWrite(PIN_RELE_VALVULA, RELE_ENCENDIDO);
  }
  // En la franja intermedia el relé conserva su último estado (histéresis).

  // --- Bomba sumergible (el razonamiento escalonado del original) ---
  if (distancia2 < DISTANCIA_MINIMA2_CM) {
    // El tanque elevado está lleno: no hay que bombear más.
    digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);
  } else if (distancia1 > DISTANCIA_MAXIMA1_CM) {
    // La cisterna está casi vacía: apagar la bomba ANTES de que quede
    // fuera del agua. Esta condición protege al hardware y por eso se
    // evalúa aunque arriba haga falta agua.
    digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);
  } else if (distancia2 > DISTANCIA_MINIMA2_CM + MARGEN_HISTERESIS_CM
             && distancia1 < DISTANCIA_MAXIMA1_CM - MARGEN_HISTERESIS_CM) {
    // Hay lugar arriba Y agua suficiente abajo: bombear.
    digitalWrite(PIN_RELE_BOMBA, RELE_ENCENDIDO);
  }
  // En las franjas intermedias la bomba conserva su estado (histéresis).

  delay(INTERVALO_MEDICION_MS);
}

// Sistema de dos tanques SIN delay(): la misma lógica del nivel intermedio
// (válvula de la cisterna + bomba al tanque elevado), pero no bloqueante.
// En vez de detener el programa entre mediciones, cada vuelta de loop()
// pregunta con millis() si ya pasaron 3 segundos desde la última medición;
// el resto del tiempo el procesador queda libre para otras tareas (esta es
// la base que en ESP32 permite sumar IoT en tanques-iot.ino).
//
// SEGURIDAD: agua y electricidad no se llevan bien. Todas las conexiones
// eléctricas van fuera y POR ENCIMA del nivel del agua, los sensores no
// se deben mojar y la bomba sumergible solo se enciende estando bajo el
// agua. La práctica se realiza con válvula y bomba de baja tensión (12 V);
// la conexión a 220 V de la guía original queda reservada al docente o a
// una instalación supervisada, y nunca sobre la protoboard (desvío
// pedagógico acordado).
//
// Plataforma: Arduino UNO.
// Conexión (la del esquema original): sensor cisterna TRIG 8 / ECHO 9,
// relé de la válvula → pin 4; sensor tanque elevado TRIG 10 / ECHO 11,
// relé de la bomba → pin 5.
//
// Basado en: Fragmentos de código 3 (patrón millis) y 4 (medición y
// control cada 3 segundos, sin la parte IoT) — Sistema de Tanques,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: (1) constantes nombradas; millisAnterior como unsigned
// long (el long del original desborda la cuenta). (2) Histéresis de 5 cm
// en los umbrales para que el ruido del HC-SR04 no haga traquetear los
// relés (el original conmutaba en el valor exacto).

// Sensor del tanque 1 (cisterna) y relé de la electroválvula.
const int PIN_TRIG1        = 8;
const int PIN_ECHO1        = 9;
const int PIN_RELE_VALVULA = 4;

// Sensor del tanque 2 (elevado) y relé de la bomba sumergible.
const int PIN_TRIG2      = 10;
const int PIN_ECHO2      = 11;
const int PIN_RELE_BOMBA = 5;

// Módulos relé activo-alto, como en el original (HIGH = actuador andando).
// Si tu módulo es activo-bajo, invertí solo estas dos constantes.
const int RELE_ENCENDIDO = HIGH;
const int RELE_APAGADO   = LOW;

// Distancias del ejemplo original (se ajustan midiendo en TU maqueta).
const float DISTANCIA_MINIMA1_CM = 40.0;  // cisterna llena
const float DISTANCIA_MAXIMA1_CM = 140.0; // cisterna casi vacía (bomba al aire)
const float DISTANCIA_MINIMA2_CM = 40.0;  // tanque elevado lleno

// Colchón anti-traqueteo (modernización, ver encabezado).
const float MARGEN_HISTERESIS_CM = 5.0;

// El Fragmento de código 4 del original mide cada 3 segundos: el agua se
// mueve despacio y medir más seguido no aporta nada.
const unsigned long INTERVALO_MEDICION_MS = 3000;

// 58 microsegundos de eco por cada cm; timeout para ecos que no llegan.
const float MICROSEGUNDOS_POR_CM = 58.0;
const unsigned long TIMEOUT_ECO_US = 30000;

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

// Mide la distancia en cm entre un sensor y la superficie del agua.
// Si no llega eco, pulseIn devuelve 0 y la distancia da 0: se interpreta
// como "tanque lleno" y todo se apaga. Falla segura.
// (pulseIn puede esperar el eco hasta 30 ms; junto con los microsegundos
// del disparo, es la única espera que queda en el programa, y es parte
// de la medición misma, no un delay() de relleno.)
float medirDistanciaCm(int pinTrig, int pinEcho) {
  digitalWrite(pinTrig, LOW);
  delayMicroseconds(2);
  digitalWrite(pinTrig, HIGH); // pulso de disparo de 10 microsegundos
  delayMicroseconds(10);
  digitalWrite(pinTrig, LOW);
  return pulseIn(pinEcho, HIGH, TIMEOUT_ECO_US) / MICROSEGUNDOS_POR_CM;
}

void setup() {
  pinMode(PIN_TRIG1, OUTPUT);
  pinMode(PIN_ECHO1, INPUT);
  pinMode(PIN_TRIG2, OUTPUT);
  pinMode(PIN_ECHO2, INPUT);
  pinMode(PIN_RELE_VALVULA, OUTPUT);
  pinMode(PIN_RELE_BOMBA, OUTPUT);

  // Estado inicial seguro: válvula cerrada y bomba apagada hasta que
  // las primeras mediciones digan otra cosa.
  digitalWrite(PIN_RELE_VALVULA, RELE_APAGADO);
  digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);
}

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

  // ¿Ya pasaron 3 segundos desde la última medición? Si no, no hacemos
  // nada: eso es NO bloquear.
  if (millisActual - millisAnterior >= INTERVALO_MEDICION_MS) {
    millisAnterior = millisActual;

    float distancia1 = medirDistanciaCm(PIN_TRIG1, PIN_ECHO1); // cisterna
    float distancia2 = medirDistanciaCm(PIN_TRIG2, PIN_ECHO2); // elevado

    // --- Válvula de la cisterna ---
    if (distancia1 < DISTANCIA_MINIMA1_CM) {
      // Cisterna llena: cerrar la válvula.
      digitalWrite(PIN_RELE_VALVULA, RELE_APAGADO);
    } else if (distancia1 > DISTANCIA_MINIMA1_CM + MARGEN_HISTERESIS_CM) {
      // Hay lugar: abrir la válvula.
      digitalWrite(PIN_RELE_VALVULA, RELE_ENCENDIDO);
    }
    // En la franja intermedia el relé conserva su estado (histéresis).

    // --- Bomba sumergible ---
    if (distancia2 < DISTANCIA_MINIMA2_CM) {
      // El tanque elevado está lleno: no hay que bombear más.
      digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);
    } else if (distancia1 > DISTANCIA_MAXIMA1_CM) {
      // La cisterna está casi vacía: apagar la bomba ANTES de que
      // quede fuera del agua (protección del hardware).
      digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);
    } else if (distancia2 > DISTANCIA_MINIMA2_CM + MARGEN_HISTERESIS_CM
               && distancia1 < DISTANCIA_MAXIMA1_CM - MARGEN_HISTERESIS_CM) {
      // Hay lugar arriba Y agua suficiente abajo: bombear.
      digitalWrite(PIN_RELE_BOMBA, RELE_ENCENDIDO);
    }
    // En las franjas intermedias la bomba conserva su estado (histéresis).
  }

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

// Sistema de dos tanques SIN delay(): la misma lógica del nivel intermedio
// (válvula de la cisterna + bomba al tanque elevado), pero no bloqueante.
// En vez de detener el programa entre mediciones, cada vuelta de loop()
// pregunta con millis() si ya pasaron 3 segundos desde la última medición;
// el resto del tiempo el procesador queda libre. Este programa es la base
// directa de tanques-iot.ino: sin código bloqueante, el ESP32 puede
// mantener el WiFi y publicar por MQTT sin desatender los tanques.
//
// SEGURIDAD: agua y electricidad no se llevan bien. Todas las conexiones
// eléctricas van fuera y POR ENCIMA del nivel del agua, los sensores no
// se deben mojar y la bomba sumergible solo se enciende estando bajo el
// agua. La práctica se realiza con válvula y bomba de baja tensión (12 V);
// la conexión a 220 V de la guía original queda reservada al docente o a
// una instalación supervisada, y nunca sobre la protoboard (desvío
// pedagógico acordado).
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: sensor cisterna TRIG GPIO 5 / ECHO GPIO 18, relé de la
// válvula → GPIO 25; sensor elevado TRIG GPIO 19 / ECHO GPIO 21, relé de
// la bomba → GPIO 26.
// NOTA ELÉCTRICA (¡importante!): el ESP32 trabaja a 3,3 V. El HC-SR04
// clásico se alimenta con 5 V y su pin ECHO devuelve el eco a 5 V: eso
// dañaría el GPIO. Es OBLIGATORIO un divisor de tensión en CADA ECHO
// (ECHO —1 kΩ— GPIO —2 kΩ— GND), que baja los 5 V a ~3,3 V. TRIG no
// necesita nada. Alternativa sin divisores: el modelo HC-SR04P, que
// puede alimentarse directamente con 3,3 V.
//
// Basado en: Fragmentos de código 3 (patrón millis) y 4 (medición y
// control cada 3 segundos, sin la parte IoT) — Sistema de Tanques,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: (1) constantes nombradas; millisAnterior como unsigned
// long (el long del original desborda la cuenta); portado a ESP32.
// (2) Histéresis de 5 cm en los umbrales para que el ruido del HC-SR04
// no haga traquetear los relés (el original conmutaba en el valor exacto).

// Sensor del tanque 1 (cisterna) y relé de la electroválvula.
const int PIN_TRIG1        = 5;
const int PIN_ECHO1        = 18; // con divisor 1 kΩ / 2 kΩ (ver nota)
const int PIN_RELE_VALVULA = 25;

// Sensor del tanque 2 (elevado) y relé de la bomba sumergible.
const int PIN_TRIG2      = 19;
const int PIN_ECHO2      = 21;   // con divisor 1 kΩ / 2 kΩ (ver nota)
const int PIN_RELE_BOMBA = 26;

// Módulos relé activo-alto, como en el original (HIGH = actuador andando).
// Si tu módulo es activo-bajo, invertí solo estas dos constantes.
const int RELE_ENCENDIDO = HIGH;
const int RELE_APAGADO   = LOW;

// Distancias del ejemplo original (se ajustan midiendo en TU maqueta).
const float DISTANCIA_MINIMA1_CM = 40.0;  // cisterna llena
const float DISTANCIA_MAXIMA1_CM = 140.0; // cisterna casi vacía (bomba al aire)
const float DISTANCIA_MINIMA2_CM = 40.0;  // tanque elevado lleno

// Colchón anti-traqueteo (modernización, ver encabezado).
const float MARGEN_HISTERESIS_CM = 5.0;

// El Fragmento de código 4 del original mide cada 3 segundos: el agua se
// mueve despacio y medir más seguido no aporta nada.
const unsigned long INTERVALO_MEDICION_MS = 3000;

// 58 microsegundos de eco por cada cm; timeout para ecos que no llegan.
const float MICROSEGUNDOS_POR_CM = 58.0;
const unsigned long TIMEOUT_ECO_US = 30000;

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

// Mide la distancia en cm entre un sensor y la superficie del agua.
// Si no llega eco, pulseIn devuelve 0 y la distancia da 0: se interpreta
// como "tanque lleno" y todo se apaga. Falla segura.
// (pulseIn puede esperar el eco hasta 30 ms; junto con los microsegundos
// del disparo, es la única espera que queda en el programa, y es parte
// de la medición misma, no un delay() de relleno.)
float medirDistanciaCm(int pinTrig, int pinEcho) {
  digitalWrite(pinTrig, LOW);
  delayMicroseconds(2);
  digitalWrite(pinTrig, HIGH); // pulso de disparo de 10 microsegundos
  delayMicroseconds(10);
  digitalWrite(pinTrig, LOW);
  return pulseIn(pinEcho, HIGH, TIMEOUT_ECO_US) / MICROSEGUNDOS_POR_CM;
}

void setup() {
  pinMode(PIN_TRIG1, OUTPUT);
  pinMode(PIN_ECHO1, INPUT);
  pinMode(PIN_TRIG2, OUTPUT);
  pinMode(PIN_ECHO2, INPUT);
  pinMode(PIN_RELE_VALVULA, OUTPUT);
  pinMode(PIN_RELE_BOMBA, OUTPUT);

  // Estado inicial seguro: válvula cerrada y bomba apagada hasta que
  // las primeras mediciones digan otra cosa.
  digitalWrite(PIN_RELE_VALVULA, RELE_APAGADO);
  digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);
}

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

  // ¿Ya pasaron 3 segundos desde la última medición? Si no, no hacemos
  // nada: eso es NO bloquear.
  if (millisActual - millisAnterior >= INTERVALO_MEDICION_MS) {
    millisAnterior = millisActual;

    float distancia1 = medirDistanciaCm(PIN_TRIG1, PIN_ECHO1); // cisterna
    float distancia2 = medirDistanciaCm(PIN_TRIG2, PIN_ECHO2); // elevado

    // --- Válvula de la cisterna ---
    if (distancia1 < DISTANCIA_MINIMA1_CM) {
      // Cisterna llena: cerrar la válvula.
      digitalWrite(PIN_RELE_VALVULA, RELE_APAGADO);
    } else if (distancia1 > DISTANCIA_MINIMA1_CM + MARGEN_HISTERESIS_CM) {
      // Hay lugar: abrir la válvula.
      digitalWrite(PIN_RELE_VALVULA, RELE_ENCENDIDO);
    }
    // En la franja intermedia el relé conserva su estado (histéresis).

    // --- Bomba sumergible ---
    if (distancia2 < DISTANCIA_MINIMA2_CM) {
      // El tanque elevado está lleno: no hay que bombear más.
      digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);
    } else if (distancia1 > DISTANCIA_MAXIMA1_CM) {
      // La cisterna está casi vacía: apagar la bomba ANTES de que
      // quede fuera del agua (protección del hardware).
      digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);
    } else if (distancia2 > DISTANCIA_MINIMA2_CM + MARGEN_HISTERESIS_CM
               && distancia1 < DISTANCIA_MAXIMA1_CM - MARGEN_HISTERESIS_CM) {
      // Hay lugar arriba Y agua suficiente abajo: bombear.
      digitalWrite(PIN_RELE_BOMBA, RELE_ENCENDIDO);
    }
    // En las franjas intermedias la bomba conserva su estado (histéresis).
  }

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

// Sistema de dos tanques con monitoreo IoT vía Adafruit IO (MQTT).
// La lógica no bloqueante de dos-tanques-no-bloqueante.ino sigue manejando
// válvula y bomba; además se publican cuatro feeds para verlos desde el
// Panel de Control de Adafruit (dos Gauge y dos Indicator, como en la guía):
//
//   "tanque1" y "tanque2": nivel medido, en cm de distancia entre el
//     sensor y el agua (número más chico = tanque más lleno, porque el
//     sensor mira desde arriba).
//   "valvula" y "bomba": 0 = apagada, 1 = encendida.
//
// SEGURIDAD: agua y electricidad no se llevan bien. Todas las conexiones
// eléctricas van fuera y POR ENCIMA del nivel del agua, los sensores no
// se deben mojar y la bomba sumergible solo se enciende estando bajo el
// agua. La práctica se realiza con válvula y bomba de baja tensión (12 V);
// la conexión a 220 V de la guía original queda reservada al docente o a
// una instalación supervisada, y nunca sobre la protoboard (desvío
// pedagógico acordado).
//
// Plataforma: ESP32 (DevKit v1) — usa su WiFi integrado.
// Conexión: sensor cisterna TRIG GPIO 5 / ECHO GPIO 18, relé de la
// válvula → GPIO 25; sensor elevado TRIG GPIO 19 / ECHO GPIO 21, relé de
// la bomba → GPIO 26.
// NOTA ELÉCTRICA (¡importante!): el ESP32 trabaja a 3,3 V. El HC-SR04
// clásico se alimenta con 5 V y su pin ECHO devuelve el eco a 5 V: eso
// dañaría el GPIO. Es OBLIGATORIO un divisor de tensión en CADA ECHO
// (ECHO —1 kΩ— GPIO —2 kΩ— GND). Alternativa: el modelo HC-SR04P, que
// puede alimentarse directamente con 3,3 V.
//
// Librería requerida (Library Manager del IDE de Arduino):
//   "Adafruit MQTT Library" (de Adafruit) — la misma elección que en el
//   proyecto del semáforo: cada feed es un objeto y publish() acepta
//   números directamente, igual que el olq.publish() del original.
//
// Basado en: Fragmento de código 4 — Sistema de Tanques,
// 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 los cuatro feeds
// en CADA medición (cada 3 s = 80 publicaciones por minuto, muy por encima
// del límite gratuito de Adafruit IO de 30/min); acá se publica solo
// cuando algo cambia: los estados al conmutar, y los niveles cuando la
// diferencia con lo último publicado es de 2 cm o más. (3) Histéresis de
// 5 cm en los umbrales de control (el original conmutaba en el valor
// exacto y el ruido del sensor haría traquetear los relés).

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

// Sensor del tanque 1 (cisterna) y relé de la electroválvula.
const int PIN_TRIG1        = 5;
const int PIN_ECHO1        = 18; // con divisor 1 kΩ / 2 kΩ (ver nota)
const int PIN_RELE_VALVULA = 25;

// Sensor del tanque 2 (elevado) y relé de la bomba sumergible.
const int PIN_TRIG2      = 19;
const int PIN_ECHO2      = 21;   // con divisor 1 kΩ / 2 kΩ (ver nota)
const int PIN_RELE_BOMBA = 26;

// Módulos relé activo-alto, como en el original (HIGH = actuador andando).
// Si tu módulo es activo-bajo, invertí solo estas dos constantes.
const int RELE_ENCENDIDO = HIGH;
const int RELE_APAGADO   = LOW;

// Distancias del ejemplo original (se ajustan midiendo en TU maqueta).
const float DISTANCIA_MINIMA1_CM = 40.0;  // cisterna llena
const float DISTANCIA_MAXIMA1_CM = 140.0; // cisterna casi vacía (bomba al aire)
const float DISTANCIA_MINIMA2_CM = 40.0;  // tanque elevado lleno

// Colchón anti-traqueteo de los relés (modernización, ver encabezado).
const float MARGEN_HISTERESIS_CM = 5.0;

// El Fragmento de código 4 del original mide cada 3 segundos.
const unsigned long INTERVALO_MEDICION_MS = 3000;

// Un nivel se re-publica solo si difiere en 2 cm o más de lo último
// publicado: los milímetros que bailan entre medición y medición no le
// aportan nada a la central y consumen el cupo gratuito de Adafruit IO.
const int UMBRAL_PUBLICACION_CM = 2;

// Si se cae la conexión MQTT, reintentamos cada tanto SIN bloquear:
// los tanques deben seguir controlados aunque no haya internet.
const unsigned long INTERVALO_REINTENTO_MQTT_MS = 5000;

// 58 microsegundos de eco por cada cm; timeout para ecos que no llegan.
const float MICROSEGUNDOS_POR_CM = 58.0;
const unsigned long TIMEOUT_ECO_US = 30000;

// 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 feedTanque1(&mqtt, IO_USERNAME "/feeds/tanque1");
Adafruit_MQTT_Publish feedTanque2(&mqtt, IO_USERNAME "/feeds/tanque2");
Adafruit_MQTT_Publish feedValvula(&mqtt, IO_USERNAME "/feeds/valvula");
Adafruit_MQTT_Publish feedBomba(&mqtt, IO_USERNAME "/feeds/bomba");

// 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ó nada: no hay que publicar niveles inventados si
// la conexión MQTT llega antes que la primera medición.
bool hayMedicion = false;

// Estado actual del sistema (lo que muestran los relés y los sensores)...
int estadoValvula = 0; // 0 = cerrada, 1 = abierta
int estadoBomba   = 0; // 0 = apagada, 1 = encendida
int nivelCm1      = 0; // última medición de la cisterna, en cm
int nivelCm2      = 0; // última medición del tanque elevado, en cm

// ...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 estadoBombaPublicado   = -1;
int nivelPublicado1        = -1000; // imposible: fuerza la primera publicación
int nivelPublicado2        = -1000;

// Mide la distancia en cm entre un sensor y la superficie del agua.
// Si no llega eco, pulseIn devuelve 0 y la distancia da 0: se interpreta
// como "tanque lleno" y todo se apaga. Falla segura.
float medirDistanciaCm(int pinTrig, int pinEcho) {
  digitalWrite(pinTrig, LOW);
  delayMicroseconds(2);
  digitalWrite(pinTrig, HIGH); // pulso de disparo de 10 microsegundos
  delayMicroseconds(10);
  digitalWrite(pinTrig, LOW);
  return pulseIn(pinEcho, HIGH, TIMEOUT_ECO_US) / MICROSEGUNDOS_POR_CM;
}

// 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 control de los tanques:
// 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
// (los niveles, solo si cambiaron 2 cm o más). Si publish() falla o no
// hay conexión, no se actualiza el registro: se reintenta en la próxima
// vuelta de loop().
void publicarCambios() {
  if (!mqtt.connected()) {
    return; // sin internet los tanques siguen; la central se pone al día al volver
  }
  if (!hayMedicion) {
    return; // solo se publica lo que realmente se midió
  }

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

  if (estadoBomba != estadoBombaPublicado
      && feedBomba.publish((int32_t)estadoBomba)) {
    estadoBombaPublicado = estadoBomba;
  }

  if (diferenciaAbsoluta(nivelCm1, nivelPublicado1) >= UMBRAL_PUBLICACION_CM
      && feedTanque1.publish((int32_t)nivelCm1)) {
    nivelPublicado1 = nivelCm1;
  }

  if (diferenciaAbsoluta(nivelCm2, nivelPublicado2) >= UMBRAL_PUBLICACION_CM
      && feedTanque2.publish((int32_t)nivelCm2)) {
    nivelPublicado2 = nivelCm2;
  }
}

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

  pinMode(PIN_TRIG1, OUTPUT);
  pinMode(PIN_ECHO1, INPUT);
  pinMode(PIN_TRIG2, OUTPUT);
  pinMode(PIN_ECHO2, INPUT);
  pinMode(PIN_RELE_VALVULA, OUTPUT);
  pinMode(PIN_RELE_BOMBA, OUTPUT);

  // Estado inicial seguro: válvula cerrada y bomba apagada hasta que
  // las primeras mediciones digan otra cosa.
  digitalWrite(PIN_RELE_VALVULA, RELE_APAGADO);
  digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);

  // Conexión WiFi. Esperar acá con delay() es aceptable porque el control
  // de los tanques 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, cada 3 segundos (como el original) ---
  if (millisActual - millisAnterior >= INTERVALO_MEDICION_MS) {
    millisAnterior = millisActual;

    float distancia1 = medirDistanciaCm(PIN_TRIG1, PIN_ECHO1); // cisterna
    float distancia2 = medirDistanciaCm(PIN_TRIG2, PIN_ECHO2); // elevado

    // Los feeds publican el nivel en cm enteros, como el original.
    nivelCm1 = (int)distancia1;
    nivelCm2 = (int)distancia2;
    hayMedicion = true; // desde ahora, publicarCambios() tiene datos reales

    // Válvula de la cisterna.
    if (distancia1 < DISTANCIA_MINIMA1_CM) {
      // Cisterna llena: cerrar la válvula.
      digitalWrite(PIN_RELE_VALVULA, RELE_APAGADO);
      estadoValvula = 0;
    } else if (distancia1 > DISTANCIA_MINIMA1_CM + MARGEN_HISTERESIS_CM) {
      // Hay lugar: abrir la válvula.
      digitalWrite(PIN_RELE_VALVULA, RELE_ENCENDIDO);
      estadoValvula = 1;
    }
    // En la franja intermedia el relé conserva su estado (histéresis).

    // Bomba sumergible.
    if (distancia2 < DISTANCIA_MINIMA2_CM) {
      // El tanque elevado está lleno: no hay que bombear más.
      digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);
      estadoBomba = 0;
    } else if (distancia1 > DISTANCIA_MAXIMA1_CM) {
      // La cisterna está casi vacía: apagar la bomba ANTES de que
      // quede fuera del agua (protección del hardware).
      digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);
      estadoBomba = 0;
    } else if (distancia2 > DISTANCIA_MINIMA2_CM + MARGEN_HISTERESIS_CM
               && distancia1 < DISTANCIA_MAXIMA1_CM - MARGEN_HISTERESIS_CM) {
      // Hay lugar arriba Y agua suficiente abajo: bombear.
      digitalWrite(PIN_RELE_BOMBA, RELE_ENCENDIDO);
      estadoBomba = 1;
    }
    // En las franjas intermedias la bomba conserva su estado (histéresis).
  }

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