Dual-Channel Signal Generator

typedef struct {
  uint8_t dacPin;                    // GPIO pin (25 or 26)
  
  volatile uint32_t phaseAcc;        // 32-bit phase accumulator
  volatile uint32_t phaseStep;       // Frequency control
  volatile bool enabled;             // Channel on/off
  
  uint8_t waveTableA[256];          // Double buffering for
  uint8_t waveTableB[256];          // glitch-free updates
  volatile uint8_t* activeWaveTable; // Currently active table
  
  hw_timer_t* timer;                // Dedicated hardware timer
  portMUX_TYPE mux;                 // Critical section protection
} SignalChannel;

// Two independent channels
SignalChannel ch1 = { DAC1_PIN, 0, 0, false, {}, {}, nullptr, nullptr,
                      portMUX_INITIALIZER_UNLOCKED };
SignalChannel ch2 = { DAC2_PIN, 0, 0, false, {}, {}, nullptr, nullptr,
                      portMUX_INITIALIZER_UNLOCKED };

void generateWaveToTable(uint8_t* table, const char* type, 
                        float amplitude, float offset) {
  amplitude = constrain(amplitude, 0, 255);
  offset = constrain(offset, 0, 255);
  
  for (int i = 0; i < 256; i++) {
    float val = 0;
    float angle = (2.0 * PI * i) / 256.0;
    
    if (strcmp(type, "SINE") == 0) {
      val = (sin(angle) + 1) * 0.5;  // 0 to 1
    }
    else if (strcmp(type, "SQUARE") == 0) {
      val = (i < 128) ? 1.0 : 0.0;
    }
    else if (strcmp(type, "TRIANGLE") == 0) {
      val = (i < 128) ? (2.0 * i / 256.0) : (2.0 - (2.0 * i / 256.0));
    }
    else if (strcmp(type, "SAW") == 0) {
      val = (float)i / 256.0;
    }
    else if (strcmp(type, "DC") == 0) {
      val = 0;  // DC offset only
    }
    
    // Scale and offset
    table[i] = (uint8_t)constrain((val * amplitude) + offset, 0, 255);
  }
}

void IRAM_ATTR onTimerCh1() {
  if (!ch1.enabled) return;
  
  // Increment phase accumulator
  ch1.phaseAcc += ch1.phaseStep;
  
  // Extract index from upper 8 bits (bits 16-23)
  uint8_t idx = ch1.phaseAcc >> 16;
  
  // Output sample to DAC
  dac_output_voltage(DAC_CHANNEL_1, ch1.activeWaveTable[idx]);
}

void IRAM_ATTR onTimerCh2() {
  if (!ch2.enabled) return;
  
  ch2.phaseAcc += ch2.phaseStep;
  uint8_t idx = ch2.phaseAcc >> 16;
  dac_output_voltage(DAC_CHANNEL_2, ch2.activeWaveTable[idx]);
}

#define SAMPLE_RATE 40000
#define TIMER_DIVIDER 80
#define TIMER_INTERVAL_US (1000000 / SAMPLE_RATE)  // 25 µs

void initChannel(SignalChannel* ch, int timerID, void (*isr)()) {
  // Initialize with default sine wave
  generateWaveToTable(ch->waveTableA, "SINE", 255, 0);
  ch->activeWaveTable = ch->waveTableA;
  
  // Configure hardware timer
  ch->timer = timerBegin(timerID, TIMER_DIVIDER, true);
  timerAttachInterrupt(ch->timer, isr, true);
  timerAlarmWrite(ch->timer, TIMER_INTERVAL_US, true);
  timerAlarmEnable(ch->timer);
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  
  // Initialize both channels with different timers
  initChannel(&ch1, 0, onTimerCh1);  // Timer 0
  initChannel(&ch2, 2, onTimerCh2);  // Timer 2
  
  // Enable DAC hardware
  dac_output_enable(DAC_CHANNEL_1);
  dac_output_enable(DAC_CHANNEL_2);
  
  Serial.println("Generador listo - CH1 y CH2 totalmente independientes");
}

void processCommand(String cmd) {
  int channel;
  char wave[10];
  float freq;
  int enable;
  float amplitude;
  float offset;
  
  // Parse command string
  if (sscanf(cmd.c_str(), "CH%d %s %f %d %f %f",
             &channel, wave, &freq, &enable, &amplitude, &offset) != 6)
    return;
  
  SignalChannel* ch = (channel == 1) ? &ch1 : &ch2;
  
  // Generate new wavetable in inactive buffer (glitch-free)
  uint8_t* newTable = (ch->activeWaveTable == ch->waveTableA) ?
                      ch->waveTableB : ch->waveTableA;
  generateWaveToTable(newTable, wave, amplitude, offset);
  
  // Critical section: update all parameters atomically
  portENTER_CRITICAL(&ch->mux);
  ch->enabled = false;                          // Stop output momentarily
  ch->phaseAcc = 0;                            // Reset phase
  ch->phaseStep = (uint32_t)((freq * 256 * 65536.0) / 40000);
  ch->activeWaveTable = newTable;              // Switch to new table
  ch->enabled = (bool)enable;
  portEXIT_CRITICAL(&ch->mux);
}

void loop() {
  if (Serial.available()) {
    String cmd = Serial.readStringUntil('\n');
    cmd.trim();
    
    if (cmd.length() > 0) {
      processCommand(cmd);
      Serial.println("OK");
    }
  }
}