DAC: Salida analógica en ESP32

/**
 * Configuración básica del DAC en ESP32
 * Autor: Curso ESP32 Mecatrónica UNAM
 * Descripción: Control preciso de salida analógica
 */

// Pines DAC del ESP32
const int DAC1_PIN = 25;  // Canal 1
const int DAC2_PIN = 26;  // Canal 2

// Clase para manejo avanzado del DAC
class ESP32_DAC {
private:
    int dac_channel;
    int current_value;
    float voltage_reference;
    
public:
    ESP32_DAC(int channel) {
        dac_channel = channel;
        current_value = 0;
        voltage_reference = 3.3;  // Voltaje de referencia ESP32
    }
    
    void initialize() {
        // Configurar el pin como salida DAC
        pinMode(dac_channel, OUTPUT);
        
        // Establecer valor inicial a 0V
        setVoltage(0.0);
        
        Serial.printf("DAC inicializado en GPIO%d\n", dac_channel);
        Serial.printf("Rango: 0V - %.2fV\n", voltage_reference);
        Serial.printf("Resolución: %.2fmV por paso\n", 
                      (voltage_reference / 255.0) * 1000);
    }
    
    void setValue(int digital_value) {
        // Limitar valor entre 0 y 255
        digital_value = constrain(digital_value, 0, 255);
        
        // Escribir al DAC
        dacWrite(dac_channel, digital_value);
        current_value = digital_value;
        
        Serial.printf("DAC%d: Código=%d, Voltaje=%.3fV\n", 
                      (dac_channel == 25) ? 1 : 2,
                      digital_value, 
                      getCurrentVoltage());
    }
    
    void setVoltage(float target_voltage) {
        // Limitar voltaje al rango válido
        target_voltage = constrain(target_voltage, 0.0, voltage_reference);
        
        // Convertir voltaje a código digital
        int digital_code = round((target_voltage / voltage_reference) * 255.0);
        
        setValue(digital_code);
    }
    
    void setPercentage(float percentage) {
        // Limitar porcentaje entre 0% y 100%
        percentage = constrain(percentage, 0.0, 100.0);
        
        // Convertir porcentaje a código digital
        int digital_code = round((percentage / 100.0) * 255.0);
        
        setValue(digital_code);
    }
    
    float getCurrentVoltage() {
        return (current_value / 255.0) * voltage_reference;
    }
    
    int getCurrentValue() {
        return current_value;
    }
    
    float getCurrentPercentage() {
        return (current_value / 255.0) * 100.0;
    }
    
    void printStatus() {
        Serial.println("========== ESTADO DAC ==========");
        Serial.printf("Canal: GPIO%d\n", dac_channel);
        Serial.printf("Código Digital: %d/255\n", current_value);
        Serial.printf("Voltaje Salida: %.3fV\n", getCurrentVoltage());
        Serial.printf("Porcentaje: %.1f%%\n", getCurrentPercentage());
        Serial.printf("Resolución: %.2fmV/LSB\n", 
                      (voltage_reference / 255.0) * 1000);
        Serial.println("==============================\n");
    }
};

// Instanciar objetos DAC
ESP32_DAC dac1(DAC1_PIN);
ESP32_DAC dac2(DAC2_PIN);

void setup() {
    Serial.begin(115200);
    Serial.println("=== SISTEMA DAC ESP32 ===");
    
    // Inicializar ambos canales DAC
    dac1.initialize();
    dac2.initialize();
    
    Serial.println("Sistema DAC listo para usar");
    Serial.println("Comandos disponibles:");
    Serial.println("- 'V1 2.5' : Establecer DAC1 a 2.5V");
    Serial.println("- 'P2 75'  : Establecer DAC2 a 75%");
    Serial.println("- 'C1 128' : Establecer DAC1 código 128");
    Serial.println("- 'STATUS' : Mostrar estado de ambos DAC");
    Serial.println("========================");
}

void loop() {
    // Demostración automática - generar rampa en DAC1
    static unsigned long last_update = 0;
    static int ramp_value = 0;
    static int direction = 1;
    
    if (millis() - last_update > 50) {  // Actualizar cada 50ms
        dac1.setValue(ramp_value);
        
        ramp_value += direction * 5;
        if (ramp_value >= 255) {
            direction = -1;
        } else if (ramp_value <= 0) {
            direction = 1;
        }
        
        last_update = millis();
    }
    
    // Procesar comandos serie
    processSerialCommands();
    
    // Estado cada 2 segundos
    static unsigned long last_status = 0;
    if (millis() - last_status > 2000) {
        Serial.printf("DAC1: %.2fV | DAC2: %.2fV\n", 
                      dac1.getCurrentVoltage(), 
                      dac2.getCurrentVoltage());
        last_status = millis();
    }
}

void processSerialCommands() {
    if (Serial.available()) {
        String command = Serial.readStringUntil('\n');
        command.trim();
        command.toUpperCase();
        
        if (command.startsWith("V1 ")) {
            float voltage = command.substring(3).toFloat();
            dac1.setVoltage(voltage);
        } else if (command.startsWith("V2 ")) {
            float voltage = command.substring(3).toFloat();
            dac2.setVoltage(voltage);
        } else if (command.startsWith("P1 ")) {
            float percentage = command.substring(3).toFloat();
            dac1.setPercentage(percentage);
        } else if (command.startsWith("P2 ")) {
            float percentage = command.substring(3).toFloat();
            dac2.setPercentage(percentage);
        } else if (command.startsWith("C1 ")) {
            int code = command.substring(3).toInt();
            dac1.setValue(code);
        } else if (command.startsWith("C2 ")) {
            int code = command.substring(3).toInt();
            dac2.setValue(code);
        } else if (command == "STATUS") {
            dac1.printStatus();
            dac2.printStatus();
        } else if (command == "HELP") {
            Serial.println("Comandos disponibles:");
            Serial.println("V1/V2 [voltaje] - Establecer voltaje (0.0-3.3V)");
            Serial.println("P1/P2 [porcentaje] - Establecer porcentaje (0-100%)");
            Serial.println("C1/C2 [código] - Establecer código digital (0-255)");
            Serial.println("STATUS - Mostrar estado completo");
        }
    }
}

/**
 * Generador de Formas de Onda con DAC ESP32
 * Genera señales sinusoidales, triangulares, cuadradas y diente de sierra
 */

#include 

enum WaveformType {
    SINE,
    TRIANGLE,
    SQUARE,
    SAWTOOTH,
    NOISE
};

class WaveformGenerator {
private:
    int dac_pin;
    WaveformType current_waveform;
    float frequency;
    float amplitude;
    float offset;
    float phase;
    unsigned long last_update;
    uint32_t sample_counter;
    
    // Tabla lookup para seno (optimización)
    static const int SINE_TABLE_SIZE = 256;
    uint8_t sine_table[SINE_TABLE_SIZE];
    bool sine_table_initialized;
    
public:
    WaveformGenerator(int pin) {
        dac_pin = pin;
        current_waveform = SINE;
        frequency = 1.0;  // 1 Hz por defecto
        amplitude = 1.0;  // Amplitud completa
        offset = 0.5;     // Centrado en 1.65V
        phase = 0.0;
        last_update = 0;
        sample_counter = 0;
        sine_table_initialized = false;
        
        initializeSineTable();
    }
    
    void initializeSineTable() {
        for (int i = 0; i < SINE_TABLE_SIZE; i++) {
            float angle = (2.0 * PI * i) / SINE_TABLE_SIZE;
            sine_table[i] = (uint8_t)((sin(angle) + 1.0) * 127.5);
        }
        sine_table_initialized = true;
    }
    
    void setWaveform(WaveformType type) {
        current_waveform = type;
        sample_counter = 0;  // Reset counter
        Serial.printf("Forma de onda cambiada a: %s\n", 
                      getWaveformName(type).c_str());
    }
    
    void setFrequency(float freq_hz) {
        frequency = constrain(freq_hz, 0.01, 1000.0);  // 0.01Hz - 1kHz
        Serial.printf("Frecuencia establecida: %.2f Hz\n", frequency);
    }
    
    void setAmplitude(float amp) {
        amplitude = constrain(amp, 0.0, 1.0);  // 0% - 100%
        Serial.printf("Amplitud establecida: %.1f%%\n", amplitude * 100);
    }
    
    void setOffset(float off) {
        offset = constrain(off, 0.0, 1.0);  // 0V - 3.3V (normalizado)
        Serial.printf("Offset establecido: %.3fV\n", offset * 3.3);
    }
    
    void setPhase(float phase_degrees) {
        phase = fmod(phase_degrees, 360.0) * PI / 180.0;  // Convertir a radianes
        Serial.printf("Fase establecida: %.1f°\n", phase_degrees);
    }
    
    void update(uint32_t sample_rate_hz = 10000) {
        unsigned long update_interval = 1000000 / sample_rate_hz;  // Microsegundos
        
        if (micros() - last_update >= update_interval) {
            uint8_t dac_value = generateSample();
            dacWrite(dac_pin, dac_value);
            
            sample_counter++;
            last_update = micros();
        }
    }
    
private:
    uint8_t generateSample() {
        float normalized_time = (float)sample_counter / (10000.0 / frequency);
        normalized_time += phase / (2.0 * PI);  // Aplicar fase
        
        float sample = 0.0;
        
        switch (current_waveform) {
            case SINE:
                sample = generateSine(normalized_time);
                break;
            case TRIANGLE:
                sample = generateTriangle(normalized_time);
                break;
            case SQUARE:
                sample = generateSquare(normalized_time);
                break;
            case SAWTOOTH:
                sample = generateSawtooth(normalized_time);
                break;
            case NOISE:
                sample = generateNoise();
                break;
        }
        
        // Aplicar amplitud y offset
        sample = (sample * amplitude) + offset;
        sample = constrain(sample, 0.0, 1.0);
        
        return (uint8_t)(sample * 255);
    }
    
    float generateSine(float time) {
        int index = (int)(fmod(time, 1.0) * SINE_TABLE_SIZE) % SINE_TABLE_SIZE;
        return (sine_table[index] / 255.0);
    }
    
    float generateTriangle(float time) {
        float phase = fmod(time, 1.0);
        if (phase < 0.5) {
            return phase * 2.0;  // Subida
        } else {
            return 2.0 - (phase * 2.0);  // Bajada
        }
    }
    
    float generateSquare(float time) {
        float phase = fmod(time, 1.0);
        return (phase < 0.5) ? 0.0 : 1.0;
    }
    
    float generateSawtooth(float time) {
        return fmod(time, 1.0);
    }
    
    float generateNoise() {
        return random(0, 256) / 255.0;
    }
    
    String getWaveformName(WaveformType type) {
        switch (type) {
            case SINE: return "Sinusoidal";
            case TRIANGLE: return "Triangular";
            case SQUARE: return "Cuadrada";
            case SAWTOOTH: return "Diente de Sierra";
            case NOISE: return "Ruido";
            default: return "Desconocida";
        }
    }
    
public:
    void printStatus() {
        Serial.println("========== GENERADOR DE ONDAS ==========");
        Serial.printf("Pin DAC: GPIO%d\n", dac_pin);
        Serial.printf("Forma de onda: %s\n", getWaveformName(current_waveform).c_str());
        Serial.printf("Frecuencia: %.2f Hz\n", frequency);
        Serial.printf("Amplitud: %.1f%% (%.2fV p-p)\n", 
                      amplitude * 100, amplitude * 3.3);
        Serial.printf("Offset: %.3fV\n", offset * 3.3);
        Serial.printf("Fase: %.1f°\n", phase * 180.0 / PI);
        Serial.printf("Muestras generadas: %lu\n", sample_counter);
        Serial.println("=======================================\n");
    }
};

WaveformGenerator generator1(25);  // DAC1
WaveformGenerator generator2(26);  // DAC2

void setup() {
    Serial.begin(115200);
    Serial.println("=== GENERADOR DE FORMAS DE ONDA ===");
    Serial.println("Comandos disponibles:");
    Serial.println("SINE/TRIANGLE/SQUARE/SAWTOOTH/NOISE - Seleccionar forma");
    Serial.println("FREQ [Hz] - Establecer frecuencia");
    Serial.println("AMP [0.0-1.0] - Establecer amplitud");
    Serial.println("OFFSET [0.0-1.0] - Establecer offset");
    Serial.println("PHASE [grados] - Establecer fase");
    Serial.println("STATUS - Mostrar estado");
    Serial.println("===================================");
    
    // Configuración inicial
    generator1.setFrequency(2.0);      // 2 Hz
    generator1.setAmplitude(0.8);      // 80%
    generator1.setOffset(0.5);         // 1.65V
    
    generator2.setWaveform(TRIANGLE);
    generator2.setFrequency(0.5);      // 0.5 Hz
}

void loop() {
    // Actualizar generadores
    generator1.update(8000);  // 8kHz sample rate
    generator2.update(8000);
    
    // Procesar comandos
    processWaveformCommands();
    
    // Status periódico
    static unsigned long last_status = 0;
    if (millis() - last_status > 5000) {
        generator1.printStatus();
        last_status = millis();
    }
}

void processWaveformCommands() {
    if (Serial.available()) {
        String command = Serial.readStringUntil('\n');
        command.trim();
        command.toUpperCase();
        
        if (command == "SINE") {
            generator1.setWaveform(SINE);
        } else if (command == "TRIANGLE") {
            generator1.setWaveform(TRIANGLE);
        } else if (command == "SQUARE") {
            generator1.setWaveform(SQUARE);
        } else if (command == "SAWTOOTH") {
            generator1.setWaveform(SAWTOOTH);
        } else if (command == "NOISE") {
            generator1.setWaveform(NOISE);
        } else if (command.startsWith("FREQ ")) {
            float freq = command.substring(5).toFloat();
            generator1.setFrequency(freq);
        } else if (command.startsWith("AMP ")) {
            float amp = command.substring(4).toFloat();
            generator1.setAmplitude(amp);
        } else if (command.startsWith("OFFSET ")) {
            float offset = command.substring(7).toFloat();
            generator1.setOffset(offset);
        } else if (command.startsWith("PHASE ")) {
            float phase = command.substring(6).toFloat();
            generator1.setPhase(phase);
        } else if (command == "STATUS") {
            generator1.printStatus();
        }
    }
}

/**
 * Sistema de Filtrado y Acondicionamiento para DAC
 * Implementa filtros digitales y calibración automática
 */

class DACFilter {
private:
    static const int BUFFER_SIZE = 16;
    float output_buffer[BUFFER_SIZE];
    int buffer_index;
    bool buffer_full;
    
    // Coeficientes del filtro pasa-bajos Butterworth
    float alpha;  // Factor de suavizado
    float filtered_output;
    
    // Calibración
    struct CalibrationData {
        float gain_error;
        float offset_error;
        bool calibrated;
    } cal_data;
    
public:
    DACFilter(float cutoff_frequency = 100.0) {  // 100Hz por defecto
        buffer_index = 0;
        buffer_full = false;
        filtered_output = 0.0;
        
        // Calcular coeficiente del filtro
        float rc = 1.0 / (2.0 * PI * cutoff_frequency);
        float dt = 1.0 / 10000.0;  // Asumiendo 10kHz de muestreo
        alpha = dt / (rc + dt);
        
        memset(output_buffer, 0, sizeof(output_buffer));
        
        cal_data.gain_error = 1.0;
        cal_data.offset_error = 0.0;
        cal_data.calibrated = false;
    }
    
    uint8_t processOutput(uint8_t raw_dac_value) {
        // Convertir a rango 0.0-1.0
        float normalized = raw_dac_value / 255.0;
        
        // Aplicar filtro pasa-bajos IIR
        filtered_output = alpha * normalized + (1.0 - alpha) * filtered_output;
        
        // Aplicar calibración si está disponible
        float calibrated = applyCalibration(filtered_output);
        
        // Almacenar en buffer para análisis
        addToBuffer(calibrated);
        
        // Convertir de vuelta a 8 bits
        return (uint8_t)(constrain(calibrated, 0.0, 1.0) * 255);
    }
    
    void addToBuffer(float value) {
        output_buffer[buffer_index] = value;
        buffer_index = (buffer_index + 1) % BUFFER_SIZE;
        
        if (!buffer_full && buffer_index == 0) {
            buffer_full = true;
        }
    }
    
    float applyCalibration(float input) {
        if (cal_data.calibrated) {
            return (input * cal_data.gain_error) + cal_data.offset_error;
        }
        return input;
    }
    
    void calibrate(float expected_low, float measured_low, 
                   float expected_high, float measured_high) {
        // Calibración de 2 puntos
        float expected_span = expected_high - expected_low;
        float measured_span = measured_high - measured_low;
        
        if (measured_span != 0) {
            cal_data.gain_error = expected_span / measured_span;
            cal_data.offset_error = expected_low - (measured_low * cal_data.gain_error);
            cal_data.calibrated = true;
            
            Serial.println("Calibración completada:");
            Serial.printf("Ganancia: %.6f\n", cal_data.gain_error);
            Serial.printf("Offset: %.6f\n", cal_data.offset_error);
        }
    }
    
    float getFilteredOutput() {
        return filtered_output;
    }
    
    float getRMS() {
        if (!buffer_full && buffer_index == 0) return 0.0;
        
        float sum_squares = 0.0;
        int count = buffer_full ? BUFFER_SIZE : buffer_index;
        
        for (int i = 0; i < count; i++) {
            sum_squares += output_buffer[i] * output_buffer[i];
        }
        
        return sqrt(sum_squares / count);
    }
    
    float getAverage() {
        if (!buffer_full && buffer_index == 0) return 0.0;
        
        float sum = 0.0;
        int count = buffer_full ? BUFFER_SIZE : buffer_index;
        
        for (int i = 0; i < count; i++) {
            sum += output_buffer[i];
        }
        
        return sum / count;
    }
    
    void printFilterStatus() {
        Serial.println("========== ESTADO DEL FILTRO ==========");
        Serial.printf("Frecuencia de corte: %.1f Hz\n", 
                      1.0 / (2.0 * PI * (1.0 - alpha) / alpha / (1.0/10000.0)));
        Serial.printf("Salida filtrada: %.3f (%.1fV)\n", 
                      filtered_output, filtered_output * 3.3);
        Serial.printf("Promedio: %.3f (%.1fV)\n", 
                      getAverage(), getAverage() * 3.3);
        Serial.printf("RMS: %.3f (%.1fV)\n", 
                      getRMS(), getRMS() * 3.3);
        Serial.printf("Calibrado: %s\n", 
                      cal_data.calibrated ? "Sí" : "No");
        
        if (cal_data.calibrated) {
            Serial.printf("Factor de ganancia: %.6f\n", cal_data.gain_error);
            Serial.printf("Offset: %.6f\n", cal_data.offset_error);
        }
        
        Serial.println("=====================================\n");
    }
};

// Sistema completo de DAC con filtrado
class HighPrecisionDAC {
private:
    int dac_pin;
    DACFilter* filter;
    uint8_t target_value;
    uint8_t current_output;
    
public:
    HighPrecisionDAC(int pin, float filter_frequency = 100.0) {
        dac_pin = pin;
        filter = new DACFilter(filter_frequency);
        target_value = 0;
        current_output = 0;
    }
    
    ~HighPrecisionDAC() {
        delete filter;
    }
    
    void setTargetValue(uint8_t value) {
        target_value = value;
    }
    
    void setTargetVoltage(float voltage) {
        voltage = constrain(voltage, 0.0, 3.3);
        target_value = (uint8_t)((voltage / 3.3) * 255);
    }
    
    void update() {
        // Procesar a través del filtro
        current_output = filter->processOutput(target_value);
        
        // Escribir al DAC
        dacWrite(dac_pin, current_output);
    }
    
    void calibrate(float low_voltage, float high_voltage) {
        Serial.println("Iniciando calibración...");
        
        // Punto bajo
        setTargetVoltage(low_voltage);
        delay(1000);  // Estabilizar
        Serial.printf("Establecer %.2fV y medir voltaje real...\n", low_voltage);
        
        // En una implementación real, aquí se leería un ADC externo
        // Por simplicidad, simulamos medición
        float measured_low = low_voltage * 0.98;  // Error simulado
        
        // Punto alto
        setTargetVoltage(high_voltage);
        delay(1000);
        Serial.printf("Establecer %.2fV y medir voltaje real...\n", high_voltage);
        
        float measured_high = high_voltage * 1.02;  // Error simulado
        
        // Aplicar calibración
        filter->calibrate(low_voltage/3.3, measured_low/3.3, 
                         high_voltage/3.3, measured_high/3.3);
    }
    
    void printStatus() {
        float target_voltage = (target_value / 255.0) * 3.3;
        float output_voltage = (current_output / 255.0) * 3.3;
        
        Serial.println("========== DAC DE ALTA PRECISIÓN ==========");
        Serial.printf("Pin: GPIO%d\n", dac_pin);
        Serial.printf("Objetivo: %d (%.3fV)\n", target_value, target_voltage);
        Serial.printf("Salida: %d (%.3fV)\n", current_output, output_voltage);
        Serial.printf("Error: %.3fV (%.2f%%)\n", 
                      output_voltage - target_voltage,
                      ((output_voltage - target_voltage) / target_voltage) * 100);
        
        filter->printFilterStatus();
        Serial.println("==========================================\n");
    }
    
    DACFilter* getFilter() {
        return filter;
    }
};

HighPrecisionDAC precision_dac(25, 50.0);  // 50Hz filtro

void setup() {
    Serial.begin(115200);
    Serial.println("=== SISTEMA DAC DE ALTA PRECISIÓN ===");
    Serial.println("Comandos:");
    Serial.println("CAL - Ejecutar calibración");
    Serial.println("SET [voltaje] - Establecer voltaje objetivo");
    Serial.println("STATUS - Mostrar estado completo");
    Serial.println("====================================");
    
    // Demostración automática
    Serial.println("Iniciando demostración...");
}

void loop() {
    // Actualizar sistema
    precision_dac.update();
    
    // Demostración automática - onda lenta
    static unsigned long last_demo = 0;
    if (millis() - last_demo > 2000) {
        static float demo_voltage = 0.5;
        static float direction = 0.5;
        
        demo_voltage += direction;
        if (demo_voltage >= 3.0 || demo_voltage <= 0.5) {
            direction = -direction;
        }
        
        precision_dac.setTargetVoltage(demo_voltage);
        last_demo = millis();
    }
    
    // Procesar comandos
    processPrecisionCommands();
    
    // Status periódico
    static unsigned long last_status = 0;
    if (millis() - last_status > 5000) {
        precision_dac.printStatus();
        last_status = millis();
    }
}

void processPrecisionCommands() {
    if (Serial.available()) {
        String command = Serial.readStringUntil('\n');
        command.trim();
        command.toUpperCase();
        
        if (command == "CAL") {
            precision_dac.calibrate(0.5, 2.8);  // Calibrar entre 0.5V y 2.8V
        } else if (command.startsWith("SET ")) {
            float voltage = command.substring(4).toFloat();
            precision_dac.setTargetVoltage(voltage);
            Serial.printf("Objetivo establecido: %.3fV\n", voltage);
        } else if (command == "STATUS") {
            precision_dac.printStatus();
        }
    }
}