Final Corrections for PWM support

Author: pschatzmann

examples/streams-generator-pwm/README.md

@@ -16,7 +16,7 @@ It should also be possible to connect a headphone to the output pins...
 
 The pins depend on the Processor:
 
-| PIEZO   |  ESP32         | AVR             | Rpi Pico
-| --------| ---------------|-----------------|--------------
-| +       |  GPIO3 / GPIO4 | GPIO3 / GPIO11  | GPIO03/GPIO04
+| PIEZO   |  ESP32         | Rpi Pico        |
+| --------| ---------------|-----------------|
+| +       |  GPIO4/GPIO5   | GPIO02/GPIO03   |
 | -       |  GND           |                 |

examples/streams-generator-pwm/streams-generator-pwm.ino

@@ -10,7 +10,7 @@
 
 using namespace audio_tools;  
 
-int pins[] = {22, 23};
+//int pins[] = {22, 23};
 int channels = 2;
 uint16_t sample_rate=22000;
 SineWaveGenerator<int16_t> sineWave(32000); // subclass of SoundGenerator with max amplitude of 32000

examples/streams-memory_wav-pwm/README.md

@@ -6,8 +6,8 @@ MemoryStream -> AudioOutputStream -> WAVDecoder -> AudioPWM
 
 The pins depend on the Processor:
 
-| PIEZO   |  ESP32         | AVR (Nano)      | Rpi Pico
-| --------| ---------------|-----------------|--------------
-| +       |  GPIO3 / GPIO4 | GPIO3 / GPIO11  | GPIO03/GPIO04
+| PIEZO   |  ESP32         | RPI Pico        | 
+| --------| ---------------|-----------------|
+| +       |  GPIO4         | GPIO2           |
 | -       |  GND           |                 |
 

examples/streams-memory_wav-pwm/streams-memory_wav-pwm.ino

@@ -14,7 +14,7 @@
 
 using namespace audio_tools;  
 
-// MemoryStream -> AudioOutputStream -> WAVDecoder -> CsvStream
+// MemoryStream -> AudioOutputStream -> WAVDecoder -> PWMAudioStream
 MemoryStream wav(knghtsng_wav, knghtsng_wav_len);
 PWMAudioStream pwm;          // PWM output 
 WAVDecoder decoder(pwm);        // decode wav to pcm and send it to printer
@@ -23,12 +23,13 @@ StreamCopy copier(out, wav);    // copy in to out
 
 void setup(){
   Serial.begin(115200);
+  while(!Serial);
   AudioLogger::instance().begin(Serial, AudioLogger::Debug);  
 
   // setup pwm output
   PWMConfig config = pwm.defaultConfig();
   config.channels = 1;
-  config.sample_rate = 1000;
+  config.sample_rate = 11025;
   pwm.begin(config);
 }
 

library.properties

@@ -6,4 +6,4 @@ sentence=Some useful audio processing classes
 paragraph=Timer, RingBuffer, I2S
 category=Device Control
 url=https://github.com/pschatzmann/arduino-audio-tools
-architectures=esp32,mbed_nano
+architectures=*

src/AudioConfig.h

@@ -41,7 +41,7 @@
 #define A2DP_BUFFER_COUNT 8
 #define DEFAUT_ADC_PIN 34
 #define PWM_BUFFER_SIZE 512
-#define PWM_BUFFERS 2
+#define PWM_BUFFERS 10
 
 /**
  * ------------------------------------------------------------------------- 

src/AudioPWM/PWMAudioStreamAVR.h

@@ -41,7 +41,7 @@ class PWMAudioStreamAVR : public PWMAudioStreamBase {
             TCCR2A = 0;
             interrupts(); // enable all interrupts
 
-            data_write_started = false;
+            is_timer_started = false;
         }
 
         /// Setup AVR timer with callback
@@ -120,11 +120,15 @@ class PWMAudioStreamAVR : public PWMAudioStreamBase {
     protected:
         int pins[2] =  {3, 11};
 
+        virtual int maxOutputValue(){
+            return 255;
+        }
+
 };
 
 /// separate method that can be defined as friend so that we can access protected information
 void defaultPWMAudioOutputCallback(){
-    if (accessAudioPWM!=nullptr && accessAudioPWM->data_write_started){
+    if (accessAudioPWM!=nullptr && accessAudioPWM->is_timer_started){
         accessAudioPWM->playNextFrame();
     }
 }

src/AudioPWM/PWMAudioStreamBase.h

@@ -9,8 +9,15 @@
 
 namespace audio_tools {
 
+// forward declarations
+// Callback for user
 typedef bool (*PWMCallbackType)(uint8_t channels, int16_t* data);
+// Callback used by system
 void defaultPWMAudioOutputCallback();
+// Stream classes
+class PWMAudioStreamESP32;
+class PWMAudioStreamPico;
+
 /**
  * PWMConfigAVR
  * @author Phil Schatzmann
@@ -27,12 +34,36 @@ struct PWMConfig {
         LOGI("sample_rate: %d", sample_rate);
         LOGI("channels: %d", channels);
         LOGI("bits_per_sample: %d", bits_per_sample);
+        LOGI("buffer_size: %d", buffer_size);
     }
 
 #ifdef ESP32
-    int resolution = 8;  // must be between 8 and 11 -> drives pwm frequency
-    int start_pin = 3; 
-    int *pins = nullptr;
+/**
+ * @brief Configuration for PWM output
+ *   RES | BITS | MAX_FREQ (kHz)
+ *   ----|------|-------
+ *    8  | 256  | 312.5
+ *    9  | 512  | 156.25
+ *   10  | 1024 | 78.125
+ *   11  | 2048 | 39.0625
+ *
+ *   The default resolution is 8. The value must be between 8 and 11 and also drives the PWM frequency.
+ */
+    int resolution = 8;     // must be between 8 and 11 -> drives pwm frequency
+    int start_pin = 4; 
+    uint8_t timer_id = 0;   // must be between 0 and 3
+#endif
+
+#ifdef ARDUINO_ARCH_RP2040
+    int pwm_freq = 60000;   // audable range is from 20 to 20,000Hz 
+    int start_pin = 2;      // channel 0 will be on gpio 2, channel 1 on 3 etc
+#endif
+
+// for architectures which support many flexible pins we support setPins
+#if defined(ESP32) || defined(ARDUINO_ARCH_RP2040)
+    friend class PWMAudioStreamESP32;
+    friend class PWMAudioStreamPico;
+
 
     // define all pins by passing an array and updates the channels by the number of pins
     template<size_t N> 
@@ -46,11 +77,11 @@ struct PWMConfig {
         pins = array;
         start_pin = -1; // mark start pin as invalid
     }
-#endif
 
-#ifdef ARDUINO_ARCH_RP2040
-    int pwm_freq = 60000;    // audable range is from 20 to 20,000Hz 
-    int start_pin = 2; // channel 0 will be on gpio 2, channel 1 on 3 etc
+    protected:
+        int *pins = nullptr;
+
+
 #endif
 
 } default_config;
@@ -71,8 +102,6 @@ class PWMAudioStreamBase : public Stream {
             return audio_config;
         }
 
-        virtual int maxChannels() = 0;
-
         /// Starts the PWMAudio using callbacks
         bool begin(uint16_t sampleRate, uint8_t channels, PWMCallbackType cb) {
 	 		LOGD(__FUNCTION__);
@@ -88,7 +117,7 @@ class PWMAudioStreamBase : public Stream {
             setupPWM();
             setupTimer();
 
-            data_write_started = true;
+            is_timer_started = true;
             return true;
         }
 
@@ -103,6 +132,7 @@ class PWMAudioStreamBase : public Stream {
             }             
             // allocate new buffer
             if (buffer==nullptr) {
+                LOGI("Allocating new buffer %d * %d bytes",config.buffers, config.buffer_size);
                 buffer = new NBuffer<uint8_t>(config.buffer_size, config.buffers);
             }
             // check allocation
@@ -153,100 +183,117 @@ class PWMAudioStreamBase : public Stream {
             size_t result = 0;
             if (buffer->availableToWrite()>1){
                 result = buffer->write(value);
-                setWriteStarted();
+                startTimer();
             }
             return result;
         }
 
         // blocking write for an array: we expect a singed value and convert it into a unsigned 
         virtual size_t write(const uint8_t *wrt_buffer, size_t size){
-            LOGI("write: %lu bytes", size)
+            LOGD("write: %lu bytes", size)
+            bool log_flag = true;
             while(availableForWrite()<size){
-       	 	    LOGI("Buffer is full - waiting...");
+                if (log_flag) LOGI("Buffer is full - waiting...");
+                log_flag = false;
                 delay(10);
             }
             size_t result = buffer->writeArray(wrt_buffer, size);
             if (result!=size){
                 LOGW("Could not write all data: %d -> %d", size, result);
             }
             // activate the timer now - if not already done
-            setWriteStarted();
+            startTimer();
             return result;
         }
 
         // When the timer does not have enough data we increase the underflow_count;
-        uint64_t underflowsPerSecond(){
-            return underflow_count;
+        uint32_t underflowsPerSecond(){
+            return underflow_per_second;
         }
-
-        uint64_t frameCount(){
-            return frame_count;
+        // provides the effectivly measured output frames per second
+        uint32_t framesPerSecond(){
+            return frames_per_second;
         }
 
+
         virtual void pwmWrite(int channel, int value) = 0;
 
     protected:
-        NBuffer<uint8_t> *buffer;
-        bool data_write_started = false;
-        uint64_t underflow_count = 0;
-        uint64_t frame_count = 0;
-        PWMCallbackType user_callback = nullptr;
         PWMConfig audio_config;
+        NBuffer<uint8_t> *buffer = nullptr;
+        PWMCallbackType user_callback = nullptr;
+        uint32_t underflow_count = 0;
+        uint32_t underflow_per_second = 0;
+        uint32_t frame_count = 0;
+        uint32_t frames_per_second = 0;
+        uint64_t time_1_sec;
+        bool is_timer_started = false;
 
         virtual void logConfig() {
             audio_config.logConfig();
         }
 
         virtual void setupPWM() = 0;
-        
         virtual void setupTimer() = 0;
+        virtual int maxChannels() = 0;
+        virtual int maxOutputValue() = 0;
 
 
         /// when we get the first write -> we activate the timer to start with the output of data
-        virtual void setWriteStarted(){
-            if (!data_write_started){
-                LOGI("timerAlarmEnable");
-                data_write_started = true;
+        virtual void startTimer(){
+            if (!is_timer_started){
+        	 	LOGD(__FUNCTION__);
+                is_timer_started = true;
             }
         }
 
+        inline void updateStatistics(){
+            frame_count++;
+            if (millis()>=time_1_sec){
+                time_1_sec = millis()+1000;
+                frames_per_second = frame_count;
+                underflow_per_second = underflow_count;
+                underflow_count = 0;
+                frame_count = 0;
+            }
+        }
+
+
         void playNextFrameCallback(){
+	 		//LOGD(__FUNCTION__);
             uint8_t channels = audio_config.channels;
             int16_t data[channels];
             if (user_callback(channels, data)){
-                frame_count++;
                 for (uint8_t j=0;j<audio_config.channels;j++){
                     int value  = map(data[j], -maxValue(16), maxValue(16), 0, 255); 
                     pwmWrite(j, value);
-                }                
+                }
+                updateStatistics();                
             }
         }
 
+
         /// writes the next frame to the output pins 
         void playNextFrameStream(){
-            static long underflow_time = millis()+1000;
-            if (data_write_started){
+            if (is_timer_started){
+	 		    //LOGD(__FUNCTION__);
                 int required = (audio_config.bits_per_sample / 8) * audio_config.channels;
                 if (buffer->available() >= required){
-                    underflow_count = 0;
-                    frame_count++;
                     for (int j=0;j<audio_config.channels;j++){
                         int value  = nextValue();
-                        Serial.println(value);
                         pwmWrite(j, value);
                     }
                 } else {
                     underflow_count++;
                 }
-
-                if (underflow_time>millis()){
-                    underflow_time = millis()+1000;
-                    underflow_count = 0;
-                }
+                updateStatistics();
+            } else {
+                //LOGE("is_timer_started is false");
             }
         } 
 
         void playNextFrame(){
+    	 	//LOGD(__FUNCTION__);
             if (user_callback!=nullptr){
                 playNextFrameCallback();
             } else {
@@ -265,31 +312,31 @@ class PWMAudioStreamBase : public Stream {
                         LOGE("Could not read full data");
                         value = 0;
                     }
-                    result = map(value, -maxValue(8), maxValue(8), 0, 255);
+                    result = map(value, -maxValue(8), maxValue(8), 0, maxOutputValue());
                     break;
                 }
                 case 16: {
                     int16_t value;
                     if (buffer->readArray((uint8_t*)&value,2)!=2){
                         LOGE("Could not read full data");
                     }
-                    result = map(value, -maxValue(16), maxValue(16), 0, 255);
+                    result = map(value, -maxValue(16), maxValue(16), 0, maxOutputValue());
                     break;
                 }
                 case 24: {
                     int24_t value;
                     if (buffer->readArray((uint8_t*)&value,3)!=3){
                         LOGE("Could not read full data");
                     }
-                    result = map((int32_t)value, -maxValue(24), maxValue(24), 0, 255);
+                    result = map((int32_t)value, -maxValue(24), maxValue(24), 0, maxOutputValue());
                     break;
                 }
                 case 32: {
                     int32_t value;
                     if (buffer->readArray((uint8_t*)&value,4)!=4){
                         LOGE("Could not read full data");
                     }
-                    result = map(value, -maxValue(32), maxValue(32), 0, 255);
+                    result = map(value, -maxValue(32), maxValue(32), 0, maxOutputValue());
                     break;
                 }
             }