Освоение ШИМ на ESP32: от базового управления затуханием до продвинутых функций с помощью Arduino IDE.

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

пустота 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)
  без подписи длинный start = micros();
  инт pulses = 0;
  константа инт targetPulses = 1000;
  
  // Generate pulses and count
  для(инт i = 0; i < targetPulses; i++) {
    ledcWrite(pin, 127); // 50% duty cycle
    delayMicroseconds(500); // Simplified timing
    pulses++;
  }
  без подписи длинный конец = micros();
  
  плавать actualFreq = (pulses * 1000000.0) / (конец - start);
  плавать errorPercent = abs(actualFreq - targetFreq) / targetFreq * 100;
  
  Серийный номер.printf("  Target: %d Hz, Estimated: %.1f Hz, Error: %.1f%%\n", 
                targetFreq, actualFreq, errorPercent);
  
  ledcDetach(pin);
}

// Best for: Simple applications, Arduino compatibility, quick prototyping
пустота setupAnalogWriteExample() {
  константа инт ledPin = 16;
  pinMode(ledPin, ВЫХОД);
  
  // Optional: Customize frequency and resolution (default: 1 kHz, 8-bit)
  analogWriteFrequency(ledPin, 5000);    // 5 kHz frequency
  analogWriteResolution(ledPin, 10);     // 10-bit resolution (0-1023)
}

пустота loopAnalogWriteExample() {
  // Simple fade effect
  для(инт duty = 0; duty <= 1023; duty++) {
    analogWrite(16, duty);
    задерживать(5);
  }
}

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

// Automatic PWM configuration based on application
struct PWMConfig {
  константа чар* приложение;
  uint32_t minFreq;
  uint32_t maxFreq;
  uint8_t minRes;
  uint8_t maxRes;
  константа чар* 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"}
};

пустота configureOptimalPWM(uint8_t pin, константа чар* приложение) {
  Серийный номер.printf("\nConfiguring PWM for: %s\n", приложение);
  
  PWMConfig* profile = nullptr;
  для(auto& p : configProfiles) {
    если(strcmp(p.приложение, приложение) == 0) {
      profile = &p;
      перерыв;
    }
  }
  
  если(!profile) {
    Серийный номер.println("Unknown application, using defaults");
    ledcAttach(pin, 1000, 8); // Default: 1 kHz, 8-bit
    возвращаться;
  }
  
  // Calculate optimal values
  uint32_t freq = (profile->minFreq + profile->maxFreq) / 2;
  uint8_t resolution = (profile->minRes + profile->maxRes) / 2;
  
  // Adjust based on ESP32 capabilities
  если(freq > 40000) {
    Серийный номер.println("Warning: Frequency may exceed ESP32 capabilities");
    freq = 20000; // Safer limit
  }
  
  Серийный номер.printf("Optimal settings: %d Hz, %d-bit resolution\n", freq, resolution);
  Серийный номер.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 канал;
    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) {
    если(count > 4 || count == 0) {
      Серийный номер.println("Error: 1-4 channels supported for synchronization");
      возвращаться ЛОЖЬ;
    }
    
    // All channels must use the same timer (same frequency/resolution)
    для(инт i = 0; i < count; i++) {
      // Assign sequential channels on the same timer
      uint8_t канал = i; // Channels 0-3 share Timer 0
      
      если(ledcAttachChannel(pins[i], freq, resolution, канал)) {
        channels[i].pin = pins[i];
        channels[i].канал = канал;
        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);
      } еще {
        Серийный номер.printf("Failed to attach channel %d\n", i);
        возвращаться ЛОЖЬ;
      }
    }
    
    Серийный номер.printf("Initialized %d synchronized PWM channels at %d Hz\n", 
                  activeChannels, freq);
    возвращаться истинный;
  }
  
  // Set phase offset between channels (0-360 degrees)
  пустота setPhaseOffset(uint8_t channelIndex, uint32_t degrees) {
    если(channelIndex >= activeChannels) возвращаться;
    
    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
    Серийный номер.printf("Channel %d phase offset: %d degrees\n", 
                  channelIndex, degrees);
  }
  
  // Create 3-phase PWM (for motor control)
  пустота setupThreePhase(uint8_t pinU, uint8_t pinV, uint8_t pinW, 
                       uint32_t freq, uint8_t resolution) {
    uint8_t pins[3] = {pinU, pinV, pinW};
    если(!initializeSynchronized(pins, 3, freq, resolution)) {
      возвращаться;
    }
    
    // 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°
    
    Серийный номер.println("3-phase PWM configured with 120° phase separation");
  }
  
  // Generate sine wave across multiple channels
  пустота generateSineWave(плавать amplitude, плавать frequencyHz) {
    uint32_t maxDuty = (1 << channels[0].resolution) - 1;
    uint32_t centerDuty = maxDuty / 2;
    uint32_t amplitudeDuty = (maxDuty * amplitude) / 2;
    
    без подписи длинный startTime = micros();
    
    пока(истинный) {
      без подписи длинный текущее время = micros();
      плавать elapsedSeconds = (текущее время - startTime) / 1000000.0;
      
      для(инт i = 0; i < activeChannels; i++) {
        // Calculate phase in radians
        плавать phase = 2 * PI * frequencyHz * elapsedSeconds + 
                     (channels[i].phaseOffset * PI / 180.0);
        
        // Calculate sine value
        плавать 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)
  плавать temperatureCoefficient = -0.003; // Typical -0.3%/°C
  плавать 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)
    для(инт i = 0; i < 256; i++) {
      плавать normalized = i / 255.0;
      плавать 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)
  пустота setBrightness(uint8_t level, плавать temperature = 25.0) {
    если(level > 255) level = 255;
    
    // Apply gamma correction
    uint32_t duty = gammaTable[level];
    
    // Apply temperature compensation
    плавать tempAdjustment = 1.0 + (temperature - referenceTemp) * 
                          temperatureCoefficient;
    duty = duty * tempAdjustment;
    
    // Constrain to valid range
    duty = constrain(duty, 0, maxDuty);
    
    ledcWrite(pwmChannel, duty);
    
    Серийный номер.printf("LED: Level=%d, Gamma Corrected Duty=%d, Temp Adjusted=%d\n",
                  level, gammaTable[level], duty);
  }
  
  // Smooth transition between brightness levels
  пустота transitionTo(uint8_t targetLevel, uint32_t durationMs, 
                    String easing = "linear") {
    uint8_t currentLevel = getCurrentBrightness();
    
    инт steps = durationMs / 20; // Update every 20ms
    для(инт i = 0; i <= steps; i++) {
      плавать progress = (плавать)i / steps;
      
      // Apply easing function
      плавать easedProgress;
      если(easing == "easeInOut") {
        easedProgress = easeInOutCubic(progress);
      } еще если(easing == "easeOut") {
        easedProgress = easeOutCubic(progress);
      } еще { // linear
        easedProgress = progress;
      }
      
      uint8_t intermediateLevel = currentLevel + 
                                  (targetLevel - currentLevel) * easedProgress;
      
      setBrightness(intermediateLevel);
      задерживать(20);
    }
    
    // Ensure exact target
    setBrightness(targetLevel);
  }
  
  // Flicker-free emergency/notification pulsing
  пустота pulseNotification(uint8_t baseLevel = 50, uint8_t pulseLevel = 200, 
                         uint32_t pulseDuration = 200) {
    uint8_t originalLevel = getCurrentBrightness();
    
    // Quick rise
    transitionTo(pulseLevel, 50, "easeOut");
    задерживать(pulseDuration);
    
    // Return to base
    transitionTo(baseLevel, 300, "easeInOut");
    
    // Optional: Return to original after delay
    задерживать(1000);
    transitionTo(originalLevel, 500);
  }
  
private:
  плавать easeInOutCubic(плавать x) {
    возвращаться x < 0.5 ? 4 * x * x * x : 1 - pow(-2 * x + 2, 3) / 2;
  }
  
  плавать easeOutCubic(плавать x) {
    возвращаться 1 - pow(1 - x, 3);
  }
  
  uint8_t getCurrentBrightness() {
    // In real implementation, track current brightness
    возвращаться 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;
  без подписи длинный 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);
    
    Серийный номер.printf("Motor PWM: %d Hz, %d-bit, Max Duty: %d\n", 
                  freq, res, maxDuty);
  }
  
  // Set motor speed (0-100%)
  пустота setSpeed(плавать percent, bool immediate = ЛОЖЬ) {
    если(percent < 0) percent = 0;
    если(percent > 100) percent = 100;
    
    targetDuty = (percent / 100.0) * maxDuty;
    
    если(immediate) {
      currentDuty = targetDuty;
      applyDutyCycle(currentDuty);
    } еще {
      // Ramped update handled in update() method
    }
  }
  
  // Call regularly in main loop for ramped control
  пустота обновлять() {
    без подписи длинный now = миллис();
    без подписи длинный elapsed = now - lastUpdate;
    
    если(elapsed >= 10) { // Update every 10ms
      если(currentDuty != targetDuty) {
        // Calculate maximum change based on ramp rate
        uint32_t maxChange = (rampRate * elapsed) / 1000;
        
        если(targetDuty > currentDuty) {
          currentDuty += мин(maxChange, targetDuty - currentDuty);
        } еще {
          currentDuty -= мин(maxChange, currentDuty - targetDuty);
        }
        
        applyDutyCycle(currentDuty);
      }
      
      lastUpdate = now;
    }
  }
  
  // Emergency stop with braking
  пустота emergencyStop(bool brake = истинный) {
    если(brake) {
      // Active braking: short motor terminals
      // Implementation depends on motor driver
      Серийный номер.println("Motor: Emergency brake engaged");
    } еще {
      // Coast to stop
      setSpeed(0, истинный);
      Серийный номер.println("Motor: Coasting to stop");
    }
  }
  
  // Generate sinusoidal commutation for brushless motors
  пустота generateSinusoidalCommutation(плавать electricalAngle, 
                                     плавать amplitude = 1.0) {
    // Calculate three-phase duty cycles
    плавать phaseU = sin(electricalAngle) * amplitude;
    плавать phaseV = sin(electricalAngle + 2 * PI / 3) * amplitude;
    плавать 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:
  пустота applyDutyCycle(uint32_t duty) {
    duty = constrain(duty, 0, maxDuty);
    
    // Apply dead time (simplified)
    если(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);
  }
  
  пустота 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)
    плавать simulatedCurrent = duty * (currentLimit / (плавать)maxDuty) * 1.2;
    
    если(simulatedCurrent > currentLimit) {
      overcurrentCount++;
      Серийный номер.printf("Warning: Current limit exceeded (%d mA)\n", 
                    (инт)simulatedCurrent);
      
      если(overcurrentCount > 5) {
        emergencyStop(ЛОЖЬ);
        Серийный номер.println("Motor: Shutdown due to sustained overcurrent");
      }
    } еще {
      overcurrentCount = 0;
    }
  }
};

// Reserve specific timer for critical PWM applications
bool reservePWMTimer(uint8_t timer, константа чар* owner) {
  static bool timerAllocated[4] = {ЛОЖЬ};
  static константа чар* timerOwners[4] = {"", "", "", ""};
  
  если(timer >= 4) возвращаться ЛОЖЬ;
  
  если(timerAllocated[timer]) {
    Серийный номер.printf("Timer %d already allocated by: %s\n", 
                  timer, timerOwners[timer]);
    возвращаться ЛОЖЬ;
  }
  
  timerAllocated[timer] = истинный;
  timerOwners[timer] = owner;
  
  Серийный номер.printf("Timer %d allocated for: %s\n", timer, owner);
  возвращаться истинный;
}

// When using Servo library, allocate different timer for PWM
пустота 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
}

пустота pwmSignalDiagnostic(uint8_t pin, uint32_t freq, uint8_t resolution) {
  Серийный номер.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);
  
  Серийный номер.printf("Testing GPIO %d at %d Hz, %d-bit resolution\n", 
                pin, freq, resolution);
  Серийный номер.println("Expected signal: 50% duty cycle");
  
  // Measure actual output (simplified)
  Серийный номер.println("\nConnect oscilloscope to:");
  Серийный номер.printf("  - GPIO %d (signal)\n", pin);
  Серийный номер.println("  - GND (ground reference)");
  
  Серийный номер.println("\nExpected measurements:");
  Серийный номер.printf("  Frequency: %.1f Hz (tolerance ±5%%)\n", (плавать)freq);
  
  плавать expectedPeriod = 1000000.0 / freq; // microseconds
  плавать expectedHighTime = expectedPeriod * 0.5; // 50% duty
  
  Серийный номер.printf("  Period: %.1f µs\n", expectedPeriod);
  Серийный номер.printf("  High Time: %.1f µs\n", expectedHighTime);
  Серийный номер.printf("  Voltage: 0-3.3V (ESP32 logic level)\n");
  
  // Test different duty cycles
  Серийный номер.println("\nTesting duty cycle sweep...");
  для(инт i = 0; i <= 10; i++) {
    uint32_t duty = (i * (1 << resolution)) / 10;
    ledcWrite(pin, duty);
    
    Серийный номер.printf("  Duty: %3d%% -> Writing: %d/%d\n", 
                  i*10, duty, (1 << resolution));
    задерживать(1000);
  }
  
  // Return to 0%
  ledcWrite(pin, 0);
  Серийный номер.println("\nDiagnostic complete. Signal should now be LOW (0V).");
}

пустота configureSilentPWM(uint8_t pin, String loadType) {
  uint32_t frequency;
  uint8_t resolution;
  
  если(loadType == "speaker" || loadType == "buzzer") {
    // Intentionally in audible range for sound generation
    frequency = 2000; // 2 kHz for typical buzzer
    resolution = 8;
    Серийный номер.println("Configured for audible output (intentional)");
  } еще {
    // 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));
    
    если(requiredDivider < 2) {
      Серийный номер.println("Warning: Frequency too high for selected resolution");
      frequency = 20000; // Reduce to 20 kHz
    }
    
    Серийный номер.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 длина) {
    dutySequence = seq;
    sequenceLength = длина;
    
    // Calculate interrupt frequency
    uint32_t interruptFreq = baseFreq * длина;
    
    // Use hardware timer for precise interrupts
    timer = timerBegin(0, 80, истинный); // Timer 0, 80 MHz / 80 = 1 MHz
    timerAttachInterrupt(timer, &timerISR, истинный);
    timerAlarmWrite(timer, 1000000 / interruptFreq, истинный); // Microseconds
    timerAlarmEnable(timer);
    
    // Configure PWM on main thread
    ledcAttach(pin, baseFreq, 12);
    
    возвращаться истинный;
  }
  
  // Timer interrupt service routine
  static пустота IRAM_ATTR timerISR() {
    // Update PWM duty cycle at precise intervals
    // Note: This requires careful implementation to avoid blocking
  }
  
  // Dynamic frequency scaling for power savings
  пустота adjustFrequencyForPower(uint8_t pin, uint32_t baseFreq, 
                               uint8_t resolution, bool powerSaveMode) {
    если(powerSaveMode) {
      // Lower frequency for reduced switching losses
      uint32_t newFreq = baseFreq / 4;
      ledcDetach(pin);
      ledcAttach(pin, newFreq, resolution);
      Серийный номер.printf("Power save: Frequency reduced to %d Hz\n", newFreq);
    } еще {
      // Full performance mode
      ledcDetach(pin);
      ledcAttach(pin, baseFreq, resolution);
      Серийный номер.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
    если(resolution <= 8) {
      // 1 byte per channel
      dutyStorage = (uint8_t*)malloc(numChannels);
    } еще если(resolution <= 16) {
      // 2 bytes per channel
      dutyStorage = (uint8_t*)malloc(numChannels * 2);
    }
    
    currentDuty = (uint32_t*)malloc(numChannels * sizeof(uint32_t));
    
    Серийный номер.printf("Allocated PWM for %d channels, %d-bit resolution\n", 
                  numChannels, resolution);
    Серийный номер.printf("Memory used: %d bytes\n", 
                  (resolution <= 8 ? numChannels : numChannels * 2) + 
                  (numChannels * sizeof(uint32_t)));
  }
  
  // Update all channels efficiently
  пустота updateChannels(uint8_t pins[], uint8_t newDuties[]) {
    без подписи длинный startTime = micros();
    
    для(инт i = 0; i < channels; i++) {
      // Only update if duty cycle changed
      если(newDuties[i] != dutyStorage[i]) {
        dutyStorage[i] = newDuties[i];
        
        // Scale to resolution
        uint32_t scaledDuty;
        если(resolution == 8) {
          scaledDuty = newDuties[i];
        } еще {
          scaledDuty = (newDuties[i] * ((1 << resolution) - 1)) / 255;
        }
        
        ledcWrite(pins[i], scaledDuty);
        currentDuty[i] = scaledDuty;
      }
    }
    
    без подписи длинный endTime = micros();
    Серийный номер.printf("Update time: %d µs for %d channels\n", 
                  endTime - startTime, channels);
  }
  
  // Fade all channels simultaneously
  пустота fadeAll(uint8_t pins[], uint8_t targetDuty, uint32_t duration) {
    uint32_t steps = duration / 20; // 20ms per step
    
    для(uint32_t step = 0; step <= steps; step++) {
      плавать progress = (плавать)step / steps;
      
      для(инт 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);
      }
      
      задерживать(20);
    }
  }
};