Error corrections (PWM for ESP32 and notes)

pschatzmann · pschatzmann · commit 8d7353bbd1be · 2021-06-28T18:59:33.000+02:00
diff --git a/README.md b/README.md
@@ -75,7 +75,7 @@ A complete list of the supported Audio Stream classes and scenarios can be found
 
 - __I2SStream__: The best quality can be achieved with the help of I2S and an external DAC.  I2S is supporting 2 channels only. 
 - __AnalogAudioStream__: Some processors are providing an analog output, this is usually an easy and good approach: The number of pins (and herewith output channels) however is usually very limited.
-- __PWMAudioStream__: The last possibility is to simulate an analog output with the help of PWM by using a frequency which is beyond the audible range of 20 KHz. This method is supported by all processor and usually supports a bigger number of output pins. In terms of audio quality this is usually the worst option.
+- __PWMAudioStream__: The last possibility is to simulate an analog output with the help of PWM by using a frequency which is beyond the audible range of 20 KHz. This method is supported by all processors and usually supports a bigger number of output pins. In terms of audio quality this is usually the worst option.
 
 
 ## Examples
diff --git a/examples/streams-generator-i2s/streams-generator-i2s.ino b/examples/streams-generator-i2s/streams-generator-i2s.ino
@@ -33,7 +33,7 @@ void setup(void) {
   out.begin(config);
 
   // Setup sine wave
-  sineWave.begin(sample_rate, B4);
+  sineWave.begin(sample_rate, N_B4);
 }
 
 // Arduino loop - copy sound to out 
diff --git a/examples/streams-generator-webserver_wav/streams-generator-server_wav.ino b/examples/streams-generator-webserver_wav/streams-generator-server_wav.ino
@@ -24,7 +24,7 @@ void setup() {
   server.begin(in, sample_rate, channels);
 
   // start generation of sound
-  sineWave.begin(sample_rate, B4);
+  sineWave.begin(sample_rate, N_B4);
   in.begin();
 }
 
diff --git a/src/AudioPWM/PWMforESP32.h b/src/AudioPWM/PWMforESP32.h
@@ -34,15 +34,31 @@ static PWMAudioStreamESP32 *accessAudioPWM = nullptr;
 struct PWMConfigESP32 {
     int sample_rate = 10000;  // sample rate in Hz
     int channels = 2;
-    int start_pin = 3; 
     int buffer_size = 1024 * 8;
     int bits_per_sample = 16;
     int resolution = 8;  // must be between 8 and 11 -> drives pwm frequency
 
+    int start_pin = 3; 
+    int *pins = nullptr;
+
+    // determine the maximum number of channels
     int maxChannels() {
         return 16;
     }
 
+    // define all pins by passing an array and updates the channels by the number of pins
+    template<size_t N> 
+    void setPins(int (&array)[N]) {
+	 	LOGD(__FUNCTION__);
+        int new_channels = sizeof(array)/sizeof(int);
+        if (channels!=new_channels) {
+            LOGI("channels updated to %d", new_channels); 
+            channels = new_channels;
+        }
+        pins = array;
+        start_pin = -1; // mark start pin as invalid
+    }
+
 } default_config;
 
 typedef PWMConfigESP32 PWMConfig;
@@ -59,7 +75,6 @@ struct PinInfoESP32 {
 
 typedef PinInfoESP32 PinInfo;
 
-
 /**
  * @brief Audio output to PWM pins for the ESP32. The ESP32 supports up to 16 channels. 
  * @author Phil Schatzmann
@@ -91,7 +106,8 @@ class PWMAudioStreamESP32 : public Stream {
             LOGI("channels: %d", audio_config.channels);
             LOGI("bits_per_sample: %d", audio_config.bits_per_sample);
             LOGI("start_pin: %d", audio_config.start_pin);
-            LOGI("resolution: %d", audio_config.resolution);
+            LOGI("resolution: %d bits", audio_config.resolution);
+            LOGI("pwm freq: %f khz", frequency(audio_config.resolution));
 
             // controller has max 16 independent channels
             if (audio_config.channels>=16){
@@ -104,7 +120,6 @@ class PWMAudioStreamESP32 : public Stream {
                 LOGE("The resolution must be between 8 and 11!");
                 return false;
             }
-
             setupPWM();
             setupTimer();
             return true;
@@ -171,10 +186,16 @@ class PWMAudioStreamESP32 : public Stream {
             if (result!=size){
                 LOGW("Could not write all data: %d -> %d", size, result);
             }
+            // activate the timer now - if not already done
             setWriteStarted();
             return result;
         }
 
+        // When the timer does not have enough data we increase the underflow_count;
+        uint64_t underflowsPerSecond(){
+            return underflow_count;
+        }
+
 
     protected:
         PWMConfig audio_config;
@@ -183,6 +204,7 @@ class PWMAudioStreamESP32 : public Stream {
         hw_timer_t * timer = nullptr;
         portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;
         bool data_write_started = false;
+        uint64_t underflow_count = 0;
 
         /// when we get the first write -> we activate the timer to start with the output of data
         void setWriteStarted(){
@@ -199,22 +221,36 @@ class PWMAudioStreamESP32 : public Stream {
 
             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.start_pin + j;
+                if (audio_config.pins==nullptr){
+                    // use sequential pins starting from start_pin
+                    LOGD("-> defining pin %d",audio_config.start_pin + j);
+                    pins[j].gpio = audio_config.start_pin + j;
+                } else {
+                    // use defined pins
+                    LOGD("-> defining pin %d",audio_config.pins[j]);
+                    pins[j].gpio = audio_config.pins[j];
+                }
+                LOGD("-> ledcSetup");
                 ledcSetup(pwmChannel, frequency(audio_config.resolution), audio_config.resolution);
-                ledcAttachPin(pwmChannel, pins[j].gpio);
+                LOGD("-> ledcAttachPin");
+                ledcAttachPin(pins[j].gpio, pwmChannel);
             }
         }
 
         /// Setup ESP32 timer with callback
         void setupTimer() {
 	 		LOGD(__FUNCTION__);
+
             // Attach timer int at sample rate
             timer = timerBegin(0, 1, true); // Timer at full 40Mhz, no prescaling
             uint64_t counter = 40000000 / audio_config.sample_rate;
-            LOGI("timer counter is %lu", counter);
+            LOGI("-> timer counter is %lu", counter);
+            LOGD("-> timerAttachInterrupt");
             timerAttachInterrupt(timer, &defaultPWMAudioOutputCallback, true);
+            LOGD("-> timerAlarmWrite");
             timerAlarmWrite(timer, counter, true); // Timer fires at ~44100Hz [40Mhz / 907]
         } 
 
@@ -241,58 +277,76 @@ class PWMAudioStreamESP32 : public Stream {
 
         /// writes the next frame to the output pins 
         void playNextFrame(){
+            static long underflow_time = millis()+1000;
             if (data_write_started){
                 int required = (audio_config.bits_per_sample / 8) * audio_config.channels;
                 if (buffer.available() >= required){
+                    underflow_count = 0;
                     for (int j=0;j<audio_config.channels;j++){
                         int value  = nextValue();
-                        //Serial.println(value);
                         ledcWrite(pins[j].pwm_channel, value);
                     }
                 } else {
-                    LOGW("playNextFrame - underflow");
+                    underflow_count++;
                 }
+
+                if (underflow_time>millis()){
+                    underflow_time = millis()+1000;
+                    underflow_count = 0;
+                }
+ 
             }
         } 
 
         /// determines the next scaled value
         int nextValue() {
+            static long counter=0; static int min_value=INT_MAX; static int max_value=INT_MIN;
+
+            counter++;
+            int result;
             switch(audio_config.bits_per_sample ){
                 case 8: {
                     int value = buffer.read();
                     if (value<0){
                         LOGE("Could not read full data");
                         value = 0;
                     }
-                    return map(value, -maxValue(8), maxValue(8), 0, maxUnsignedValue());
+                    result = map(value, -maxValue(8), maxValue(8), 0, maxUnsignedValue());
+                    break;
                 }
                 case 16: {
                     int16_t value;
                     if (buffer.readArray((uint8_t*)&value,2)!=2){
                         LOGE("Could not read full data");
                     }
-                    //Serial.print(value);
-                    //Serial.print(" -> ");
-                    //Serial.println(map(value, -maxValue(16), maxValue(16), 0, maxUnsignedValue()));
-                    return map(value, -maxValue(16), maxValue(16), 0, maxUnsignedValue());
+                    result = map(value, -maxValue(16), maxValue(16), 0, maxUnsignedValue());
+                    break;
                 }
                 case 24: {
                     int24_t value;
                     if (buffer.readArray((uint8_t*)&value,3)!=3){
                         LOGE("Could not read full data");
                     }
-                    return map((int32_t)value, -maxValue(24), maxValue(24), 0, maxUnsignedValue());
+                    result = map((int32_t)value, -maxValue(24), maxValue(24), 0, maxUnsignedValue());
+                    break;
                 }
                 case 32: {
                     int32_t value;
                     if (buffer.readArray((uint8_t*)&value,4)!=4){
                         LOGE("Could not read full data");
                     }
-                    return map(value, -maxValue(32), maxValue(32), 0, maxUnsignedValue());
+                    result = map(value, -maxValue(32), maxValue(32), 0, maxUnsignedValue());
+                    break;
                 }
-            }            
-            LOGE("nextValue could not be determined because bits_per_sample is not valid: ",audio_config.bits_per_sample);
-            return 0;
+            }        
+
+            // if (counter>=1024){
+            //     max_value = max(max_value, result);
+            //     min_value = min(min_value, result);
+            //     LOGD("output: min %d / max %d", min_value, max_value);
+            //     counter = 0;
+            // }  
+            return result;
         }      
       
 };

Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ void setup(void) {`
`33`	`33`	`out.begin(config);`
`34`	`34`
`35`	`35`	`// Setup sine wave`
`36`		`- sineWave.begin(sample_rate, B4);`
	`36`	`+ sineWave.begin(sample_rate, N_B4);`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`// Arduino loop - copy sound to out`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ void setup() {`
`24`	`24`	`server.begin(in, sample_rate, channels);`
`25`	`25`
`26`	`26`	`// start generation of sound`
`27`		`- sineWave.begin(sample_rate, B4);`
	`27`	`+ sineWave.begin(sample_rate, N_B4);`
`28`	`28`	`in.begin();`
`29`	`29`	`}`
`30`	`30`