PWMAudioESP32.h

 
#pragma once
#ifdef ESP32
#include "AudioTools/CoreAudio/AudioPWM/PWMAudioBase.h"
 
namespace audio_tools {
 
// forward declaration
class PWMDriverESP32;
using PWMDriver = PWMDriverESP32;
 
struct PinInfoESP32 {
  int pwm_channel;
  int gpio;
};
struct PinInfoESP32 {…};
 
typedef PinInfoESP32 PinInfo;
 
class PWMDriverESP32 : public DriverPWMBase {
 public:
  // friend void pwm_callback(void*ptr);
 
  PWMDriverESP32() { TRACED(); }
 
  // Ends the output
  virtual void end() {
    TRACED();
    timer.end();
    is_timer_started = false;
    for (int j = 0; j < audio_config.channels; j++) {
#if ESP_IDF_VERSION > ESP_IDF_VERSION_VAL(5, 0, 0)
      ledcDetach(pins[j].gpio);
#else
      ledcDetachPin(pins[j].gpio);
#endif
    }
    deleteBuffer();
  }
 
  virtual void startTimer() {
    if (!timer) {
      TRACEI();
      timer.begin(pwm_callback, effectiveOutputSampleRate(), HZ);
      actual_timer_frequency = effectiveOutputSampleRate();
      is_timer_started = true;
    }
  }
  virtual void startTimer() {…}
 
  virtual void setupPWM() {
    // frequency is driven by selected resolution
    if (audio_config.pwm_frequency == 0){
      audio_config.pwm_frequency = frequency(audio_config.resolution) * 1000;
    }
 
    pins.resize(audio_config.channels);
    for (int j = 0; j < audio_config.channels; j++) {
      pins[j].gpio = audio_config.pins()[j];
#if ESP_IDF_VERSION > ESP_IDF_VERSION_VAL(5, 0, 0)
      if (!ledcAttach(pins[j].gpio, audio_config.pwm_frequency,
                      audio_config.resolution)) {
        LOGE("ledcAttach: %d", pins[j].gpio);
      }
#else
      int pwmChannel = j;
      pins[j].pwm_channel = pwmChannel;
      ledcSetup(pins[j].pwm_channel, audio_config.pwm_frequency,
                audio_config.resolution);
      ledcAttachPin(pins[j].gpio, pins[j].pwm_channel);
#endif
      LOGI("setupPWM: pin=%d, channel=%d, frequency=%u, resolution=%d",
           pins[j].gpio, pins[j].pwm_channel, (unsigned)audio_config.pwm_frequency,
           audio_config.resolution);
    }
    logPins();
  }
  virtual void setupPWM() {…}
 
  void logPins() {
    for (int j = 0; j < pins.size(); j++) {
      LOGI("pin%d: %d", j, pins[j].gpio);
    }
  }
 
  virtual void setupTimer() {
    timer.setCallbackParameter(this);
    timer.setIsSave(false);
 
    if (actual_timer_frequency != effectiveOutputSampleRate()){
      timer.end();
      startTimer();
    }
  }
  virtual void setupTimer() {…}
 
  virtual void pwmWrite(int channel, int value) {
#if ESP_IDF_VERSION > ESP_IDF_VERSION_VAL(5, 0, 0)
    ledcWrite(pins[channel].gpio, value);
#else
    ledcWrite(pins[channel].pwm_channel, value);
#endif
  }
  virtual void pwmWrite(int channel, int value) {…}
 
 protected:
  Vector<PinInfo> pins;
  TimerAlarmRepeating timer;
  uint32_t actual_timer_frequency = 0;
 
  int maxUnsignedValue(int resolution) { return pow(2, resolution); }
 
  virtual int maxChannels() { return 16; };
 
  virtual int maxOutputValue() {
    return maxUnsignedValue(audio_config.resolution);
  }
  virtual int maxOutputValue() {…}
 
  float frequency(int resolution) {
// On ESP32S2 and S3, the frequncy seems off by a factor of 2
#if defined(ESP32S2) || defined(ESP32S3)
    switch (resolution) {
      case 7:
        return 312.5;
      case 8:
        return 156.25;
      case 9:
        return 78.125;
      case 10:
        return 39.0625;
      case 11:
        return 19.53125;
    }
    return 312.5;
#else
    switch (resolution) {
      case 8:
        return 312.5;
      case 9:
        return 156.25;
      case 10:
        return 78.125;
      case 11:
        return 39.0625;
    }
    return 312.5;
#endif
  }
  float frequency(int resolution) {…}
 
  static void pwm_callback(void *ptr) {
    PWMDriverESP32 *accessAudioPWM = (PWMDriverESP32 *)ptr;
    if (accessAudioPWM != nullptr) {
      accessAudioPWM->playNextFrame();
    }
  }
  static void pwm_callback(void *ptr) {…}
};
class PWMDriverESP32 : public DriverPWMBase {…};
 
}  // namespace audio_tools
 
#endif