Multioutput -- play wav, fft, volume meter and mic w fft and volumeter

[hammerheaddown]

I used the sine generator fft sampled and tweaked and that working , then saw info on volume meeter and wanted to add that ... so many cool features on here lol

anyway i want to record a wav, and use volume meter to detect silence like:
https://github.com/pschatzmann/arduino-audio-tools/discussions/1661

i used some code from:
https://github.com/pschatzmann/arduino-audio-tools/discussions/405

i cant seem to get the pipeline right and trust me trying and just gave up and posted this here and see what the heck is wrong, i knew @pschatzmann could point it out in a min

thanks for all these cool features, been reading a ton of your blog posts and it got me into the fft

EDIT : i know you have a recording code, but i have been using another one but willing to use yours as well as cutting cutting off silence. i may have forgotten to ad the wav saving part of code :( its ok i can record i know that lol

#include <Arduino.h>
#include "FS.h"
#include "SD.h"
#include <SPI.h>
#include "AudioTools.h"
#include "AudioTools/AudioLibs/AudioRealFFT.h"
#include "AudioTools/AudioCodecs/CodecWAV.h"
#include "driver/i2s_std.h"

// Debug mode
#define DEBUG_MODE

// SD Pin Setup
#define SD_MISO GPIO_NUM_13
#define SD_MOSI GPIO_NUM_11
#define SD_SCK GPIO_NUM_12
#define SD_CS GPIO_NUM_10

// Mic Pin Setup
#define I2S_MIC_LEFT_RIGHT_CLOCK GPIO_NUM_2
#define I2S_MIC_SERIAL_DATA GPIO_NUM_4
#define I2S_MIC_SERIAL_CLOCK GPIO_NUM_15
i2s_chan_handle_t mic_rx_handle;

// Amp Pin Setup
#define I2S_BCLK GPIO_NUM_5
#define I2S_DOUT GPIO_NUM_6
#define I2S_LRC GPIO_NUM_14
i2s_chan_handle_t tx_handle;

// Config
#define SAMPLE_RATE 16000
#define REC_BUFFER_SIZE 1024
const char* wavFilename = "/audio.wav";

// Audio Processing Setup
File file;                      // SD file source/sink
WAVDecoder decoder;             // WAV decoder
WAVEncoder encoder;             // WAV encoder for recording
VolumeMeter volumeMeter;        // Volume analysis
AudioRealFFT fft;               // FFT analysis
I2SStream i2s_out;              // Amp output
MultiOutput multiOut;           // Split to amp, volume, FFT
AudioInfo info(SAMPLE_RATE, 1, 16); // Mono, 16-bit, 16kHz
EncodedAudioStream encoderStream(&file, &encoder); // Recording stream
StreamCopy copier;              // For playback only

// Global Variables
String serialCommand = "";
bool isRecording = false;
int16_t buffer[REC_BUFFER_SIZE];

// FFT Callback
void fftResult(AudioFFTBase &fft) {
    auto result = fft.result();
    #ifdef DEBUG_MODE
    Serial.print("Frequency: ");
    Serial.print(result.frequency);
    Serial.print(" Hz | Magnitude: ");
    Serial.println(result.magnitude);
    #endif
}

// Setup Functions
void SD_setup() {
    pinMode(SD_CS, OUTPUT);
    digitalWrite(SD_CS, HIGH);
    delay(10);

    SPI.begin(SD_SCK, SD_MISO, SD_MOSI, SD_CS);
    SPI.setFrequency(4000000);
    delay(1000);

    if (!SD.begin(SD_CS)) {
        #ifdef DEBUG_MODE
        Serial.println("SD card mount failed!");
        #endif
        ESP.restart();
    }
    #ifdef DEBUG_MODE
    Serial.println("SD card initialized.");
    #endif
}

void mic_setup() {
    i2s_chan_config_t chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_0, I2S_ROLE_MASTER);
    i2s_new_channel(&chan_cfg, NULL, &mic_rx_handle);

    i2s_std_config_t std_cfg = {
        .clk_cfg = {
            .sample_rate_hz = SAMPLE_RATE,
            .clk_src = I2S_CLK_SRC_DEFAULT,
            .mclk_multiple = I2S_MCLK_MULTIPLE_256,
        },
        .slot_cfg = {
            .data_bit_width = I2S_DATA_BIT_WIDTH_32BIT,
            .slot_bit_width = I2S_SLOT_BIT_WIDTH_AUTO,
            .slot_mode = I2S_SLOT_MODE_MONO,
            .slot_mask = I2S_STD_SLOT_LEFT,
            .ws_width = I2S_DATA_BIT_WIDTH_16BIT,
            .ws_pol = false,
            .bit_shift = true,
        },
        .gpio_cfg = {
            .mclk = I2S_GPIO_UNUSED,
            .bclk = I2S_MIC_SERIAL_CLOCK,
            .ws = I2S_MIC_LEFT_RIGHT_CLOCK,
            .dout = I2S_GPIO_UNUSED,
            .din = I2S_MIC_SERIAL_DATA,
            .invert_flags = {0},
        },
    };

    if (i2s_channel_init_std_mode(mic_rx_handle, &std_cfg) != ESP_OK) {
        #ifdef DEBUG_MODE
        Serial.println("Error installing Mic driver");
        #endif
        while (1);
    }
    if (i2s_channel_enable(mic_rx_handle) != ESP_OK) {
        #ifdef DEBUG_MODE
        Serial.println("Error enabling mic channel");
        #endif
        while (1);
    }
    #ifdef DEBUG_MODE
    Serial.println("Mic setup complete.");
    #endif
}

void amp_setup() {
    i2s_chan_config_t tx_chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_1, I2S_ROLE_MASTER);
    esp_err_t ret = i2s_new_channel(&tx_chan_cfg, &tx_handle, NULL);
    if (ret != ESP_OK) {
        #ifdef DEBUG_MODE
        Serial.printf("Amp channel creation failed: %x\n", ret);
        #endif
        return;
    }

    i2s_std_config_t std_tx_cfg = {
        .clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(SAMPLE_RATE),
        .slot_cfg = I2S_STD_MSB_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO),
        .gpio_cfg = {
            .mclk = I2S_GPIO_UNUSED,
            .bclk = I2S_BCLK,
            .ws = I2S_LRC,
            .dout = I2S_DOUT,
            .din = I2S_GPIO_UNUSED,
            .invert_flags = {0},
        },
    };

    if (i2s_channel_init_std_mode(tx_handle, &std_tx_cfg) != ESP_OK) {
        #ifdef DEBUG_MODE
        Serial.println("Error installing Amp driver");
        #endif
        while (1);
    }
    #ifdef DEBUG_MODE
    Serial.println("Amp setup complete.");
    #endif
}

void pipeline_setup() {
    auto fftCfg = fft.defaultConfig();
    fftCfg.length = 1024;
    fftCfg.channels = 1;
    fftCfg.sample_rate = SAMPLE_RATE;
    fftCfg.bits_per_sample = 16;
    fftCfg.callback = &fftResult;
    fft.begin(fftCfg);

    auto cfg_out = i2s_out.defaultConfig(TX_MODE);
    cfg_out.copyFrom(info);
    cfg_out.port_no = I2S_NUM_1;
    cfg_out.pin_bck = I2S_BCLK;
    cfg_out.pin_ws = I2S_LRC;
    cfg_out.pin_data = I2S_DOUT;
    i2s_out.begin(cfg_out);

    volumeMeter.begin(info);
    multiOut.add(i2s_out);
    multiOut.add(volumeMeter);
    multiOut.add(fft);
    multiOut.begin(info);

    #ifdef DEBUG_MODE
    Serial.println("Pipeline setup complete.");
    #endif
}

void setup() {
    Serial.begin(115200);
    AudioLogger::instance().begin(Serial, AudioLogger::Error);
    SD_setup();
    mic_setup();
    amp_setup();
    pipeline_setup();
    #ifdef DEBUG_MODE
    Serial.println("Setup complete!");
    printCommands();
    #endif
}

// Playback Function
void playAudio() {
    file = SD.open(wavFilename, FILE_READ);
    if (!file) {
        #ifdef DEBUG_MODE
        Serial.println("Failed to open WAV file for playback!");
        #endif
        return;
    }

    #ifdef DEBUG_MODE
    Serial.println("Playing: " + String(wavFilename));
    #endif

    decoder.begin();
    copier.begin(multiOut, file); // File -> MultiOutput (amp, volume, FFT)
    while (file.available()) {
        copier.copy();
    }
    file.close();
    decoder.end();
    copier.end();
    i2s_out.flush(); // Clear I2S buffer
    #ifdef DEBUG_MODE
    Serial.println("Playback finished.");
    #endif
}

// Recording Function
void recordAudio() {
    if (SD.exists(wavFilename)) SD.remove(wavFilename);
    file = SD.open(wavFilename, FILE_WRITE);
    if (!file) {
        #ifdef DEBUG_MODE
        Serial.println("Failed to open WAV file for recording!");
        #endif
        return;
    }

    #ifdef DEBUG_MODE
    Serial.println("Recording to: " + String(wavFilename));
    #endif

    encoder.begin();
    isRecording = true;
}

// Stop Recording
void stopRecording() {
    if (isRecording) {
        isRecording = false;
        encoder.end();
        file.close();
        #ifdef DEBUG_MODE
        Serial.println("Recording stopped.");
        #endif
    }
}

// Helper Functions
void printCommands() {
    #ifdef DEBUG_MODE
    Serial.println("Commands: '1' record, '2' stop, '3' play");
    #endif
}

// Main Loop
void loop() {
    if (Serial.available() > 0) {
        char c = Serial.read();
        if (c == '\n' || c == '\r') {
            if (serialCommand.length() > 0) {
                if (serialCommand == "1" && !isRecording) {
                    recordAudio();
                } else if (serialCommand == "2" && isRecording) {
                    stopRecording();
                    printCommands();
                } else if (serialCommand == "3" && !isRecording) {
                    playAudio();
                } else {
                    #ifdef DEBUG_MODE
                    Serial.println("Invalid command or state!");
                    #endif
                }
                serialCommand = "";
            }
        } else {
            serialCommand += c;
        }
    }

    if (isRecording) {
        size_t bytesRead;
        if (i2s_channel_read(mic_rx_handle, buffer, REC_BUFFER_SIZE * sizeof(int16_t), &bytesRead, portMAX_DELAY) == ESP_OK) {
            multiOut.write((uint8_t *)buffer, bytesRead); // Mic -> amp, volume, FFT
            encoderStream.write((uint8_t *)buffer, bytesRead); // Mic -> file
        }
    }
}

[pschatzmann]

Please follow the advice given here and build your sketch step by step: otherwise you have no chance to find what's wrong.

Some additional comments:

• I don't understand why you don't just use another I2SStream i2s_in for reading to be opened in RX_MODE .
  If you share the clock pins, you could even use one single I2SStream in doublex mode (RXTX_MODE) to read from and write to.
• The number of channels in the fft definition is wrong: you provide a stereo signal, so it must be 2! Just to the copyFrom(info); for fft and volumeMeter...

[hammerheaddown]

so since i was too excited to sleep i got these working too...

and followed your advice of one that at a time.... tomorrow i will show the full code once i combine them and hope it doesnt take me 15 hours lol

so this is Step Two:

Apply FFT to both recording and audio playback

Pipeline:
Mic -> FFT -> SD
SD -> FFT -> Amp (mono, 16 kHz, 18.5x mic boost)

#include "driver/i2s_std.h"
#include "Arduino.h"
#include <SPI.h>
#include <SD.h>
#include "FS.h"
#include "AudioTools.h"
#include "AudioTools/AudioLibs/AudioRealFFT.h"
#include "AudioTools/AudioCodecs/CodecWAV.h"

// -------------------------- Pin Setup --------------------------------------
#define SD_MISO GPIO_NUM_13
#define SD_MOSI GPIO_NUM_11
#define SD_SCK GPIO_NUM_12
#define SD_CS GPIO_NUM_10

#define I2S_MIC_LEFT_RIGHT_CLOCK GPIO_NUM_42  
#define I2S_MIC_SERIAL_DATA GPIO_NUM_17
#define I2S_MIC_SERIAL_CLOCK GPIO_NUM_18

#define I2S_BCLK GPIO_NUM_5
#define I2S_DOUT GPIO_NUM_6
#define I2S_LRC GPIO_NUM_14

#define PUSH_BUTTON_PIN GPIO_NUM_21
#define MY_DEBOUNCE_DELAY 50

// -------------------------- Config --------------------------------------
#define SAMPLE_RATE 16000
#define REC_BUFFER_SIZE 1024
const char* wavFilename = "/audio.wav";
AudioInfo info(SAMPLE_RATE, 1, 16); // Mono

// -------------------------- Audio Tools Setup --------------------------------------
I2SStream i2s_in;                                                                                // Mic input
VolumeStream mic_volume(i2s_in);                                                   // Boost mic input
I2SStream i2s_out;                                                                                // Amp output
File file;                                                                                                     // SD file
WAVEncoder encoder;                                                                          // WAV encoder
WAVDecoder decoder;                                                                          // WAV decoder
AudioRealFFT fft;                                                                                    // FFT analysis
EncodedAudioStream encoderStream(&file, &encoder);                       // Recording stream to file
StreamCopy copier;        // Generic copier

// -------------------------- Global Variables --------------------------------------
bool isRecording = false;
String serialCommand = "";

// -------------------------- FFT Callback --------------------------------------
void fftResult(AudioFFTBase &fft) {
  auto result = fft.result();
  if (result.magnitude > 100) {
    Serial.print("Frequency: ");
    Serial.print(result.frequency);
    Serial.print(" Hz | Magnitude: ");
    Serial.println(result.magnitude);
  }
}

// -------------------------- Setup Functions --------------------------------------
void SD_setup() {
  pinMode(SD_CS, OUTPUT);
  digitalWrite(SD_CS, HIGH);
  delay(10);
  SPI.begin(SD_SCK, SD_MISO, SD_MOSI, SD_CS);
  SPI.setFrequency(4000000);
  delay(100);
  if (!SD.begin(SD_CS)) {
    Serial.println("SD card mount failed!");
    while (1);
  }
  Serial.println("SD card mounted successfully.");
}

void mic_setup() {
  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Error);
  auto cfg_in = i2s_in.defaultConfig(RX_MODE);
  cfg_in.copyFrom(info);
  cfg_in.channels = 1;
  cfg_in.sample_rate = SAMPLE_RATE;
  cfg_in.use_apll = false;
  cfg_in.i2s_format = I2S_STD_FORMAT;
  cfg_in.is_master = true;
  cfg_in.port_no = 0;
  cfg_in.pin_bck = I2S_MIC_SERIAL_CLOCK;
  cfg_in.pin_ws = I2S_MIC_LEFT_RIGHT_CLOCK;
  cfg_in.pin_data = I2S_MIC_SERIAL_DATA;
  cfg_in.buffer_size = 1024;
  cfg_in.buffer_count = 8;
  i2s_in.begin(cfg_in);

  auto vcfg = mic_volume.defaultConfig();
  vcfg.channels = 1;
  vcfg.sample_rate = 16000;
  vcfg.bits_per_sample = 16;
  vcfg.allow_boost = true;
  mic_volume.begin(vcfg);
  mic_volume.setVolume(18.5);                                     // adjust how you need
  Serial.println("Mic setup complete.");
}

void amp_setup() {
  auto cfg_out = i2s_out.defaultConfig(TX_MODE);
  cfg_out.copyFrom(info);
  cfg_out.port_no = I2S_NUM_1;
  cfg_out.pin_bck = I2S_BCLK;
  cfg_out.pin_ws = I2S_LRC;
  cfg_out.pin_data = I2S_DOUT;
  i2s_out.begin(cfg_out);

  // Test tone: 1 second via loops
  int16_t test[100];
  for (int i = 0; i < 100; i++) {
    test[i] = sin(2 * PI * 440 * i / SAMPLE_RATE) * 10000;
  }
  for (int j = 0; j < 160; j++) {
    i2s_out.write((uint8_t*)test, 200);
  }
  Serial.println("Amp setup complete with 1-second test tone.");        //  this all can be taken out
}

void pipeline_setup() {
  auto fftCfg = fft.defaultConfig();
  fftCfg.length = 1024;
  fftCfg.channels = 1;  // Mono
  fftCfg.sample_rate = SAMPLE_RATE;
  fftCfg.bits_per_sample = 16;
  fftCfg.callback = &fftResult;
  fft.begin(fftCfg);
  Serial.println("Pipeline setup complete.");
}

void setup() {
  Serial.begin(115200);
  pinMode(PUSH_BUTTON_PIN, INPUT_PULLUP);
  SD_setup();
  mic_setup();
  amp_setup();
  pipeline_setup();
  Serial.println("Setup complete! Commands: '1' record, '2' stop, '3' play; Button toggles recording.");
}

// -------------------------- Playback Function --------------------------------------
void playAudio() {
  file = SD.open(wavFilename, FILE_READ);
  if (!file) {
    Serial.println("Failed to open WAV file for playback!");
    return;
  }

  Serial.println("Playing: " + String(wavFilename));
  copier.begin(i2s_out, file); // Direct to amp for now
  copier.setCheckAvailableForWrite(false);

  while (file.available()) {
    uint8_t buffer[REC_BUFFER_SIZE];
    size_t bytesRead = file.read(buffer, REC_BUFFER_SIZE);
    if (bytesRead > 0) {
      fft.write(buffer, bytesRead); // FFT analyzes
      i2s_out.write(buffer, bytesRead); // Direct to amp
      Serial.print("Raw sample (playback): ");
      Serial.println(((int16_t*)buffer)[0]); // Debug playback data
    }
  }

  file.close();
  copier.end();
  Serial.println("Playback finished.");
}

// -------------------------- Recording Functions --------------------------------------
void recordAudio() {
  if (SD.exists(wavFilename)) SD.remove(wavFilename);
  file = SD.open(wavFilename, FILE_WRITE);
  if (!file) {
    Serial.println("Failed to open WAV file for recording!");
    return;
  }

  Serial.println("Recording to: " + String(wavFilename));
  encoder.begin();
  copier.begin(encoderStream, mic_volume);
  copier.setCheckAvailableForWrite(false);
  isRecording = true;
}

void stopRecording() {
  if (isRecording) {
    isRecording = false;
    copier.end();
    encoder.end();
    file.close();
    Serial.println("Recording stopped.");
  }
}

// -------------------------- Loop --------------------------------------
void loop() {
  static bool buttonState = HIGH;
  static bool lastButtonState = HIGH;
  int currentButtonState = digitalRead(PUSH_BUTTON_PIN);

  if (currentButtonState != lastButtonState) {
    delay(MY_DEBOUNCE_DELAY);
    currentButtonState = digitalRead(PUSH_BUTTON_PIN);
    if (currentButtonState == LOW && lastButtonState == HIGH && !isRecording) {
      recordAudio();
    } else if (currentButtonState == HIGH && lastButtonState == LOW && isRecording) {
      stopRecording();
    }
    lastButtonState = currentButtonState;
  }

  if (Serial.available() > 0) {
    char c = Serial.read();
    if (c == '\n' || c == '\r') {
      if (serialCommand.length() > 0) {
        if (serialCommand == "1" && !isRecording) {
          recordAudio();
        } else if (serialCommand == "2" && isRecording) {
          stopRecording();
        } else if (serialCommand == "3" && !isRecording) {
          playAudio();
        } else {
          Serial.println("Invalid command or state!");
        }
        serialCommand = "";
      }
    } else {
      serialCommand += c;
    }
  }

  if (isRecording) {
    uint8_t buffer[REC_BUFFER_SIZE];
    size_t bytesRead = mic_volume.readBytes(buffer, REC_BUFFER_SIZE);
    if (bytesRead > 0) {
      fft.write(buffer, bytesRead);       // Mic -> FFT
      encoderStream.write(buffer, bytesRead); // FFT -> SD
      Serial.print("Raw sample (record): ");
      Serial.println(((int16_t*)buffer)[0]); // Debug mic input
    }
  }

  vTaskDelay(10 / portTICK_PERIOD_MS);
}

[hammerheaddown]

This is step 3

this step sets up the volume meter

Apply the volume meter to both recording and audio playback

Pipeline:
Mic -> VolumeMeter -> SD
SD -> VolumeMeter -> Amp (mono, 16 kHz, 18.5x mic boost)

#include "driver/i2s_std.h"
#include "Arduino.h"
#include <SPI.h>
#include <SD.h>
#include "FS.h"
#include "AudioTools.h"
#include "AudioTools/AudioCodecs/CodecWAV.h"

// -------------------------- Pin Setup --------------------------------------
#define SD_MISO GPIO_NUM_13
#define SD_MOSI GPIO_NUM_11
#define SD_SCK GPIO_NUM_12
#define SD_CS GPIO_NUM_10

#define I2S_MIC_LEFT_RIGHT_CLOCK GPIO_NUM_42  
#define I2S_MIC_SERIAL_DATA GPIO_NUM_17
#define I2S_MIC_SERIAL_CLOCK GPIO_NUM_18

#define I2S_BCLK GPIO_NUM_5
#define I2S_DOUT GPIO_NUM_6
#define I2S_LRC GPIO_NUM_14

#define PUSH_BUTTON_PIN GPIO_NUM_21
#define MY_DEBOUNCE_DELAY 50

// -------------------------- Config --------------------------------------
#define SAMPLE_RATE 16000
#define REC_BUFFER_SIZE 1024
const char* wavFilename = "/audio.wav";
AudioInfo info(SAMPLE_RATE, 1, 16); // Mono

// -------------------------- Audio Tools Setup --------------------------------------
I2SStream i2s_in;                                                                         // Mic input
VolumeStream mic_volume(i2s_in);                                        // Boost mic input
I2SStream i2s_out;                                                                // Amp output
File file;                                                                                      // SD file
WAVEncoder encoder;                                                               // WAV encoder
WAVDecoder decoder;                                                               // WAV decoder
VolumeMeter volumeMeter;                                                    // Volume meter
EncodedAudioStream encoderStream(&file, &encoder);            // Recording stream to file
StreamCopy copier;        // Generic copier

// -------------------------- Global Variables --------------------------------------
bool isRecording = false;
String serialCommand = "";

// -------------------------- Setup Functions --------------------------------------
void SD_setup() {
  pinMode(SD_CS, OUTPUT);
  digitalWrite(SD_CS, HIGH);
  delay(10);
  SPI.begin(SD_SCK, SD_MISO, SD_MOSI, SD_CS);
  SPI.setFrequency(4000000);
  delay(100);
  if (!SD.begin(SD_CS)) {
    Serial.println("SD card mount failed!");
    while (1);
  }
  Serial.println("SD card mounted successfully.");
}

void mic_setup() {
  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Error);
  auto cfg_in = i2s_in.defaultConfig(RX_MODE);
  cfg_in.copyFrom(info);
  cfg_in.channels = 1;
  cfg_in.sample_rate = SAMPLE_RATE;
  cfg_in.use_apll = false;
  cfg_in.i2s_format = I2S_STD_FORMAT;
  cfg_in.is_master = true;
  cfg_in.port_no = 0;
  cfg_in.pin_bck = I2S_MIC_SERIAL_CLOCK;
  cfg_in.pin_ws = I2S_MIC_LEFT_RIGHT_CLOCK;
  cfg_in.pin_data = I2S_MIC_SERIAL_DATA;
  cfg_in.buffer_size = 1024;
  cfg_in.buffer_count = 8;
  i2s_in.begin(cfg_in);

  auto vcfg = mic_volume.defaultConfig();
  vcfg.channels = 1;
  vcfg.sample_rate = 16000;
  vcfg.bits_per_sample = 16;
  vcfg.allow_boost = true;
  mic_volume.begin(vcfg);
  mic_volume.setVolume(18.5);                                                               // adjust as needed
  Serial.println("Mic setup complete.");
}

void amp_setup() {
  auto cfg_out = i2s_out.defaultConfig(TX_MODE);
  cfg_out.copyFrom(info);
  cfg_out.port_no = I2S_NUM_1;
  cfg_out.pin_bck = I2S_BCLK;
  cfg_out.pin_ws = I2S_LRC;
  cfg_out.pin_data = I2S_DOUT;
  i2s_out.begin(cfg_out);

  // Test tone: 1 second via loops
  int16_t test[100];
  for (int i = 0; i < 100; i++) {
    test[i] = sin(2 * PI * 440 * i / SAMPLE_RATE) * 10000;
  }
  for (int j = 0; j < 160; j++) {
    i2s_out.write((uint8_t*)test, 200);
  }
  Serial.println("Amp setup complete with 1-second test tone.");            //  take if you need to
}

void pipeline_setup() {
  volumeMeter.begin(info);
  Serial.println("Pipeline setup complete.");
}

void setup() {
  Serial.begin(115200);
  pinMode(PUSH_BUTTON_PIN, INPUT_PULLUP);
  SD_setup();
  mic_setup();
  amp_setup();
  pipeline_setup();
  Serial.println("Setup complete! Commands: '1' record, '2' stop, '3' play; Button toggles recording.");
}

// -------------------------- Playback Function --------------------------------------
void playAudio() {
  file = SD.open(wavFilename, FILE_READ);
  if (!file) {
    Serial.println("Failed to open WAV file for playback!");
    return;
  }

  Serial.println("Playing: " + String(wavFilename));
  copier.begin(i2s_out, file); // Direct to amp for now
  copier.setCheckAvailableForWrite(false);

  while (file.available()) {
    uint8_t buffer[REC_BUFFER_SIZE];
    size_t bytesRead = file.read(buffer, REC_BUFFER_SIZE);
    if (bytesRead > 0) {
      volumeMeter.write(buffer, bytesRead); // VolumeMeter analyzes
      i2s_out.write(buffer, bytesRead);    // Direct to amp
      Serial.print("Raw sample (playback): ");
      Serial.println(((int16_t*)buffer)[0]); // Debug playback data
    }
    float volume = volumeMeter.volume(0);
    Serial.print("Volume: ");
    Serial.println(volume);
  }

  file.close();
  copier.end();
  Serial.println("Playback finished.");
}

// -------------------------- Recording Functions --------------------------------------
void recordAudio() {
  if (SD.exists(wavFilename)) SD.remove(wavFilename);
  file = SD.open(wavFilename, FILE_WRITE);
  if (!file) {
    Serial.println("Failed to open WAV file for recording!");
    return;
  }

  Serial.println("Recording to: " + String(wavFilename));
  encoder.begin();
  copier.begin(encoderStream, mic_volume);
  copier.setCheckAvailableForWrite(false);
  isRecording = true;
}

void stopRecording() {
  if (isRecording) {
    isRecording = false;
    copier.end();
    encoder.end();
    file.close();
    Serial.println("Recording stopped.");
  }
}

// -------------------------- Loop --------------------------------------
void loop() {
  static bool buttonState = HIGH;
  static bool lastButtonState = HIGH;
  int currentButtonState = digitalRead(PUSH_BUTTON_PIN);

  if (currentButtonState != lastButtonState) {
    delay(MY_DEBOUNCE_DELAY);
    currentButtonState = digitalRead(PUSH_BUTTON_PIN);
    if (currentButtonState == LOW && lastButtonState == HIGH && !isRecording) {
      recordAudio();
    } else if (currentButtonState == HIGH && lastButtonState == LOW && isRecording) {
      stopRecording();
    }
    lastButtonState = currentButtonState;
  }

  if (Serial.available() > 0) {
    char c = Serial.read();
    if (c == '\n' || c == '\r') {
      if (serialCommand.length() > 0) {
        if (serialCommand == "1" && !isRecording) {
          recordAudio();
        } else if (serialCommand == "2" && isRecording) {
          stopRecording();
        } else if (serialCommand == "3" && !isRecording) {
          playAudio();
        } else {
          Serial.println("Invalid command or state!");
        }
        serialCommand = "";
      }
    } else {
      serialCommand += c;
    }
  }

  if (isRecording) {
    uint8_t buffer[REC_BUFFER_SIZE];
    size_t bytesRead = mic_volume.readBytes(buffer, REC_BUFFER_SIZE);
    if (bytesRead > 0) {
      volumeMeter.write(buffer, bytesRead); // Mic -> VolumeMeter
      encoderStream.write(buffer, bytesRead); // VolumeMeter -> SD
      Serial.print("Raw sample (record): ");
      Serial.println(((int16_t*)buffer)[0]); // Debug mic input
    }
    float volume = volumeMeter.volume(0);
    Serial.print("Volume: ");
    Serial.println(volume);
  }

  vTaskDelay(10 / portTICK_PERIOD_MS);
}

[pschatzmann]

My 5 cents:

• don't mix different APIs: the Arduino API for vTaskDelay is delay()!
• avoid distributing samplerate, channels and bits_per_sample all over your sketch: use copyFrom(info) to ensure consistency
• I would move the menu logic into a separate method that returns an enum of actions and keep the action handling in the loop
• Consider to use a debounce library to make your sketch a bit shorter and more readable
• the disadvantage of doing the full playback in the loop, is that you can't interrupt it

[hammerheaddown]

sweet thanks! I will try and clean those up and when i get these combined will be sure to use that info in the part 4

[hammerheaddown]

wow it took forever to make the complete switch to just using your code for recording . i have a bitcoin miner and fish tank nearby and it causes so much noise in recording with its humming etc. But i finally got the filters set up like i did in all my other recordings and it is making great recording.

I tried to implement as much as you said and clean up the mixing of apis etc.

I know this could be shorter and more polished but it is doing what i wanted it to do, the filters work awesome. so here is what i got done. And i welcome your suggestions... I would like to add to show and tell for others if you think it will be helpful

there is a interrupt in case you are using for speech to text and want to start over as well as if you are getting a response back from say Chat GPT you can interrupt the playback and ask another question.

Speaking of Chat GPT, i do NOT suggest it for coding lol... will change your code if you are not paying attention and break things more than helping, i tried it. I did get some guidance but not worth the stress and hassle of it messing up code like it did

Apply the volume meter to both recording and audio playback. I also added custom filters for audio recording and FFT for future plans.

#include "driver/i2s_std.h"
#include "Arduino.h"
#include <SPI.h>
#include <SD.h>
#include "FS.h"
#include "AudioTools.h"
#include "AudioTools/AudioLibs/AudioRealFFT.h"
#include "AudioTools/AudioCodecs/CodecWAV.h"

// -------------------------- Pin Setup --------------------------------------
#define SD_MISO GPIO_NUM_13
#define SD_MOSI GPIO_NUM_11
#define SD_SCK GPIO_NUM_12
#define SD_CS GPIO_NUM_10

#define I2S_MIC_LEFT_RIGHT_CLOCK GPIO_NUM_42  
#define I2S_MIC_SERIAL_DATA GPIO_NUM_17
#define I2S_MIC_SERIAL_CLOCK GPIO_NUM_18

#define I2S_BCLK GPIO_NUM_5
#define I2S_DOUT GPIO_NUM_6
#define I2S_LRC GPIO_NUM_14

#define PUSH_BUTTON_PIN GPIO_NUM_21
#define MY_DEBOUNCE_DELAY 100  									// Reduced to 100ms for faster response

// -------------------------- Config --------------------------------------
#define SAMPLE_RATE 16000
#define REC_BUFFER_SIZE 1024
const char* wavFilename = "/audio,wav";
AudioInfo info(SAMPLE_RATE, 1, 16); 							// Mono, centralized config

// -------------------------- Filter Config --------------------------------------
#define VOLUME_SCALE 1.0
#define LIMITER_THRESHOLD 25000
#define NOISE_GATE_THRESHOLD 500
#define HIGH_PASS_FREQ 100
#define LOW_PASS_FREQ 6000

// Filter State
float lastSampleHP = 0;
float lastSampleLP = 0;

// Custom Filter Stream (for limiter, noise gate, band-pass)
class FilteredAudioStream : public AudioStream {
public:
    FilteredAudioStream(AudioStream &source) : source(source) {}

    size_t readBytes(uint8_t *buffer, size_t length) override {
        size_t bytesRead = source.readBytes(buffer, length);
        if (bytesRead > 0) {
            int16_t *samples = (int16_t *)buffer;
            size_t sampleCount = bytesRead / sizeof(int16_t);
            for (size_t i = 0; i < sampleCount; i++) {
                int16_t sample = samples[i] * VOLUME_SCALE;

                // Noise Gate
                if (abs(sample) <= NOISE_GATE_THRESHOLD) {
                    sample = 0;
                } else {
                    // High-Pass Filter
                    float hp = highPassFilter(sample, &lastSampleHP, HIGH_PASS_FREQ, SAMPLE_RATE);
                    // Low-Pass Filter (Band-Pass = HP + LP)
                    float lp = lowPassFilter(hp, &lastSampleLP, LOW_PASS_FREQ, SAMPLE_RATE);
                    sample = (int16_t)lp;

                    // Limiter
                    if (sample > LIMITER_THRESHOLD) sample = LIMITER_THRESHOLD;
                    else if (sample < -LIMITER_THRESHOLD) sample = -LIMITER_THRESHOLD;
                }
                samples[i] = sample;
            }
        }
        return bytesRead;
    }

    // Required overrides (corrected to match base class)
    size_t write(const uint8_t *, size_t) override { return 0; }  
    int available() override { return source.available(); }
    bool begin() override { return source.begin(); } 

private:
    AudioStream &source;
    
    float highPassFilter(int16_t sample, float *lastSample, float cutoffFreq, float sampleRate) {
        float RC = 1.0 / (cutoffFreq * 2 * M_PI);
        float dt = 1.0 / sampleRate;
        float alpha = RC / (RC + dt);
        *lastSample = sample * (1.0 - alpha) + (*lastSample) * alpha;
        return sample - *lastSample;
    }

    float lowPassFilter(float sample, float *lastSample, float cutoffFreq, float sampleRate) {
        float RC = 1.0 / (cutoffFreq * 2 * M_PI);
        float dt = 1.0 / sampleRate;
        float alpha = dt / (RC + dt);
        *lastSample = alpha * sample + (1 - alpha) * (*lastSample);
        return *lastSample;
    }
};

// -------------------------- Audio Tools Setup --------------------------------------
I2SStream i2s_in;         										// Mic input
VolumeStream mic_volume(i2s_in); 								// Boost mic input 
FilteredAudioStream filteredStream(mic_volume); 				// Wrap mic_volume with filters

I2SStream i2s_out;
VolumeStream amp_volume(i2s_out);

File file;                										// SD file
WAVEncoder encoder;       										// WAV encoder
WAVDecoder decoder;       										// WAV decoder

AudioRealFFT fft;         										// FFT analysis
VolumeMeter volumeMeter;  										// Volume meter

EncodedAudioStream encoderStream(&file, &encoder); 				// Recording stream to file
StreamCopy copier;        										// Generic copier

// -------------------------- Global Variables --------------------------------------
bool isRecording = false;
bool interruptRequested = false;  								// Global interrupt flag for playback
String serialCommand = "";  									// Declare serialCommand globally

// --------------------------  Action enum  --------------------------------------
enum Action {
  NONE,
  RECORD,
  STOP,
  PLAY
};

// -------------------------- FFT Callback --------------------------------------
void fftResult(AudioFFTBase &fft) {
  auto result = fft.result();
  if (result.magnitude > 100) {
    //Serial.print("Frequency: ");  							// Commented out to reduce Serial noise
    //Serial.print(result.frequency);							// Commented out to reduce Serial noise
    //Serial.print(" Hz | Magnitude: ");						// Commented out to reduce Serial noise
    //Serial.println(result.magnitude);							// Commented out to reduce Serial noise
  }
}

// -------------------------- Setup Functions --------------------------------------
void SD_setup() {
  pinMode(SD_CS, OUTPUT);
  digitalWrite(SD_CS, HIGH);
  delay(10);
  SPI.begin(SD_SCK, SD_MISO, SD_MOSI, SD_CS);
  SPI.setFrequency(4000000);
  delay(100);
  if (!SD.begin(SD_CS)) {
    Serial.println("SD card mount failed!");
    while (1);
  }
  //Serial.println("SD card mounted successfully.");  			// Commented out to reduce Serial noise			
}

void mic_setup() {
  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Error);
  auto cfg_in = i2s_in.defaultConfig(RX_MODE);
  cfg_in.copyFrom(info);  										// Use centralized AudioInfo
  cfg_in.port_no = 0;
  cfg_in.pin_bck = I2S_MIC_SERIAL_CLOCK;
  cfg_in.pin_ws = I2S_MIC_LEFT_RIGHT_CLOCK;
  cfg_in.pin_data = I2S_MIC_SERIAL_DATA;
  cfg_in.buffer_size = 1024;
  cfg_in.buffer_count = 8;
  i2s_in.begin(cfg_in);

  auto vcfg = mic_volume.defaultConfig();
  vcfg.copyFrom(info);  										// Use centralized AudioInfo
  vcfg.allow_boost = true;
  mic_volume.begin(vcfg);
  mic_volume.setVolume(15.5); 									// Match working code, check for clipping
  //Serial.println("Mic setup complete.");  					// Commented out to reduce Serial noise
}

void amp_setup() {
    auto cfg_out = i2s_out.defaultConfig(TX_MODE);
    cfg_out.copyFrom(info);
    cfg_out.port_no = I2S_NUM_1;
    cfg_out.pin_bck = I2S_BCLK;
    cfg_out.pin_ws = I2S_LRC;
    cfg_out.pin_data = I2S_DOUT;
    i2s_out.begin(cfg_out);

    auto vcfg = amp_volume.defaultConfig();
    vcfg.copyFrom(info);
    vcfg.allow_boost = true;
    amp_volume.begin(vcfg);
    amp_volume.setVolume(10.0);
    Serial.println("Amp setup complete. Volume set to: (Value: " + String(10.0) + ")");
}

void pipeline_setup() {
  auto fftCfg = fft.defaultConfig();
  fftCfg.copyFrom(info);  										// Use centralized AudioInfo
  fftCfg.length = 1024;
  fftCfg.callback = &fftResult;
  fft.begin(fftCfg);

  volumeMeter.begin(info);  									// Use centralized AudioInfo
  //Serial.println("Pipeline setup complete.");  				// Commented out to reduce Serial noise

}

void setup() {
  delay(100);
  Serial.begin(115200);
  pinMode(PUSH_BUTTON_PIN, INPUT_PULLUP);

  delay(10);
  SD_setup();
  #ifdef DEBUG_MODE
    Serial.println("Free Heap B4 we continue " + String(ESP.getFreeHeap()));
  #endif

  delay(10);
  mic_setup();
  #ifdef DEBUG_MODE
    Serial.println("Free Heap B4 we continue " + String(ESP.getFreeHeap()));
  #endif

  delay(10);
  amp_setup();
   #ifdef DEBUG_MODE
    Serial.println("Free Heap B4 we continue " + String(ESP.getFreeHeap()));
  #endif

  delay(10);
  pipeline_setup();
  #ifdef DEBUG_MODE
    Serial.println("Free Heap B4 we continue " + String(ESP.getFreeHeap()));
  #endif

  delay(10);
  printCommands();
  #ifdef DEBUG_MODE
    Serial.println("Free Heap B4 we continue " + String(ESP.getFreeHeap()));
  #endif
}

// -------------------------- Helper functions --------------------------------------
void printCommands() {   
    Serial.println("Commands: '1' record, '2' stop, '3' play, '8' or 'interrupt' interrupt");
    Serial.println("Commands:  Button toggles recording/interrupts playback via polling.");  
}

// -------------------------- Action Handling --------------------------------------
Action handleMenu() {
  // Button polling with debouncing (mirroring your working loop)
  static bool buttonState = HIGH;
  static bool lastButtonState = HIGH;
  int currentButtonState = digitalRead(PUSH_BUTTON_PIN);

  if (currentButtonState != lastButtonState) {
    delay(MY_DEBOUNCE_DELAY); 																	// 100ms debounce for stability
    currentButtonState = digitalRead(PUSH_BUTTON_PIN);
    Serial.print("Button 21 state: "); Serial.println(currentButtonState);  					// Debug for GPIO 21
    if (currentButtonState == LOW && lastButtonState == HIGH) {
      if (!isRecording) {
        interruptAudioPlayback();  																// Button press interrupts playback
        return NONE;  																			// No action in enum, handled in playAudio
      }
      else return RECORD;  																		// Button press starts recording
    }
    else if (currentButtonState == HIGH && lastButtonState == LOW && isRecording) return STOP;  // Button release stops recording
    lastButtonState = currentButtonState;
  }

  // Serial command handling 
  if (Serial.available() > 0) {
    String command = Serial.readStringUntil('\n');
    command.trim();
    Serial.print("Received command: "); Serial.println(command);  								// Debug to track input
    if (command == "1" && !isRecording) return RECORD;
    else if (command == "2" && isRecording) return STOP;
    else if (command == "3" && !isRecording) {
      delay(500); 																				// Delay to stabilize state after interrupt
      return PLAY;
    }
    else if (command == "8" || command.equalsIgnoreCase("interrupt")) {
      interruptAudioPlayback();  																// Serial '8' or "interrupt" interrupts playback
      return NONE;  																			// No action in enum, handled in playAudio
    }
    else Serial.println("Invalid command or state!");
  }
  return NONE;
}

// -------------------------- Interrupt Functions --------------------------------------
void interruptAudioPlayback() {
  interruptRequested = true;
  // Add a small delay for debounce
  delay(100);
  //Serial.println("WAV playback interrupted.");  												// Commented out to reduce Serial noise
}

// -------------------------- Playback Function --------------------------------------
void playAudio() {
  file = SD.open(wavFilename, FILE_READ);
  if (!file) {
    Serial.println("Failed to open WAV file for playback!");
    return;
  }

  interruptRequested = false;  																	// Reset interrupt flag at playback start
  Serial.println("Playing: " + String(wavFilename));  
  copier.begin(i2s_out, file); 																	// Direct to amp for now
  copier.setCheckAvailableForWrite(false);

  while (copier.copy()) {  																		// Use copier.copy() for reliable playback
    uint8_t buffer[REC_BUFFER_SIZE];
    size_t bytesRead = file.read(buffer, REC_BUFFER_SIZE);
    if (bytesRead > 0) {
      fft.write(buffer, bytesRead);       														// SD -> FFT
      volumeMeter.write(buffer, bytesRead); 													// FFT -> VolumeMeter
      i2s_out.write(buffer, bytesRead);    														// VolumeMeter -> Amp
      //Serial.print("Raw sample (playback): ");  												// Commented out to reduce Serial noise
      //Serial.println(((int16_t*)buffer)[0]); 													// Debug playback data (commented out)
    }
    float volume = volumeMeter.volume(0);
    //Serial.print("Volume: ");  																// Commented out to reduce Serial noise
    //Serial.println(volume);

    // Check for interrupts during playback, mirroring your example
    if (interruptRequested) {
      //Serial.println("Interrupt Block Executed!");  											// Debug (commented out)
      //Serial.println("Free Heap before interrupt " + String(ESP.getFreeHeap()));  			// Commented out to reduce Serial noise
      copier.end();
      file.close();
      interruptRequested = false;
      Serial.println("WAV playback interrupted.");  // Commented out
      printCommands();
      return;
    }

    // Check for serial input more frequently for interrupt
    if (Serial.available() > 0) {
      String command = Serial.readStringUntil('\n');
      command.trim();
      Serial.print("Playback command: "); Serial.println(command);  							// Debug to track input
      if (command == "8" || command.equalsIgnoreCase("interrupt") || command == "3") {
        interruptAudioPlayback();
      }
    }

    // Poll button state during playback for interrupt
    int buttonState = digitalRead(PUSH_BUTTON_PIN);
    static bool lastButtonState = HIGH;
    if (buttonState != lastButtonState) {
      delay(MY_DEBOUNCE_DELAY); 																// 100ms debounce
      buttonState = digitalRead(PUSH_BUTTON_PIN);
      Serial.print("Button 21 state during playback: "); Serial.println(buttonState);  			// Debug for GPIO 21
      if (buttonState == LOW && lastButtonState == HIGH) {
        interruptAudioPlayback();  																// Button press interrupts playback
      }
      lastButtonState = buttonState;
    }
  }

  file.close();
  copier.end();
  //Serial.println("Playback finished.");  														// Commented out to reduce Serial noise
  printCommands();
}

// -------------------------- Recording Functions --------------------------------------
void recordAudio() {
  if (SD.exists(wavFilename)) SD.remove(wavFilename);
  file = SD.open(wavFilename, FILE_WRITE);
  if (!file) {
    Serial.println("Failed to open WAV file for recording!");
    return;
  }

  Serial.println("Recording to: " + String(wavFilename));  										// Commented out to reduce Serial noise
  encoder.begin();
  copier.begin(encoderStream, filteredStream); 													// Use filteredStream instead of mic_volume
  copier.setCheckAvailableForWrite(false);

  isRecording = true;
}

void mic_volume_meter() {
  if (isRecording) {
    uint8_t buffer[REC_BUFFER_SIZE];
    size_t bytesRead = filteredStream.readBytes(buffer, REC_BUFFER_SIZE); 						// Read from filteredStream
    if (bytesRead > 0) {
      fft.write(buffer, bytesRead);       														// Mic (filtered) -> FFT
      volumeMeter.write(buffer, bytesRead); 													// FFT -> VolumeMeter
      encoderStream.write(buffer, bytesRead); 													// VolumeMeter -> SD
      //Serial.print("Raw sample (record): ");  												// Commented out to reduce Serial noise
      //Serial.println(((int16_t*)buffer)[0]); 													// Debug mic input (commented out)
    }
    float volume = volumeMeter.volume(0);
    // Serial.print("Volume: ");  																// Commented out to reduce Serial noise
    // Serial.println(volume);																	// Commented out to reduce Serial noise
  }
}

void stopRecording() {
  if (isRecording) {
    isRecording = false;
    copier.end();
    encoder.end();
    file.close();
    //Serial.println("Recording stopped.");  													// Commented out to reduce Serial noise
  }
  printCommands();
}

// -------------------------- Loop --------------------------------------
void loop() {
  // Check interrupt first, mirroring your working loop
  if (interruptRequested) {
    interruptRequested = false;
    //Serial.println("Interrupt handled in loop.");  											// Debug (commented out)
  }

  Action action = handleMenu();
  switch (action) {
    case RECORD:
      recordAudio();
      break;
    case STOP:
      stopRecording();
      break;
    case PLAY:
      playAudio();
      break;
    case NONE:
      break;
  }
  delay(10);
  mic_volume_meter();
  #ifdef DEBUG_MODE
    Serial.println("Free Heap B4 we continue " + String(ESP.getFreeHeap()));
  #endif
  delay(10);  
}