PWM Support for MBED

Author: pschatzmann

docs/.DS_Store

@@ -8,28 +8,42 @@
  * @copyright Copyright (c) 2021
  */
 
+/**
+ * @file stream-memory_wav-pwm.ino
+ * @author Phil Schatzmann
+ * @brief decode WAV stream and output to PWM pins
+ * @version 0.1
+ * @date 2021-01-24
+ * 
+ * @copyright Copyright (c) 2021
+ */
+
 #include "AudioTools.h"
 #include "CodecWAV.h"
-#include "knghtsng.h"
+//#include "knghtsng.h"
+#include "alice.h"
 
 using namespace audio_tools;  
 
-// MemoryStream -> AudioOutputStream -> WAVDecoder -> PWMAudioStream
-MemoryStream wav(knghtsng_wav, knghtsng_wav_len);
+//Data Flow: MemoryStream -> AudioOutputStream -> WAVDecoder -> PWMAudioStream
+
+//MemoryStream wav(knghtsng_wav, knghtsng_wav_len);
+MemoryStream wav(alice_wav, alice_wav_len);
 PWMAudioStream pwm;          // PWM output 
 WAVDecoder decoder(pwm);        // decode wav to pcm and send it to printer
 AudioOutputStream out(decoder); // output to decoder
 StreamCopy copier(out, wav);    // copy in to out
+PWMConfig config = pwm.defaultConfig();
 
 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 = 11025;
+  //config.sample_rate = 11025;  // for knghtsng_wav
+  config.sample_rate = 8000;  // for alice_wav
   pwm.begin(config);
 }
 
@@ -41,6 +55,12 @@ void loop(){
     auto info = decoder.audioInfo();
     LOGI("The audio rate from the wav file is %d", info.sample_rate);
     LOGI("The channels from the wav file is %d", info.channels);
-    stop();
+
+    // restart from the beginning
+    Serial.println("Restarting...");
+    delay(5000);
+    decoder.begin();   // indicate that we process the WAV header
+    wav.begin();       // reset actual position to 0
+    pwm.begin();       // reset counters 
   }
 }

examples/streams-memory_wav-pwm/alice.h

@@ -40,16 +40,27 @@
 #define A2DP_BUFFER_SIZE 4096
 #define A2DP_BUFFER_COUNT 8
 #define DEFAUT_ADC_PIN 34
+
+
+/**
+ * ------------------------------------------------------------------------- 
+ * @brief PWM
+ */
 #define PWM_BUFFER_SIZE 512
 #define PWM_BUFFERS 10
-
+#define PWM_FREQUENCY 60000
+#if defined(ESP32)
+#define PWM_START_PIN 4
+#elif defined(__arm__)
+#define PWM_START_PIN 2
+#endif
 /**
  * ------------------------------------------------------------------------- 
- * @brief Optional Functionality - comment out if not wanted
+ * @brief Optional Functionality - comment out if not wanted 
  */
-
+#ifndef __arm__
 #define USE_URL_ARDUINO
-
+#endif
 
 // Activate ESP32 Audio - for ESP32, ESP8266 and Raspberry Pico
 #define USE_ESP8266_AUDIO

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

@@ -17,53 +17,30 @@ void defaultPWMAudioOutputCallback();
 // Stream classes
 class PWMAudioStreamESP32;
 class PWMAudioStreamPico;
+class PWMAudioStreamMBED;
 
 /**
  * PWMConfigAVR
  * @author Phil Schatzmann
  * @copyright GPLv3
  */
 struct PWMConfig {
+    friend class PWMAudioStreamESP32;
+    friend class PWMAudioStreamPico;
+    friend class PWMAudioStreamMBED;
+
+    // basic information
     uint16_t sample_rate = 10000;  // sample rate in Hz
     uint8_t channels = 2;
     uint8_t bits_per_sample = 16;
     uint16_t buffer_size = PWM_BUFFER_SIZE;
     uint8_t buffers = PWM_BUFFERS; 
 
-    void logConfig(){
-        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
-/**
- * @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;
-
+    // additinal info
+    uint16_t start_pin = PWM_START_PIN; 
+    uint32_t pwm_frequency = PWM_FREQUENCY;  // audable range is from 20 to 20,000Hz (not used by ESP32)
+    uint8_t resolution = 8;     // Only used by ESP32: must be between 8 and 11 -> drives pwm frequency
+    uint8_t timer_id = 0;       // Only used by ESP32 must be between 0 and 3
 
     // define all pins by passing an array and updates the channels by the number of pins
     template<size_t N> 
@@ -78,12 +55,21 @@ struct PWMConfig {
         start_pin = -1; // mark start pin as invalid
     }
 
+    void logConfig(){
+        LOGI("sample_rate: %d", sample_rate);
+        LOGI("channels: %d", channels);
+        LOGI("bits_per_sample: %d", bits_per_sample);
+        LOGI("buffer_size: %d", buffer_size);
+        LOGI("start_pin: %d", start_pin);
+        LOGI("pwm_frequency: %d", pwm_frequency);
+        //LOGI("resolution: %d", resolution);
+        //LOGI("timer_id: %d", timer_id);
+    }
+
     protected:
         int *pins = nullptr;
 
 
-#endif
-
 } default_config;
 
 
@@ -93,6 +79,11 @@ struct PWMConfig {
  */
 class PWMAudioStreamBase : public Stream {
     public:
+        ~PWMAudioStreamBase(){
+            if (is_timer_started){
+                end();
+            }
+        }
 
         PWMConfig defaultConfig() {
             return default_config;
@@ -134,6 +125,8 @@ class PWMAudioStreamBase : public Stream {
             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);
+            } else {
+                buffer->reset();
             }
             // check allocation
             if (buffer==nullptr){
@@ -146,7 +139,45 @@ class PWMAudioStreamBase : public Stream {
             setupTimer();
 
             return true;
-        }   
+        }  
+
+        // restart with prior definitions
+        bool begin(){
+	 		LOGD(__FUNCTION__);
+            // allocate buffer if necessary
+            if (user_callback==nullptr) {
+                if (buffer==nullptr) {
+                    LOGI("->Allocating new buffer %d * %d bytes",audio_config.buffers, audio_config.buffer_size);
+                    buffer = new NBuffer<uint8_t>(audio_config.buffer_size, audio_config.buffers);
+                } else {
+                    buffer->reset();
+                }
+            }
+            // initialize if necessary
+            if (!is_timer_started){
+                logConfig();
+                setupPWM();
+                setupTimer();
+            }
+
+            // reset class variables
+            is_timer_started = true;
+            underflow_count = 0;
+            underflow_per_second = 0;
+            frame_count = 0;
+            frames_per_second = 0;     
+            
+            LOGI("->Buffer available: %d", buffer->available());
+            LOGI("->Buffer available for write: %d", buffer->availableToWrite());
+            LOGI("->is_timer_started: %s ", is_timer_started ? "true" : "false");
+        } 
+
+        virtual void end(){
+	 		LOGD(__FUNCTION__);
+            is_timer_started = false;
+        }
+
+
         // not supported
         virtual int available() {
             LOGE("not supported");
@@ -190,15 +221,10 @@ class PWMAudioStreamBase : public Stream {
 
         // 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){
-            LOGD("write: %lu bytes", size)
-            bool log_flag = true;
-            while(availableForWrite()<size){
-                if (log_flag) LOGI("Buffer is full - waiting...");
-                log_flag = false;
-                delay(10);
-            }
-            size_t result = buffer->writeArray(wrt_buffer, size);
-            if (result!=size){
+            size_t available = min((size_t)availableForWrite(),size);
+            LOGD("write: %lu bytes -> %lu", size, available);
+            size_t result = buffer->writeArray(wrt_buffer, available);
+            if (result!=available){
                 LOGW("Could not write all data: %d -> %d", size, result);
             }
             // activate the timer now - if not already done
@@ -229,10 +255,6 @@ class PWMAudioStreamBase : public Stream {
         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;
@@ -258,6 +280,9 @@ class PWMAudioStreamBase : public Stream {
             }
         }
 
+        void logConfig() {
+            audio_config.logConfig();
+        }
 
         void playNextFrameCallback(){
 	 		//LOGD(__FUNCTION__);

src/AudioConfig.h

@@ -68,6 +68,9 @@ class PWMAudioStreamESP32 : public PWMAudioStreamBase {
         /// Setup LED PWM
         virtual void setupPWM(){
             LOGD(__FUNCTION__);
+            // frequency is driven by selected resolution
+            uint64_t freq = frequency(audio_config.resolution)*1000;
+            audio_config.pwm_frequency = freq;
 
             pins.resize(audio_config.channels);
             for (int j=0;j<audio_config.channels;j++){
@@ -83,7 +86,6 @@ class PWMAudioStreamESP32 : public PWMAudioStreamBase {
                     LOGD("-> defining pin %d",audio_config.pins[j]);
                     pins[j].gpio = audio_config.pins[j];
                 }
-                uint64_t freq = frequency(audio_config.resolution)*1000;
                 LOGD("-> ledcSetup:  frequency=%d / resolution=%d", freq, audio_config.resolution);
                 ledcSetup(pwmChannel, freq, audio_config.resolution);
                 LOGD("-> ledcAttachPin: %d", pins[j].gpio);