//Vanino Domotic software for your Van
//Version 1.2.0 10/08/2024

#define VERSION "1.2.0"
#define RELEASE_DATE "11/08/2024"

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <DHT.h>
#include <SoftwareSerial.h>

//pins for devices
#define buzzer 22
//#define heater_2 29;

// Pins for buttons
const int button_home = 52;
const int button_up = 46;
const int button_down = 48;
const int button_select = 50;

// Pins for relays
const int roof_fan = 33;
const int wc_fan = 35;
const int water_pump = 37;
const int dirtywatersolenoid = 39;
const int fridge = 32;
const int hydronic = 34;
const int rest_pump = 36;
const int rest_solenoid = 38;
const int inverter = 40;

// Pins for temperature sensors
const int heat_exchanger_sensor = 53;
const int fridge_sensor = 51;
const int wc_humidity_sensor = 24;
const int engine_sensor = 47;
const int roof_habitacle = 49;
const int wc_presence_sensor = 27;
const int heater_2 = 28;


// Initialize temperature sensors
OneWire oneWire_heat_exchanger(heat_exchanger_sensor);
DallasTemperature temp_heat_exchanger(&oneWire_heat_exchanger);

OneWire oneWire_fridge(fridge_sensor);
DallasTemperature temp_fridge(&oneWire_fridge);

OneWire oneWire_engine(engine_sensor);
DallasTemperature temp_engine(&oneWire_engine);

// Initialize DHT sensor
#define DHTTYPE DHT11
DHT dht_wc(wc_humidity_sensor, DHTTYPE);
#define DHTTYPE DHT22
DHT dht_roof(roof_habitacle, DHTTYPE);

// Initialize LCD
LiquidCrystal_I2C lcd(0x27, 20, 4);  // 20 columns, 4 rows

byte degreeSymbol[8] = {
  0b00111,
  0b00101,
  0b00111,
  0b00000,
  0b00000,
  0b00000,
  0b00000,
  0b00000
};

// Initialize Bluetooth
SoftwareSerial Bluetooth(18, 19); // rx tx  

// Variables for menu navigation
const int numOptions = 8;
const char* options[] = {
  "Turn on hot water", 
  "Turn on cold water", 
  "Heat engine", 
  "Turn on inverter", 
  "Turn on fridge", 
  "Open dirty water", 
  "Turn on shower fan", 
  "Turn on wc fan"
};
const char* optionsActive[] = {
  "Turn off hot water", 
  "Turn off cold water", 
  "Stop heating engine", 
  "Turn off inverter", 
  "Turn off fridge", 
  "Close dirty water", 
  "Turn off shower fan", 
  "Turn off wc fan"
};

int currentOption = 0;
int firstOption = 0; // Index of the first option to show on screen

// Variables for states
bool hotWaterOn = false;
bool coldWaterOn = false;
bool heatEngineOn = false;
bool inverterOn = false;
bool fridgeOn = true;
bool dirtywatersolenoidOn = false;
bool roof_fanOn = false;
bool wc_fanOn = false;

// Variables for flags
bool heatExchangerHot = false; // flag to indicate Heat exchanger temperature is fine now
bool heatExchangerCold = false; // flag to indicate Heat exchanger temperature is low
bool mensaje_mostrado = false;

// Variables for debouncing buttons
unsigned long lastDebounceTime_home = 0;
unsigned long lastDebounceTime_up = 0;
unsigned long lastDebounceTime_down = 0;
unsigned long lastDebounceTime_select = 0;
const unsigned long debounceDelay = 50; // Debounce time in milliseconds
const unsigned long buttonDelay = 200; // Delay to slow down menu scrolling

// Tiempo en milisegundos que el ventilador continuará funcionando después de que se deje de detectar presencia
const unsigned long fanRunTime = 60000; // 1 minuto en milisegundos

// Timing intervals
const unsigned long presenceCheckInterval = 5000; // Check presence every 5 seconds
const unsigned long fridgeCheckInterval = 30000;  // Check fridge temperature every 30 seconds
const unsigned long presenceTimeout = 60000;     // 1 minute fan on time after presence detected
//const unsigned long debounceDelay = 200;         // Debounce delay for presence sensor
unsigned long previousMillis = 0;
unsigned long sensorInterval = 20000; // Interval for sensor readings (20 seconds)
unsigned long pinChangeMillis = 0;
unsigned long pinChangeInterval = 500; // Interval to debounce pin changes
const unsigned long buzzerinterval = 900000; // 15 minutos en milisegundos (900000 ms)
const unsigned long buzzerintervalImportant = 300000; // 5 minutos en milisegundos (900000 ms)

// Variables para detección de cambios
//int lastPresenceState = HIGH;
const unsigned long checkInterval = 10000; // Intervalo de 10 segundos
unsigned long previousPresenceCheck = 0;
unsigned long previousFridgeCheck = 0;
unsigned long presenceDetectedTime = 0;
unsigned long previousBuzzerTime = 0;
unsigned long lastDebounceTime = 0;
bool presenceDetected = false;
bool lastPresenceState = LOW;
bool presenceState = LOW;

// Variables para el estado del ventilador y el temporizador
//bool presenceDetected = false;
bool fanState = HIGH; // Estado inicial del ventilador (apagado)
unsigned long presenceEndTime = 0;
const unsigned long fanDelay = 60000; // 1 minuto en milisegundos

//Constantes para el dashboard
unsigned long lastButtonPress = 0;
unsigned long lastActivityTime = 0;
unsigned long lastPageChangeTime = 0;

const unsigned long inactivityTimeout = 10000; // 10 segundos de inactividad
const unsigned long pageDisplayTime = 5000;    // 5 segundos por página
const unsigned long backlightTime = 10000;      // 10 segundos de retroiluminación

bool backlightOn = false;
bool displayingSensorInfo = false;
int currentPage = 1;

// Track previous pin states for change detection
bool lastState_hydronic = HIGH;
bool lastState_water_pump = HIGH;
bool lastState_dirtywatersolenoid = HIGH;
bool lastState_roof_fan = HIGH;
bool lastState_wc_fan = HIGH;
bool lastState_fridge = LOW;
bool lastState_inverter = HIGH;
bool lastState_rest_pump = HIGH;
bool lastState_rest_solenoid = HIGH;

void setup() {
  // Set up pins for buttons
  pinMode(button_home, INPUT_PULLUP);
  pinMode(button_up, INPUT_PULLUP);
  pinMode(button_down, INPUT_PULLUP);
  pinMode(button_select, INPUT_PULLUP);

  // Set up pins for relays
  pinMode(hydronic, OUTPUT);
  pinMode(water_pump, OUTPUT);
  pinMode(rest_solenoid, OUTPUT);
  pinMode(rest_pump, OUTPUT);
  pinMode(roof_fan, OUTPUT);
  pinMode(wc_fan, OUTPUT);
  pinMode(inverter, OUTPUT);
  pinMode(fridge, OUTPUT);
  pinMode(dirtywatersolenoid, OUTPUT);

  // Set up pins for buzzer
  pinMode(buzzer, OUTPUT);

  // Inicializar el pin del sensor de presencia y el ventilador
  pinMode(wc_presence_sensor, INPUT);

  // Initialize pin states
  digitalWrite(hydronic, HIGH);
  digitalWrite(water_pump, HIGH);
  digitalWrite(rest_solenoid, HIGH);
  digitalWrite(rest_pump, HIGH);
  digitalWrite(roof_fan, HIGH);
  digitalWrite(wc_fan, HIGH);
  digitalWrite(inverter, HIGH);
  digitalWrite(fridge, LOW);
  digitalWrite(dirtywatersolenoid, HIGH);

  // Initialize LCD
  lcd.init();                         // Inicializa el LCD
  lcd.backlight();                    // Enciende la luz de fondo del LCD
  lcd.clear();
  lcd.createChar(0, degreeSymbol);  // Crea el símbolo de grado

  // Initialize temperature sensors
  temp_heat_exchanger.begin();
  temp_fridge.begin();
  temp_engine.begin();

  // Initialize humidity sensors
  dht_wc.begin();
  dht_roof.begin();

  // Initialize Bluetooth
  Bluetooth.begin(9600);

  // Show welcome message
  lcd.setCursor(0, 0);
  lcd.print("****** Vanino ******");
  lcd.setCursor(0, 1);
  lcd.print("The complete domotic");
  lcd.setCursor(0, 2);
  lcd.print("system for your Van");
  lcd.setCursor(0, 3);
  lcd.print("***** Version: " VERSION);

  // Initialize serial
  Serial.begin(115200);
  Serial.println(F("Vanino Domotic software for your Van"));
  Serial.println(F("Version " VERSION));
  Serial.println(F("Release date: " RELEASE_DATE));

  // Allow sensor to stabilize
  delay(1000);
  presenceState = digitalRead(wc_presence_sensor);
  lastPresenceState = presenceState;

  delay(2000); // Mostrar el mensaje de bienvenida durante 2 segundos

  // Show first option on screen
  lcd.clear();
  updateMenu();
}

void loop() {
  // if (Bluetooth.available()) {
  //   char receivedChar = Bluetooth.read();
  //   processCommand(receivedChar);
  // }

  handleInactivity();
  handleOtherButtons();

  unsigned long currentMillis = millis();

  // Check fridge temperature
  if (currentMillis - previousFridgeCheck >= fridgeCheckInterval) {
    previousFridgeCheck = currentMillis;
    temp_fridge.requestTemperatures();
    float fridgeTemperature = temp_fridge.getTempCByIndex(0);

    Serial.print("Fridge temperature: ");
    Serial.println(fridgeTemperature);
    Serial.println("°C");

    if (fridgeTemperature > 50 && digitalRead(fridge) == LOW) {
      digitalWrite(wc_fan, LOW);
      Serial.println("Fridge temperature above 50C, turning fan ON");
    } else if (!presenceDetected) {
      digitalWrite(wc_fan, HIGH);
      Serial.println("Fridge temperature below 50C, turning fan OFF");
    }
  }

  // Check presence sensor with debounce
  bool reading = digitalRead(wc_presence_sensor);
  if (reading != lastPresenceState) {
    lastDebounceTime = currentMillis;
  }

  if ((currentMillis - lastDebounceTime) > debounceDelay) {
    if (reading != presenceState) {
      presenceState = reading;
      if (presenceState == LOW) {
        presenceDetectedTime = currentMillis;
        presenceDetected = true;
        digitalWrite(wc_fan, LOW);
        Serial.println("Presence detected, turning fan ON");
      } else {
        Serial.println("No presence detected");
      }
    }
  }

  lastPresenceState = reading;

  if (presenceDetected && (currentMillis - presenceDetectedTime > presenceTimeout)) {
    presenceDetected = false;
    if (temp_fridge.getTempCByIndex(0) <= 50) {
      digitalWrite(wc_fan, HIGH);
      Serial.println("No presence detected for 1 minute and fridge temperature below 50C, turning fan OFF");
    }
  }


  // int presenceState = digitalRead(wc_presence_sensor);

  // // Detectar cambio en el estado del sensor
  // if (presenceState != lastPresenceState) {
  //   lastPresenceState = presenceState;
    
  //   if (presenceState == LOW) {
  //     // Presencia detectada
  //     presenceDetected = true;
  //     digitalWrite(wc_fan, LOW); // Encender el ventilador
  //     fanState = LOW; // Actualizar el estado del ventilador
  //     Serial.println("Presencia detectada. Ventilador encendido.");
  //   } else {
  //     // No hay presencia
  //     presenceDetected = false;
  //     presenceEndTime = currentMillis + fanDelay; // Actualizar el tiempo de apagado
  //     Serial.println("Presencia no detectada.");
  //   }
  // }

  // // Si no hay presencia detectada, verificar si el tiempo de apagado ha pasado
  // if (!presenceDetected && currentMillis >= presenceEndTime) {
  //   if (fanState == LOW) {
  //     digitalWrite(wc_fan, HIGH); // Apagar el ventilador
  //     fanState = HIGH; // Actualizar el estado del ventilador
  //     Serial.println("Extractor apagado tras de 1 minuto.");
  //   }
  // }

  // // Si la presencia se detectó previamente o el tiempo no ha expirado, mantener el ventilador encendido
  // if (presenceDetected || currentMillis < presenceEndTime) {
  //   if (fanState == HIGH) {
  //     digitalWrite(wc_fan, LOW); // Mantener el ventilador encendido
  //     fanState = LOW; // Actualizar el estado del ventilador
  //   }
  // } else {
  //   if (fanState == LOW) {
  //     digitalWrite(wc_fan, HIGH); // Asegurarse de que el ventilador esté apagado si no hay presencia
  //     fanState = HIGH; // Actualizar el estado del ventilador
  //   }
  // }


//  unsigned long currentMillis = millis();

  // Handle button debouncing
  checkButtonPress(button_home, lastDebounceTime_home);
  checkButtonPress(button_up, lastDebounceTime_up);
  checkButtonPress(button_down, lastDebounceTime_down);
  checkButtonPress(button_select, lastDebounceTime_select);

  // Check if it's time to update sensor readings and pin states
  if (currentMillis - previousMillis >= sensorInterval) {
    previousMillis = currentMillis;
    readSensors();
  }

  // Check for pin state changes
  if (currentMillis - pinChangeMillis >= pinChangeInterval) {
    pinChangeMillis = currentMillis;
    checkPinStateChange();
  }

  // Check if it's time to turn off LCD backlight
  if (currentMillis - lastDebounceTime_home > 20000 && currentMillis - lastDebounceTime_up > 20000 &&
      currentMillis - lastDebounceTime_down > 20000 && currentMillis - lastDebounceTime_select > 20000) {
    lcd.noBacklight();
  } else {
    lcd.backlight();
  }

  if (currentMillis - previousBuzzerTime >= buzzerinterval) {
    previousBuzzerTime = currentMillis;
    
    if (hotWaterOn) {
      beepTwice();
      displayMessage("Agua caliente esta encendida");
    }
    
    if (coldWaterOn) {
      beepTwice();
      displayMessage("Agua fria esta encendida");
    }
    
    if (heatEngineOn) {
      beepTwice();
      displayMessage("El calentamiento del motor esta activo");
    }
    
    if (inverterOn) {
      beepTwice();  
      displayMessage("Inversor encendido. Apagalo si no lo necesitas mas");
    }

  }



  if (currentMillis - previousBuzzerTime >= buzzerintervalImportant) {
    previousBuzzerTime = currentMillis;
       
    if (dirtywatersolenoidOn) {
      beepTwiceImportant();
      displayMessage("Aguas sucias vaciando. Por favor cierralo");
    }
  }


}

void checkButtonPress(int buttonPin, unsigned long& lastDebounceTime) {
  int buttonState = digitalRead(buttonPin);
  if (buttonState == LOW) {
    if ((millis() - lastDebounceTime) > debounceDelay) {
      handleButtonPress(buttonPin);
      lastDebounceTime = millis();
      delay(buttonDelay); // Introduce delay to slow down button processing
    }
  }
}


void handleButtonPress(int buttonPin) {
  if (buttonPin == button_up) {
    Serial.println("Botón Arriba presionado");
    // Navegar hacia arriba en el menú
    if (currentOption > 0) {
      currentOption--;
    } else {
      // Si está en la primera opción, saltar a la última
      currentOption = numOptions - 1;
    }

    // Ajustar firstOption para manejar el desplazamiento en la pantalla
    if (currentOption < firstOption) {
      firstOption = currentOption;
    } else if (currentOption >= firstOption + 4) {  // 4 es el número de líneas visibles en la LCD 2004
      firstOption = currentOption - 3;
    }

    updateMenu();
  } else if (buttonPin == button_down) {
    Serial.println("Botón Abajo presionado");
    // Navegar hacia abajo en el menú
    if (currentOption < numOptions - 1) {
      currentOption++;
    } else {
      // Si está en la última opción, saltar a la primera
      currentOption = 0;
    }

    // Ajustar firstOption para manejar el desplazamiento en la pantalla
    if (currentOption >= firstOption + 4) {  // 4 es el número de líneas visibles en la LCD 2004
      firstOption = currentOption - 3;
    } else if (currentOption < firstOption) {
      firstOption = currentOption;
    }

    updateMenu();
  } else if (buttonPin == button_select) {
    Serial.println("Botón Seleccionar presionado");
    // Seleccionar la opción actual
    selectOption(currentOption);
  }
}

void updateMenu() {
  lcd.clear();
  for (int i = 0; i < 4; i++) {  // 4 es el número de líneas en la LCD 2004
    int optionIndex = firstOption + i;
    if (optionIndex < numOptions) {
      lcd.setCursor(0, i);
      if (optionIndex == currentOption) {
        lcd.print("> ");
      } else {
        lcd.print("  ");
      }
      if (optionIndex == 0 && hotWaterOn ||
          optionIndex == 1 && coldWaterOn ||
          optionIndex == 2 && heatEngineOn ||
          optionIndex == 3 && inverterOn ||
          optionIndex == 4 && fridgeOn ||
          optionIndex == 5 && dirtywatersolenoidOn ||
          optionIndex == 6 && roof_fanOn ||
          optionIndex == 7 && wc_fanOn) {
        lcd.print(optionsActive[optionIndex]);
      } else {
        lcd.print(options[optionIndex]);
      }
    }
  }
}




void selectOption(int option) {
  switch (option) {
    case 0:
      if (hotWaterOn) {
        turnOffHotWater();
      } else {
        turnOnHotWater();
      }
      // hotWaterOn = !hotWaterOn;
      // digitalWrite(hydronic, hotWaterOn ? LOW : HIGH);
      // Serial.print("Pin hydronic: ");
      //Serial.println(hotWaterOn ? "LOW" : "HIGH");
      Serial.println(hotWaterOn ? "Activando agua caliente" : "Desactivando agua caliente");
      break;
    case 1:
      if (coldWaterOn) {
        turnOffcoldWater();
      } else {
        turnOncoldWater();
      }
      // coldWaterOn = !coldWaterOn;
      // digitalWrite(water_pump, coldWaterOn ? LOW : HIGH);
      // Serial.print("Pin water_pump: ");
      //Serial.println(coldWaterOn ? "LOW" : "HIGH");
      Serial.println(coldWaterOn ? "Activando agua fría" : "Desactivando agua fría");
      break;
    case 2:
      if (heatEngineOn) {
//        Serial.println("Desactivando motor");
        turnOffHeatEngine();
      } else {
//        Serial.println("Activando motor");
        turnOnHeatEngine();
      }
    //  heatEngineOn = !heatEngineOn;
      Serial.println(heatEngineOn ? "Activando motor" : "Desactivando motor");
      break;
    case 3:
      inverterOn = !inverterOn;
      digitalWrite(inverter, inverterOn ? LOW : HIGH);
  //    Serial.print("Pin inverter: ");
  //    Serial.println(inverterOn ? "LOW" : "HIGH");
      Serial.println(inverterOn ? "Activando inversor" : "Desactivando inversor");
      break;
    case 4:
      fridgeOn = !fridgeOn;
      digitalWrite(fridge, fridgeOn ? LOW : HIGH);
  //    Serial.print("Pin fridge: ");
  //    Serial.println(fridgeOn ? "LOW" : "HIGH");
      Serial.println(fridgeOn ? "Activando nevera" : "Desactivando nevera");
      break;
    case 5:
      dirtywatersolenoidOn = !dirtywatersolenoidOn;
      digitalWrite(dirtywatersolenoid, dirtywatersolenoidOn ? LOW : HIGH);
  //    Serial.print("Pin dirtywatersolenoid: ");
  //    Serial.println(dirtywatersolenoidOn ? "LOW" : "HIGH");
      Serial.println(dirtywatersolenoidOn ? "Activando solenoide de aguas residuales" : "Desactivando solenoide de aguas residuales");
      break;
    case 6:
      roof_fanOn = !roof_fanOn;
      digitalWrite(roof_fan, roof_fanOn ? LOW : HIGH);
  //    Serial.print("Pin roof_fan: ");
  //    Serial.println(roof_fanOn ? "LOW" : "HIGH");
      Serial.println(roof_fanOn ? "Activando ventilador del techo" : "Desactivando ventilador del techo");
      break;
    case 7:
      wc_fanOn = !wc_fanOn;
      digitalWrite(wc_fan, wc_fanOn ? LOW : HIGH);
  //    Serial.print("Pin wc_fan: ");
  //    Serial.println(wc_fanOn ? "LOW" : "HIGH");
      Serial.println(wc_fanOn ? "Activando ventilador del WC" : "Desactivando ventilador del WC");
      break;
    default:
      break;
  }
  updateMenu(); // Update the menu to reflect changes
}

void turnOnHotWater() {
  // Desactivar agua fría si está activada
  if (coldWaterOn) {
    turnOffcoldWater();
  }
  
  hotWaterOn = true;

  // Leer las temperaturas del motor y del intercambiador de calor
  float engineTemp = getTemperature(engine_sensor);
  float heatExchangerTemp = getTemperature(heat_exchanger_sensor);

  // Caso 4: Temperaturas suficientemente altas
  if (engineTemp >= 70 && heatExchangerTemp >= 65) {
    // Mostrar mensaje en el LCD
    lcd.clear();
    lcd.print("El agua esta lista");
    delay(2000); // Esperar 2 segundos

    // Encender relés según los requisitos
    digitalWrite(hydronic, HIGH);
    digitalWrite(rest_pump, LOW);
    digitalWrite(rest_solenoid, HIGH);
    digitalWrite(water_pump, LOW);
    
    // Imprimir estado en el Serial Monitor
    Serial.println("El agua está lista");
  }
  // Caso 1: Temperatura del intercambiador baja
  else if (engineTemp >= 70 && heatExchangerTemp < 65) {
    // Mostrar mensaje en el LCD
    lcd.clear();
    lcd.print("Calentando el agua");
    delay(2000); // Esperar 2 segundos

    // Encender relés según los requisitos
    digitalWrite(hydronic, HIGH);
    digitalWrite(rest_pump, LOW);
  //  digitalWrite(rest_solenoid, HIGH);
    digitalWrite(water_pump, LOW);
    
    // Imprimir estado en el Serial Monitor
    Serial.println("Calentando el agua");
  }
  // Caso 2: Temperatura del motor baja
  else if (engineTemp < 70 && heatExchangerTemp >= 65) {
    // Mostrar mensaje en el LCD
    lcd.clear();
    lcd.print("Calentando el agua");
    delay(2000); // Esperar 2 segundos

    // Apagar relés
    digitalWrite(hydronic, LOW);
    digitalWrite(rest_pump, LOW);
  //  digitalWrite(rest_solenoid, LOW);
    digitalWrite(water_pump, LOW);

    // Mostrar mensaje en el LCD
    lcd.clear();
    lcd.print("Agua caliente");
    delay(3000); // Esperar 3 segundos
    
    // Imprimir estado en el Serial Monitor
    Serial.println("Agua caliente");
  }
  // Caso 3: Temperaturas bajas
  else if (engineTemp < 70 && heatExchangerTemp < 65) {
    // Mostrar mensaje en el LCD
    lcd.clear();
    lcd.print("Calentando el agua");
    delay(2000); // Esperar 2 segundos

    // Apagar relés
    digitalWrite(hydronic, LOW);
    digitalWrite(rest_pump, LOW);
  //  digitalWrite(rest_solenoid, LOW);
    digitalWrite(water_pump, LOW);
    
    // Imprimir estado en el Serial Monitor
    Serial.println("Calentando el agua");
  }
  
  // Actualizar la opción en el menú
  options[0] = "Turn off hot water";
  updateMenu(); // Actualizar el menú para reflejar los cambios
}

void turnOffHotWater() {
  hotWaterOn = false;
  // Mostrar mensaje en el LCD
  lcd.clear();
  lcd.print("Apagando el agua caliente");
  delay(2000); // Esperar 2 segundos

  // Apagar relés
  digitalWrite(hydronic, HIGH);
  digitalWrite(water_pump, HIGH);
//  digitalWrite(rest_solenoid, HIGH);
  digitalWrite(rest_pump, HIGH);

  // Mostrar mensaje en el LCD
  lcd.clear();
  lcd.print("El agua esta");
  lcd.setCursor(0, 1);
  lcd.print("apagada");
  
  // Actualizar la opción en el menú
  options[0] = "Turn on hot water";
  updateMenu(); // Update the menu to reflect changes

}

void turnOncoldWater() {
  // Desactivar agua caliente si está activada
  if (hotWaterOn) {
    turnOffHotWater(); // Asegúrate de que esta función esté bien definida en tu código
  }
  coldWaterOn = true;

  // Mostrar mensaje en el LCD
  lcd.clear();
  lcd.print("Encendiendo");
  lcd.setCursor(0, 1);
  lcd.print("el agua fria");

  // Guardar el tiempo en que se mostró el mensaje
  unsigned long startMillis = millis();
  while (millis() - startMillis < 1000) {
    // Esperar 1 segundos
    // Nota: Puedes añadir aquí otras tareas que deban realizarse durante la espera
  }

  digitalWrite(water_pump, LOW); // Encender la bomba de agua

  // Mostrar mensaje de agua corriente encendida
  lcd.clear();
  lcd.print("Agua corriente");
  lcd.setCursor(0, 1);
  lcd.print("encendida");

  // Guardar el tiempo en que se mostró el mensaje
  startMillis = millis();
  while (millis() - startMillis < 2000) {
    // Esperar 3 segundos
    // Nota: Puedes añadir aquí otras tareas que deban realizarse durante la espera
  }

  // Actualizar la opción en el menú
  options[1] = "Turn off cold water";
  updateMenu(); // Actualizar el menú para reflejar los cambios
}

void turnOffcoldWater() {
  coldWaterOn = false;
  digitalWrite(water_pump, HIGH); // Apagar la bomba de agua

  // Mostrar mensaje en el LCD
  lcd.clear();
  lcd.print("Apagando el agua");

  // Guardar el tiempo en que se mostró el mensaje
  unsigned long startMillis = millis();
  while (millis() - startMillis < 1000) {
    // Esperar 2 segundos
    // Nota: Puedes añadir aquí otras tareas que deban realizarse durante la espera
  }

  // Mostrar mensaje de agua corriente apagada
  lcd.clear();
  lcd.print("Agua fria");
  lcd.setCursor(0, 1);
  lcd.print("apagada");

  // Guardar el tiempo en que se mostró el mensaje
  startMillis = millis();
  while (millis() - startMillis < 2000) {
    // Esperar 3 segundos
    // Nota: Puedes añadir aquí otras tareas que deban realizarse durante la espera
  }

  // Actualizar la opción en el menú
  options[1] = "Turn on cold water";
  updateMenu(); // Actualizar el menú para reflejar los cambios
}

void turnOnHeatEngine() {
  heatEngineOn = true;

  // Check engine temperature
  float engineTemp = temp_engine.getTempCByIndex(0);

  if (engineTemp <= 8) {
    // Turn on relays
    digitalWrite(hydronic, LOW);
    digitalWrite(rest_pump, LOW);
  //  digitalWrite(rest_solenoid, HIGH);

    // Show message on LCD
    lcd.clear();
    lcd.print("Calentando el motor");
    delay(3000); // Wait 3 seconds

    // Update menu
    options[2] = "Stop heating engine";
    updateMenu();
  } else {
    // Show message on LCD
    lcd.clear();
    lcd.print("El motor esta");
    lcd.setCursor(0, 1);
    lcd.print("caliente");
    delay(3000); // Wait 3 seconds

    // Turn off heating engine system
    digitalWrite(hydronic, HIGH);
    digitalWrite(rest_pump, HIGH);
  //  digitalWrite(rest_solenoid, HIGH);

    // Update menu
    heatEngineOn = false;
    options[2] = "Heat engine";
    updateMenu();
  }
}

void turnOffHeatEngine() {
  heatEngineOn = false;

  // Show message on LCD
  lcd.clear();
  lcd.print("Parando");
  lcd.setCursor(0, 1);
  lcd.print("calentamiento");
  lcd.setCursor(0, 2);
  lcd.print("del motor");
  delay(3000); // Wait 3 seconds

  // Turn off relays
  digitalWrite(hydronic, HIGH);
  digitalWrite(rest_pump, HIGH);
//  digitalWrite(rest_solenoid, HIGH);

  // Show message on LCD
  lcd.clear();
  lcd.print("Se ha dejado de");
  lcd.setCursor(0, 1);
  lcd.print("calentar el motor");
  delay(5000); // Wait 5 seconds

  // Update menu
  options[2] = "Heat engine";
  updateMenu();
}


void readSensors() {
  // // Read temperatures and humidity
  // temp_heat_exchanger.requestTemperatures();   //Se envía el comando para leer la temperatura
  // temp_engine.requestTemperatures();   //Se envía el comando para leer la temperatura
  // temp_fridge.requestTemperatures();   //Se envía el comando para leer la temperatura
  // float heatExchangerTemp = temp_heat_exchanger.getTempCByIndex(0);
  // float engineTemp = temp_engine.getTempCByIndex(0);
  // float fridgeTemp = temp_fridge.getTempCByIndex(0);
  float wcHumidity = dht_wc.readHumidity();
  // float wcTemp = dht_wc.readTemperature();
  // float roofHumidity = dht_roof.readHumidity();
  // float roofTemp = dht_roof.readTemperature();

  // // Print to Serial Monitor
  // Serial.println("*******************");
  // Serial.print("Heat Exchanger Temp: ");
  // // Verificar si la temperatura es válida
  // if (heatExchangerTemp == DEVICE_DISCONNECTED_C) {
  //   Serial.println("No sensor detected");
  // } else {
  //   Serial.println(temp_heat_exchanger.getTempCByIndex(0));
  //   Serial.println("°C");
  // }

  // Serial.print("Fridge Temp: ");
  // // Verificar si la temperatura es válida
  // if (fridgeTemp == DEVICE_DISCONNECTED_C) {
  //   Serial.println("No sensor detected");
  // } else {
  //   Serial.println(temp_fridge.getTempCByIndex(0));
  //   Serial.println("°C");
  // }

  // Serial.print("Engine Temp: ");
  // // Verificar si la temperatura es válida
  // if (engineTemp == DEVICE_DISCONNECTED_C) {
  //   Serial.println("No sensor detected");
  // } else {
  //   Serial.println(temp_engine.getTempCByIndex(0));
  //   Serial.println("°C");
  // }

  // Serial.print("WC Temp: ");
  // if (isnan(wcTemp)) {
  //   Serial.println("No sensor detected.");
  // } else {
  //   Serial.println(wcTemp);
  //   Serial.println("°C");
  // }

  // Serial.print("WC Humidity: ");
  // if (isnan(wcHumidity)) {
  //   Serial.println("No sensor detected");
  // } else {
  //   Serial.println(wcHumidity);
  //   Serial.println("%");
  // }

  // Serial.print("Roof Temp: ");
  // if (isnan(roofTemp)) {
  //   Serial.println("No sensor detected.");
  // } else {
  //   Serial.println(roofTemp);
  //   Serial.println("ºC");
  // }

  // Serial.print("Roof Humidity: ");
  // if (isnan(roofTemp)) {
  //   Serial.println("No sensor detected.");
  // } else {
  //   Serial.println(roofHumidity);
  //   Serial.println("%");
  // }

  // Check humidity and activate roof fan if necessary
  //float wcHumidity = dht.readHumidity();
  if (wcHumidity > 90 && digitalRead(water_pump) == LOW) {
    digitalWrite(roof_fan, LOW);
    Serial.println("Humidity above 90% AND water pump ON, turning roof fan ON");
  } else if (wcHumidity <= 80 || digitalRead(water_pump) == HIGH) {
    digitalWrite(roof_fan, HIGH);
    Serial.println("Humidity 80% or below OR water pump OFF, turning roof fan OFF");
  }

  //check fridge temperature and activates wc fan if necesary
  //float humidity = dht.readHumidity();
  // activate roof fan if wc humidity is > 85%
//  if (fridgeTemp > 50) {
//    digitalWrite(wc_fan, LOW);
//  }
  // deactivate roof fan if humidity is < 75%
//  if (fridgeTemp <= 40) {
//    digitalWrite(wc_fan, HIGH);
//  }
//   Serial.println("*******************");
 }

float getTemperature(int pin) {
  // Placeholder function - replace with actual temperature reading code
  // Implement actual temperature reading here
  return 0.0; // Replace with actual temperature value or NaN if no sensor is detected
}

void checkPinStateChange() {
  // Check hydronic pin state change
  bool currentState_hydronic = digitalRead(hydronic);
  if (currentState_hydronic != lastState_hydronic) {
    Serial.print("Pin hydronic: ");
    Serial.println(currentState_hydronic ? "LOW" : "HIGH");
    lastState_hydronic = currentState_hydronic;
  }

  // Check water_pump pin state change
  bool currentState_water_pump = digitalRead(water_pump);
  if (currentState_water_pump != lastState_water_pump) {
    Serial.print("Pin water_pump: ");
    Serial.println(currentState_water_pump ? "LOW" : "HIGH");
    lastState_water_pump = currentState_water_pump;
  }

  // Check dirtywatersolenoid pin state change
  bool currentState_dirtywatersolenoid = digitalRead(dirtywatersolenoid);
  if (currentState_dirtywatersolenoid != lastState_dirtywatersolenoid) {
    Serial.print("Pin dirtywatersolenoid: ");
    Serial.println(currentState_dirtywatersolenoid ? "LOW" : "HIGH");
    lastState_dirtywatersolenoid = currentState_dirtywatersolenoid;
  }

  // Check roof_fan pin state change
  bool currentState_roof_fan = digitalRead(roof_fan);
  if (currentState_roof_fan != lastState_roof_fan) {
    Serial.print("Pin roof_fan: ");
    Serial.println(currentState_roof_fan ? "LOW" : "HIGH");
    lastState_roof_fan = currentState_roof_fan;
  }

  // Check wc_fan pin state change
  bool currentState_wc_fan = digitalRead(wc_fan);
  if (currentState_wc_fan != lastState_wc_fan) {
    Serial.print("Pin wc_fan: ");
    Serial.println(currentState_wc_fan ? "LOW" : "HIGH");
    lastState_wc_fan = currentState_wc_fan;
  }

  // Check fridge pin state change
  bool currentState_fridge = digitalRead(fridge);
  if (currentState_fridge != lastState_fridge) {
    Serial.print("Pin fridge: ");
    Serial.println(currentState_fridge ? "LOW" : "HIGH");
    lastState_fridge = currentState_fridge;
  }

  // Check inverter pin state change
  bool currentState_inverter = digitalRead(inverter);
  if (currentState_inverter != lastState_inverter) {
    Serial.print("Pin inverter: ");
    Serial.println(currentState_inverter ? "LOW" : "HIGH");
    lastState_inverter = currentState_inverter;
  }

  // Check rest_pump pin state change
  bool currentState_rest_pump = digitalRead(rest_pump);
  if (currentState_rest_pump != lastState_rest_pump) {
    Serial.print("Pin rest_pump: ");
    Serial.println(currentState_rest_pump ? "LOW" : "HIGH");
    lastState_rest_pump = currentState_rest_pump;
  }

  // Check rest_solenoid pin state change
  bool currentState_rest_solenoid = digitalRead(rest_solenoid);
  if (currentState_rest_solenoid != lastState_rest_solenoid) {
    Serial.print("Pin rest_solenoid: ");
    Serial.println(currentState_rest_solenoid ? "LOW" : "HIGH");
    lastState_rest_solenoid = currentState_rest_solenoid;
  }
}

void beepTwice() {
  tone(buzzer, 2000); // Emitir tono
  delay(100); // Esperar 100ms
  noTone(buzzer); // Apagar tono
  delay(100); // Esperar 100ms
  tone(buzzer, 2000); // Emitir tono
  delay(100); // Esperar 100ms
  noTone(buzzer); // Apagar tono
}

void beepTwiceImportant() {
  tone(buzzer, 2000); // Emitir tono
  delay(100); // Esperar 100ms
  noTone(buzzer); // Apagar tono
  delay(100); // Esperar 100ms
  tone(buzzer, 2000); // Emitir tono
  delay(100); // Esperar 100ms
  noTone(buzzer); // Apagar tono
  delay(100); // Esperar 100ms
  tone(buzzer, 2000); // Emitir tono
  delay(100); // Esperar 100ms
  noTone(buzzer); // Apagar tono
  delay(100); // Esperar 100ms
  tone(buzzer, 2000); // Emitir tono
  delay(100); // Esperar 100ms
  noTone(buzzer); // Apagar tono
}

void displayMessage(String message) {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(message);
  Serial.println(message);
  delay(5000); // Mostrar mensaje durante 5 segundos
  lcd.clear();
  updateMenu();
}

void displaySensorInfo(int page) {

  // Read temperatures and humidity
  temp_heat_exchanger.requestTemperatures();   //Se envía el comando para leer la temperatura
  temp_engine.requestTemperatures();   //Se envía el comando para leer la temperatura
  temp_fridge.requestTemperatures();   //Se envía el comando para leer la temperatura
  float heatExchangerTemp = temp_heat_exchanger.getTempCByIndex(0);
  float engineTemp = temp_engine.getTempCByIndex(0);
  float fridgeTemp = temp_fridge.getTempCByIndex(0);
  float wcHumidity = dht_wc.readHumidity();
  float wcTemp = dht_wc.readTemperature();
  float roofHumidity = dht_roof.readHumidity();
  float roofTemp = dht_roof.readTemperature();

  lcd.clear();  // Borra la pantalla
    switch (page) {
    case 0:
    // Página 1
    lcd.setCursor(0, 0);
    lcd.print("Temperat.");
    lcd.setCursor(10, 0);
    lcd.print("Humidity");
      
    lcd.setCursor(1, 1);
    lcd.print(roofTemp);
    lcd.write(byte(0));  // Imprime el símbolo de grado
    lcd.print("C");
    lcd.setCursor(11, 1);
    lcd.print(roofHumidity);
    lcd.print("%");
    
    lcd.setCursor(0, 2);
    lcd.print("WC temp.");
    lcd.setCursor(10, 2);
    lcd.print("WC humidi.");

    lcd.setCursor(1, 3);
    lcd.print(wcTemp);
    lcd.write(byte(0));  // Imprime el símbolo de grado
    lcd.print("C");
    lcd.setCursor(11, 3);
    lcd.print(wcHumidity);
    lcd.print("%");

    break;

    case 1:
    // Página 2
    lcd.setCursor(0, 0);
    lcd.print("Engine");
    lcd.setCursor(10, 0);
    lcd.print("Exchanger");
      
    lcd.setCursor(1, 1);
    lcd.print(engineTemp);
    lcd.write(byte(0));  // Imprime el símbolo de grado
    lcd.print("C");
    lcd.setCursor(11, 1);
    lcd.print(heatExchangerTemp);
    lcd.write(byte(0));  // Imprime el símbolo de grado
    lcd.print("C");
    
    lcd.setCursor(0, 2);
    lcd.print("Fridge");

    lcd.setCursor(1, 3);
    lcd.print(fridgeTemp);
    lcd.write(byte(0));  // Imprime el símbolo de grado
    lcd.print("C");
    break;

    case 2:
    // Página 3
    lcd.setCursor(0, 0);
    lcd.print("Hot Water");
    lcd.setCursor(12, 0);
    lcd.print("Cold Water");
    lcd.setCursor(3, 1);
    lcd.print(hotWaterOn ? "On" : "Off");
    lcd.setCursor(13, 1);
    lcd.print(coldWaterOn ? "On" : "Off");
    lcd.setCursor(0, 2);
    lcd.print("Inverter");
    lcd.setCursor(12, 2);
    lcd.print("Fridge");
    lcd.setCursor(3, 3);
    lcd.print(inverterOn ? "On" : "Off");
    lcd.setCursor(13, 3);
    lcd.print(fridgeOn ? "On" : "Off");
    break;

    case 3:
    // Página 4
    lcd.setCursor(0, 0);
    lcd.print("Dirty water");
    lcd.setCursor(0, 1);
    lcd.print(dirtywatersolenoidOn ? "Tap open" : "Tap Closed");
    //  lcd.setCursor(0, 2);
    //  lcd.print("WC fan");
    //  lcd.setCursor(11, 2);
    //  lcd.print("Shower fan");
    //  lcd.setCursor(0, 3);
    //  lcd.print(wcFanOn ? "On" : "Off"); 
    //  lcd.setCursor(13, 3);
    //  lcd.print(showerFanOn ? "On" : "Off");
    break;
    }
}

void handleInactivity() {
  unsigned long currentMillis = millis();

  // Si se presiona el botón home
  if (digitalRead(button_home) == LOW) {
    Serial.println("Botón Home presionado");
    lastButtonPress = currentMillis;
    lastActivityTime = currentMillis;
    backlightOn = true;
    displayingSensorInfo = true;
    currentPage = (currentPage + 1) % 4;
    displaySensorInfo(currentPage);
  //  delay(200); // Debounce del botón
  }

  // Manejo de la retroiluminación
  if (currentMillis - lastButtonPress >= backlightTime) {
    backlightOn = false;
    // Aquí apaga la retroiluminación
  }

  // Manejo de la inactividad
  if (currentMillis - lastActivityTime >= inactivityTimeout) {
    if (!displayingSensorInfo) {
      displayingSensorInfo = true;
      displaySensorInfo(currentPage);
      lastPageChangeTime = currentMillis;
    } else {
      if (currentMillis - lastPageChangeTime >= pageDisplayTime) {
        currentPage = (currentPage + 1) % 4;
        displaySensorInfo(currentPage);
        lastPageChangeTime = currentMillis;
      }
    }
  }
}

void handleOtherButtons() {
  if (digitalRead(button_up) == LOW || digitalRead(button_down) == LOW || digitalRead(button_select) == LOW) {
    lastActivityTime = millis();
    displayingSensorInfo = false;
    // Aquí puedes poner la lógica para navegar por el menú...
  //  delay(200); // Debounce del botón
  }
}




// void processCommand(char command) {
//   switch (command) {
//     case 'A':
//       currentOption = 0;
//       selectOption();
//       break;
//     case 'B':
//       currentOption = 1;
//       selectOption();
//       break;
//     case 'C':
//       currentOption = 2;
//       selectOption();
//       break;
//     case 'D':
//       currentOption = 3;
//       selectOption();
//       break;
//     case 'E':
//       currentOption = 4;
//       selectOption();
//       break;
//     case 'F':
//       currentOption = 5;
//       selectOption();
//       break;
//     case 'G':
//       currentOption = 6;
//       selectOption();
//       break;
//     case 'H':
//       currentOption = 7;
//       selectOption();
//       break;
//   }
//   updateMenu();
// }