Sistema Acuapónico

// Sistema acuapónico automatizado — nivel inicial (SIN código bloqueante).
// Dos cargas, cada una con su relé, dentro de un ciclo de 60 s que se
// repite indefinidamente:
//   - Aireador de la pecera : 20 s encendido / 40 s apagado.
//   - Bomba de recirculación:  5 s encendida / 55 s apagada.
// Estos regímenes de funcionamiento son los del ejemplo de la guía (se
// ajustan a mano en TU maqueta hasta que la batea no rebalse).
//
// ¿POR QUÉ NO USAR delay()? Con una sola carga alcanzaría con encender,
// esperar y apagar. Pero acá el aireador y la bomba tienen ciclos DISTINTOS
// que corren AL MISMO TIEMPO: si el programa se queda "esperando" (delay)
// los 40 s apagados del aireador, no puede atender a la bomba en ese rato.
// Eso se llama "código bloqueante" y es exactamente el problema que plantea
// el Paso 5 del original. La solución: un CRONÓMETRO. En cada vuelta de
// loop() miramos cuánto tiempo lleva el ciclo (millis() - inicioCiclo) y,
// para CADA carga por separado, decidimos si en este instante le toca estar
// encendida o apagada. El procesador nunca queda clavado esperando: esta es
// la base no bloqueante sobre la que después se apoyará el IoT (ESP32).
//
// SEGURIDAD (220 V + agua): el aireador y la bomba son cargas de 220 V
// conmutadas por un relé. En el aula se trabaja con cargas de BAJA
// TENSIÓN; la conexión real a 220 V queda reservada al docente o a una
// instalación supervisada, NUNCA sobre la protoboard, y con todas las
// conexiones eléctricas fuera y por encima del nivel del agua. La BOMBA
// NO DEBE FUNCIONAR EN SECO: si se enciende fuera del agua, se quema
// (por eso primero se llena la pecera y recién ahí se prueba).
//
// Plataforma: Arduino UNO.
// Conexión (contrato de la reedición): entrada "S" del relé del aireador
// → pin 2; entrada "S" del relé de la bomba → pin 3.
//
// Basado en: Fragmento de código 2 (Nivel Inicial, "Programar sin código
// bloqueante") — Sistema Acuapónico Automatizado, Saberes Digitales
// (INET/EDUCAR 2019).
// Modernización: se reemplazó el código generado por mBlock3 (getLastTime
// con double de millis()/1000.0, _delay/_loop, angle_rad/deg) por C++
// idiomático con constantes nombradas y aritmética de unsigned long en
// milisegundos (evita el desborde de la resta que arrastraba el original).

// Relés de las dos cargas de 220 V (ver advertencia de SEGURIDAD arriba).
const int PIN_RELE_AIREADOR = 2;
const int PIN_RELE_BOMBA    = 3;

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

// Umbrales de encendido dentro del ciclo (los del ejemplo original). Cada
// carga arranca encendida al comenzar el ciclo y se apaga al cruzar su
// umbral; a los 60 s el ciclo se reinicia.
const unsigned long AIREADOR_ON_MS = 20000UL; // aireador ON los primeros 20 s
const unsigned long BOMBA_ON_MS    = 5000UL;  // bomba ON los primeros 5 s
const unsigned long CICLO_TOTAL_MS = 60000UL; // el ciclo dura 60 s

// Marca de tiempo (ms desde el arranque) en la que empezó el ciclo actual.
// Es nuestro "cronómetro": el tiempo transcurrido es millis() - inicioCiclo.
unsigned long inicioCiclo = 0;

void setup() {
  pinMode(PIN_RELE_AIREADOR, OUTPUT);
  pinMode(PIN_RELE_BOMBA, OUTPUT);

  // Estado inicial seguro: ambas cargas apagadas hasta la primera vuelta.
  digitalWrite(PIN_RELE_AIREADOR, RELE_APAGADO);
  digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);

  inicioCiclo = millis();
}

void loop() {
  // Tiempo transcurrido desde el inicio del ciclo. Con unsigned long, la
  // resta funciona bien aun cuando millis() desborda (~cada 50 días).
  unsigned long transcurrido = millis() - inicioCiclo;

  // Cada carga decide su estado mirando el cronómetro. Nada de delay():
  // esta función entra y sale al instante y las dos se atienden "a la vez".
  digitalWrite(PIN_RELE_AIREADOR,
               transcurrido < AIREADOR_ON_MS ? RELE_ENCENDIDO : RELE_APAGADO);
  digitalWrite(PIN_RELE_BOMBA,
               transcurrido < BOMBA_ON_MS ? RELE_ENCENDIDO : RELE_APAGADO);

  // Cumplidos los 60 s, reiniciamos el cronómetro y el ciclo vuelve a cero.
  if (transcurrido >= CICLO_TOTAL_MS) {
    inicioCiclo = millis();
  }
}

// Sistema acuapónico automatizado — nivel inicial (SIN código bloqueante).
// Dos cargas, cada una con su relé, dentro de un ciclo de 60 s que se
// repite indefinidamente:
//   - Aireador de la pecera : 20 s encendido / 40 s apagado.
//   - Bomba de recirculación:  5 s encendida / 55 s apagada.
// Estos regímenes son los del ejemplo de la guía (se ajustan a mano en TU
// maqueta hasta que la batea no rebalse).
//
// ¿POR QUÉ NO USAR delay()? El aireador y la bomba tienen ciclos DISTINTOS
// que corren AL MISMO TIEMPO: si el programa se queda "esperando" (delay)
// los 40 s apagados del aireador, no puede atender a la bomba en ese rato.
// Eso es "código bloqueante", el problema que plantea el Paso 5 del
// original. La solución es un CRONÓMETRO: en cada vuelta de loop() miramos
// cuánto lleva el ciclo (millis() - inicioCiclo) y, para CADA carga por
// separado, decidimos si le toca estar encendida o apagada. El procesador
// nunca queda clavado esperando: esta es la base no bloqueante sobre la que
// se apoya el IoT del nivel avanzado.
//
// SEGURIDAD (220 V + agua): el aireador y la bomba son cargas de 220 V
// conmutadas por un relé. En el aula se trabaja con cargas de BAJA
// TENSIÓN; la conexión real a 220 V queda reservada al docente o a una
// instalación supervisada, NUNCA sobre la protoboard, y con todas las
// conexiones eléctricas fuera y por encima del nivel del agua. La BOMBA
// NO DEBE FUNCIONAR EN SECO: si se enciende fuera del agua, se quema.
//
// Plataforma: ESP32 (DevKit v1).
// Conexión (contrato de la reedición): entrada "S" del relé del aireador
// → GPIO 25; entrada "S" del relé de la bomba → GPIO 26.
// NOTA ELÉCTRICA: la lógica del ESP32 es de 3,3 V. La entrada de señal de
// la mayoría de los módulos relé la reconoce, pero el módulo se ALIMENTA
// con 5 V (VCC al 5V/VIN de la placa) y la masa (GND) debe ser común. Para
// conmutar 220 V, usar sí o sí un módulo relé con optoacoplador.
//
// Basado en: Fragmento de código 2 (Nivel Inicial, "Programar sin código
// bloqueante") — Sistema Acuapónico Automatizado, Saberes Digitales
// (INET/EDUCAR 2019).
// Modernización: C++ idiomático con constantes nombradas en vez del código
// de mBlock3; portado del UNO (pines 2/3) al ESP32 (GPIO 25/26); aritmética
// de unsigned long en ms (evita el desborde de la resta del original).

// Relés de las dos cargas de 220 V (ver advertencia de SEGURIDAD arriba).
const int PIN_RELE_AIREADOR = 25;
const int PIN_RELE_BOMBA    = 26;

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

// Umbrales de encendido dentro del ciclo (los del ejemplo original). Cada
// carga arranca encendida al comenzar el ciclo y se apaga al cruzar su
// umbral; a los 60 s el ciclo se reinicia.
const unsigned long AIREADOR_ON_MS = 20000UL; // aireador ON los primeros 20 s
const unsigned long BOMBA_ON_MS    = 5000UL;  // bomba ON los primeros 5 s
const unsigned long CICLO_TOTAL_MS = 60000UL; // el ciclo dura 60 s

// Marca de tiempo (ms desde el arranque) en la que empezó el ciclo actual.
// Es nuestro "cronómetro": el tiempo transcurrido es millis() - inicioCiclo.
unsigned long inicioCiclo = 0;

void setup() {
  pinMode(PIN_RELE_AIREADOR, OUTPUT);
  pinMode(PIN_RELE_BOMBA, OUTPUT);

  // Estado inicial seguro: ambas cargas apagadas hasta la primera vuelta.
  digitalWrite(PIN_RELE_AIREADOR, RELE_APAGADO);
  digitalWrite(PIN_RELE_BOMBA, RELE_APAGADO);

  inicioCiclo = millis();
}

void loop() {
  // Tiempo transcurrido desde el inicio del ciclo. Con unsigned long, la
  // resta funciona bien aun cuando millis() desborda (~cada 50 días).
  unsigned long transcurrido = millis() - inicioCiclo;

  // Cada carga decide su estado mirando el cronómetro. Nada de delay():
  // esta función entra y sale al instante y las dos se atienden "a la vez".
  digitalWrite(PIN_RELE_AIREADOR,
               transcurrido < AIREADOR_ON_MS ? RELE_ENCENDIDO : RELE_APAGADO);
  digitalWrite(PIN_RELE_BOMBA,
               transcurrido < BOMBA_ON_MS ? RELE_ENCENDIDO : RELE_APAGADO);

  // Cumplidos los 60 s, reiniciamos el cronómetro y el ciclo vuelve a cero.
  if (transcurrido >= CICLO_TOTAL_MS) {
    inicioCiclo = millis();
  }
}

// Sistema acuapónico automatizado — nivel intermedio (dosificador de
// alimento). Se suma al aireador y la bomba un tercer actuador: un motor
// DC con reducción que hace girar un dosificador impreso en 3D para
// alimentar a los peces. Todo dentro del mismo ciclo de 60 s, resuelto con
// el mismo CRONÓMETRO no bloqueante del nivel inicial:
//   - Aireador de la pecera : 20 s encendido / 40 s apagado.
//   - Bomba de recirculación:  5 s encendida / 55 s apagada.
//   - Dosificador (motor)   :  1 s encendido / 59 s apagado.
//
// COMPONENTE NUEVO — ULN2003: el motor del dosificador NO puede conectarse
// directo a un pin del Arduino, porque un motor pide más corriente de la
// que un pin puede entregar. El ULN2003 es el "amplificador" intermedio
// (un arreglo de transistores Darlington): recibe la señal débil del pin
// y con ella deja pasar la corriente que el motor necesita desde una
// fuente aparte. Acá lo usamos como un simple INTERRUPTOR de motor
// UNIDIRECCIONAL (encendido/apagado): mientras el pin está en HIGH, el
// motor gira en un sentido y dosifica; en LOW, se detiene. Se cablea la
// entrada IN1 del ULN2003 al pin del Arduino, la salida OUT1 a un borne
// del motor, el otro borne del motor a la fuente, y la masa (GND) común.
//
// SEGURIDAD (220 V + agua): el aireador y la bomba son cargas de 220 V
// conmutadas por relé. En el aula se trabaja con BAJA TENSIÓN; la conexión
// real a 220 V queda reservada al docente o a una instalación supervisada,
// NUNCA sobre la protoboard, y con las conexiones eléctricas fuera y por
// encima del nivel del agua. La BOMBA NO DEBE FUNCIONAR EN SECO: se quema.
// (El motor del dosificador es de baja tensión y no maneja 220 V.)
//
// Plataforma: Arduino UNO.
// Conexión (contrato de la reedición): relé del aireador → pin 2, relé de
// la bomba → pin 3, entrada IN1 del ULN2003 (motor del dosificador) → pin 4.
//
// Basado en: Fragmento de código 3 (Nivel Intermedio) — Sistema Acuapónico
// Automatizado, Saberes Digitales (INET/EDUCAR 2019).
// Modernización: C++ idiomático con constantes nombradas en vez de mBlock3;
// aritmética de unsigned long en ms (el original llevaba la cuenta con un
// double de millis()/1000.0, con riesgo de desborde en la resta).

// Relés de las dos cargas de 220 V (ver advertencia de SEGURIDAD arriba).
const int PIN_RELE_AIREADOR = 2;
const int PIN_RELE_BOMBA    = 3;

// Entrada de control del ULN2003 que mueve el motor del dosificador.
const int PIN_DOSIFICADOR = 4;

// Módulos relé activo-alto (HIGH = carga encendida). El ULN2003 también
// activa el motor con HIGH en su entrada, así que compartimos convención.
const int ENCENDIDO = HIGH;
const int APAGADO   = LOW;

// Umbrales de encendido dentro del ciclo (los del ejemplo original). Los
// tres actuadores arrancan encendidos al comenzar el ciclo y se apagan al
// cruzar su umbral; a los 60 s el ciclo se reinicia.
const unsigned long AIREADOR_ON_MS    = 20000UL; // aireador ON los primeros 20 s
const unsigned long BOMBA_ON_MS       = 5000UL;  // bomba ON los primeros 5 s
const unsigned long DOSIFICADOR_ON_MS = 1000UL;  // dosificador ON el primer 1 s
const unsigned long CICLO_TOTAL_MS    = 60000UL; // el ciclo dura 60 s

// Marca de tiempo (ms desde el arranque) en la que empezó el ciclo actual.
// Es nuestro "cronómetro": el tiempo transcurrido es millis() - inicioCiclo.
unsigned long inicioCiclo = 0;

void setup() {
  pinMode(PIN_RELE_AIREADOR, OUTPUT);
  pinMode(PIN_RELE_BOMBA, OUTPUT);
  pinMode(PIN_DOSIFICADOR, OUTPUT);

  // Estado inicial seguro: todo apagado hasta la primera vuelta del loop.
  digitalWrite(PIN_RELE_AIREADOR, APAGADO);
  digitalWrite(PIN_RELE_BOMBA, APAGADO);
  digitalWrite(PIN_DOSIFICADOR, APAGADO);

  inicioCiclo = millis();
}

void loop() {
  // Tiempo transcurrido desde el inicio del ciclo. Con unsigned long, la
  // resta funciona bien aun cuando millis() desborda (~cada 50 días).
  unsigned long transcurrido = millis() - inicioCiclo;

  // Cada actuador decide su estado según el cronómetro. Nada de delay():
  // esta función entra y sale al instante, así que los tres se atienden
  // "a la vez" (y queda tiempo de procesador para el IoT del ESP32).
  digitalWrite(PIN_RELE_AIREADOR,
               transcurrido < AIREADOR_ON_MS ? ENCENDIDO : APAGADO);
  digitalWrite(PIN_RELE_BOMBA,
               transcurrido < BOMBA_ON_MS ? ENCENDIDO : APAGADO);
  digitalWrite(PIN_DOSIFICADOR,
               transcurrido < DOSIFICADOR_ON_MS ? ENCENDIDO : APAGADO);

  // Cumplidos los 60 s, reiniciamos el cronómetro y el ciclo vuelve a cero.
  if (transcurrido >= CICLO_TOTAL_MS) {
    inicioCiclo = millis();
  }
}

// Sistema acuapónico automatizado — nivel intermedio (dosificador de
// alimento). Se suma al aireador y la bomba un tercer actuador: un motor
// DC con reducción que mueve un dosificador impreso en 3D para alimentar
// a los peces. Todo dentro del mismo ciclo de 60 s, resuelto con el mismo
// CRONÓMETRO no bloqueante del nivel inicial:
//   - Aireador de la pecera : 20 s encendido / 40 s apagado.
//   - Bomba de recirculación:  5 s encendida / 55 s apagada.
//   - Dosificador (motor)   :  1 s encendido / 59 s apagado.
//
// COMPONENTE NUEVO — ULN2003: el motor del dosificador NO puede conectarse
// directo a un pin del ESP32, porque un motor pide más corriente de la que
// un pin puede entregar. El ULN2003 es el "amplificador" intermedio (un
// arreglo de transistores Darlington): recibe la señal débil del pin y con
// ella deja pasar la corriente que el motor necesita desde una fuente
// aparte. Acá lo usamos como interruptor de motor UNIDIRECCIONAL
// (encendido/apagado): con el pin en HIGH el motor gira y dosifica, en LOW
// se detiene. Cableado: pin del ESP32 → IN1 del ULN2003, OUT1 → un borne
// del motor, el otro borne del motor → fuente, y GND común.
//
// SEGURIDAD (220 V + agua): aireador y bomba son cargas de 220 V por relé.
// En el aula, BAJA TENSIÓN; los 220 V solo el docente / instalación
// supervisada, nunca sobre la protoboard, conexiones fuera y por encima
// del agua. La BOMBA NO DEBE FUNCIONAR EN SECO: se quema. (El motor del
// dosificador es de baja tensión.)
//
// Plataforma: ESP32 (DevKit v1).
// Conexión (contrato de la reedición): relé del aireador → GPIO 25, relé
// de la bomba → GPIO 26, entrada IN1 del ULN2003 (dosificador) → GPIO 27.
// NOTA ELÉCTRICA: los módulos relé se alimentan con 5 V (VCC al 5V/VIN),
// GND común, y la señal la toman del GPIO de 3,3 V. Para 220 V, usar
// módulos con optoacoplador.
//
// Basado en: Fragmento de código 3 (Nivel Intermedio) — Sistema Acuapónico
// Automatizado, Saberes Digitales (INET/EDUCAR 2019).
// Modernización: C++ idiomático en vez de mBlock3; portado del UNO
// (pines 2/3/4) al ESP32 (GPIO 25/26/27); aritmética de unsigned long en ms.

// Relés de las dos cargas de 220 V (ver advertencia de SEGURIDAD arriba).
const int PIN_RELE_AIREADOR = 25;
const int PIN_RELE_BOMBA    = 26;

// Entrada de control del ULN2003 que mueve el motor del dosificador.
const int PIN_DOSIFICADOR = 27;

// Módulos relé activo-alto (HIGH = carga encendida). El ULN2003 también
// activa el motor con HIGH en su entrada, así que compartimos convención.
const int ENCENDIDO = HIGH;
const int APAGADO   = LOW;

// Umbrales de encendido dentro del ciclo (los del ejemplo original). Los
// tres actuadores arrancan encendidos al comenzar el ciclo y se apagan al
// cruzar su umbral; a los 60 s el ciclo se reinicia.
const unsigned long AIREADOR_ON_MS    = 20000UL; // aireador ON los primeros 20 s
const unsigned long BOMBA_ON_MS       = 5000UL;  // bomba ON los primeros 5 s
const unsigned long DOSIFICADOR_ON_MS = 1000UL;  // dosificador ON el primer 1 s
const unsigned long CICLO_TOTAL_MS    = 60000UL; // el ciclo dura 60 s

// Marca de tiempo (ms desde el arranque) en la que empezó el ciclo actual.
// Es nuestro "cronómetro": el tiempo transcurrido es millis() - inicioCiclo.
unsigned long inicioCiclo = 0;

void setup() {
  pinMode(PIN_RELE_AIREADOR, OUTPUT);
  pinMode(PIN_RELE_BOMBA, OUTPUT);
  pinMode(PIN_DOSIFICADOR, OUTPUT);

  // Estado inicial seguro: todo apagado hasta la primera vuelta del loop.
  digitalWrite(PIN_RELE_AIREADOR, APAGADO);
  digitalWrite(PIN_RELE_BOMBA, APAGADO);
  digitalWrite(PIN_DOSIFICADOR, APAGADO);

  inicioCiclo = millis();
}

void loop() {
  // Tiempo transcurrido desde el inicio del ciclo. Con unsigned long, la
  // resta funciona bien aun cuando millis() desborda (~cada 50 días).
  unsigned long transcurrido = millis() - inicioCiclo;

  // Cada actuador decide su estado según el cronómetro. Nada de delay():
  // esta función entra y sale al instante, así que los tres se atienden
  // "a la vez" (y queda tiempo de procesador para el IoT del ESP32).
  digitalWrite(PIN_RELE_AIREADOR,
               transcurrido < AIREADOR_ON_MS ? ENCENDIDO : APAGADO);
  digitalWrite(PIN_RELE_BOMBA,
               transcurrido < BOMBA_ON_MS ? ENCENDIDO : APAGADO);
  digitalWrite(PIN_DOSIFICADOR,
               transcurrido < DOSIFICADOR_ON_MS ? ENCENDIDO : APAGADO);

  // Cumplidos los 60 s, reiniciamos el cronómetro y el ciclo vuelve a cero.
  if (transcurrido >= CICLO_TOTAL_MS) {
    inicioCiclo = millis();
  }
}

// Sistema acuapónico automatizado — nivel avanzado (base para IoT).
// Mismo comportamiento y mismos regímenes de los niveles anteriores, con el
// mismo CRONÓMETRO no bloqueante, dentro de un ciclo de 60 s:
//   - Aireador de la pecera : 20 s encendido / 40 s apagado.
//   - Bomba de recirculación:  5 s encendida / 55 s apagada.
//   - Dosificador (motor)   :  1 s encendido / 59 s apagado.
//
// ¿QUÉ CAMBIA RESPECTO DEL NIVEL INTERMEDIO? El comportamiento es idéntico.
// Lo único nuevo es que ahora guardamos el estado de cada actuador en una
// variable (estadoAireador, estadoBomba, estadoDosificador; 0 = apagado,
// 1 = encendido). Acá esas variables "no hacen falta" para prender los
// relés... pero son la pieza clave del paso siguiente: en la variante ESP32
// (acuaponico-iot.ino) permiten publicar a internet SOLO cuando el estado
// CAMBIA, en vez de repetir el mismo dato una y otra vez. Este sketch es esa
// base, todavía SIN internet. En el Arduino UNO, que no tiene WiFi, este es
// el punto final del proyecto; el monitoreo IoT se realiza con el ESP32.
//
// COMPONENTE ULN2003: el motor del dosificador se maneja por un ULN2003
// (arreglo Darlington) que amplifica la señal del pin para dar al motor la
// corriente que necesita. HIGH en la entrada IN1 = gira y dosifica, LOW =
// detenido.
//
// SEGURIDAD (220 V + agua): aireador y bomba son cargas de 220 V por relé.
// En el aula, BAJA TENSIÓN; los 220 V solo el docente / instalación
// supervisada, nunca sobre la protoboard, conexiones fuera y por encima
// del agua. La BOMBA NO DEBE FUNCIONAR EN SECO: se quema.
//
// Plataforma: Arduino UNO.
// Conexión (contrato de la reedición): relé del aireador → pin 2, relé de
// la bomba → pin 3, entrada IN1 del ULN2003 (dosificador) → pin 4.
//
// Basado en: Fragmento de código 4 (Nivel Avanzado, sin la parte IoT) —
// Sistema Acuapónico Automatizado, Saberes Digitales (INET/EDUCAR 2019).
// Modernización: C++ idiomático en vez de mBlock3; aritmética de unsigned
// long en ms. Se conserva del original la idea de llevar el estado de cada
// carga en una variable (allá servía para publicar; acá deja el terreno
// listo para el IoT del ESP32).

// Relés de las dos cargas de 220 V (ver advertencia de SEGURIDAD arriba).
const int PIN_RELE_AIREADOR = 2;
const int PIN_RELE_BOMBA    = 3;

// Entrada de control del ULN2003 que mueve el motor del dosificador.
const int PIN_DOSIFICADOR = 4;

// Relés / entrada del ULN2003 activos en alto (HIGH = actuador andando).
// Si tu módulo relé es activo-bajo, invertí solo estas dos constantes.
const int ENCENDIDO = HIGH;
const int APAGADO   = LOW;

// Umbrales de encendido dentro del ciclo (los del ejemplo original).
const unsigned long AIREADOR_ON_MS    = 20000UL; // aireador ON los primeros 20 s
const unsigned long BOMBA_ON_MS       = 5000UL;  // bomba ON los primeros 5 s
const unsigned long DOSIFICADOR_ON_MS = 1000UL;  // dosificador ON el primer 1 s
const unsigned long CICLO_TOTAL_MS    = 60000UL; // el ciclo dura 60 s

// Marca de tiempo (ms) en la que empezó el ciclo actual: es el cronómetro.
unsigned long inicioCiclo = 0;

// Estado actual de cada actuador (0 = apagado, 1 = encendido). Es el valor
// que la versión IoT publicará —solo cuando cambie— a Adafruit.
int estadoAireador    = 0;
int estadoBomba       = 0;
int estadoDosificador = 0;

void setup() {
  pinMode(PIN_RELE_AIREADOR, OUTPUT);
  pinMode(PIN_RELE_BOMBA, OUTPUT);
  pinMode(PIN_DOSIFICADOR, OUTPUT);

  // Estado inicial seguro: todo apagado (coincide con las variables en 0).
  digitalWrite(PIN_RELE_AIREADOR, APAGADO);
  digitalWrite(PIN_RELE_BOMBA, APAGADO);
  digitalWrite(PIN_DOSIFICADOR, APAGADO);

  inicioCiclo = millis();
}

void loop() {
  // Tiempo transcurrido desde el inicio del ciclo. Con unsigned long, la
  // resta funciona bien aun cuando millis() desborda (~cada 50 días).
  unsigned long transcurrido = millis() - inicioCiclo;

  // El cronómetro define el estado que le toca a cada actuador...
  estadoAireador    = (transcurrido < AIREADOR_ON_MS) ? 1 : 0;
  estadoBomba       = (transcurrido < BOMBA_ON_MS) ? 1 : 0;
  estadoDosificador = (transcurrido < DOSIFICADOR_ON_MS) ? 1 : 0;

  // ...y ese estado se refleja en los pines (nada de delay(): el loop entra
  // y sale al instante, listo para atender otras tareas —el IoT del ESP32—).
  digitalWrite(PIN_RELE_AIREADOR, estadoAireador ? ENCENDIDO : APAGADO);
  digitalWrite(PIN_RELE_BOMBA, estadoBomba ? ENCENDIDO : APAGADO);
  digitalWrite(PIN_DOSIFICADOR, estadoDosificador ? ENCENDIDO : APAGADO);

  // Cumplidos los 60 s, reiniciamos el cronómetro y el ciclo vuelve a cero.
  if (transcurrido >= CICLO_TOTAL_MS) {
    inicioCiclo = millis();
  }
}

// Sistema acuapónico automatizado — nivel avanzado (base para IoT).
// Mismo comportamiento y mismos regímenes de los niveles anteriores, con el
// mismo CRONÓMETRO no bloqueante, dentro de un ciclo de 60 s:
//   - Aireador de la pecera : 20 s encendido / 40 s apagado.
//   - Bomba de recirculación:  5 s encendida / 55 s apagada.
//   - Dosificador (motor)   :  1 s encendido / 59 s apagado.
//
// ¿QUÉ CAMBIA RESPECTO DEL NIVEL INTERMEDIO? El comportamiento es idéntico.
// Lo único nuevo es que ahora guardamos el estado de cada actuador en una
// variable (estadoAireador, estadoBomba, estadoDosificador; 0 = apagado,
// 1 = encendido). Acá esas variables "no hacen falta" para prender los
// relés... pero son la pieza clave del paso siguiente: en acuaponico-iot.ino
// permiten publicar a internet SOLO cuando el estado CAMBIA, en vez de
// repetir el mismo dato una y otra vez. Este sketch es esa base, todavía
// SIN la parte de red: agregarle WiFi + Adafruit IO es el último paso.
//
// COMPONENTE ULN2003: el motor del dosificador se maneja por un ULN2003
// (arreglo Darlington) que amplifica la señal del pin para dar al motor la
// corriente que necesita. Interruptor de motor unidireccional: HIGH = gira
// y dosifica, LOW = detenido.
//
// SEGURIDAD (220 V + agua): aireador y bomba son cargas de 220 V por relé.
// En el aula, BAJA TENSIÓN; los 220 V solo el docente / instalación
// supervisada, nunca sobre la protoboard, conexiones fuera y por encima
// del agua. La BOMBA NO DEBE FUNCIONAR EN SECO: se quema.
//
// Plataforma: ESP32 (DevKit v1).
// Conexión (contrato de la reedición): relé del aireador → GPIO 25, relé
// de la bomba → GPIO 26, entrada IN1 del ULN2003 (dosificador) → GPIO 27.
// NOTA ELÉCTRICA: módulos relé alimentados con 5 V, GND común, señal desde
// el GPIO de 3,3 V; para 220 V, módulos con optoacoplador.
//
// Basado en: Fragmento de código 4 (Nivel Avanzado, sin la parte IoT) —
// Sistema Acuapónico Automatizado, Saberes Digitales (INET/EDUCAR 2019).
// Modernización: (1) C++ idiomático en vez de mBlock3; portado a ESP32.
// (2) El original contaba con un double de millis()/1000.0; acá usamos
// aritmética de unsigned long en milisegundos (más precisa y sin el riesgo
// de desborde de la resta que arrastraba el patrón original).

// Relés de las dos cargas de 220 V (ver advertencia de SEGURIDAD arriba).
const int PIN_RELE_AIREADOR = 25;
const int PIN_RELE_BOMBA    = 26;

// Entrada de control del ULN2003 que mueve el motor del dosificador.
const int PIN_DOSIFICADOR = 27;

// Módulos relé / entrada del ULN2003 activos en alto (HIGH = actuador andando).
const int ENCENDIDO = HIGH;
const int APAGADO   = LOW;

// Umbrales de encendido dentro del ciclo (los del ejemplo original).
const unsigned long AIREADOR_ON_MS    = 20000UL; // aireador ON los primeros 20 s
const unsigned long BOMBA_ON_MS       = 5000UL;  // bomba ON los primeros 5 s
const unsigned long DOSIFICADOR_ON_MS = 1000UL;  // dosificador ON el primer 1 s
const unsigned long CICLO_TOTAL_MS    = 60000UL; // el ciclo dura 60 s

// Marca de tiempo (ms) en la que empezó el ciclo actual: es el cronómetro.
unsigned long inicioCiclo = 0;

// Estado actual de cada actuador (0 = apagado, 1 = encendido). Es el valor
// que la versión IoT publicará —solo cuando cambie— a Adafruit.
int estadoAireador    = 0;
int estadoBomba       = 0;
int estadoDosificador = 0;

void setup() {
  pinMode(PIN_RELE_AIREADOR, OUTPUT);
  pinMode(PIN_RELE_BOMBA, OUTPUT);
  pinMode(PIN_DOSIFICADOR, OUTPUT);

  // Estado inicial seguro: todo apagado hasta la primera vuelta del loop.
  digitalWrite(PIN_RELE_AIREADOR, APAGADO);
  digitalWrite(PIN_RELE_BOMBA, APAGADO);
  digitalWrite(PIN_DOSIFICADOR, APAGADO);

  inicioCiclo = millis();
}

void loop() {
  // Tiempo transcurrido desde el inicio del ciclo. Con unsigned long, la
  // resta funciona bien aun cuando millis() desborda (~cada 50 días).
  unsigned long transcurrido = millis() - inicioCiclo;

  // El cronómetro define el estado que le toca a cada actuador...
  estadoAireador    = (transcurrido < AIREADOR_ON_MS) ? 1 : 0;
  estadoBomba       = (transcurrido < BOMBA_ON_MS) ? 1 : 0;
  estadoDosificador = (transcurrido < DOSIFICADOR_ON_MS) ? 1 : 0;

  // ...y ese estado se refleja en los pines (nada de delay(): el loop entra
  // y sale al instante y queda libre para atender otras tareas —el IoT—).
  digitalWrite(PIN_RELE_AIREADOR, estadoAireador ? ENCENDIDO : APAGADO);
  digitalWrite(PIN_RELE_BOMBA, estadoBomba ? ENCENDIDO : APAGADO);
  digitalWrite(PIN_DOSIFICADOR, estadoDosificador ? ENCENDIDO : APAGADO);

  // Cumplidos los 60 s, reiniciamos el cronómetro y el ciclo vuelve a cero.
  if (transcurrido >= CICLO_TOTAL_MS) {
    inicioCiclo = millis();
  }
}

// Sistema acuapónico automatizado — nivel avanzado con monitoreo IoT.
// La lógica NO bloqueante de acuaponico-no-bloqueante.ino sigue manejando
// el aireador, la bomba y el dosificador; además se publican tres feeds a
// Adafruit IO para verlos desde el Panel de Control (tres Indicator, como
// en la guía):
//   "aireador", "bomba", "dosificador": 0 = apagado, 1 = encendido.
//
// PUBLICACIÓN POR CAMBIO (event-driven): NO publicamos en cada vuelta del
// loop. Cada feed se publica SOLO cuando su estado cambia respecto de lo
// último que se envió. Así el envío es económico y respeta el límite del
// plan gratuito de Adafruit IO (30 publicaciones/min): cada actuador
// cambia como mucho dos veces por ciclo de 60 s (enciende y apaga), o sea
// 3 actuadores x 2 = 6 publicaciones/min en total, muy por debajo del tope.
// El código IoT del original ya estaba resuelto así (publica al conmutar);
// se mantiene ese criterio.
//
// COMPONENTE ULN2003: el motor del dosificador se maneja por un ULN2003
// (arreglo Darlington) que amplifica la señal del pin. Interruptor de motor
// unidireccional: HIGH = gira y dosifica, LOW = detenido.
//
// SEGURIDAD (220 V + agua): aireador y bomba son cargas de 220 V por relé.
// En el aula, BAJA TENSIÓN; los 220 V solo el docente / instalación
// supervisada, nunca sobre la protoboard, conexiones fuera y por encima
// del agua. La BOMBA NO DEBE FUNCIONAR EN SECO: se quema.
//
// Plataforma: ESP32 (DevKit v1) — usa su WiFi integrado.
// Conexión (contrato de la reedición): relé del aireador → GPIO 25, relé
// de la bomba → GPIO 26, entrada IN1 del ULN2003 (dosificador) → GPIO 27.
// NOTA ELÉCTRICA: módulos relé alimentados con 5 V, GND común, señal desde
// el GPIO de 3,3 V; para 220 V, módulos con optoacoplador.
//
// Librería requerida (Library Manager del IDE de Arduino):
//   "Adafruit MQTT Library" (de Adafruit) — misma elección que en el resto
//   de la colección: cada feed es un objeto y publish() acepta números
//   directamente, igual que el olq.publish() del original.
//
// Basado en: Fragmento de código del Nivel Avanzado (IoT) — Sistema
// Acuapónico Automatizado, Saberes Digitales (INET/EDUCAR 2019).
// Modernización: 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 con la Adafruit MQTT Library. Se conserva la
// publicación por cambio de estado del original (event-driven).

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

// Relés de las dos cargas de 220 V (ver advertencia de SEGURIDAD arriba).
const int PIN_RELE_AIREADOR = 25;
const int PIN_RELE_BOMBA    = 26;

// Entrada de control del ULN2003 que mueve el motor del dosificador.
const int PIN_DOSIFICADOR = 27;

// Módulos relé / entrada del ULN2003 activos en alto (HIGH = actuador andando).
const int ENCENDIDO = HIGH;
const int APAGADO   = LOW;

// Umbrales de encendido dentro del ciclo (los del ejemplo original).
const unsigned long AIREADOR_ON_MS    = 20000UL; // aireador ON los primeros 20 s
const unsigned long BOMBA_ON_MS       = 5000UL;  // bomba ON los primeros 5 s
const unsigned long DOSIFICADOR_ON_MS = 1000UL;  // dosificador ON el primer 1 s
const unsigned long CICLO_TOTAL_MS    = 60000UL; // el ciclo dura 60 s

// Si se cae la conexión MQTT, reintentamos cada tanto SIN bloquear: el
// control del acuapónico debe seguir 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 feedAireador(&mqtt, IO_USERNAME "/feeds/aireador");
Adafruit_MQTT_Publish feedBomba(&mqtt, IO_USERNAME "/feeds/bomba");
Adafruit_MQTT_Publish feedDosificador(&mqtt, IO_USERNAME "/feeds/dosificador");

// Marca de tiempo (ms) en la que empezó el ciclo actual: es el cronómetro.
unsigned long inicioCiclo = 0;
// Último intento de (re)conexión MQTT.
unsigned long millisUltimoIntentoMqtt = 0;

// Estado ACTUAL de cada actuador (lo que muestran los relés y el motor)...
int estadoAireador    = 0; // 0 = apagado, 1 = encendido
int estadoBomba       = 0;
int estadoDosificador = 0;

// ...y lo ÚLTIMO que llegó a publicarse en cada feed. Separarlos permite
// publicar solo los CAMBIOS y, si la conexión estaba caída, ponerse al día
// al reconectar (-1 = todavía no se publicó nada).
int aireadorPublicado    = -1;
int bombaPublicado       = -1;
int dosificadorPublicado = -1;

// Mantiene viva la conexión MQTT sin bloquear el control: 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 un feed SOLO si su estado cambió desde la última publicación
// exitosa. Si publish() falla, no se actualiza el registro: se reintenta
// en la próxima vuelta. Devuelve nada; actualiza *publicado por referencia.
void publicarSiCambio(Adafruit_MQTT_Publish &feed, int estado, int &publicado) {
  if (estado != publicado && feed.publish((int32_t)estado)) {
    publicado = estado;
  }
}

// Envía a Adafruit los cambios de estado (event-driven). Si no hay conexión
// no publica: el control local sigue y la central se pone al día al volver.
void publicarCambios() {
  if (!mqtt.connected()) {
    return;
  }
  publicarSiCambio(feedAireador, estadoAireador, aireadorPublicado);
  publicarSiCambio(feedBomba, estadoBomba, bombaPublicado);
  publicarSiCambio(feedDosificador, estadoDosificador, dosificadorPublicado);
}

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

  pinMode(PIN_RELE_AIREADOR, OUTPUT);
  pinMode(PIN_RELE_BOMBA, OUTPUT);
  pinMode(PIN_DOSIFICADOR, OUTPUT);

  // Estado inicial seguro: todo apagado hasta la primera vuelta del loop.
  digitalWrite(PIN_RELE_AIREADOR, APAGADO);
  digitalWrite(PIN_RELE_BOMBA, APAGADO);
  digitalWrite(PIN_DOSIFICADOR, APAGADO);

  // Conexión WiFi. Esperar acá con delay() es aceptable porque el control
  // 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());

  inicioCiclo = millis();
}

void loop() {
  // --- Control no bloqueante (idéntico a acuaponico-no-bloqueante.ino) ---
  unsigned long transcurrido = millis() - inicioCiclo;

  estadoAireador    = (transcurrido < AIREADOR_ON_MS) ? 1 : 0;
  estadoBomba       = (transcurrido < BOMBA_ON_MS) ? 1 : 0;
  estadoDosificador = (transcurrido < DOSIFICADOR_ON_MS) ? 1 : 0;

  digitalWrite(PIN_RELE_AIREADOR, estadoAireador ? ENCENDIDO : APAGADO);
  digitalWrite(PIN_RELE_BOMBA, estadoBomba ? ENCENDIDO : APAGADO);
  digitalWrite(PIN_DOSIFICADOR, estadoDosificador ? ENCENDIDO : APAGADO);

  if (transcurrido >= CICLO_TOTAL_MS) {
    inicioCiclo = millis();
  }

  // --- Parte IoT ---
  // Gracias a que el control no bloquea, estas dos tareas se atienden en
  // CADA vuelta del loop. publicarCambios() solo envía cuando un estado
  // cambió, así que el tráfico real es de unas pocas publicaciones por
  // minuto (event-driven).
  mantenerConexionMqtt();
  publicarCambios();
}