#include <Arduino.h>

// Definición de pines
const int voltagePin = 1;     // Pin ADC para potenciómetro simulando voltaje
const int currentPin = 2;     // Pin ADC para potenciómetro simulando corriente
const int controlPin = 7;     // Pin de control para el LED verde (SSR Out)
const int statusLedPin = 8;   // LED naranja de estado

// Variables para límites de seguridad
float minVoltage = 108.5;     // Límite inferior de voltaje
float maxVoltage = 110.5;     // Límite superior de voltaje
float maxCurrent = 20.0;      // Límite de corriente máxima

// Variables globales para mediciones
float VAC = 0.0;              // Voltaje AC RMS
float AmpAC = 0.0;            // Corriente AC RMS
float Power = 0.0;            // Potencia activa
float Frequency = 50.0;       // Frecuencia de la red (valor fijo para simulación)
bool systemEnabled = false;   // Estado del sistema (cambiado a false para forzar evaluación inicial)

// Tiempos para control de intervalos
unsigned long lastVoltageReadTime = 0;
unsigned long lastCurrentReadTime = 0;
unsigned long lastDisplayTime = 0;
unsigned long lastControlTime = 0;

// Función para mapear el valor del ADC a voltaje (simulación)
float readVoltageFromADC() {
  int adcValue = analogRead(voltagePin);
  
  // Mapear el valor del ADC (0-4095 para ESP32) a un rango de voltaje (0-130V)
  float voltage = map(adcValue, 0, 4095, 0, 1300) / 10.0;
  
  return voltage;
}

// Función para mapear el valor del ADC a corriente (simulación)
float readCurrentFromADC() {
  int adcValue = analogRead(currentPin);
  
  // Mapear el valor del ADC (0-4095 para ESP32) a un rango de corriente (0-25A)
  float current = map(adcValue, 0, 4095, 0, 250) / 10.0;
  
  return current;
}

// Función para calcular potencia
float calculatePower(float voltage, float current) {
  return voltage * current;
}

// Función para control de potencia
void controlPower() {
  // Verificar si las condiciones están dentro de los límites
  bool withinLimits = (VAC >= minVoltage && VAC <= maxVoltage && AmpAC <= maxCurrent);
  
  // Modificada para evaluar en cada llamada, no solo en cambios de estado
  if (withinLimits) {
    if (!systemEnabled) {
      Serial.println("✅ Condiciones óptimas: Carga activada");
      systemEnabled = true;
    }
    digitalWrite(controlPin, HIGH);  // Activar SSR (LED verde)
    digitalWrite(statusLedPin, HIGH); // LED naranja encendido
  } else {
    if (systemEnabled) {
      systemEnabled = false;
      // Identificar la razón de la desactivación
      if (VAC < minVoltage) {
        Serial.println("⚠️ Bajo voltaje detectado: Carga desactivada");
      } else if (VAC > maxVoltage) {
        Serial.println("⚠️ Sobrevoltaje detectado: Carga desactivada");
      } else if (AmpAC > maxCurrent) {
        Serial.println("⚠️ Sobrecorriente detectada: Carga desactivada");
      }
    }
    digitalWrite(controlPin, LOW);   // Desactivar SSR (LED verde)
    digitalWrite(statusLedPin, LOW);  // LED naranja apagado
  }
}

// Función para mostrar datos
void displayData() {
  Serial.println("------- DATOS DEL SISTEMA -------");
  Serial.print("Voltaje: ");
  Serial.print(VAC, 2);
  Serial.println(" V");
  
  Serial.print("Corriente: ");
  Serial.print(AmpAC, 2);
  Serial.println(" A");
  
  Serial.print("Potencia: ");
  Serial.print(Power, 2);
  Serial.println(" W");
  
  Serial.print("Frecuencia: ");
  Serial.print(Frequency, 1);
  Serial.println(" Hz");
  
  Serial.print("Estado del sistema: ");
  Serial.println(systemEnabled ? "ACTIVO" : "INACTIVO");
  Serial.println("--------------------------------");
}

void setup() {
  // Inicialización de comunicación serial
  Serial.begin(115200);
  Serial.println("Inicializando Sistema de Control de Potencia AC para ESP32 C6...");
  
  // Configuración de pines ADC para ESP32
  analogReadResolution(12); // ESP32 tiene resolución de 12 bits (0-4095)
  
  // Configuración de pines
  pinMode(controlPin, OUTPUT);
  pinMode(statusLedPin, OUTPUT);
  
  // Estado inicial de salidas (cambiado a LOW para evaluación inicial)
  digitalWrite(controlPin, LOW);  
  digitalWrite(statusLedPin, LOW);
  
  // Obtener lecturas iniciales antes de continuar
  delay(500); // Pequeña pausa para estabilización
  VAC = readVoltageFromADC();
  AmpAC = readCurrentFromADC();
  Power = calculatePower(VAC, AmpAC);
  
  // Evaluar condiciones iniciales
  controlPower();
  
  Serial.println("Sistema iniciado correctamente");
}

void loop() {
  unsigned long currentMillis = millis();
  
  // Actualizar lectura de voltaje cada 100ms
  if (currentMillis - lastVoltageReadTime >= 100) {
    VAC = readVoltageFromADC();
    lastVoltageReadTime = currentMillis;
  }
  
  // Actualizar lectura de corriente cada 100ms
  if (currentMillis - lastCurrentReadTime >= 100) {
    AmpAC = readCurrentFromADC();
    lastCurrentReadTime = currentMillis;
  }
  
  // Calcular potencia después de actualizar voltaje y corriente
  Power = calculatePower(VAC, AmpAC);
  
  // Control de potencia cada 200ms
  if (currentMillis - lastControlTime >= 200) {
    controlPower();
    lastControlTime = currentMillis;
  }
  
  // Mostrar datos cada 2 segundos
  if (currentMillis - lastDisplayTime >= 2000) {
    displayData();
    lastDisplayTime = currentMillis;
  }
  
  // Pequeña pausa para no saturar el CPU
  delay(5);
}