#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Define pins
#define BATTERY_PIN 34         // Analog pin for battery voltage monitoring (GPIO34 on ESP32)
#define RELAY1_PIN 27          // Digital pin to control relay 1
#define RELAY2_PIN 26          // Digital pin to control relay 2
#define RELAY3_PIN 25          // Digital pin to control relay 3
#define RELAY4_PIN 33          // Digital pin to control relay 4
#define RELAY5_PIN 32          // Digital pin to control relay 5
#define RELAY6_PIN 12          // Digital pin to control relay 6
#define RELAY7_PIN 13          // Digital pin to control relay 7
#define RELAY8_PIN 14          // Digital pin to control relay 8

// Define voltage thresholds (adjust these according to your setup)
#define MAX_BATTERY_VOLTAGE 10.0   // Maximum battery voltage before diverting (V)
#define RELAY2_VOLTAGE_THRESHOLD 11.0   // Voltage threshold for RELAY2
#define RELAY3_VOLTAGE_THRESHOLD 12.0   // Voltage threshold for RELAY3
#define RELAY4_VOLTAGE_THRESHOLD 13.0   // Voltage threshold for RELAY4
#define RELAY5_VOLTAGE_THRESHOLD 14.0   // Voltage threshold for RELAY5
#define RELAY6_VOLTAGE_THRESHOLD 15.0   // Voltage threshold for RELAY6
#define RELAY7_VOLTAGE_THRESHOLD 16.0   // Voltage threshold for RELAY7
#define RELAY8_VOLTAGE_THRESHOLD 17.0   // Voltage threshold for RELAY8
#define MIN_BATTERY_VOLTAGE 6.0        // Minimum battery voltage to stop diverting
#define MIN_RELAY2_VOLTAGE_THRESHOLD 7.0   // Voltage threshold for RELAY2
#define MIN_RELAY3_VOLTAGE_THRESHOLD 8.0   // Voltage threshold for RELAY3
#define MIN_RELAY4_VOLTAGE_THRESHOLD 9.0   // Voltage threshold for RELAY4
#define MIN_RELAY5_VOLTAGE_THRESHOLD 10.0   // Voltage threshold for RELAY5
#define MIN_RELAY6_VOLTAGE_THRESHOLD 11.0   // Voltage threshold for RELAY6
#define MIN_RELAY7_VOLTAGE_THRESHOLD 12.0   // Voltage threshold for RELAY7
#define MIN_RELAY8_VOLTAGE_THRESHOLD 13.0   // Voltage threshold for RELAY8

// Voltage divider resistors values (in ohms)
#define R1 10000.0  // 10kΩ resistor
#define R2 2000.0   // 2kΩ resistor

// Initialize the LCDs with I2C address 0x27 (assuming both displays have the same address)
LiquidCrystal_I2C lcd1(0x27, 16, 2);  // Display 1 for battery voltage
LiquidCrystal_I2C lcd2(0x26, 16, 2);  // Display 2 for relay countdowns (change address if needed)

// Variables to track the timing for each relay
unsigned long relay1Timer = 0;
unsigned long relay2Timer = 0;
unsigned long relay3Timer = 0;
unsigned long relay4Timer = 0;
unsigned long relay5Timer = 0;
unsigned long relay6Timer = 0;
unsigned long relay7Timer = 0;
unsigned long relay8Timer = 0;

// Status flags to determine if relays have been triggered
bool relay1Triggered = false;
bool relay2Triggered = false;
bool relay3Triggered = false;
bool relay4Triggered = false;
bool relay5Triggered = false;
bool relay6Triggered = false;
bool relay7Triggered = false;
bool relay8Triggered = false;

// Function to read the battery voltage
float readBatteryVoltage() {
    int sensorValue = analogRead(BATTERY_PIN);  // Read the analog pin value (0-4095 for ESP32)
    float voltage = sensorValue * (3.3 / 4095.0);  // Convert to voltage (0-3.3V)
    voltage = voltage * ((R1 + R2) / R2);  // Convert to the actual battery voltage
    return voltage;
}

void setup() {
    // Initialize serial communication for debugging
    Serial.begin(115200);

    // Initialize the relay pins as outputs
    pinMode(RELAY1_PIN, OUTPUT); 
    pinMode(RELAY2_PIN, OUTPUT);
    pinMode(RELAY3_PIN, OUTPUT);
    pinMode(RELAY4_PIN, OUTPUT);
    pinMode(RELAY5_PIN, OUTPUT);
    pinMode(RELAY6_PIN, OUTPUT);
    pinMode(RELAY7_PIN, OUTPUT);
    pinMode(RELAY8_PIN, OUTPUT);

    // Ensure all relays are off initially
    digitalWrite(RELAY1_PIN, LOW);
    digitalWrite(RELAY2_PIN, LOW);
    digitalWrite(RELAY3_PIN, LOW);
    digitalWrite(RELAY4_PIN, LOW);
    digitalWrite(RELAY5_PIN, LOW);
    digitalWrite(RELAY6_PIN, LOW);
    digitalWrite(RELAY7_PIN, LOW);
    digitalWrite(RELAY8_PIN, LOW);

    // Initialize the LCDs
    lcd1.init();       // Initialize the first LCD
    lcd1.backlight();  // Turn on the backlight
    lcd1.clear();      // Clear the display
    lcd1.setCursor(0, 0);
    lcd1.print("Battery Voltage:");

    // Initialize the LCDs
    lcd2.init();       // Initialize the second LCD
    lcd2.backlight();  // Turn on the backlight
    lcd2.clear();      // Clear the display
    lcd2.setCursor(0, 0);
    lcd2.print("Relay Countdown:");
}

void loop() {
    float batteryVoltage = readBatteryVoltage();  // Read the current battery voltage
    unsigned long currentMillis = millis();  // Get the current time in milliseconds

    Serial.print("Battery Voltage: ");
    Serial.println(batteryVoltage);  // Print the battery voltage to the serial monitor

    // Update the first LCD display with the battery voltage
    lcd1.setCursor(0, 1);
    lcd1.print(batteryVoltage, 2);  // Print the voltage with 2 decimal places
    lcd1.print(" V  ");

    // Display the countdown for each relay on the second LCD
    int remainingTime1 = relay1Triggered ? max(0, (int)(10 - (currentMillis - relay1Timer) / 1000)) : 10;
    int remainingTime2 = relay2Triggered ? max(0, (int)(10 - (currentMillis - relay2Timer) / 1000)) : 10;
    int remainingTime3 = relay3Triggered ? max(0, (int)(10 - (currentMillis - relay3Timer) / 1000)) : 10;
    int remainingTime4 = relay4Triggered ? max(0, (int)(10 - (currentMillis - relay4Timer) / 1000)) : 10;
    int remainingTime5 = relay5Triggered ? max(0, (int)(10 - (currentMillis - relay5Timer) / 1000)) : 10;
    int remainingTime6 = relay6Triggered ? max(0, (int)(10 - (currentMillis - relay6Timer) / 1000)) : 10;
    int remainingTime7 = relay7Triggered ? max(0, (int)(10 - (currentMillis - relay7Timer) / 1000)) : 10;
    int remainingTime8 = relay8Triggered ? max(0, (int)(10 - (currentMillis - relay8Timer) / 1000)) : 10;

    lcd2.setCursor(0, 1);
    lcd2.print("R1:");
    lcd2.print(remainingTime1);
    lcd2.print(" R2:");
    lcd2.print(remainingTime2);
    lcd2.print(" R3:");
    lcd2.print(remainingTime3);
    lcd2.print(" R4:");
    lcd2.print(remainingTime4);

    lcd2.setCursor(0, 1);
    lcd2.print("R5:");
    lcd2.print(remainingTime5);
    lcd2.print(" R6:");
    lcd2.print(remainingTime6);
    lcd2.print(" R7:");
    lcd2.print(remainingTime7);
    lcd2.print(" R8:");
    lcd2.print(remainingTime8);

    // Check voltage levels and control relays with 10-second delay
    if (batteryVoltage >= MAX_BATTERY_VOLTAGE) {
        if (!relay1Triggered) {
            relay1Timer = currentMillis;
            relay1Triggered = true;
        } else if (currentMillis - relay1Timer >= 10000) {  // 10-second delay
            digitalWrite(RELAY1_PIN, HIGH);
        }
    } else {
        digitalWrite(RELAY1_PIN, LOW);
        relay1Triggered = false;
    }

    if (batteryVoltage >= RELAY2_VOLTAGE_THRESHOLD) {
        if (!relay2Triggered) {
            relay2Timer = currentMillis;
            relay2Triggered = true;
        } else if (currentMillis - relay2Timer >= 10000) {  // 10-second delay
            digitalWrite(RELAY2_PIN, HIGH);
        }
    } else {
        digitalWrite(RELAY2_PIN, LOW);
        relay2Triggered = false;
    }

    if (batteryVoltage >= RELAY3_VOLTAGE_THRESHOLD) {
        if (!relay3Triggered) {
            relay3Timer = currentMillis;
            relay3Triggered = true;
        } else if (currentMillis - relay3Timer >= 10000) {  // 10-second delay
            digitalWrite(RELAY3_PIN, HIGH);
        }
    } else {
        digitalWrite(RELAY3_PIN, LOW);
        relay3Triggered = false;
    }

    if (batteryVoltage >= RELAY4_VOLTAGE_THRESHOLD) {
        if (!relay4Triggered) {
            relay4Timer = currentMillis;
            relay4Triggered = true;
        } else if (currentMillis - relay4Timer >= 10000) {  // 10-second delay
            digitalWrite(RELAY4_PIN, HIGH);
        }
    } else {
        digitalWrite(RELAY4_PIN, LOW);
        relay4Triggered = false;
    }

    if (batteryVoltage >= RELAY5_VOLTAGE_THRESHOLD) {
        if (!relay5Triggered) {
            relay5Timer = currentMillis;
            relay5Triggered = true;
        } else if (currentMillis - relay5Timer >= 10000) {  // 10-second delay
            digitalWrite(RELAY5_PIN, HIGH);
        }
    } else {
        digitalWrite(RELAY5_PIN, LOW);
        relay5Triggered = false;
    }

    if (batteryVoltage >= RELAY6_VOLTAGE_THRESHOLD) {
        if (!relay6Triggered) {
            relay6Timer = currentMillis;
            relay6Triggered = true;
        } else if (currentMillis - relay6Timer >= 10000) {  // 10-second delay
            digitalWrite(RELAY6_PIN, HIGH);
        }
    } else {
        digitalWrite(RELAY6_PIN, LOW);
        relay6Triggered = false;
    }

    if (batteryVoltage >= RELAY7_VOLTAGE_THRESHOLD) {
        if (!relay7Triggered) {
            relay7Timer = currentMillis;
            relay7Triggered = true;
        } else if (currentMillis - relay7Timer >= 10000) {  // 10-second delay
            digitalWrite(RELAY7_PIN, HIGH);
        }
    } else {
        digitalWrite(RELAY7_PIN, LOW);
        relay7Triggered = false;
    }

    if (batteryVoltage >= RELAY8_VOLTAGE_THRESHOLD) {
        if (!relay8Triggered) {
            relay8Timer = currentMillis;
            relay8Triggered = true;
        } else if (currentMillis - relay8Timer >= 10000) {  // 10-second delay
            digitalWrite(RELAY8_PIN, HIGH);
        }
    } else {
        digitalWrite(RELAY8_PIN, LOW);
        relay8Triggered = false;
    }

    delay(1000);  // Wait for 1 second before the next loop
}