ESP32 A1S Audio Kit microphone problem

[mrbayri]

I want to connect to the internet using the ESP32 A1S Audio Kit, record audio from the microphone, save the recording to the SD card, then convert the recorded audio to base64 and send it to a web service. After receiving the response, I want to save it to the SD card and then play it through the speaker. My code is below — could you please help me?

#include "AudioTools.h"
#include "AudioTools/AudioLibs/AudioBoardStream.h"
#include "AudioTools/Disk/AudioSourceSDMMC.h"
#include "AudioTools/AudioCodecs/CodecMP3Helix.h"
#include <WiFi.h>
#include <HTTPClient.h>
#include <SD_MMC.h>
#include <driver/i2s.h>
#include "mbedtls/base64.h"
#include <WiFiClientSecure.h>
#include "base64.h"

const char *ssid = "*****";
const char *password = "******";

const char *speakToTextUrl = "https://******";
const char *audioFilePath = "/recorded.wav";

#define I2S_BCLK 27
#define I2S_LRC 26
#define I2S_DIN 35
#define KEY1_PIN 13

const int sampleRate = 16000;
const int bitsPerSample = 16;
const int channels = 1;
const int recordDuration = 5;

I2SStream i2s;
const char *startFilePath="/";
const char* ext="mp3";
AudioSourceSDMMC source(startFilePath, ext);
AudioBoardStream kit(AudioKitEs8388V1);
MP3DecoderHelix decoder; 
AudioPlayer player(source, kit, decoder);

void setup() {
  Serial.begin(115200);
  connectToWiFi();
  initializeSDCard();
  initializeI2S();
  pinMode(KEY1_PIN, INPUT_PULLUP);
}

void loop() {
  if (digitalRead(KEY1_PIN) == LOW) {
    delay(200);
    recordAudio();
    if (sendAudioToServer()) {
      Serial.println("✅ Success!");
    } else {
      Serial.println("❌ Fail");
    }

    while (digitalRead(KEY1_PIN) == LOW) {
      delay(10);
    }
  }
}

void connectToWiFi() {
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("\nWiFi connected!");
  Serial.print("IP Address: ");
  Serial.println(WiFi.localIP());
}

void initializeSDCard() {
  if (!SD_MMC.begin("/sdcard", true)) {
    Serial.println("SD card fail");
    while (1);
  }
  Serial.println("SD card success");
}

void initializeI2S() {
  auto i2sConfig = i2s.defaultConfig(RX_MODE);
  i2sConfig.sample_rate = sampleRate;
  i2sConfig.bits_per_sample = bitsPerSample;
  i2sConfig.channels = channels;
  i2sConfig.pin_bck = I2S_BCLK;
  i2sConfig.pin_ws = I2S_LRC;
  i2sConfig.pin_data = I2S_DIN;
  i2sConfig.i2s_format = I2S_STD_FORMAT;
  //i2sConfig.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT; // veya RIGHT
  i2s.begin(i2sConfig);
  Serial.println("I2S success");
}

void recordAudio() {
  uint8_t wavHeader[44];
  createWavHeader(wavHeader, sampleRate, bitsPerSample, channels, recordDuration * sampleRate * channels * (bitsPerSample / 8));

  File file = SD_MMC.open(audioFilePath, FILE_WRITE);
  if (!file) {
    Serial.println("Dosya oluşturulamadı!");
    return;
  }

  file.write(wavHeader, 44);
  uint8_t buffer[1024];
  unsigned long startTime = millis();

  while (millis() - startTime < recordDuration * 1000) {
    size_t bytesRead = i2s.readBytes(buffer, sizeof(buffer));
    //file.write(buffer, bytesRead);
    if (file.write(buffer, bytesRead) != bytesRead) {
      Serial.println("File write error!");
      break;
    }
  }

  file.close();
  Serial.println("Record ok");
}

#include "mbedtls/base64.h"

bool sendAudioToServer() {
  WiFiClient client;
  HTTPClient http;

  String boundary = "----WebKitFormBoundary" + String(millis(), HEX);
  String contentType = "multipart/form-data; boundary=" + boundary;

  if (!http.begin(client, speakToTextUrl)) {
    Serial.println("HTTP connection error");
    return false;
  }

  http.addHeader("Content-Type", contentType);

  // Dosyayı aç
  File file = SD_MMC.open(audioFilePath, FILE_READ);
  if (!file) {
    Serial.println("voice file error!");
    http.end();
    return false;
  }

  
  Serial.printf("File size: %d byte\n", file.size());

  const size_t chunkSize2 = 512;
  uint8_t buffer2[chunkSize2];
  size_t bytesRead2 = i2s.readBytes(buffer2, sizeof(buffer2));
  Serial.printf("readBytes: %d\n", bytesRead2);
  for (int i = 0; i < 10; i++) {
    Serial.printf("%02X ", buffer2[i]);
  }
  Serial.println();

  Serial.println("\n\n Base64 starting.");

  const size_t chunkSize = 512;
  uint8_t buffer[chunkSize];
  String encodedData = "";
  while (file.available()) {
    size_t bytesRead = file.read(buffer, chunkSize);
    encodedData += base64::encode(buffer, bytesRead);
    Serial.println(encodedData);
  }

  file.close();
  Serial.println("\n\n[✓] Base64 encode done.");

  // HTTP İsteği
  http.begin(speakToTextUrl);
  http.addHeader("Content-Type", "application/x-www-form-urlencoded");

  String postData = "audio=" + encodedData;
  int httpResponseCode = http.POST(postData);

  if (httpResponseCode == 200) {
      Serial.println("✅ HTTP success, data receiving...");

      WiFiClient *stream = http.getStreamPtr();
      File file = SD_MMC.open("/voice.mp3", FILE_WRITE);

      if (!file) {
        Serial.println("❌ File error!");
        return false;
      }

      uint8_t buffer[2048];           // buffer büyütüldü → daha az I/O çağrısı
      unsigned long lastData = millis();
      int total = 0;

      // maksimum 10 saniye boyunca veri bekle (timeout)
      while ((millis() - lastData < 10000)) {
        if (stream->available()) {
          int len = stream->read(buffer, sizeof(buffer));
          if (len > 0) {
            file.write(buffer, len);
            total += len;
            lastData = millis();  // en son veri geldiği zamanı güncelle
          }
        } else {
          delay(10);  // CPU yüklenmesin
        }
      }

      file.close();
      Serial.printf("✅ File write done. Total size: %d byte\n", total);
  } else {
    Serial.printf("HTTP error: %d\n", httpResponseCode);
  }
  http.end();
  
  
  //AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Info);

  // setup output
  auto cfg = kit.defaultConfig(TX_MODE);
  cfg.sd_active = false;
  kit.begin(cfg);

  // setup player
  player.setVolume(0.8);
  player.begin();

  // select file with setPath() or setIndex()
  player.setPath("/voice.mp3");
  player.setIndex(0); // 2nd file
  


  return true;
}

void createWavHeader(uint8_t* header, uint32_t sampleRate, uint16_t bitsPerSample, uint16_t channels, uint32_t dataSize) {
  header[0] = 'R'; header[1] = 'I'; header[2] = 'F'; header[3] = 'F';
  uint32_t fileSize = dataSize + 36;
  header[4] = fileSize & 0xFF;
  header[5] = (fileSize >> 8) & 0xFF;
  header[6] = (fileSize >> 16) & 0xFF;
  header[7] = (fileSize >> 24) & 0xFF;
  header[8] = 'W'; header[9] = 'A'; header[10] = 'V'; header[11] = 'E';
  header[12] = 'f'; header[13] = 'm'; header[14] = 't'; header[15] = ' ';
  header[16] = 16; header[17] = 0; header[18] = 0; header[19] = 0;
  header[20] = 1; header[21] = 0;
  header[22] = channels; header[23] = 0;
  header[24] = sampleRate & 0xFF;
  header[25] = (sampleRate >> 8) & 0xFF;
  header[26] = (sampleRate >> 16) & 0xFF;
  header[27] = (sampleRate >> 24) & 0xFF;
  uint32_t byteRate = sampleRate * channels * (bitsPerSample / 8);
  header[28] = byteRate & 0xFF;
  header[29] = (byteRate >> 8) & 0xFF;
  header[30] = (byteRate >> 16) & 0xFF;
  header[31] = (byteRate >> 24) & 0xFF;
  header[32] = channels * (bitsPerSample / 8);
  header[33] = 0;
  header[34] = bitsPerSample; header[35] = 0;
  header[36] = 'd'; header[37] = 'a'; header[38] = 't'; header[39] = 'a';
  header[40] = dataSize & 0xFF;
  header[41] = (dataSize >> 8) & 0xFF;
  header[42] = (dataSize >> 16) & 0xFF;
  header[43] = (dataSize >> 24) & 0xFF;
}

[pschatzmann]

This is way too complicated to build in one step: follow the advice given in this Wiki and test each function separatly!

You could also use more functionality from this library and use a more declarative way and define processing chains for the processing:

• Use an EncodedAudioStream To write the WAV with WAVEncoder
• Use an EncodedAudioStream with EncoderBase64 (though I recommend to skip this unnecessary step)

Here is a simple example that posts the audio directly w/o the need to write anything into a file