// ============================================
// ACTIVADOR DE VENTILADOR Y LÁMPARA POR PRESENCIA
// NHduino UNO
// ============================================

// --- PINES ---
// Sensor ultrasónico #1 (entrada/puerta)
const int TRIG_ENTRADA = 9;
const int ECHO_ENTRADA = 10;

// Sensor ultrasónico #2 (taza)
const int TRIG_TAZA = 6;
const int ECHO_TAZA = 7;

// Relé (LOW = activa el relé en módulos estándar)
const int RELE_LAMPARA    = 3;  // Canal 1
const int RELE_VENTILADOR = 4;  // Canal 2

// --- DISTANCIAS DE DETECCIÓN ---
// Ajusta estos valores según tu instalación física
const int DIST_ENTRADA_CM = 50; // Detecta persona cruzando la puerta
const int DIST_TAZA_CM    = 35;  // Detecta persona sentada en la taza

// --- TIEMPOS ---
// Todos en milisegundos (1000ms = 1 segundo)
const unsigned long TIMER_LAMPARA     = 5UL * 60 * 1000;  // 5 minutos
const unsigned long TIMER_VENTILADOR  = 5UL * 60 * 1000; // 10 minutos
const unsigned long DELAY_VENTILADOR  = 2UL * 60 * 1000;  // 2 min sentada antes de encender ventilador

// --- VARIABLES DE ESTADO ---
bool lamparaEncendida     = false;
bool ventiladorEncendido  = false;
bool tazaOcupada          = false;

// Guardamos el momento exacto en que algo ocurrió
// para calcular cuánto tiempo ha pasado
unsigned long tiempoLampara        = 0; // Cuándo se detectó la última persona en entrada
unsigned long tiempoVentilador     = 0; // Cuándo se desocupó la taza
unsigned long tiempoSentada        = 0; // Cuándo se ocupó la taza

// ============================================
// FUNCIÓN: medir distancia con HC-SR04
// Recibe los pines Trig y Echo
// Devuelve la distancia en centímetros
// ============================================
long medirDistancia(int pinTrig, int pinEcho) {
  // Aseguramos que Trig esté apagado
  digitalWrite(pinTrig, LOW);
  delayMicroseconds(2);

  // Mandamos un pulso de 10 microsegundos
  // Esto le dice al sensor que emita el ultrasonido
  digitalWrite(pinTrig, HIGH);
  delayMicroseconds(10);
  digitalWrite(pinTrig, LOW);

  // Medimos cuánto tarda en regresar el eco
  // pulseIn devuelve el tiempo en microsegundos
  long duracion = pulseIn(pinEcho, HIGH, 30000);
  // 30000 = timeout de 30ms, evita que el programa
  // se congele si no hay eco

  // Convertimos tiempo a centímetros
  // El sonido viaja a 343 m/s
  // dividimos entre 2 porque es ida y vuelta
  return duracion / 58;
}

// ============================================
// SETUP: se ejecuta una sola vez al encender
// ============================================
void setup() {
  // Configuramos los pines de los sensores
  pinMode(TRIG_ENTRADA, OUTPUT);
  pinMode(ECHO_ENTRADA, INPUT);
  pinMode(TRIG_TAZA, OUTPUT);
  pinMode(ECHO_TAZA, INPUT);

  // Configuramos los pines del relé como salida
  pinMode(RELE_LAMPARA, OUTPUT);
  pinMode(RELE_VENTILADOR, OUTPUT);

  // IMPORTANTE: Los módulos relé estándar se activan
  // con LOW y se desactivan con HIGH (lógica invertida)
  // Iniciamos ambos APAGADOS
  digitalWrite(RELE_LAMPARA, LOW);
  digitalWrite(RELE_VENTILADOR, LOW);

  // Iniciamos el monitor serial para depuración
  // Útil para ver qué está pasando desde la PC
  Serial.begin(9600);
  Serial.println("Sistema iniciado");
}

// ============================================
// LOOP: se repite constantemente
// ============================================
void loop() {

  // Guardamos el tiempo actual en esta iteración
  // millis() cuenta los ms desde que encendió el Arduino
  unsigned long ahora = millis();

  // --- LECTURA DE SENSORES ---
  long distEntrada = medirDistancia(TRIG_ENTRADA, ECHO_ENTRADA);
  long distTaza    = medirDistancia(TRIG_TAZA, ECHO_TAZA);

  // Pequeña pausa entre lecturas para no saturar los sensores
  // Dos HC-SR04 muy seguidos pueden interferirse entre sí
  delay(60);

  // Imprimimos las distancias para verificar en monitor serial
  Serial.print("Entrada: "); Serial.print(distEntrada); Serial.print("cm | ");
  Serial.print("Taza: ");    Serial.print(distTaza);    Serial.println("cm");


  // ============================================
  // LÓGICA: SENSOR DE ENTRADA → LÁMPARA
  // ============================================

  // ¿Hay alguien cruzando la puerta?
  if (distEntrada > 0 && distEntrada < DIST_ENTRADA_CM) {

    // Encendemos la lámpara si no estaba encendida
    if (!lamparaEncendida) {
      digitalWrite(RELE_LAMPARA, HIGH); // LOW = activa el relé
      lamparaEncendida = true;
      Serial.println("Lámpara ENCENDIDA");
    }

    // Reiniciamos el timer cada vez que detecta alguien
    // Así una nueva persona reinicia la cuenta
    tiempoLampara = ahora;
  }

  // ¿La lámpara está encendida y ya pasaron 5 minutos
  // sin detectar a nadie en la entrada?
  if (lamparaEncendida && (ahora - tiempoLampara >= TIMER_LAMPARA)) {
    digitalWrite(RELE_LAMPARA, LOW); // HIGH = desactiva el relé
    lamparaEncendida = false;
    Serial.println("Lámpara APAGADA por timer");
  }


  // ============================================
  // LÓGICA: SENSOR DE TAZA → VENTILADOR
  // ============================================

  bool hayAlguienEnTaza = (distTaza > 0 && distTaza < DIST_TAZA_CM);

  // ¿La taza acaba de ocuparse?
  if (hayAlguienEnTaza && !tazaOcupada) {
    tazaOcupada = true;
    tiempoSentada = ahora; // Guardamos cuándo se sentó
    Serial.println("Taza OCUPADA");
  }

  // ¿La taza acaba de desocuparse?
  if (!hayAlguienEnTaza && tazaOcupada) {
    tazaOcupada = false;
    tiempoVentilador = ahora; // Aquí empieza el timer del ventilador
    Serial.println("Taza DESOCUPADA - timer ventilador iniciado");
  }

  // ¿Lleva más de 2 minutos sentada y ventilador apagado?
  if (tazaOcupada && !ventiladorEncendido &&
     (ahora - tiempoSentada >= DELAY_VENTILADOR)) {
    digitalWrite(RELE_VENTILADOR, HIGH); // Encendemos ventilador
    ventiladorEncendido = true;
    Serial.println("Ventilador ENCENDIDO");
  }

  // ¿El ventilador está encendido, la taza está vacía
  // y ya pasaron 10 minutos desde que se desocupó?
  if (ventiladorEncendido && !tazaOcupada &&
     (ahora - tiempoVentilador >= TIMER_VENTILADOR)) {
    digitalWrite(RELE_VENTILADOR, LOW); // Apagamos ventilador
    ventiladorEncendido = false;
    Serial.println("Ventilador APAGADO por timer");
  }

  // Nota: si alguien vuelve a sentarse antes de que
  // termine el timer, tazaOcupada vuelve a true
  // y el timer del ventilador queda pausado hasta
  // que se desocupe de nuevo
}