ESP32 correct PWM output

pschatzmann · pschatzmann · commit 02f859f1d424 · 2023-07-14T10:05:27.000+02:00
diff --git a/src/AudioPWM/PWMAudioBase.h b/src/AudioPWM/PWMAudioBase.h
@@ -161,7 +161,7 @@ class DriverPWMBase {
         virtual size_t write(const uint8_t *wrt_buffer, size_t size){
             if (is_blocking_write && availableForWrite()==0){
                 LOGD("Waiting for buffer to clear");
-                while (availableForWrite()==0) delay(1);
+                while (availableForWrite()==0) delay(5);
             }
             
             size_t available = min((size_t)availableForWrite(),size);
diff --git a/src/AudioPWM/PWMAudioESP32.h b/src/AudioPWM/PWMAudioESP32.h
@@ -13,8 +13,6 @@ class PWMDriverESP32;
  * @brief Please use DriverPWMBase!
  */
 using PWMDriver = PWMDriverESP32;
-static PWMDriverESP32 *accessAudioPWM = nullptr; 
-void IRAM_ATTR defaultPWMAudioOutputCallback();
 
 
 /**
@@ -38,50 +36,45 @@ typedef PinInfoESP32 PinInfo;
 
 class PWMDriverESP32 : public DriverPWMBase {
     public:
-        friend void defaultPWMAudioOutputCallback();
+        //friend void pwm_callback(void*ptr);
 
         PWMDriverESP32(){
             TRACED();
-            accessAudioPWM = this;
         }
 
         // Ends the output
         virtual void end(){
             TRACED();
-            timerAlarmDisable(timer);
+            timer.end();
+            is_timer_started = false;
             for (int j=0;j<audio_config.channels;j++){
                 ledcDetachPin(pins[j].gpio);
             }
-            is_timer_started = false;
         }
 
         /// when we get the first write -> we activate the timer to start with the output of data
         virtual void startTimer(){
-            if (!is_timer_started){
+            if (!timer){
+                TRACEI();
                 audio_config = audioInfo();
-                LOGI("timerAlarmEnable");
+                timer.begin(pwm_callback, audio_config.sample_rate, HZ);
                 is_timer_started = true;
-                timerAlarmEnable(timer);
             }
         }
 
         /// Setup LED PWM
         virtual void setupPWM(){
-            TRACED();
             // frequency is driven by selected resolution
-            uint32_t freq = frequency(audio_config.resolution)*1000;
-            audio_config.pwm_frequency = freq;
+            audio_config.pwm_frequency = frequency(audio_config.resolution) * 1000;
 
             pins.resize(audio_config.channels);
             for (int j=0;j<audio_config.channels;j++){
-                LOGD("Processing channel %d", j);
                 int pwmChannel = j;
                 pins[j].pwm_channel = pwmChannel;
                 pins[j].gpio = audio_config.pins()[j];
-                LOGI("-> ledcSetup:  frequency=%d / resolution=%d", freq, audio_config.resolution);
-                ledcSetup(pwmChannel, freq, audio_config.resolution);
-                LOGD("-> ledcAttachPin: %d", pins[j].gpio);
-                ledcAttachPin(pins[j].gpio, pwmChannel);
+                ledcSetup(pins[j].pwm_channel, audio_config.pwm_frequency, audio_config.resolution);
+                ledcAttachPin(pins[j].gpio, pins[j].pwm_channel);
+                LOGI("setupPWM: pin=%d, channel=%d, frequency=%d, resolution=%d", pins[j].gpio, pins[j].pwm_channel, audio_config.pwm_frequency, audio_config.resolution);
             }
             logPins();
         }
@@ -94,31 +87,18 @@ class PWMDriverESP32 : public DriverPWMBase {
 
         /// Setup ESP32 timer with callback
         virtual void setupTimer() {
-            TRACED();
-
-            // Attach timer int at sample rate
-            int prescale = 2;
-            bool rising_edge = true;
-            timer = timerBegin(audio_config.timer_id, prescale, rising_edge); // Timer at full 40Mhz,  prescaling 2
-            uint32_t counter = 20000000 / audio_config.sample_rate;
-            LOGI("-> timer counter is %zu", counter);
-            LOGD("-> timerAttachInterrupt");
-            bool interrupt_edge_type = true;
-            timerAttachInterrupt(timer, defaultPWMAudioOutputCallback, interrupt_edge_type);
-            LOGD("-> timerAlarmWrite");
-            bool auto_reload = true;
-            timerAlarmWrite(timer, counter, auto_reload); // Timer fires at ~44100Hz [40Mhz / 907]
+            timer.setCallbackParameter(this);
+            timer.setIsSave(false);
         } 
 
         /// write a pwm value to the indicated channel. The max value depends on the resolution
         virtual void pwmWrite(int channel, int value){
-            ledcWrite(pins[channel].pwm_channel, value);          
+            ledcWrite(pins[channel].pwm_channel, value);  
         }
 
     protected:
         Vector<PinInfo> pins;      
-        hw_timer_t * timer = nullptr;
-        portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;
+        TimerAlarmRepeating timer;
 
         /// provides the max value for the indicated resulution
         int maxUnsignedValue(int resolution){
@@ -143,17 +123,18 @@ class PWMDriverESP32 : public DriverPWMBase {
                 case 11: return 39.0625;
             }
             return 312.5;
-        }      
+        }    
+
+        /// timer callback: write the next frame to the pins
+        static void pwm_callback(void*ptr){
+            PWMDriverESP32 *accessAudioPWM =  (PWMDriverESP32*)ptr;
+            if (accessAudioPWM!=nullptr){
+                accessAudioPWM->playNextFrame();
+            }
+        }
+
 };
 
-/// timer callback: write the next frame to the pins
-void IRAM_ATTR defaultPWMAudioOutputCallback() {
-    if (accessAudioPWM!=nullptr){
-        portENTER_CRITICAL_ISR(&(accessAudioPWM->timerMux));
-        accessAudioPWM->playNextFrame();
-        portEXIT_CRITICAL_ISR(&(accessAudioPWM->timerMux));
-    }
-}
 
 }
 
diff --git a/src/AudioPWM/PWMAudioRenesas.h b/src/AudioPWM/PWMAudioRenesas.h
@@ -105,9 +105,6 @@ class PWMDriverRenesas : public DriverPWMBase {
         /// write a pwm value to the indicated channel. The max value depends on the resolution
         virtual void pwmWrite(int channel, int value){
             pins[channel]->pulse_perc(value);
-            //char buffer[80];
-            //sprintf(buffer,"channel %d - value: %d", channel, value);
-            //LOGD("%s", buffer);
         }
 
         /// timer callback: write the next frame to the pins
diff --git a/src/AudioTimer/AudioTimer.h b/src/AudioTimer/AudioTimer.h
@@ -37,9 +37,11 @@ class TimerAlarmRepeating {
         virtual ~TimerAlarmRepeating() = default;
 
         bool begin(repeating_timer_callback_t callback_f, uint32_t time, TimeUnit unit = MS) {
-            return p_driver->begin(callback_f, time, unit);
+            is_active = p_driver->begin(callback_f, time, unit);
+            return is_active;
         }
         bool end() { 
+            is_active = false;
             return p_driver->end(); 
         };
 
@@ -59,8 +61,16 @@ class TimerAlarmRepeating {
             p_driver->setTimerFunction(function);
         }
 
+        void setIsSave(bool is_save){
+            p_driver->setIsSave(is_save);
+        }
+
+        /// @brief Returns true if the timer is active
+        operator bool() { return is_active; }
+
     protected:
         void* object=nullptr;
+        bool is_active = false;;
         TimerAlarmRepeatingDriver driver; // platform specific driver
         TimerAlarmRepeatingDriverBase *p_driver=&driver;
 
diff --git a/src/AudioTimer/AudioTimerBase.h b/src/AudioTimer/AudioTimerBase.h
@@ -35,6 +35,8 @@ class TimerAlarmRepeatingDriverBase {
 
         virtual void setTimer(int timer){}
         virtual void setTimerFunction(TimerFunction function=DirectTimerCallback){}
+        /// @brief Not used
+        virtual void setIsSave(bool is_save){}
 
     protected:
         void* object=nullptr;
diff --git a/src/AudioTimer/AudioTimerESP32.h b/src/AudioTimer/AudioTimerESP32.h
@@ -6,11 +6,9 @@
 
 namespace audio_tools {
 
-typedef void (* simple_callback )(void);
-
-
 /**
  * @brief Internal class to manage User callbacks. An optinal parameter can be passed to the callback method
+ * We support 4 timers
  * @author Phil Schatzmann
  * @copyright GPLv3
  */
@@ -138,7 +136,7 @@ class TimerAlarmRepeatingDriverESP32 : public TimerAlarmRepeatingDriverBase  {
           }
         }
 
-        virtual void setTimerFunction(TimerFunction function=DirectTimerCallback) override{
+        void setTimerFunction(TimerFunction function=DirectTimerCallback) override{
             this->function = function;
         }
 
@@ -162,7 +160,6 @@ class TimerAlarmRepeatingDriverESP32 : public TimerAlarmRepeatingDriverBase  {
             LOGI("Timer every: %u us", timeUs);
             adc_timer = timerBegin(timer_id, 80, true);  // divider=80 -> 1000000 calls per second
 
-
             switch (function) {
                 case DirectTimerCallback:
                   setupDirectTimerCallback(callback_f);
@@ -175,7 +172,6 @@ class TimerAlarmRepeatingDriverESP32 : public TimerAlarmRepeatingDriverBase  {
                 case SimpleThreadLoop:
                   setupSimpleThreadLoop(callback_f);
                   break;
-
             }
 
             started = true;
@@ -201,13 +197,19 @@ class TimerAlarmRepeatingDriverESP32 : public TimerAlarmRepeatingDriverBase  {
         void setCore(int core){
           this->core = core;
         }
+        
+        /// Selects the TimerFunction: default is DirectTimerCallback, when set to save we use TimerCallbackInThread
+        void setIsSave(bool is_save) override{
+            setTimerFunction(is_save?TimerCallbackInThread : DirectTimerCallback);
+        }
+
 
     protected:
       int timer_id=0;
       volatile bool started = false;
       TaskHandle_t handler_task = nullptr;
       hw_timer_t* adc_timer = nullptr; // our timer
-      UserCallback user_callback;
+      UserCallback user_callback; // for task
       TimerFunction function;
       int core = 1;
       int priority = configMAX_PRIORITIES -1;
@@ -227,12 +229,11 @@ class TimerAlarmRepeatingDriverESP32 : public TimerAlarmRepeatingDriverBase  {
         else if (timer_id==3) timerAttachInterrupt(adc_timer, userCallback3, false); 
 
         timerAlarmWrite(adc_timer, timeUs, true);
-        //timerSetAutoReload(adc_timer, true);
         timerAlarmEnable(adc_timer);
 
       }
 
-      /// timer callback is notifiying task
+      /// timer callback is notifiying task: supports functionality which can not be called in an interrupt e.g. i2c
       void setupTimerCallbackInThread(repeating_timer_callback_t callback_f){
         TRACED();
         // we start the timer which runs the callback in a seprate task

Original file line number	Diff line number	Diff line change
`@@ -161,7 +161,7 @@ class DriverPWMBase {`
`161`	`161`	`virtual size_t write(const uint8_t *wrt_buffer, size_t size){`
`162`	`162`	`if (is_blocking_write && availableForWrite()==0){`
`163`	`163`	`LOGD("Waiting for buffer to clear");`
`164`		`- while (availableForWrite()==0) delay(1);`
	`164`	`+ while (availableForWrite()==0) delay(5);`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`size_t available = min((size_t)availableForWrite(),size);`
Original file line number	Diff line number	Diff line change
`@@ -105,9 +105,6 @@ class PWMDriverRenesas : public DriverPWMBase {`
`105`	`105`	`/// write a pwm value to the indicated channel. The max value depends on the resolution`
`106`	`106`	`virtual void pwmWrite(int channel, int value){`
`107`	`107`	`pins[channel]->pulse_perc(value);`
`108`		`- //char buffer[80];`
`109`		`- //sprintf(buffer,"channel %d - value: %d", channel, value);`
`110`		`- //LOGD("%s", buffer);`
`111`	`108`	`}`
`112`	`109`
`113`	`110`	`/// timer callback: write the next frame to the pins`