Simple Arduino Analog Read for the STM32

Author: pschatzmann

examples/tests/timer/test-timer/test-timer.ino

@@ -1,7 +1,5 @@
 #include "AudioTools.h"
 
-
-
 uint32_t sampling_rate = 44100;
 uint32_t delay_us = AudioUtils::toTimeUs(sampling_rate);
 uint32_t count;

src/AudioAnalog/AnalogAudioArduino.h

@@ -24,7 +24,7 @@ class AnalogConfig : public AudioBaseInfo {
   }
   int start_pin = PIN_ADC_START;
   uint16_t buffer_size = ADC_BUFFER_SIZE;
-  uint8_t buffers = ADC_BUFFERS;
+  uint16_t buffers = ADC_BUFFERS;
 };
 
 /**
@@ -37,7 +37,7 @@ class AnalogAudioStream : public AudioStreamX {
  public:
   AnalogAudioStream() = default;
 
-  AnalogConfig defaultConfig() {
+  AnalogConfig defaultConfig(RxTxMode mode=RX_MODE) {
     AnalogConfig cfg;
     return cfg;
   }
@@ -51,18 +51,15 @@ class AnalogAudioStream : public AudioStreamX {
  }
 
   bool begin(AnalogConfig cfg) {
-    LOGD("%s", __func__);
+    TRACED();
     config = cfg;
     if (buffer == nullptr) {
       // allocate buffers
       buffer = new NBuffer<int16_t>(cfg.buffer_size, cfg.buffers);
       if (buffer==nullptr){
         LOGE("Not enough memory for buffer");
         return false;
-      } else {
-        LOGI("buffer: %d", (int) buffer);
-        LOGI("self: %d", (int) this);
-      }
+      } 
       // setup pins
       setupPins();
     } else {
@@ -77,7 +74,7 @@ class AnalogAudioStream : public AudioStreamX {
     return timer.begin(callback, time, TimeUnit::US);
   }
 
-  virtual int available() { return buffer==nullptr ? 0 : buffer->available(); };
+  virtual int available() { return buffer==nullptr ? 0 : buffer->available()*2; };
 
   /// Provides the sampled audio data
   size_t readBytes(uint8_t *values, size_t len) {
@@ -90,6 +87,7 @@ class AnalogAudioStream : public AudioStreamX {
   AnalogConfig config;
   TimerAlarmRepeating timer;
   BaseBuffer<int16_t> *buffer = nullptr;
+  int16_t avg_value=0;
 
   /// Sample data and write to buffer
   static void callback(void *arg) {
@@ -98,26 +96,32 @@ class AnalogAudioStream : public AudioStreamX {
     if (self->buffer != nullptr) {
       int channels = self->config.channels;
       for (int j = 0; j < channels; j++) {
-        //Serial.print("+"); 
         // provides value in range 0…4095
         value = analogRead(self->config.start_pin + j);
-        //Serial.print("-");
-        value = (value-2048)*15;
+        value = (value - self->avg_value) * 16;
         self->buffer->write(value);
       }
     } 
   }
 
   /// pinmode input for defined analog pins
   void setupPins() {
-    LOGD("%s", __func__);
+    TRACED();
     LOGI("start_pin: %d", config.start_pin);
     // setup pins for read
     for (int j = 0; j < config.channels; j++) {
       int pin = config.start_pin + j;
       pinMode(pin, INPUT);
       LOGD("pinMode(%d, INPUT)",pin);
     }
+    // calculate the avarage value to center the signal
+    float total=0;
+    for (int j=0;j<200;j++){
+      total += analogRead(config.start_pin);
+    }
+    avg_value = total / 200.0;
+    LOGI("Avg Signal was %d", avg_value);
+
   }
 };
 

src/AudioConfig.h

@@ -405,7 +405,11 @@ typedef uint32_t eps32_i2s_sample_rate_type;
 #define USE_I2S
 #define USE_PWM
 #define USE_TIMER
+#define USE_ADC_ARDUINO
+#define ADC_BUFFER_SIZE 1024
+#define ADC_BUFFERS 20
 
+#define PIN_ADC_START PA0
 #define PIN_PWM_START 6
 #define PIN_I2S_BCK 1
 #define PIN_I2S_WS PIN_I2S_BCK+1

src/AudioI2S/I2SSTM32.h

@@ -8,7 +8,7 @@ namespace audio_tools {
 
 /**
  * @brief Basic I2S API - for the STM32
- * Depends on https://github.com/pschatzmann/STM32F411-i2s-prototype
+ * Depends on https://github.com/pschatzmann/stm32f411-i2s
  * We just add a write and read buffer and pass some parameters to the STM32 API!
  * @author Phil Schatzmann
  * @copyright GPLv3
@@ -27,11 +27,14 @@ class I2SBase {
 
     /// starts the DAC with the default config in TX Mode
     bool begin(RxTxMode mode = TX_MODE) {
+      TRACED();
       return begin(defaultConfig(mode));
     }
 
     /// starts the DAC 
     bool begin(I2SConfig cfg) {
+      TRACED();
+      bool result = false;
       deleteBuffers();
 
       if (cfg.bits_per_sample!=16){
@@ -48,27 +51,28 @@ class I2SBase {
       switch(cfg.rx_tx_mode){
         case RX_MODE:
           p_rx_buffer = new NBuffer<uint8_t>(cfg.buffer_size, cfg.buffer_count);
-        	startI2SReceive(&i2s_stm32, writeFromReceive, cfg.buffer_size);
+        	result = startI2SReceive(&i2s_stm32, writeFromReceive, cfg.buffer_size);
           break;
         case TX_MODE:
           p_tx_buffer = new NBuffer<uint8_t>(cfg.buffer_size, cfg.buffer_count);
-      	  startI2STransmit(&i2s_stm32, readToTransmit, cfg.buffer_size);
+      	  result =  startI2STransmit(&i2s_stm32, readToTransmit, cfg.buffer_size);
           break;
         case RXTX_MODE:
           p_tx_buffer = new NBuffer<uint8_t>(cfg.buffer_size, cfg.buffer_count);
-	        startI2STransmitReceive(&i2s_stm32, readToTransmit, writeFromReceive, cfg.buffer_size);
+	        result = startI2STransmitReceive(&i2s_stm32, readToTransmit, writeFromReceive, cfg.buffer_size);
           break;
         default:
           LOGE("Unsupported mode");
           return false;
 
       }
 
-      return true;
+      return result;
     }
 
     /// stops the I2C and unistalls the driver
     void end(){
+      TRACED();
       stopI2S();
       deleteBuffers();
     }
@@ -80,42 +84,33 @@ class I2SBase {
 
     /// We limit the write size to the buffer size
     int availableForWrite() {
-      return I2S_BUFFER_COUNT*I2S_BUFFER_SIZE;
+      return I2S_BUFFER_SIZE;
     }
 
     /// provides the actual configuration
     I2SConfig config() {
       return cfg;
     }
 
-    /// writes the data to the I2S interface
+    /// blocking writes for the data to the I2S interface
     size_t writeBytes(const void *src, size_t size_bytes){
+      TRACED();
       size_t result = 0;
-      if (cfg.channels == 2){
-        result = p_tx_buffer->writeArray((uint8_t*)src, size_bytes);
-      } else {
-        // write each sample 2 times 
-        int samples = size_bytes / 2;
-        int16_t *src_16 = (int16_t *)src;
-        int16_t tmp[2];
-        int result = 0;
-        for (int j=0;j<samples;j++){
-          tmp[0]=src_16[j];
-          tmp[1]=src_16[j];
-          if (p_tx_buffer->availableForWrite()>=4){
-            p_tx_buffer->writeArray((uint8_t*)tmp, 4);
-            result = j*2;
-          } else {
-            // abort if the buffer is full
-            break;
-          }
-        } 
+      int open = size_bytes;
+      while(open>0){
+        int actual_written = writeBytesExt(src, size_bytes);
+        result+= actual_written;
+        open -= actual_written;
+        if (open>0){
+          delay(10);
+        }
       }
       return result;
     }
 
     size_t readBytes(void *dest, size_t size_bytes){
-      if (cfg.channels == 2){
+       TRACED();
+     if (cfg.channels == 2){
         return p_rx_buffer->readArray((uint8_t*)dest, size_bytes);
       } else {
         // combine two channels to 1: so request double the amout
@@ -134,10 +129,12 @@ class I2SBase {
       }
     }
 
+    /// @brief Callback function used by https://github.com/pschatzmann/stm32f411-i2s 
     static void writeFromReceive(uint8_t *buffer, uint16_t byteCount){
       p_rx_buffer->writeArray(buffer, byteCount);
     }
 
+    /// @brief Callback function used by https://github.com/pschatzmann/stm32f411-i2s 
     static void readToTransmit(uint8_t *buffer, uint16_t byteCount) {
       memset(buffer,0,byteCount);
       p_tx_buffer->readArray(buffer, byteCount);
@@ -227,7 +224,31 @@ class I2SBase {
       }
     }
 
-
+    size_t writeBytesExt(const void *src, size_t size_bytes){
+      size_t result = 0;
+      if (cfg.channels == 2){
+        result = p_tx_buffer->writeArray((uint8_t*)src, size_bytes);
+      } else {
+        // write each sample 2 times 
+        int samples = size_bytes / 2;
+        int16_t *src_16 = (int16_t *)src;
+        int16_t tmp[2];
+        int result = 0;
+        for (int j=0;j<samples;j++){
+          tmp[0]=src_16[j];
+          tmp[1]=src_16[j];
+          if (p_tx_buffer->availableForWrite()>=4){
+            p_tx_buffer->writeArray((uint8_t*)tmp, 4);
+            result = j*2;
+          } else {
+            // abort if the buffer is full
+            break;
+          }
+        } 
+      }
+      LOGD("writeBytesExt: %u", result)
+      return result;
+    }
 };
 
 }

src/AudioTimer/AudioTimerSTM32.h

@@ -33,7 +33,8 @@ class TimerAlarmRepeatingSTM32 : public TimerAlarmRepeatingDef {
          * Starts the alarm timer
          */
         bool begin(repeating_timer_callback_t callback_f, uint32_t time, TimeUnit unit = MS) override {
-            timer->attachInterrupt(std::bind(callback_f, this)); 
+            TRACEI();
+            timer->attachInterrupt(std::bind(callback_f, object)); 
 
             // we determine the time in microseconds
             switch(unit){
@@ -50,6 +51,7 @@ class TimerAlarmRepeatingSTM32 : public TimerAlarmRepeatingDef {
 
         // ends the timer and if necessary the task
         bool end() override {
+            TRACEI();
             timer->pause();
             return true;
         }