Comparadores analógicos

/**
 * Ejercicio 1: Control Automático de Iluminación
 * Sistema que activa iluminación basado en nivel de luz ambiente
 */

#include "driver/adc.h"
#include "esp_adc_cal.h"

esp_adc_cal_characteristics_t adc_chars;

// Configuración de pines
const adc_channel_t LDR_CHANNEL = ADC_CHANNEL_0;        // GPIO36
const adc_channel_t THRESHOLD_CHANNEL = ADC_CHANNEL_3;  // GPIO39
const int LED_PINS[] = {2, 4, 16};  // 3 LEDs de salida
const int NUM_LEDS = 3;

// Sistema de comparación con histéresis
class LightComparator {
private:
    float hysteresis_margin = 0.1;  // 100mV de histéresis
    bool lights_on = false;
    
public:
    bool shouldTurnOn(float ambient, float threshold) {
        if (!lights_on) {
            // Luces apagadas - encender si está muy oscuro
            return ambient < (threshold - hysteresis_margin);
        } else {
            // Luces encendidas - apagar solo si hay suficiente luz
            return ambient < (threshold + hysteresis_margin);
        }
    }
    
    void setState(bool state) { lights_on = state; }
    bool getState() { return lights_on; }
};

LightComparator lightController;

void setup() {
    Serial.begin(115200);
    
    // Configurar ADC
    adc1_config_width(ADC_WIDTH_BIT_12);
    adc1_config_channel_atten(LDR_CHANNEL, ADC_ATTEN_DB_11);
    adc1_config_channel_atten(THRESHOLD_CHANNEL, ADC_ATTEN_DB_11);
    esp_adc_cal_characterize(ADC_UNIT_1, ADC_ATTEN_DB_11, 
                            ADC_WIDTH_BIT_12, 1100, &adc_chars);
    
    // Configurar LEDs
    for (int i = 0; i < NUM_LEDS; i++) {
        pinMode(LED_PINS[i], OUTPUT);
        digitalWrite(LED_PINS[i], LOW);
    }
    
    Serial.println("=== SISTEMA DE ILUMINACIÓN AUTOMÁTICA ===");
    Serial.println("LDR: GPIO36 | Umbral: GPIO39");
    Serial.println("LEDs: GPIO2, GPIO4, GPIO16");
    Serial.println("========================================");
}

void loop() {
    // Leer sensores con filtrado
    float ambient_light = readVoltageFiltered(LDR_CHANNEL);
    float threshold_voltage = readVoltageFiltered(THRESHOLD_CHANNEL);
    
    // Determinar estado de iluminación
    bool should_light = lightController.shouldTurnOn(ambient_light, threshold_voltage);
    lightController.setState(should_light);
    
    // Controlar LEDs con efecto gradual
    controlLEDs(should_light);
    
    // Mostrar estado
    printSystemStatus(ambient_light, threshold_voltage, should_light);
    
    delay(200);
}

float readVoltageFiltered(adc_channel_t channel) {
    uint32_t adc_sum = 0;
    const int samples = 8;
    
    for (int i = 0; i < samples; i++) {
        adc_sum += adc1_get_raw(channel);
        delayMicroseconds(500);
    }
    
    uint32_t adc_avg = adc_sum / samples;
    uint32_t voltage_mv = esp_adc_cal_raw_to_voltage(adc_avg, &adc_chars);
    return voltage_mv / 1000.0;
}

void controlLEDs(bool enable) {
    static unsigned long last_update = 0;
    static int led_index = 0;
    static bool transitioning = false;
    
    if (enable) {
        // Encender LEDs secuencialmente para efecto visual
        if (millis() - last_update > 100) {
            digitalWrite(LED_PINS[led_index], HIGH);
            led_index = (led_index + 1) % NUM_LEDS;
            
            if (led_index == 0 && !transitioning) {
                // Todos encendidos
                for (int i = 0; i < NUM_LEDS; i++) {
                    digitalWrite(LED_PINS[i], HIGH);
                }
            }
            last_update = millis();
        }
    } else {
        // Apagar todos los LEDs
        for (int i = 0; i < NUM_LEDS; i++) {
            digitalWrite(LED_PINS[i], LOW);
        }
        led_index = 0;
    }
}

void printSystemStatus(float ambient, float threshold, bool lights_on) {
    // Convertir voltajes a porcentajes de luz
    float ambient_percent = (ambient / 3.3) * 100;
    float threshold_percent = (threshold / 3.3) * 100;
    
    Serial.printf("Luz ambiente: %.2fV (%.1f%%) | ", ambient, ambient_percent);
    Serial.printf("Umbral: %.2fV (%.1f%%) | ", threshold, threshold_percent);
    Serial.printf("Iluminación: %s", lights_on ? "🔆 ON" : "🌙 OFF");
    
    if (lights_on && ambient < threshold) {
        Serial.println(" [MODO NOCTURNO]");
    } else if (!lights_on && ambient >= threshold) {
        Serial.println(" [LUZ SUFICIENTE]");
    } else {
        Serial.println(" [TRANSICIÓN]");
    }
}

/**
 * Ejercicio 2: Sistema de Protección por Temperatura
 * Control de seguridad térmica con múltiples niveles de alarma
 */

#include "driver/adc.h"
#include "esp_adc_cal.h"

esp_adc_cal_characteristics_t adc_chars;

// Configuración de pines
const adc_channel_t TEMP_CHANNEL = ADC_CHANNEL_0;      // GPIO36 - TMP36
const adc_channel_t SETPOINT_CHANNEL = ADC_CHANNEL_3;  // GPIO39 - Setpoint
const int FAN_RELAY_PIN = 2;     // Control de ventilador
const int ALARM_LED_PIN = 4;     // LED de alarma
const int BUZZER_PIN = 16;       // Buzzer de alarma
const int STATUS_LED_PIN = 17;   // LED de estado normal

// Estados del sistema de protección
enum ThermalProtectionState {
    NORMAL,           // Temperatura normal
    WARNING,          // Temperatura elevada
    CRITICAL,         // Temperatura crítica
    EMERGENCY         // Emergencia térmica
};

class ThermalProtectionSystem {
private:
    ThermalProtectionState current_state;
    float warning_offset = 5.0;    // °C sobre setpoint
    float critical_offset = 10.0;  // °C sobre setpoint
    float emergency_offset = 15.0; // °C sobre setpoint
    
    // Histéresis para cada nivel
    float hysteresis = 2.0;  // °C
    
    unsigned long state_change_time;
    unsigned long alarm_start_time;
    bool alarm_active;
    
public:
    ThermalProtectionSystem() {
        current_state = NORMAL;
        state_change_time = 0;
        alarm_start_time = 0;
        alarm_active = false;
    }
    
    ThermalProtectionState evaluateTemperature(float temp, float setpoint) {
        ThermalProtectionState new_state = current_state;
        
        // Calcular umbrales con histéresis
        float warning_temp = setpoint + warning_offset;
        float critical_temp = setpoint + critical_offset;
        float emergency_temp = setpoint + emergency_offset;
        
        // Lógica de transición de estados con histéresis
        switch (current_state) {
            case NORMAL:
                if (temp > warning_temp) new_state = WARNING;
                break;
                
            case WARNING:
                if (temp < warning_temp - hysteresis) {
                    new_state = NORMAL;
                } else if (temp > critical_temp) {
                    new_state = CRITICAL;
                }
                break;
                
            case CRITICAL:
                if (temp < critical_temp - hysteresis) {
                    new_state = WARNING;
                } else if (temp > emergency_temp) {
                    new_state = EMERGENCY;
                }
                break;
                
            case EMERGENCY:
                if (temp < emergency_temp - hysteresis) {
                    new_state = CRITICAL;
                }
                break;
        }
        
        // Actualizar estado si cambió
        if (new_state != current_state) {
            current_state = new_state;
            state_change_time = millis();
            
            if (current_state >= WARNING && !alarm_active) {
                alarm_start_time = millis();
                alarm_active = true;
            } else if (current_state == NORMAL) {
                alarm_active = false;
            }
        }
        
        return current_state;
    }
    
    String getStateString() {
        switch (current_state) {
            case NORMAL: return "NORMAL";
            case WARNING: return "WARNING";
            case CRITICAL: return "CRITICAL";
            case EMERGENCY: return "EMERGENCY";
            default: return "UNKNOWN";
        }
    }
    
    bool shouldActivateFan() {
        return current_state >= WARNING;
    }
    
    bool shouldActivateAlarm() {
        return current_state >= CRITICAL;
    }
    
    bool isEmergency() {
        return current_state == EMERGENCY;
    }
    
    unsigned long getTimeSinceStateChange() {
        return millis() - state_change_time;
    }
    
    unsigned long getAlarmDuration() {
        return alarm_active ? millis() - alarm_start_time : 0;
    }
};

ThermalProtectionSystem thermalSystem;

void setup() {
    Serial.begin(115200);
    
    // Configurar ADC
    adc1_config_width(ADC_WIDTH_BIT_12);
    adc1_config_channel_atten(TEMP_CHANNEL, ADC_ATTEN_DB_11);
    adc1_config_channel_atten(SETPOINT_CHANNEL, ADC_ATTEN_DB_11);
    esp_adc_cal_characterize(ADC_UNIT_1, ADC_ATTEN_DB_11, 
                            ADC_WIDTH_BIT_12, 1100, &adc_chars);
    
    // Configurar pines de salida
    pinMode(FAN_RELAY_PIN, OUTPUT);
    pinMode(ALARM_LED_PIN, OUTPUT);
    pinMode(BUZZER_PIN, OUTPUT);
    pinMode(STATUS_LED_PIN, OUTPUT);
    
    // Estado inicial
    digitalWrite(FAN_RELAY_PIN, LOW);
    digitalWrite(ALARM_LED_PIN, LOW);
    digitalWrite(BUZZER_PIN, LOW);
    digitalWrite(STATUS_LED_PIN, HIGH);
    
    Serial.println("=== SISTEMA DE PROTECCIÓN TÉRMICA ===");
    Serial.println("TMP36: GPIO36 | Setpoint: GPIO39");
    Serial.println("Ventilador: GPIO2 | Alarma: GPIO4");
    Serial.println("Niveles: +5°C Warning, +10°C Critical, +15°C Emergency");
    Serial.println("====================================");
}

void loop() {
    // Leer temperatura y setpoint
    float temperature = readTemperatureTMP36();
    float setpoint = readSetpoint();
    
    // Evaluar estado térmico
    ThermalProtectionState state = thermalSystem.evaluateTemperature(temperature, setpoint);
    
    // Controlar actuadores
    controlOutputs(state);
    
    // Mostrar estado detallado
    printThermalStatus(temperature, setpoint, state);
    
    delay(500);
}

float readTemperatureTMP36() {
    // Leer TMP36 con filtrado
    uint32_t adc_sum = 0;
    const int samples = 10;
    
    for (int i = 0; i < samples; i++) {
        adc_sum += adc1_get_raw(TEMP_CHANNEL);
        delayMicroseconds(1000);
    }
    
    uint32_t adc_avg = adc_sum / samples;
    uint32_t voltage_mv = esp_adc_cal_raw_to_voltage(adc_avg, &adc_chars);
    
    // Conversión TMP36: 10mV/°C, 500mV offset a 0°C
    float temperature = (voltage_mv - 500.0) / 10.0;
    return temperature;
}

float readSetpoint() {
    // Convertir potenciómetro a rango de temperatura (20-60°C)
    uint32_t adc_raw = adc1_get_raw(SETPOINT_CHANNEL);
    uint32_t voltage_mv = esp_adc_cal_raw_to_voltage(adc_raw, &adc_chars);
    
    // Mapear 0-3.3V a 20-60°C
    float setpoint = 20.0 + (voltage_mv / 3300.0) * 40.0;
    return setpoint;
}

void controlOutputs(ThermalProtectionState state) {
    static unsigned long last_blink = 0;
    static bool blink_state = false;
    
    // Control del ventilador
    digitalWrite(FAN_RELAY_PIN, thermalSystem.shouldActivateFan() ? HIGH : LOW);
    
    // Control del LED de estado
    digitalWrite(STATUS_LED_PIN, (state == NORMAL) ? HIGH : LOW);
    
    // Control de alarmas con patrones de parpadeo
    if (thermalSystem.shouldActivateAlarm()) {
        // Parpadeo rápido para critical, muy rápido para emergency
        int blink_interval = (state == EMERGENCY) ? 100 : 300;
        
        if (millis() - last_blink > blink_interval) {
            blink_state = !blink_state;
            digitalWrite(ALARM_LED_PIN, blink_state ? HIGH : LOW);
            
            // Buzzer solo en emergency
            if (state == EMERGENCY) {
                digitalWrite(BUZZER_PIN, blink_state ? HIGH : LOW);
            }
            
            last_blink = millis();
        }
    } else {
        // Apagar alarmas
        digitalWrite(ALARM_LED_PIN, LOW);
        digitalWrite(BUZZER_PIN, LOW);
    }
}

void printThermalStatus(float temp, float setpoint, ThermalProtectionState state) {
    Serial.println("========== ESTADO TÉRMICO ==========");
    Serial.printf("Temperatura: %.2f°C\n", temp);
    Serial.printf("Setpoint: %.2f°C\n", setpoint);
    Serial.printf("Diferencia: %+.2f°C\n", temp - setpoint);
    Serial.printf("Estado: %s\n", thermalSystem.getStateString().c_str());
    
    // Tiempo en estado actual
    unsigned long time_in_state = thermalSystem.getTimeSinceStateChange();
    Serial.printf("Tiempo en estado: %lu seg\n", time_in_state / 1000);
    
    // Estado de actuadores
    Serial.printf("Ventilador: %s\n", thermalSystem.shouldActivateFan() ? "🌀 ACTIVO" : "⭕ OFF");
    
    if (thermalSystem.shouldActivateAlarm()) {
        unsigned long alarm_time = thermalSystem.getAlarmDuration();
        Serial.printf("🚨 ALARMA ACTIVA (%lu seg)\n", alarm_time / 1000);
    }
    
    // Indicadores de estado
    switch (state) {
        case NORMAL:
            Serial.println("Status: ✅ Temperatura normal");
            break;
        case WARNING:
            Serial.println("Status: ⚠️  Temperatura elevada - Ventilación activada");
            break;
        case CRITICAL:
            Serial.println("Status: 🔥 Temperatura crítica - Alarma activa");
            break;
        case EMERGENCY:
            Serial.println("Status: 🆘 EMERGENCIA TÉRMICA - Protocolo de seguridad");
            break;
    }
    
    Serial.println("==================================\n");
}

/**
 * Ejercicio 3: Monitor de Calidad de Energía
 * Sistema avanzado de monitoreo con múltiples comparadores
 * y registro de eventos
 */

#include "driver/adc.h"
#include "esp_adc_cal.h"
#include 
#include 

esp_adc_cal_characteristics_t adc_chars;

// Canales de medición
const adc_channel_t VOLTAGE_CHANNEL = ADC_CHANNEL_0;    // GPIO36
const adc_channel_t CURRENT_CHANNEL = ADC_CHANNEL_3;    // GPIO39
const adc_channel_t REFERENCE_CHANNEL = ADC_CHANNEL_6;  // GPIO34

// Pines de indicadores
const int GREEN_LED = 2;      // Operación normal
const int YELLOW_LED = 4;     // Advertencia
const int RED_LED = 16;       // Falla crítica
const int BUZZER_PIN = 17;    // Alarma sonora

// Estándares de calidad de energía (IEEE 519)
struct PowerQualityLimits {
    float nominal_voltage = 120.0;      // Voltaje nominal (V)
    float voltage_tolerance = 0.05;     // ±5%
    float voltage_warning = 0.08;       // ±8%
    float voltage_critical = 0.10;      // ±10%
    
    float nominal_frequency = 60.0;     // Frecuencia nominal (Hz)
    float frequency_tolerance = 0.1;    // ±0.1 Hz
    
    float thd_warning = 0.05;           // 5% THD
    float thd_critical = 0.08;          // 8% THD
};

enum PowerQualityEvent {
    NORMAL_OPERATION,
    VOLTAGE_SAG,        // Subtensión
    VOLTAGE_SWELL,      // Sobretensión  
    VOLTAGE_INTERRUPTION, // Interrupción
    FREQUENCY_DEVIATION,  // Desviación de frecuencia
    HARMONIC_DISTORTION  // Distorsión armónica
};

struct PowerQualityData {
    float voltage_rms;
    float current_rms;
    float frequency;
    float thd_voltage;
    float power_factor;
    PowerQualityEvent active_event;
    unsigned long event_start_time;
    unsigned long event_duration;
};

class PowerQualityMonitor {
private:
    PowerQualityLimits limits;
    PowerQualityData current_data;
    
    // Buffers para análisis
    static const int SAMPLE_BUFFER_SIZE = 128;
    float voltage_buffer[SAMPLE_BUFFER_SIZE];
    float current_buffer[SAMPLE_BUFFER_SIZE];
    int buffer_index;
    
    // Estadísticas de eventos
    struct EventStatistics {
        unsigned long total_events;
        unsigned long sag_events;
        unsigned long swell_events;
        unsigned long interruption_events;
        unsigned long frequency_events;
        unsigned long harmonic_events;
        unsigned long last_event_time;
    } event_stats;
    
    // Estado del monitor
    bool monitoring_active;
    unsigned long last_analysis_time;
    unsigned long analysis_interval = 1000; // 1 segundo
    
public:
    PowerQualityMonitor() {
        buffer_index = 0;
        monitoring_active = false;
        last_analysis_time = 0;
        memset(&event_stats, 0, sizeof(event_stats));
        current_data.active_event = NORMAL_OPERATION;
        current_data.event_start_time = 0;
    }
    
    void initialize() {
        // Configurar ADC con alta precisión
        adc1_config_width(ADC_WIDTH_BIT_12);
        adc1_config_channel_atten(VOLTAGE_CHANNEL, ADC_ATTEN_DB_11);
        adc1_config_channel_atten(CURRENT_CHANNEL, ADC_ATTEN_DB_11);
        adc1_config_channel_atten(REFERENCE_CHANNEL, ADC_ATTEN_DB_11);
        
        esp_adc_cal_characterize(ADC_UNIT_1, ADC_ATTEN_DB_11, 
                                ADC_WIDTH_BIT_12, 1100, &adc_chars);
        
        monitoring_active = true;
        Serial.println("Monitor de Calidad de Energía inicializado");
    }
    
    void update() {
        if (!monitoring_active) return;
        
        // Adquisición continua de muestras
        acquireSamples();
        
        // Análisis periódico
        if (millis() - last_analysis_time >= analysis_interval) {
            performPowerQualityAnalysis();
            detectPowerQualityEvents();
            last_analysis_time = millis();
        }
    }
    
private:
    void acquireSamples() {
        // Muestreo de voltaje y corriente
        uint32_t voltage_adc = adc1_get_raw(VOLTAGE_CHANNEL);
        uint32_t current_adc = adc1_get_raw(CURRENT_CHANNEL);
        
        // Convertir a valores reales
        uint32_t voltage_mv = esp_adc_cal_raw_to_voltage(voltage_adc, &adc_chars);
        uint32_t current_mv = esp_adc_cal_raw_to_voltage(current_adc, &adc_chars);
        
        // Escalado para voltaje y corriente reales
        voltage_buffer[buffer_index] = (voltage_mv / 1000.0) * 50.0; // Factor de escala del divisor
        current_buffer[buffer_index] = (current_mv / 1000.0) * 10.0; // Factor de escala del sensor
        
        buffer_index = (buffer_index + 1) % SAMPLE_BUFFER_SIZE;
    }
    
    void performPowerQualityAnalysis() {
        // Calcular RMS de voltaje
        current_data.voltage_rms = calculateRMS(voltage_buffer, SAMPLE_BUFFER_SIZE);
        current_data.current_rms = calculateRMS(current_buffer, SAMPLE_BUFFER_SIZE);
        
        // Calcular frecuencia (simulada - requiere análisis de cruces por cero)
        current_data.frequency = estimateFrequency();
        
        // Calcular THD (Total Harmonic Distortion) simplificado
        current_data.thd_voltage = calculateTHD(voltage_buffer, SAMPLE_BUFFER_SIZE);
        
        // Calcular factor de potencia (simulado)
        current_data.power_factor = calculatePowerFactor();
    }
    
    float calculateRMS(float* buffer, int size) {
        float sum_squares = 0;
        for (int i = 0; i < size; i++) {
            sum_squares += buffer[i] * buffer[i];
        }
        return sqrt(sum_squares / size);
    }
    
    float estimateFrequency() {
        // Implementación simplificada - detecta cruces por cero
        int zero_crossings = 0;
        float last_sample = voltage_buffer[0];
        
        for (int i = 1; i < SAMPLE_BUFFER_SIZE; i++) {
            if ((last_sample < 0 && voltage_buffer[i] >= 0) ||
                (last_sample >= 0 && voltage_buffer[i] < 0)) {
                zero_crossings++;
            }
            last_sample = voltage_buffer[i];
        }
        
        // Frecuencia estimada basada en cruces por cero
        float sample_rate = 1000.0; // Hz (asumiendo 1ms entre muestras)
        float estimated_freq = (zero_crossings * sample_rate) / (2 * SAMPLE_BUFFER_SIZE);
        
        return estimated_freq > 0 ? estimated_freq : limits.nominal_frequency;
    }
    
    float calculateTHD(float* buffer, int size) {
        // THD simplificado - mide distorsión respecto a senoidal ideal
        float fundamental_power = 0;
        float total_power = 0;
        
        // Análisis simplificado de armónicos
        for (int i = 0; i < size; i++) {
            float sample = buffer[i];
            total_power += sample * sample;
            
            // Aproximación del fundamental (muy simplificada)
            float ideal_sine = limits.nominal_voltage * sin(2 * M_PI * limits.nominal_frequency * i / 1000.0);
            fundamental_power += ideal_sine * ideal_sine;
        }
        
        if (fundamental_power > 0) {
            return sqrt((total_power - fundamental_power) / fundamental_power);
        }
        return 0;
    }
    
    float calculatePowerFactor() {
        // Factor de potencia simplificado (requiere análisis de fase)
        // Por simplicidad, retornamos un valor basado en la calidad de la forma de onda
        float distortion_factor = 1.0 - current_data.thd_voltage;
        return constrain(distortion_factor, 0.7, 1.0);
    }
    
    void detectPowerQualityEvents() {
        PowerQualityEvent new_event = NORMAL_OPERATION;
        
        // Análisis de voltaje
        float voltage_deviation = abs(current_data.voltage_rms - limits.nominal_voltage) / limits.nominal_voltage;
        
        if (current_data.voltage_rms < limits.nominal_voltage * 0.1) {
            new_event = VOLTAGE_INTERRUPTION;
        } else if (voltage_deviation > limits.voltage_critical) {
            if (current_data.voltage_rms > limits.nominal_voltage) {
                new_event = VOLTAGE_SWELL;
            } else {
                new_event = VOLTAGE_SAG;
            }
        }
        
        // Análisis de frecuencia
        float freq_deviation = abs(current_data.frequency - limits.nominal_frequency);
        if (freq_deviation > limits.frequency_tolerance) {
            new_event = FREQUENCY_DEVIATION;
        }
        
        // Análisis de THD
        if (current_data.thd_voltage > limits.thd_critical) {
            new_event = HARMONIC_DISTORTION;
        }
        
        // Gestión de eventos
        if (new_event != current_data.active_event) {
            if (current_data.active_event != NORMAL_OPERATION) {
                // Finalizar evento anterior
                current_data.event_duration = millis() - current_data.event_start_time;
                logPowerQualityEvent(current_data.active_event, current_data.event_duration);
            }
            
            // Iniciar nuevo evento
            current_data.active_event = new_event;
            current_data.event_start_time = millis();
            
            if (new_event != NORMAL_OPERATION) {
                event_stats.total_events++;
                event_stats.last_event_time = millis();
                updateEventStatistics(new_event);
            }
        }
    }
    
    void updateEventStatistics(PowerQualityEvent event) {
        switch (event) {
            case VOLTAGE_SAG: event_stats.sag_events++; break;
            case VOLTAGE_SWELL: event_stats.swell_events++; break;
            case VOLTAGE_INTERRUPTION: event_stats.interruption_events++; break;
            case FREQUENCY_DEVIATION: event_stats.frequency_events++; break;
            case HARMONIC_DISTORTION: event_stats.harmonic_events++; break;
            default: break;
        }
    }
    
    void logPowerQualityEvent(PowerQualityEvent event, unsigned long duration) {
        Serial.println("========== EVENTO DE CALIDAD DE ENERGÍA ==========");
        Serial.printf("Tipo: %s\n", getEventString(event).c_str());
        Serial.printf("Duración: %lu ms\n", duration);
        Serial.printf("Voltaje RMS: %.2f V\n", current_data.voltage_rms);
        Serial.printf("Frecuencia: %.2f Hz\n", current_data.frequency);
        Serial.printf("THD: %.2f%%\n", current_data.thd_voltage * 100);
        Serial.println("===============================================");
    }
    
    String getEventString(PowerQualityEvent event) {
        switch (event) {
            case NORMAL_OPERATION: return "Operación Normal";
            case VOLTAGE_SAG: return "Subtensión (SAG)";
            case VOLTAGE_SWELL: return "Sobretensión (SWELL)";
            case VOLTAGE_INTERRUPTION: return "Interrupción de Voltaje";
            case FREQUENCY_DEVIATION: return "Desviación de Frecuencia";
            case HARMONIC_DISTORTION: return "Distorsión Armónica";
            default: return "Evento Desconocido";
        }
    }
    
public:
    void printDetailedStatus() {
        Serial.println("========== ESTADO DE CALIDAD DE ENERGÍA ==========");
        Serial.printf("Voltaje RMS: %.2f V (Nom: %.2f V)\n", 
                      current_data.voltage_rms, limits.nominal_voltage);
        Serial.printf("Corriente RMS: %.2f A\n", current_data.current_rms);
        Serial.printf("Frecuencia: %.2f Hz (Nom: %.2f Hz)\n", 
                      current_data.frequency, limits.nominal_frequency);
        Serial.printf("THD Voltaje: %.2f%% (Límite: %.2f%%)\n", 
                      current_data.thd_voltage * 100, limits.thd_critical * 100);
        Serial.printf("Factor de Potencia: %.3f\n", current_data.power_factor);
        Serial.printf("Evento Actual: %s\n", getEventString(current_data.active_event).c_str());
        
        if (current_data.active_event != NORMAL_OPERATION) {
            unsigned long current_duration = millis() - current_data.event_start_time;
            Serial.printf("Duración del Evento: %lu ms\n", current_duration);
        }
        
        Serial.println("\n--- ESTADÍSTICAS DE EVENTOS ---");
        Serial.printf("Total de Eventos: %lu\n", event_stats.total_events);
        Serial.printf("Subtensiones: %lu\n", event_stats.sag_events);
        Serial.printf("Sobretensiones: %lu\n", event_stats.swell_events);
        Serial.printf("Interrupciones: %lu\n", event_stats.interruption_events);
        Serial.printf("Desviaciones de Frecuencia: %lu\n", event_stats.frequency_events);
        Serial.printf("Distorsiones Armónicas: %lu\n", event_stats.harmonic_events);
        Serial.println("============================================\n");
    }
    
    PowerQualityEvent getCurrentEvent() {
        return current_data.active_event;
    }
    
    PowerQualityData getCurrentData() {
        return current_data;
    }
};

PowerQualityMonitor powerMonitor;

void setup() {
    Serial.begin(115200);
    
    // Configurar pines de indicadores
    pinMode(GREEN_LED, OUTPUT);
    pinMode(YELLOW_LED, OUTPUT);
    pinMode(RED_LED, OUTPUT);
    pinMode(BUZZER_PIN, OUTPUT);
    
    // Estado inicial
    digitalWrite(GREEN_LED, HIGH);
    digitalWrite(YELLOW_LED, LOW);
    digitalWrite(RED_LED, LOW);
    digitalWrite(BUZZER_PIN, LOW);
    
    // Inicializar monitor
    powerMonitor.initialize();
    
    Serial.println("=== SISTEMA DE MONITOREO DE CALIDAD DE ENERGÍA ===");
    Serial.println("Estándares IEEE 519 implementados");
    Serial.println("Monitoreo continuo de voltaje, frecuencia y THD");
    Serial.println("================================================");
}

void loop() {
    // Actualizar monitor de calidad
    powerMonitor.update();
    
    // Controlar indicadores
    controlIndicators();
    
    // Status detallado cada 5 segundos
    static unsigned long last_detailed_status = 0;
    if (millis() - last_detailed_status > 5000) {
        powerMonitor.printDetailedStatus();
        last_detailed_status = millis();
    }
    
    delay(50);  // 20 Hz de actualización
}

void controlIndicators() {
    PowerQualityEvent current_event = powerMonitor.getCurrentEvent();
    PowerQualityData data = powerMonitor.getCurrentData();
    
    // Resetear todos los indicadores
    digitalWrite(GREEN_LED, LOW);
    digitalWrite(YELLOW_LED, LOW);
    digitalWrite(RED_LED, LOW);
    digitalWrite(BUZZER_PIN, LOW);
    
    // Control basado en el tipo de evento
    switch (current_event) {
        case NORMAL_OPERATION:
            digitalWrite(GREEN_LED, HIGH);
            break;
            
        case VOLTAGE_SAG:
        case VOLTAGE_SWELL:
        case FREQUENCY_DEVIATION:
            // Eventos de advertencia - LED amarillo parpadeante
            digitalWrite(YELLOW_LED, (millis() % 1000) < 500);
            break;
            
        case VOLTAGE_INTERRUPTION:
        case HARMONIC_DISTORTION:
            // Eventos críticos - LED rojo y alarma
            digitalWrite(RED_LED, (millis() % 500) < 250);
            digitalWrite(BUZZER_PIN, (millis() % 1000) < 100); // Beep corto
            break;
    }
}