Mastering ESP32 PWM: From Basic Fading to Advanced Control with Arduino IDE

// Professional PWM channel diagnostic utility
void pwmHardwareDiagnostic() {
  Serial.println("\n=== ESP32 PWM HARDWARE ANALYSIS ===");
  
  // Determine ESP32 model (simplified approach)
  uint32_t chipId = 0;
  for(int i=0; i<17; i=i+8) {
    chipId |= ((ESP.getEfuseMac() >> (40-i)) & 0xff) << i;
  }
  
  Serial.printf("Chip ID: 0x%04X\n", (uint16_t)(chipId >> 16));
  
  // PWM capabilities based on model
  Serial.println("\nPWM Hardware Configuration:");
  
  #ifdef CONFIG_IDF_TARGET_ESP32
    Serial.println("- Model: ESP32");
    Serial.println("- Total PWM Channels: 16 (8 high-speed, 8 low-speed)");
    Serial.println("- Max Frequency (theoretical): 40 MHz");
    Serial.println("- Timer Groups: 4 (0-3) with 2 timers each");
  #elif CONFIG_IDF_TARGET_ESP32S2
    Serial.println("- Model: ESP32-S2");
    Serial.println("- Total PWM Channels: 8");
    Serial.println("- Max Frequency: 20 MHz");
    Serial.println("- Timer Groups: 4");
  #elif CONFIG_IDF_TARGET_ESP32S3
    Serial.println("- Model: ESP32-S3");
    Serial.println("- Total PWM Channels: 8");
    Serial.println("- Max Frequency: 20 MHz");
    Serial.println("- Timer Groups: 4");
  #elif CONFIG_IDF_TARGET_ESP32C3
    Serial.println("- Model: ESP32-C3");
    Serial.println("- Total PWM Channels: 6");
    Serial.println("- Max Frequency: 40 MHz");
    Serial.println("- Timer Groups: 2");
  #endif
  
  // Test actual frequency accuracy
  Serial.println("\nFrequency Accuracy Test (1 kHz target):");
  testFrequencyAccuracy(16, 1000, 8);
}

void testFrequencyAccuracy(uint8_t pin, uint32_t targetFreq, uint8_t resolution) {
  ledcAttach(pin, targetFreq, resolution);
  
  // Measure using timing-based estimation (in real use, use an oscilloscope)
  unsigned long start = micros();
  int pulses = 0;
  const int targetPulses = 1000;
  
  // Generate pulses and count
  for(int i = 0; i < targetPulses; i++) {
    ledcWrite(pin, 127); // 50% duty cycle
    delayMicroseconds(500); // Simplified timing
    pulses++;
  }
  unsigned long end = micros();
  
  float actualFreq = (pulses * 1000000.0) / (end - start);
  float errorPercent = abs(actualFreq - targetFreq) / targetFreq * 100;
  
  Serial.printf("  Target: %d Hz, Estimated: %.1f Hz, Error: %.1f%%\n", 
                targetFreq, actualFreq, errorPercent);
  
  ledcDetach(pin);
}

// Best for: Simple applications, Arduino compatibility, quick prototyping
void setupAnalogWriteExample() {
  const int ledPin = 16;
  pinMode(ledPin, OUTPUT);
  
  // Optional: Customize frequency and resolution (default: 1 kHz, 8-bit)
  analogWriteFrequency(ledPin, 5000);    // 5 kHz frequency
  analogWriteResolution(ledPin, 10);     // 10-bit resolution (0-1023)
}

void loopAnalogWriteExample() {
  // Simple fade effect
  for(int duty = 0; duty <= 1023; duty++) {
    analogWrite(16, duty);
    delay(5);
  }
}

// Best for: Precision control, multiple channels, advanced applications
class ProfessionalPWMController {
private:
  struct PWMChannel {
    uint8_t pin;
    uint8_t channel;
    uint32_t frequency;
    uint8_t resolution;
    bool isAttached;
  };
  
  PWMChannel channels[16];
  uint8_t channelCount = 0;
  
  // Channel allocation tracking
  bool usedChannels[16] = {false};
  bool usedTimers[4] = {false}; // ESP32 has 4 timers
  
public:
  // Allocate a PWM channel with optimal settings
  int allocateChannel(uint8_t pin, uint32_t freq, uint8_t resolution, 
                      const char* application = "general") {
    
    // Validate parameters
    if(!isValidPin(pin)) {
      Serial.printf("Error: GPIO %d cannot output PWM\n", pin);
      return -1;
    }
    
    // Calculate required timer
    int timer = calculateOptimalTimer(freq, resolution, application);
    if(timer < 0) {
      Serial.println("Error: No suitable timer available");
      return -1;
    }
    
    // Find available channel for this timer
    int channel = findAvailableChannelForTimer(timer);
    if(channel < 0) {
      Serial.println("Error: No channel available for selected timer");
      return -1;
    }
    
    // Configure the channel
    if(ledcAttachChannel(pin, freq, resolution, channel)) {
      channels[channelCount].pin = pin;
      channels[channelCount].channel = channel;
      channels[channelCount].frequency = freq;
      channels[channelCount].resolution = resolution;
      channels[channelCount].isAttached = true;
      
      usedChannels[channel] = true;
      usedTimers[timer] = true;
      channelCount++;
      
      Serial.printf("Allocated PWM: GPIO %d, Channel %d, %d Hz, %d-bit\n",
                    pin, channel, freq, resolution);
      return channel;
    }
    
    return -1;
  }
  
  // Set duty cycle with validation
  bool setDutyCycle(int channel, uint32_t duty) {
    if(channel < 0 || channel >= 16 || !channels[channel].isAttached) {
      return false;
    }
    
    uint32_t maxDuty = (1 << channels[channel].resolution) - 1;
    duty = min(duty, maxDuty); // Prevent overflow
    
    ledcWrite(channels[channel].pin, duty);
    return true;
  }
  
  // Advanced: Ramp duty cycle smoothly
  void rampDutyCycle(int channel, uint32_t targetDuty, uint32_t durationMs) {
    if(!channels[channel].isAttached) return;
    
    uint32_t currentDuty = getCurrentDuty(channel);
    uint32_t steps = durationMs / 10; // Update every 10ms
    uint32_t increment = (targetDuty - currentDuty) / steps;
    
    for(uint32_t i = 0; i < steps; i++) {
      currentDuty += increment;
      setDutyCycle(channel, currentDuty);
      delay(10);
    }
    setDutyCycle(channel, targetDuty); // Ensure exact target
  }
  
private:
  bool isValidPin(uint8_t pin) {
    // Check if pin can output PWM
    if(pin >= 34 && pin <= 39) return false; // Input-only pins
    return true;
  }
  
  int calculateOptimalTimer(uint32_t freq, uint8_t resolution, 
                           const char* application) {
    // Implementation based on application requirements
    if(strcmp(application, "motor") == 0) {
      return 0; // Timer 0 for motor control (higher priority)
    } else if(strcmp(application, "led") == 0) {
      return 1; // Timer 1 for LED control
    } else if(strcmp(application, "audio") == 0) {
      return 2; // Timer 2 for audio (if available)
    }
    return 0; // Default
  }
  
  int findAvailableChannelForTimer(int timer) {
    // Implementation to find first available channel for given timer
    // Channels 0-3 use Timer 0, 4-7 use Timer 1, etc.
    int startChannel = timer * 4;
    for(int i = startChannel; i < startChannel + 4; i++) {
      if(!usedChannels[i] && i < 16) return i;
    }
    return -1;
  }
  
  uint32_t getCurrentDuty(int channel) {
    // In a real implementation, you would track this
    return 0; // Placeholder
  }
};

// Automatic PWM configuration based on application
struct PWMConfig {
  const char* application;
  uint32_t minFreq;
  uint32_t maxFreq;
  uint8_t minRes;
  uint8_t maxRes;
  const char* notes;
};

PWMConfig configProfiles[] = {
  {"led_dimming", 100, 5000, 8, 12, "Higher freq eliminates visible flicker"},
  {"motor_control", 5000, 20000, 8, 10, "Above audible range, reduces ripple"},
  {"servo", 50, 50, 12, 16, "Standard 50Hz servo signal"},
  {"audio", 8000, 44100, 8, 12, "8kHz for speech, 44.1kHz for music"},
  {"power_switching", 20000, 100000, 8, 10, "High freq for smaller components"},
  {"thermal", 1, 100, 8, 8, "Slow frequency for thermal inertia"}
};

void configureOptimalPWM(uint8_t pin, const char* application) {
  Serial.printf("\nConfiguring PWM for: %s\n", application);
  
  PWMConfig* profile = nullptr;
  for(auto& p : configProfiles) {
    if(strcmp(p.application, application) == 0) {
      profile = &p;
      break;
    }
  }
  
  if(!profile) {
    Serial.println("Unknown application, using defaults");
    ledcAttach(pin, 1000, 8); // Default: 1 kHz, 8-bit
    return;
  }
  
  // Calculate optimal values
  uint32_t freq = (profile->minFreq + profile->maxFreq) / 2;
  uint8_t resolution = (profile->minRes + profile->maxRes) / 2;
  
  // Adjust based on ESP32 capabilities
  if(freq > 40000) {
    Serial.println("Warning: Frequency may exceed ESP32 capabilities");
    freq = 20000; // Safer limit
  }
  
  Serial.printf("Optimal settings: %d Hz, %d-bit resolution\n", freq, resolution);
  Serial.printf("Notes: %s\n", profile->notes);
  
  ledcAttach(pin, freq, resolution);
}

// Advanced multi-channel PWM controller with synchronization
class SynchronizedPWMController {
private:
  typedef struct {
    uint8_t pin;
    uint8_t channel;
    uint32_t frequency;
    uint8_t resolution;
    uint32_t phaseOffset; // Degrees (0-360)
  } SyncChannel;
  
  SyncChannel channels[4]; // Maximum 4 synchronized channels per timer
  uint8_t activeChannels = 0;
  uint8_t timerGroup = 0;
  
public:
  // Initialize synchronized PWM channels
  bool initializeSynchronized(uint8_t pins[], uint8_t count, 
                              uint32_t freq, uint8_t resolution) {
    if(count > 4 || count == 0) {
      Serial.println("Error: 1-4 channels supported for synchronization");
      return false;
    }
    
    // All channels must use the same timer (same frequency/resolution)
    for(int i = 0; i < count; i++) {
      // Assign sequential channels on the same timer
      uint8_t channel = i; // Channels 0-3 share Timer 0
      
      if(ledcAttachChannel(pins[i], freq, resolution, channel)) {
        channels[i].pin = pins[i];
        channels[i].channel = channel;
        channels[i].frequency = freq;
        channels[i].resolution = resolution;
        channels[i].phaseOffset = 0; // Default: no offset
        
        activeChannels++;
        
        // Calculate and set initial duty cycle for phase offset
        setPhaseOffset(i, 0);
      } else {
        Serial.printf("Failed to attach channel %d\n", i);
        return false;
      }
    }
    
    Serial.printf("Initialized %d synchronized PWM channels at %d Hz\n", 
                  activeChannels, freq);
    return true;
  }
  
  // Set phase offset between channels (0-360 degrees)
  void setPhaseOffset(uint8_t channelIndex, uint32_t degrees) {
    if(channelIndex >= activeChannels) return;
    
    degrees = degrees % 360;
    channels[channelIndex].phaseOffset = degrees;
    
    // For demonstration, we'll simulate phase offset
    // In real implementation, you'd use hardware features or precise timing
    Serial.printf("Channel %d phase offset: %d degrees\n", 
                  channelIndex, degrees);
  }
  
  // Create 3-phase PWM (for motor control)
  void setupThreePhase(uint8_t pinU, uint8_t pinV, uint8_t pinW, 
                       uint32_t freq, uint8_t resolution) {
    uint8_t pins[3] = {pinU, pinV, pinW};
    if(!initializeSynchronized(pins, 3, freq, resolution)) {
      return;
    }
    
    // Set 120-degree phase offsets for 3-phase
    setPhaseOffset(0, 0);    // Phase U: 0°
    setPhaseOffset(1, 120);  // Phase V: 120°
    setPhaseOffset(2, 240);  // Phase W: 240°
    
    Serial.println("3-phase PWM configured with 120° phase separation");
  }
  
  // Generate sine wave across multiple channels
  void generateSineWave(float amplitude, float frequencyHz) {
    uint32_t maxDuty = (1 << channels[0].resolution) - 1;
    uint32_t centerDuty = maxDuty / 2;
    uint32_t amplitudeDuty = (maxDuty * amplitude) / 2;
    
    unsigned long startTime = micros();
    
    while(true) {
      unsigned long currentTime = micros();
      float elapsedSeconds = (currentTime - startTime) / 1000000.0;
      
      for(int i = 0; i < activeChannels; i++) {
        // Calculate phase in radians
        float phase = 2 * PI * frequencyHz * elapsedSeconds + 
                     (channels[i].phaseOffset * PI / 180.0);
        
        // Calculate sine value
        float sineValue = sin(phase);
        
        // Convert to duty cycle
        uint32_t duty = centerDuty + (sineValue * amplitudeDuty);
        duty = constrain(duty, 0, maxDuty);
        
        ledcWrite(channels[i].pin, duty);
      }
      
      // Control update rate
      delayMicroseconds(100); // 10 kHz update rate
    }
  }
};

class ProfessionalLEDController {
private:
  uint8_t pwmChannel;
  uint8_t resolution;
  uint32_t maxDuty;
  
  // Gamma correction table for perceptually linear dimming
  uint16_t gammaTable[256];
  
  // Temperature compensation (LED brightness varies with temperature)
  float temperatureCoefficient = -0.003; // Typical -0.3%/°C
  float referenceTemp = 25.0; // °C
  
public:
  ProfessionalLEDController(uint8_t pin, uint32_t freq = 1000, 
                           uint8_t res = 12) {
    resolution = res;
    maxDuty = (1 << resolution) - 1;
    
    // Initialize gamma table (sRGB approximation)
    for(int i = 0; i < 256; i++) {
      float normalized = i / 255.0;
      float gammaCorrected = pow(normalized, 2.2);
      gammaTable[i] = gammaCorrected * maxDuty;
    }
    
    // Attach PWM channel
    pwmChannel = 0; // Would be allocated properly in real implementation
    ledcAttach(pin, freq, resolution);
  }
  
  // Set brightness with gamma correction (0-255)
  void setBrightness(uint8_t level, float temperature = 25.0) {
    if(level > 255) level = 255;
    
    // Apply gamma correction
    uint32_t duty = gammaTable[level];
    
    // Apply temperature compensation
    float tempAdjustment = 1.0 + (temperature - referenceTemp) * 
                          temperatureCoefficient;
    duty = duty * tempAdjustment;
    
    // Constrain to valid range
    duty = constrain(duty, 0, maxDuty);
    
    ledcWrite(pwmChannel, duty);
    
    Serial.printf("LED: Level=%d, Gamma Corrected Duty=%d, Temp Adjusted=%d\n",
                  level, gammaTable[level], duty);
  }
  
  // Smooth transition between brightness levels
  void transitionTo(uint8_t targetLevel, uint32_t durationMs, 
                    String easing = "linear") {
    uint8_t currentLevel = getCurrentBrightness();
    
    int steps = durationMs / 20; // Update every 20ms
    for(int i = 0; i <= steps; i++) {
      float progress = (float)i / steps;
      
      // Apply easing function
      float easedProgress;
      if(easing == "easeInOut") {
        easedProgress = easeInOutCubic(progress);
      } else if(easing == "easeOut") {
        easedProgress = easeOutCubic(progress);
      } else { // linear
        easedProgress = progress;
      }
      
      uint8_t intermediateLevel = currentLevel + 
                                  (targetLevel - currentLevel) * easedProgress;
      
      setBrightness(intermediateLevel);
      delay(20);
    }
    
    // Ensure exact target
    setBrightness(targetLevel);
  }
  
  // Flicker-free emergency/notification pulsing
  void pulseNotification(uint8_t baseLevel = 50, uint8_t pulseLevel = 200, 
                         uint32_t pulseDuration = 200) {
    uint8_t originalLevel = getCurrentBrightness();
    
    // Quick rise
    transitionTo(pulseLevel, 50, "easeOut");
    delay(pulseDuration);
    
    // Return to base
    transitionTo(baseLevel, 300, "easeInOut");
    
    // Optional: Return to original after delay
    delay(1000);
    transitionTo(originalLevel, 500);
  }
  
private:
  float easeInOutCubic(float x) {
    return x < 0.5 ? 4 * x * x * x : 1 - pow(-2 * x + 2, 3) / 2;
  }
  
  float easeOutCubic(float x) {
    return 1 - pow(1 - x, 3);
  }
  
  uint8_t getCurrentBrightness() {
    // In real implementation, track current brightness
    return 0;
  }
};

class MotorPWMController {
private:
  uint8_t pwmPin;
  uint8_t resolution;
  uint32_t frequency;
  uint32_t maxDuty;
  
  // Motor protection parameters
  uint32_t currentLimit = 2000; // mA
  uint32_t rampRate = 100; // Duty cycle units per second
  uint32_t deadTime = 10; // microseconds
  
  // State tracking
  uint32_t currentDuty = 0;
  uint32_t targetDuty = 0;
  unsigned long lastUpdate = 0;
  
public:
  MotorPWMController(uint8_t pin, uint32_t freq = 20000, 
                     uint8_t res = 10) {
    pwmPin = pin;
    frequency = freq;
    resolution = res;
    maxDuty = (1 << resolution) - 1;
    
    // High frequency for motor control (above audible range)
    ledcAttach(pin, freq, res);
    
    // Start with motor off
    ledcWrite(pin, 0);
    
    Serial.printf("Motor PWM: %d Hz, %d-bit, Max Duty: %d\n", 
                  freq, res, maxDuty);
  }
  
  // Set motor speed (0-100%)
  void setSpeed(float percent, bool immediate = false) {
    if(percent < 0) percent = 0;
    if(percent > 100) percent = 100;
    
    targetDuty = (percent / 100.0) * maxDuty;
    
    if(immediate) {
      currentDuty = targetDuty;
      applyDutyCycle(currentDuty);
    } else {
      // Ramped update handled in update() method
    }
  }
  
  // Call regularly in main loop for ramped control
  void update() {
    unsigned long now = millis();
    unsigned long elapsed = now - lastUpdate;
    
    if(elapsed >= 10) { // Update every 10ms
      if(currentDuty != targetDuty) {
        // Calculate maximum change based on ramp rate
        uint32_t maxChange = (rampRate * elapsed) / 1000;
        
        if(targetDuty > currentDuty) {
          currentDuty += min(maxChange, targetDuty - currentDuty);
        } else {
          currentDuty -= min(maxChange, currentDuty - targetDuty);
        }
        
        applyDutyCycle(currentDuty);
      }
      
      lastUpdate = now;
    }
  }
  
  // Emergency stop with braking
  void emergencyStop(bool brake = true) {
    if(brake) {
      // Active braking: short motor terminals
      // Implementation depends on motor driver
      Serial.println("Motor: Emergency brake engaged");
    } else {
      // Coast to stop
      setSpeed(0, true);
      Serial.println("Motor: Coasting to stop");
    }
  }
  
  // Generate sinusoidal commutation for brushless motors
  void generateSinusoidalCommutation(float electricalAngle, 
                                     float amplitude = 1.0) {
    // Calculate three-phase duty cycles
    float phaseU = sin(electricalAngle) * amplitude;
    float phaseV = sin(electricalAngle + 2 * PI / 3) * amplitude;
    float phaseW = sin(electricalAngle + 4 * PI / 3) * amplitude;
    
    // Convert to duty cycles (offset to 0-maxDuty range)
    uint32_t dutyU = (phaseU + 1.0) / 2.0 * maxDuty;
    uint32_t dutyV = (phaseV + 1.0) / 2.0 * maxDuty;
    uint32_t dutyW = (phaseW + 1.0) / 2.0 * maxDuty;
    
    // Apply duty cycles (assuming 3 PWM channels)
    // ledcWrite(pinU, dutyU);
    // ledcWrite(pinV, dutyV);
    // ledcWrite(pinW, dutyW);
  }
  
private:
  void applyDutyCycle(uint32_t duty) {
    duty = constrain(duty, 0, maxDuty);
    
    // Apply dead time (simplified)
    if(duty > 0 && duty < maxDuty) {
      // For H-bridge drivers, ensure complementary signals don't overlap
      // This is a simplified representation
    }
    
    ledcWrite(pwmPin, duty);
    
    // Monitor for current limiting (would interface with current sensor)
    monitorCurrent(duty);
  }
  
  void monitorCurrent(uint32_t duty) {
    // Interface with current sensor
    // Reduce duty cycle if current exceeds limit
    static uint32_t overcurrentCount = 0;
    
    // Simulated current reading (would be ADC read in real implementation)
    float simulatedCurrent = duty * (currentLimit / (float)maxDuty) * 1.2;
    
    if(simulatedCurrent > currentLimit) {
      overcurrentCount++;
      Serial.printf("Warning: Current limit exceeded (%d mA)\n", 
                    (int)simulatedCurrent);
      
      if(overcurrentCount > 5) {
        emergencyStop(false);
        Serial.println("Motor: Shutdown due to sustained overcurrent");
      }
    } else {
      overcurrentCount = 0;
    }
  }
};

// Reserve specific timer for critical PWM applications
bool reservePWMTimer(uint8_t timer, const char* owner) {
  static bool timerAllocated[4] = {false};
  static const char* timerOwners[4] = {"", "", "", ""};
  
  if(timer >= 4) return false;
  
  if(timerAllocated[timer]) {
    Serial.printf("Timer %d already allocated by: %s\n", 
                  timer, timerOwners[timer]);
    return false;
  }
  
  timerAllocated[timer] = true;
  timerOwners[timer] = owner;
  
  Serial.printf("Timer %d allocated for: %s\n", timer, owner);
  return true;
}

// When using Servo library, allocate different timer for PWM
void setupNonConflictingPWM() {
  // Reserve timer 0 for servos (if using Servo library)
  reservePWMTimer(0, "Servo_Library");
  
  // Use timer 1 for PWM
  reservePWMTimer(1, "LED_PWM");
  
  // Configure PWM on timer 1 (channels 4-7)
  ledcAttachChannel(16, 1000, 8, 4); // Channel 4 uses Timer 1
}

void pwmSignalDiagnostic(uint8_t pin, uint32_t freq, uint8_t resolution) {
  Serial.println("\n=== PWM SIGNAL DIAGNOSTIC ===");
  
  // Test basic functionality
  ledcAttach(pin, freq, resolution);
  
  // Test 50% duty cycle
  uint32_t midDuty = (1 << resolution) / 2;
  ledcWrite(pin, midDuty);
  
  Serial.printf("Testing GPIO %d at %d Hz, %d-bit resolution\n", 
                pin, freq, resolution);
  Serial.println("Expected signal: 50% duty cycle");
  
  // Measure actual output (simplified)
  Serial.println("\nConnect oscilloscope to:");
  Serial.printf("  - GPIO %d (signal)\n", pin);
  Serial.println("  - GND (ground reference)");
  
  Serial.println("\nExpected measurements:");
  Serial.printf("  Frequency: %.1f Hz (tolerance ±5%%)\n", (float)freq);
  
  float expectedPeriod = 1000000.0 / freq; // microseconds
  float expectedHighTime = expectedPeriod * 0.5; // 50% duty
  
  Serial.printf("  Period: %.1f µs\n", expectedPeriod);
  Serial.printf("  High Time: %.1f µs\n", expectedHighTime);
  Serial.printf("  Voltage: 0-3.3V (ESP32 logic level)\n");
  
  // Test different duty cycles
  Serial.println("\nTesting duty cycle sweep...");
  for(int i = 0; i <= 10; i++) {
    uint32_t duty = (i * (1 << resolution)) / 10;
    ledcWrite(pin, duty);
    
    Serial.printf("  Duty: %3d%% -> Writing: %d/%d\n", 
                  i*10, duty, (1 << resolution));
    delay(1000);
  }
  
  // Return to 0%
  ledcWrite(pin, 0);
  Serial.println("\nDiagnostic complete. Signal should now be LOW (0V).");
}

void configureSilentPWM(uint8_t pin, String loadType) {
  uint32_t frequency;
  uint8_t resolution;
  
  if(loadType == "speaker" || loadType == "buzzer") {
    // Intentionally in audible range for sound generation
    frequency = 2000; // 2 kHz for typical buzzer
    resolution = 8;
    Serial.println("Configured for audible output (intentional)");
  } else {
    // Configure above human hearing
    frequency = 25000; // 25 kHz
    resolution = 10; // Good resolution at this frequency
    
    // Validate ESP32 can handle this frequency at given resolution
    uint32_t clockFreq = 80000000; // 80 MHz typical
    uint32_t requiredDivider = clockFreq / (frequency * (1 << resolution));
    
    if(requiredDivider < 2) {
      Serial.println("Warning: Frequency too high for selected resolution");
      frequency = 20000; // Reduce to 20 kHz
    }
    
    Serial.printf("Configured for silent operation: %d Hz, %d-bit\n", 
                  frequency, resolution);
  }
  
  ledcAttach(pin, frequency, resolution);
}

class LowJitterPWM {
private:
  // Use dedicated timer for critical timing
  hw_timer_t* timer = NULL;
  volatile uint32_t pwmSequenceStep = 0;
  
  // Pre-calculated duty cycle values
  uint32_t* dutySequence = NULL;
  uint32_t sequenceLength = 0;
  
public:
  // Create precisely timed PWM sequence
  bool createPreciseSequence(uint8_t pin, uint32_t baseFreq, 
                            uint32_t seq[], uint32_t length) {
    dutySequence = seq;
    sequenceLength = length;
    
    // Calculate interrupt frequency
    uint32_t interruptFreq = baseFreq * length;
    
    // Use hardware timer for precise interrupts
    timer = timerBegin(0, 80, true); // Timer 0, 80 MHz / 80 = 1 MHz
    timerAttachInterrupt(timer, &timerISR, true);
    timerAlarmWrite(timer, 1000000 / interruptFreq, true); // Microseconds
    timerAlarmEnable(timer);
    
    // Configure PWM on main thread
    ledcAttach(pin, baseFreq, 12);
    
    return true;
  }
  
  // Timer interrupt service routine
  static void IRAM_ATTR timerISR() {
    // Update PWM duty cycle at precise intervals
    // Note: This requires careful implementation to avoid blocking
  }
  
  // Dynamic frequency scaling for power savings
  void adjustFrequencyForPower(uint8_t pin, uint32_t baseFreq, 
                               uint8_t resolution, bool powerSaveMode) {
    if(powerSaveMode) {
      // Lower frequency for reduced switching losses
      uint32_t newFreq = baseFreq / 4;
      ledcDetach(pin);
      ledcAttach(pin, newFreq, resolution);
      Serial.printf("Power save: Frequency reduced to %d Hz\n", newFreq);
    } else {
      // Full performance mode
      ledcDetach(pin);
      ledcAttach(pin, baseFreq, resolution);
      Serial.printf("Performance mode: %d Hz\n", baseFreq);
    }
  }
};

class MemoryEfficientPWM {
private:
  // Bit-packed duty cycle storage (for large arrays)
  uint8_t* dutyStorage = NULL;
  uint8_t channels;
  uint8_t resolution;
  
  // Current output states
  uint32_t* currentDuty = NULL;
  
public:
  MemoryEfficientPWM(uint8_t numChannels, uint8_t res = 8) {
    channels = numChannels;
    resolution = res;
    
    // Allocate memory efficiently
    if(resolution <= 8) {
      // 1 byte per channel
      dutyStorage = (uint8_t*)malloc(numChannels);
    } else if(resolution <= 16) {
      // 2 bytes per channel
      dutyStorage = (uint8_t*)malloc(numChannels * 2);
    }
    
    currentDuty = (uint32_t*)malloc(numChannels * sizeof(uint32_t));
    
    Serial.printf("Allocated PWM for %d channels, %d-bit resolution\n", 
                  numChannels, resolution);
    Serial.printf("Memory used: %d bytes\n", 
                  (resolution <= 8 ? numChannels : numChannels * 2) + 
                  (numChannels * sizeof(uint32_t)));
  }
  
  // Update all channels efficiently
  void updateChannels(uint8_t pins[], uint8_t newDuties[]) {
    unsigned long startTime = micros();
    
    for(int i = 0; i < channels; i++) {
      // Only update if duty cycle changed
      if(newDuties[i] != dutyStorage[i]) {
        dutyStorage[i] = newDuties[i];
        
        // Scale to resolution
        uint32_t scaledDuty;
        if(resolution == 8) {
          scaledDuty = newDuties[i];
        } else {
          scaledDuty = (newDuties[i] * ((1 << resolution) - 1)) / 255;
        }
        
        ledcWrite(pins[i], scaledDuty);
        currentDuty[i] = scaledDuty;
      }
    }
    
    unsigned long endTime = micros();
    Serial.printf("Update time: %d µs for %d channels\n", 
                  endTime - startTime, channels);
  }
  
  // Fade all channels simultaneously
  void fadeAll(uint8_t pins[], uint8_t targetDuty, uint32_t duration) {
    uint32_t steps = duration / 20; // 20ms per step
    
    for(uint32_t step = 0; step <= steps; step++) {
      float progress = (float)step / steps;
      
      for(int i = 0; i < channels; i++) {
        uint8_t current = dutyStorage[i];
        uint8_t intermediate = current + (targetDuty - current) * progress;
        
        dutyStorage[i] = intermediate;
        uint32_t scaledDuty = (intermediate * ((1 << resolution) - 1)) / 255;
        ledcWrite(pins[i], scaledDuty);
      }
      
      delay(20);
    }
  }
};