// SISTEMA DE MONITOREO INDUSTRIAL DE VIBRACION
// ESP32 + MPU6050 + Sistema de Análisis Avanzado
// Versión: 3.0 Industrial

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

// Configuración del sistema industrial
#define SYSTEM_VERSION "3.0"
#define SAMPLE_RATE 1000        // Hz - Frecuencia de muestreo industrial
#define FFT_SIZE 1024           // Tamaño FFT para análisis espectral
#define ALARM_THRESHOLD_HIGH 8.0 // g - Umbral alarma alta
#define ALARM_THRESHOLD_MED 4.0  // g - Umbral alarma media
#define DATA_RETENTION_DAYS 30   // Días de retención de datos

// Pines del sistema
#define MPU6050_ADDR 0x68
#define OLED_ADDR 0x3C
#define LED_NORMAL 2
#define LED_WARNING 4
#define LED_ALARM 5
#define BUZZER_PIN 18
#define SD_CS_PIN 15
#define RELAY_OUTPUT 19

// Configuración de red industrial
const char* ssid = "PLANTA_INDUSTRIAL";
const char* password = "Industria4.0";
const char* ntp_server = "pool.ntp.org";

class IndustrialVibrationMonitor {
private:
    // Componentes del sistema
    Adafruit_SSD1306 display;
    WebServer server;
    WiFiUDP ntpUDP;
    NTPClient timeClient;
    ModbusMaster modbus;
    
    // Estructuras de datos industriales
    struct VibrationData {
        float rms_x, rms_y, rms_z;     // RMS de vibración por eje
        float peak_x, peak_y, peak_z;   // Picos máximos
        float frequency_peak;            // Frecuencia dominante
        float temperature;               // Temperatura del sensor
        uint32_t timestamp;              // Timestamp Unix
        uint8_t alarm_status;            // 0=Normal, 1=Advertencia, 2=Alarma
    };
    
    struct MachineProfile {
        char name[32];
        float normal_rms[3];       // Niveles normales RMS por eje
        float warning_factor;      // Factor para advertencia (ej. 1.5x normal)
        float alarm_factor;        // Factor para alarma (ej. 3x normal)
        uint16_t rpm_nominal;      // RPM nominales de la máquina
        bool active;
    };
    
    struct SystemHealth {
        uint32_t uptime_seconds;
        uint16_t samples_per_second;
        uint8_t wifi_quality;
        float cpu_temperature;
        uint32_t free_memory;
        uint16_t sd_write_errors;
        bool ntp_synchronized;
    };
    
    // Variables del sistema
    VibrationData current_data;
    MachineProfile machine_config;
    SystemHealth health_status;
    
    // Buffers para procesamiento
    float accel_buffer_x[FFT_SIZE];
    float accel_buffer_y[FFT_SIZE];
    float accel_buffer_z[FFT_SIZE];
    uint16_t buffer_index = 0;
    
    // Sistema de alarmas
    bool alarm_active = false;
    bool warning_active = false;
    uint32_t last_alarm_time = 0;
    uint16_t alarm_count_day = 0;
    
    // Análisis espectral
    float fft_result[FFT_SIZE/2];
    float frequency_bins[FFT_SIZE/2];
    
public:
    IndustrialVibrationMonitor() : 
        display(128, 64, &Wire, -1),
        server(80),
        timeClient(ntpUDP, ntp_server, 0, 60000) {
    }
    
    bool initializeSystem() {
        Serial.begin(115200);
        Serial.println("=== SISTEMA INDUSTRIAL DE MONITOREO ===");
        Serial.printf("Versión: %s\n", SYSTEM_VERSION);
        
        // Inicializar componentes críticos
        if (!initializeHardware()) return false;
        if (!initializeNetwork()) return false;
        if (!initializeStorage()) return false;
        
        // Cargar configuración de máquina
        loadMachineProfile();
        
        // Configurar sistema de tiempo
        timeClient.begin();
        updateSystemTime();
        
        // Inicializar Modbus (protocolo industrial)
        modbus.begin(1, Serial2);
        
        // Configurar alarmas y salidas
        setupAlarmSystem();
        
        Serial.println("Sistema inicializado correctamente");
        return true;
    }
    
private:
    bool initializeHardware() {
        // Configurar pines de salida
        pinMode(LED_NORMAL, OUTPUT);
        pinMode(LED_WARNING, OUTPUT);
        pinMode(LED_ALARM, OUTPUT);
        pinMode(BUZZER_PIN, OUTPUT);
        pinMode(RELAY_OUTPUT, OUTPUT);
        
        // Inicializar I2C
        Wire.begin(21, 22);
        Wire.setClock(400000);
        
        // Verificar MPU6050
        Wire.beginTransmission(MPU6050_ADDR);
        if (Wire.endTransmission() != 0) {
            Serial.println("ERROR: MPU6050 no detectado");
            return false;
        }
        
        // Configurar MPU6050 para aplicación industrial
        configureMPU6050Industrial();
        
        // Inicializar OLED
        if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) {
            Serial.println("ERROR: OLED no inicializado");
            return false;
        }
        
        display.clearDisplay();
        display.setTextColor(SSD1306_WHITE);
        display.setTextSize(1);
        display.setCursor(0, 0);
        display.println("SISTEMA INDUSTRIAL");
        display.println("Inicializando...");
        display.display();
        
        return true;
    }
    
    void configureMPU6050Industrial() {
        // Configuración optimizada para monitoreo industrial
        writeRegister(0x6B, 0x00);  // Despertar MPU6050
        delay(100);
        
        // Configurar filtro paso bajo a 94 Hz (ideal para análisis de vibración)
        writeRegister(0x1A, 0x02);
        
        // Configurar acelerómetro a ±16g (máximo rango para aplicaciones industriales)
        writeRegister(0x1C, 0x18);
        
        // Configurar giroscopio a ±2000°/s
        writeRegister(0x1B, 0x18);
        
        // Configurar frecuencia de muestreo (1 kHz)
        writeRegister(0x19, 0x07);  // Sample Rate = Gyro Rate / (1 + 7) = 1kHz
        
        Serial.println("MPU6050 configurado para monitoreo industrial");
    }
    
    void writeRegister(uint8_t reg, uint8_t value) {
        Wire.beginTransmission(MPU6050_ADDR);
        Wire.write(reg);
        Wire.write(value);
        Wire.endTransmission(true);
    }
    
    bool initializeNetwork() {
        WiFi.begin(ssid, password);
        
        int attempts = 0;
        while (WiFi.status() != WL_CONNECTED && attempts < 20) {
            delay(500);
            Serial.print(".");
            attempts++;
        }
        
        if (WiFi.status() != WL_CONNECTED) {
            Serial.println("ERROR: No se pudo conectar a WiFi");
            return false;
        }
        
        Serial.println();
        Serial.printf("WiFi conectado. IP: %s\n", WiFi.localIP().toString().c_str());
        
        // Configurar servidor web industrial
        setupWebServer();
        
        return true;
    }
    
    bool initializeStorage() {
        if (!SPIFFS.begin(true)) {
            Serial.println("ERROR: SPIFFS no inicializado");
            return false;
        }
        
        if (!SD.begin(SD_CS_PIN)) {
            Serial.println("WARNING: SD no disponible - solo almacenamiento interno");
        }
        
        return true;
    }
    
    void setupAlarmSystem() {
        // Test inicial de alarmas
        digitalWrite(LED_NORMAL, HIGH);
        delay(200);
        digitalWrite(LED_WARNING, HIGH);
        delay(200);
        digitalWrite(LED_ALARM, HIGH);
        digitalWrite(BUZZER_PIN, HIGH);
        delay(200);
        
        // Apagar todas las alarmas
        digitalWrite(LED_NORMAL, LOW);
        digitalWrite(LED_WARNING, LOW);
        digitalWrite(LED_ALARM, LOW);
        digitalWrite(BUZZER_PIN, LOW);
        digitalWrite(RELAY_OUTPUT, LOW);
        
        Serial.println("Sistema de alarmas configurado");
    }
    
    void setupWebServer() {
        // Página principal de monitoreo
        server.on("/", HTTP_GET, [this]() {
            String html = generateIndustrialDashboard();
            server.send(200, "text/html", html);
        });
        
        // API de datos en tiempo real
        server.on("/api/data", HTTP_GET, [this]() {
            DynamicJsonDocument doc(2048);
            
            doc["vibration"]["rms_x"] = current_data.rms_x;
            doc["vibration"]["rms_y"] = current_data.rms_y;
            doc["vibration"]["rms_z"] = current_data.rms_z;
            doc["vibration"]["peak_x"] = current_data.peak_x;
            doc["vibration"]["peak_y"] = current_data.peak_y;
            doc["vibration"]["peak_z"] = current_data.peak_z;
            doc["vibration"]["frequency_peak"] = current_data.frequency_peak;
            doc["vibration"]["temperature"] = current_data.temperature;
            doc["vibration"]["alarm_status"] = current_data.alarm_status;
            
            doc["machine"]["name"] = machine_config.name;
            doc["machine"]["rpm_nominal"] = machine_config.rpm_nominal;
            doc["machine"]["active"] = machine_config.active;
            
            doc["system"]["uptime"] = health_status.uptime_seconds;
            doc["system"]["samples_per_second"] = health_status.samples_per_second;
            doc["system"]["wifi_quality"] = health_status.wifi_quality;
            doc["system"]["free_memory"] = health_status.free_memory;
            doc["system"]["timestamp"] = current_data.timestamp;
            
            String response;
            serializeJson(doc, response);
            server.send(200, "application/json", response);
        });
        
        // API de configuración
        server.on("/api/config", HTTP_POST, [this]() {
            if (server.hasArg("plain")) {
                DynamicJsonDocument doc(1024);
                deserializeJson(doc, server.arg("plain"));
                
                if (doc.containsKey("machine_name")) {
                    strncpy(machine_config.name, doc["machine_name"], 31);
                }
                if (doc.containsKey("rpm_nominal")) {
                    machine_config.rpm_nominal = doc["rpm_nominal"];
                }
                if (doc.containsKey("warning_factor")) {
                    machine_config.warning_factor = doc["warning_factor"];
                }
                if (doc.containsKey("alarm_factor")) {
                    machine_config.alarm_factor = doc["alarm_factor"];
                }
                
                saveMachineProfile();
                server.send(200, "text/plain", "Configuración actualizada");
            } else {
                server.send(400, "text/plain", "Datos inválidos");
            }
        });
        
        // Análisis de espectro de frecuencias
        server.on("/api/spectrum", HTTP_GET, [this]() {
            DynamicJsonDocument doc(4096);
            JsonArray frequencies = doc.createNestedArray("frequencies");
            JsonArray amplitudes = doc.createNestedArray("amplitudes");
            
            for (int i = 0; i < FFT_SIZE/2; i += 4) {  // Reducir datos para transmisión
                frequencies.add(frequency_bins[i]);
                amplitudes.add(fft_result[i]);
            }
            
            doc["peak_frequency"] = current_data.frequency_peak;
            doc["sample_rate"] = SAMPLE_RATE;
            
            String response;
            serializeJson(doc, response);
            server.send(200, "application/json", response);
        });
        
        server.begin();
        Serial.println("Servidor web industrial iniciado");
    }
    
public:
    void processIndustrialLoop() {
        static unsigned long last_sample = 0;
        static unsigned long last_display = 0;
        static unsigned long last_health = 0;
        static unsigned long last_log = 0;
        
        unsigned long now = millis();
        
        // Adquisición de datos a 1 kHz
        if (now - last_sample >= 1) {
            acquireVibrationSample();
            last_sample = now;
        }
        
        // Actualizar display cada 250ms
        if (now - last_display >= 250) {
            updateIndustrialDisplay();
            last_display = now;
        }
        
        // Actualizar estadísticas del sistema cada 5 segundos
        if (now - last_health >= 5000) {
            updateSystemHealth();
            last_health = now;
        }
        
        // Guardar datos cada minuto
        if (now - last_log >= 60000) {
            logVibrationData();
            last_log = now;
        }
        
        // Procesar servidor web
        server.handleClient();
        
        // Procesar comunicación Modbus
        processModbusComm();
        
        // Procesar sistema de alarmas
        processAlarmSystem();
    }
    
private:
    void acquireVibrationSample() {
        // Leer datos del MPU6050
        Wire.beginTransmission(MPU6050_ADDR);
        Wire.write(0x3B);  // Registro de acelerómetro
        Wire.endTransmission(false);
        Wire.requestFrom(MPU6050_ADDR, 14, true);
        
        // Leer acelerómetro (16-bit, ±16g)
        int16_t ax = (Wire.read() << 8) | Wire.read();
        int16_t ay = (Wire.read() << 8) | Wire.read();
        int16_t az = (Wire.read() << 8) | Wire.read();
        
        // Saltar temperatura por ahora
        Wire.read(); Wire.read();
        
        // Leer giroscopio
        int16_t gx = (Wire.read() << 8) | Wire.read();
        int16_t gy = (Wire.read() << 8) | Wire.read();
        int16_t gz = (Wire.read() << 8) | Wire.read();
        
        // Convertir a unidades físicas (g)
        float accel_x = ax / 2048.0;  // ±16g range
        float accel_y = ay / 2048.0;
        float accel_z = az / 2048.0;
        
        // Almacenar en buffer para análisis FFT
        accel_buffer_x[buffer_index] = accel_x;
        accel_buffer_y[buffer_index] = accel_y;
        accel_buffer_z[buffer_index] = accel_z;
        
        buffer_index = (buffer_index + 1) % FFT_SIZE;
        
        // Calcular métricas en tiempo real
        if (buffer_index == 0) {  // Buffer completo, procesar
            processVibrationAnalysis();
        }
    }
    
    void processVibrationAnalysis() {
        // Calcular RMS para cada eje
        current_data.rms_x = calculateRMS(accel_buffer_x, FFT_SIZE);
        current_data.rms_y = calculateRMS(accel_buffer_y, FFT_SIZE);
        current_data.rms_z = calculateRMS(accel_buffer_z, FFT_SIZE);
        
        // Encontrar picos máximos
        current_data.peak_x = findPeak(accel_buffer_x, FFT_SIZE);
        current_data.peak_y = findPeak(accel_buffer_y, FFT_SIZE);
        current_data.peak_z = findPeak(accel_buffer_z, FFT_SIZE);
        
        // Análisis de frecuencias (FFT simplificado)
        performFFTAnalysis();
        
        // Actualizar timestamp
        current_data.timestamp = now();
        
        // Evaluar estado de alarma
        evaluateAlarmConditions();
    }
    
    float calculateRMS(float* data, int size) {
        float sum_squares = 0;
        for (int i = 0; i < size; i++) {
            sum_squares += data[i] * data[i];
        }
        return sqrt(sum_squares / size);
    }
    
    float findPeak(float* data, int size) {
        float max_val = 0;
        for (int i = 0; i < size; i++) {
            float abs_val = abs(data[i]);
            if (abs_val > max_val) {
                max_val = abs_val;
            }
        }
        return max_val;
    }
    
    void performFFTAnalysis() {
        // FFT simplificada para encontrar frecuencia dominante
        // En aplicación real, usar librería FFT optimizada
        
        float max_magnitude = 0;
        int peak_bin = 0;
        
        // Análisis de frecuencias básico
        for (int freq_bin = 1; freq_bin < FFT_SIZE/2; freq_bin++) {
            float magnitude = 0;
            
            // Calcular magnitud para esta frecuencia
            for (int i = 0; i < FFT_SIZE; i++) {
                float angle = 2.0 * PI * freq_bin * i / FFT_SIZE;
                magnitude += accel_buffer_x[i] * cos(angle);
            }
            
            magnitude = abs(magnitude);
            fft_result[freq_bin] = magnitude;
            frequency_bins[freq_bin] = (float)freq_bin * SAMPLE_RATE / FFT_SIZE;
            
            if (magnitude > max_magnitude) {
                max_magnitude = magnitude;
                peak_bin = freq_bin;
            }
        }
        
        current_data.frequency_peak = frequency_bins[peak_bin];
    }
    
    void evaluateAlarmConditions() {
        float max_rms = max({current_data.rms_x, current_data.rms_y, current_data.rms_z});
        
        // Evaluar según configuración de máquina
        if (max_rms > machine_config.normal_rms[0] * machine_config.alarm_factor) {
            current_data.alarm_status = 2;  // Alarma alta
        } else if (max_rms > machine_config.normal_rms[0] * machine_config.warning_factor) {
            current_data.alarm_status = 1;  // Advertencia
        } else {
            current_data.alarm_status = 0;  // Normal
        }
    }
    
    void updateIndustrialDisplay() {
        display.clearDisplay();
        
        // Header con estado del sistema
        display.setTextSize(1);
        display.setCursor(0, 0);
        display.printf("MONITOREO INDUSTRIAL");
        
        // Línea de estado
        display.setCursor(0, 10);
        const char* status_text[] = {"NORMAL", "ALERTA", "ALARMA"};
        display.printf("Estado: %s", status_text[current_data.alarm_status]);
        
        // Valores RMS
        display.setCursor(0, 20);
        display.printf("RMS X: %.2f g", current_data.rms_x);
        display.setCursor(0, 30);
        display.printf("RMS Y: %.2f g", current_data.rms_y);
        display.setCursor(0, 40);
        display.printf("RMS Z: %.2f g", current_data.rms_z);
        
        // Frecuencia dominante y temperatura
        display.setCursor(0, 50);
        display.printf("Freq: %.1f Hz", current_data.frequency_peak);
        display.setCursor(0, 58);
        display.printf("Temp: %.1f C", current_data.temperature);
        
        display.display();
    }
    
    void processAlarmSystem() {
        // Gestión de LEDs de estado
        digitalWrite(LED_NORMAL, current_data.alarm_status == 0);
        digitalWrite(LED_WARNING, current_data.alarm_status == 1);
        digitalWrite(LED_ALARM, current_data.alarm_status == 2);
        
        // Gestión de buzzer y relay para alarmas críticas
        if (current_data.alarm_status == 2) {
            if (!alarm_active) {
                alarm_active = true;
                last_alarm_time = millis();
                alarm_count_day++;
                
                // Activar alarma sonora por 5 segundos
                digitalWrite(BUZZER_PIN, HIGH);
                digitalWrite(RELAY_OUTPUT, HIGH);  // Relay para parada de emergencia
                
                Serial.printf("ALARMA ACTIVADA - RMS Max: %.2f g\n", 
                             max({current_data.rms_x, current_data.rms_y, current_data.rms_z}));
            }
            
            // Desactivar alarma sonora después de 5 segundos
            if (millis() - last_alarm_time > 5000) {
                digitalWrite(BUZZER_PIN, LOW);
            }
        } else {
            if (alarm_active) {
                alarm_active = false;
                digitalWrite(BUZZER_PIN, LOW);
                digitalWrite(RELAY_OUTPUT, LOW);
                Serial.println("Alarma desactivada");
            }
        }
    }
    
    void updateSystemHealth() {
        health_status.uptime_seconds = millis() / 1000;
        health_status.samples_per_second = 1000;  // Fijo a 1kHz
        health_status.wifi_quality = map(WiFi.RSSI(), -100, -30, 0, 100);
        health_status.cpu_temperature = temperatureRead();
        health_status.free_memory = ESP.getFreeHeap();
        health_status.ntp_synchronized = timeClient.update();
        
        // Actualizar tiempo del sistema
        if (health_status.ntp_synchronized) {
            setTime(timeClient.getEpochTime());
        }
    }
    
    void logVibrationData() {
        // Crear registro JSON
        DynamicJsonDocument doc(1024);
        doc["timestamp"] = current_data.timestamp;
        doc["rms_x"] = current_data.rms_x;
        doc["rms_y"] = current_data.rms_y;
        doc["rms_z"] = current_data.rms_z;
        doc["peak_x"] = current_data.peak_x;
        doc["peak_y"] = current_data.peak_y;
        doc["peak_z"] = current_data.peak_z;
        doc["frequency_peak"] = current_data.frequency_peak;
        doc["alarm_status"] = current_data.alarm_status;
        doc["temperature"] = current_data.temperature;
        
        String log_entry;
        serializeJson(doc, log_entry);
        
        // Guardar en SD si está disponible
        if (SD.begin(SD_CS_PIN)) {
            String filename = "/vibration_" + String(year()) + 
                             String(month()) + String(day()) + ".json";
            File log_file = SD.open(filename, FILE_APPEND);
            if (log_file) {
                log_file.println(log_entry);
                log_file.close();
            }
        }
        
        Serial.printf("Log guardado - RMS: %.2f,%.2f,%.2f g\n", 
                     current_data.rms_x, current_data.rms_y, current_data.rms_z);
    }
    
    void processModbusComm() {
        // Comunicación Modbus para integración con sistemas SCADA
        // Registros Modbus para datos de vibración
        static uint16_t modbus_registers[20];
        
        // Convertir datos a registros Modbus (16-bit)
        modbus_registers[0] = (uint16_t)(current_data.rms_x * 1000);  // RMS X en milli-g
        modbus_registers[1] = (uint16_t)(current_data.rms_y * 1000);  // RMS Y en milli-g
        modbus_registers[2] = (uint16_t)(current_data.rms_z * 1000);  // RMS Z en milli-g
        modbus_registers[3] = (uint16_t)(current_data.peak_x * 1000); // Peak X en milli-g
        modbus_registers[4] = (uint16_t)(current_data.peak_y * 1000); // Peak Y en milli-g
        modbus_registers[5] = (uint16_t)(current_data.peak_z * 1000); // Peak Z en milli-g
        modbus_registers[6] = (uint16_t)(current_data.frequency_peak * 10); // Freq en deci-Hz
        modbus_registers[7] = (uint16_t)(current_data.temperature * 100);   // Temp en centi-°C
        modbus_registers[8] = current_data.alarm_status;
        modbus_registers[9] = health_status.samples_per_second;
        modbus_registers[10] = (uint16_t)(health_status.uptime_seconds & 0xFFFF);
        modbus_registers[11] = (uint16_t)(health_status.uptime_seconds >> 16);
        
        // En aplicación real, responder a consultas Modbus aquí
    }
    
    String generateIndustrialDashboard() {
        return R"(


    
    
    


    

        

            
🏭 SISTEMA DE MONITOREO INDUSTRIAL
            
Análisis de Vibración en Tiempo Real - ESP32 + MPU6050
        
        
        

            

                
📊 Vibración RMS
                

                    Eje X:
                    0.00 g
                
                

                    Eje Y:
                    0.00 g
                
                

                    Eje Z:
                    0.00 g
                
            
            
            

                
⚡ Picos Máximos
                

                    Peak X:
                    0.00 g
                
                

                    Peak Y:
                    0.00 g
                
                

                    Peak Z:
                    0.00 g
                
            
            
            

                
🌡️ Estado del Sistema
                

                    Estado:
                    Normal
                
                

                    Frecuencia:
                    0 Hz
                
                

                    Temperatura:
                    0°C
                
                

                    Normal
                    Alerta
                    Alarma
                
            
            
            

                
⚙️ Información de Máquina
                

                    Nombre:
                    Cargando...
                
                

                    RPM Nominal:
                    0
                
                

                    Tiempo Activo:
                    0h 0m
                
            
        
        
        

            
📈 Espectro de Frecuencias
            
        
    

    

)";
    }
    
    void loadMachineProfile() {
        // Configuración por defecto
        strcpy(machine_config.name, "Maquina Industrial");
        machine_config.normal_rms[0] = 1.0;   // 1g RMS normal
        machine_config.normal_rms[1] = 1.0;
        machine_config.normal_rms[2] = 1.0;
        machine_config.warning_factor = 1.5;  // 1.5x normal = advertencia
        machine_config.alarm_factor = 3.0;    // 3x normal = alarma
        machine_config.rpm_nominal = 1800;    // RPM típicos
        machine_config.active = true;
        
        // Cargar desde SPIFFS si existe
        if (SPIFFS.exists("/machine_config.json")) {
            File config_file = SPIFFS.open("/machine_config.json", "r");
            if (config_file) {
                DynamicJsonDocument doc(1024);
                deserializeJson(doc, config_file);
                
                if (doc.containsKey("name")) {
                    strncpy(machine_config.name, doc["name"], 31);
                }
                if (doc.containsKey("normal_rms")) {
                    machine_config.normal_rms[0] = doc["normal_rms"];
                    machine_config.normal_rms[1] = doc["normal_rms"];
                    machine_config.normal_rms[2] = doc["normal_rms"];
                }
                if (doc.containsKey("warning_factor")) {
                    machine_config.warning_factor = doc["warning_factor"];
                }
                if (doc.containsKey("alarm_factor")) {
                    machine_config.alarm_factor = doc["alarm_factor"];
                }
                if (doc.containsKey("rpm_nominal")) {
                    machine_config.rpm_nominal = doc["rpm_nominal"];
                }
                
                config_file.close();
                Serial.println("Configuración de máquina cargada");
            }
        }
    }
    
    void saveMachineProfile() {
        DynamicJsonDocument doc(1024);
        doc["name"] = machine_config.name;
        doc["normal_rms"] = machine_config.normal_rms[0];
        doc["warning_factor"] = machine_config.warning_factor;
        doc["alarm_factor"] = machine_config.alarm_factor;
        doc["rpm_nominal"] = machine_config.rpm_nominal;
        doc["active"] = machine_config.active;
        
        File config_file = SPIFFS.open("/machine_config.json", "w");
        if (config_file) {
            serializeJson(doc, config_file);
            config_file.close();
            Serial.println("Configuración de máquina guardada");
        }
    }
    
    void updateSystemTime() {
        if (WiFi.status() == WL_CONNECTED) {
            timeClient.update();
            setTime(timeClient.getEpochTime());
            Serial.printf("Hora sincronizada: %02d:%02d:%02d\n", 
                         hour(), minute(), second());
        }
    }
};

// Instancia global del sistema
IndustrialVibrationMonitor vibration_monitor;

void setup() {
    // Inicializar sistema industrial
    if (!vibration_monitor.initializeSystem()) {
        Serial.println("ERROR CRÍTICO: Sistema no inicializado");
        Serial.println("Verificar conexiones de hardware");
        
        // Parpadear LED de error
        pinMode(LED_BUILTIN, OUTPUT);
        while (1) {
            digitalWrite(LED_BUILTIN, HIGH);
            delay(200);
            digitalWrite(LED_BUILTIN, LOW);
            delay(200);
        }
    }
    
    Serial.println("=== SISTEMA INDUSTRIAL OPERATIVO ===");
    Serial.println("Monitor de vibración iniciado correctamente");
    Serial.printf("Acceso web: http://%s\n", WiFi.localIP().toString().c_str());
    Serial.println("Frecuencia de muestreo: 1 kHz");
    Serial.println("Análisis espectral activo");
    Serial.println("Sistema de alarmas operativo");
    Serial.println("======================================");
}

void loop() {
    // Ejecutar loop principal del sistema industrial
    vibration_monitor.processIndustrialLoop();
}