feat ✨: Updated src/main.cpp to utilize FormatConverterStream for converting 32-bit I2S input to 16-bit output and configured an AudioFFTBase with the correct bits per sample

- Modified `src/main.cpp` to use `FormatConverterStream` for converting 32-bit I2S input to 16-bit output, then configured an `AudioFFTBase` with the appropriate bits per sample.

platformio.ini

@@ -33,6 +33,4 @@ monitor_filters = esp32_exception_decoder
 lib_deps = 
     https://github.com/pschatzmann/arduino-audio-tools.git
     https://github.com/pschatzmann/arduino-audio-driver.git
-    https://github.com/tzapu/WiFiManager.git
-    me-no-dev/AsyncTCP
-    https://github.com/me-no-dev/ESPAsyncWebServer.git
+    

src/main.cpp

@@ -1,130 +1,99 @@
-#include <Arduino.h>
-#include <driver/i2s.h>
-#include <deque>
+#include "AudioTools.h"
+// #include "AudioTools/AudioLibs/AudioI2SStream.h"
+#include "AudioTools/AudioLibs/AudioRealFFT.h" // or AudioKissFFT
 
-// you shouldn't need to change these settings
-#define SAMPLE_BUFFER_SIZE 512
-#define SAMPLE_RATE 8000
-// most microphones will probably default to left channel but you may need to tie the L/R pin low
-#define I2S_MIC_CHANNEL I2S_CHANNEL_FMT_ONLY_LEFT
-// either wire your microphone to the same pins or change these to match your wiring
-#define I2S_MIC_SERIAL_CLOCK 8
-#define I2S_MIC_LEFT_RIGHT_CLOCK 9
-#define I2S_MIC_SERIAL_DATA 10
+I2SStream i2sStream;              // I2S input stream for INMP441
+AudioRealFFT fft;                 // FFT analyzer
+FormatConverterStream converter(i2sStream); // Convert 32-bit input to 16-bit output
+StreamCopy copier(fft, converter);  // copy converted data to FFT
 
-// Add sample history tracking for range limiting
-#define HISTORY_DURATION_MS 1000  // 1 seconds history
-#define SAMPLES_PER_MS (SAMPLE_RATE / 1000)
-#define HISTORY_SIZE (HISTORY_DURATION_MS * SAMPLES_PER_MS)
+int channels = 1;                // INMP441 is mono
+int samples_per_second = 11025;
+int input_bits_per_sample = 32;        // INMP441 sends 24-bit data in 32-bit words
+int fft_bits_per_sample = 16;
 
-#define MAX_RANGE_LIMIT 150000000  // Maximum allowed range limit
-#define DEFAULT_RANGE_LIMIT 20000  // Default range limit when no history
+AudioInfo from(samples_per_second, channels, input_bits_per_sample);                                           
+AudioInfo to(samples_per_second, channels, fft_bits_per_sample);  
 
-class AudioLevelTracker {
-public:
-    AudioLevelTracker() {
-        resetMaxLevel();
-    }
-
-    void updateMaxLevel(int32_t sample) {
-        uint32_t currentTime = millis();
-        
-        // Remove old samples (older than 10 seconds)
-        while (!sampleHistory.empty() && 
-               (currentTime - sampleHistory.front().timestamp) > HISTORY_DURATION_MS) {
-            sampleHistory.pop_front();
-        }
-
-        // Add new sample, but cap it at MAX_RANGE_LIMIT
-        int32_t absValue = abs(sample);
-        absValue = min(absValue, MAX_RANGE_LIMIT);  // Cap the value
-        SamplePoint newPoint = {currentTime, absValue};
-        sampleHistory.push_back(newPoint);
-
-        // Update maximum
-        maxLevel = 0;
-        for (const auto& point : sampleHistory) {
-            if (point.value > maxLevel) {
-                maxLevel = point.value;
-            }
-        }
-    }
-
-    int32_t getMaxLevel() const {
-        return maxLevel;
-    }
-
-    void resetMaxLevel() {
-        maxLevel = 0;
-        sampleHistory.clear();
-    }
-
-private:
-    struct SamplePoint {
-        uint32_t timestamp;
-        int32_t value;
+const char* solfegeName(uint8_t midiNote) {
+    static const char* solfegeNames[] = {
+        "Do", "Do#", "Re", "Re#", "Mi", "Fa", "Fa#", "Sol", "Sol#", "La", "La#", "Si"
     };
-    std::deque<SamplePoint> sampleHistory;
-    int32_t maxLevel;
-};
+    return solfegeNames[midiNote % 12];
+}
 
-AudioLevelTracker audioLevelTracker;
+void fftResult(AudioFFTBase &fft) {
+    float diff;
+    auto result = fft.result();
 
-// don't mess around with this
-i2s_config_t i2s_config = {
-    .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
-    .sample_rate = SAMPLE_RATE,
-    .bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
-    .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
-    .communication_format = I2S_COMM_FORMAT_STAND_I2S,  // Updated from I2S_COMM_FORMAT_I2S
-    .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
-    .dma_buf_count = 4,
-    .dma_buf_len = 1024,
-    .use_apll = false,
-    .tx_desc_auto_clear = false,
-    .fixed_mclk = 0};
+    if (result.magnitude > 100) {  // avoid noise floor
+        float magnitude_dB = 20.0 * log10(result.magnitude);
+        float freq = result.frequency;
 
-// and don't mess around with this
-i2s_pin_config_t i2s_mic_pins = {
-    .bck_io_num = I2S_MIC_SERIAL_CLOCK,
-    .ws_io_num = I2S_MIC_LEFT_RIGHT_CLOCK,
-    .data_out_num = I2S_PIN_NO_CHANGE,
-    .data_in_num = I2S_MIC_SERIAL_DATA};
+        // MIDI note number
+        int midiNote = round(69 + 12.0 * log2(freq / 440.0));
+        const char* solfege = solfegeName(midiNote);
+        int octave = (midiNote / 12) - 1;
 
-void setup()
-{
-  // we need serial output for the plotter
+        Serial.print(freq, 0);
+        Serial.print(" Hz | ");
+
+        Serial.print("MIDI ");
+        Serial.print(midiNote);
+        Serial.print(" | ");
+
+        Serial.print("Note: ");
+        Serial.print(result.frequencyAsNote(diff));
+        Serial.print(" | ");
+
+        Serial.print("Solfège: ");
+        Serial.print(solfege);
+        Serial.print(octave);
+
+        Serial.print(" | dB: ");
+        Serial.print(magnitude_dB, 2);
+
+        Serial.print(" | Diff: ");
+        Serial.println(diff, 2);
+
+        Serial.print(" | Amp: ");
+        Serial.println(result.magnitude, 0);
+    }
+}
+
+
+void setup() {
   Serial.begin(115200);
-  // start up the I2S peripheral
-  i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
-  i2s_set_pin(I2S_NUM_0, &i2s_mic_pins);
+  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Warning);
+
+  // Configure I2SStream for INMP441
+  auto cfg = i2sStream.defaultConfig(RX_MODE);
+  cfg.i2s_format = I2S_STD_FORMAT;
+  cfg.bits_per_sample = input_bits_per_sample;
+  cfg.channels = channels;
+  cfg.sample_rate = samples_per_second;
+  cfg.is_master = true;
+  cfg.pin_bck = 8;     // SCK
+  cfg.pin_ws = 9;      // WS
+  cfg.pin_data = 10;   // SD
+  i2sStream.begin(cfg);
+
+  // Configure FormatConverterStream to convert 32-bit to 16-bit
+  converter.begin(from, to);  // Convert to 16-bit
+
+  // Configure FFT
+  auto tcfg = fft.defaultConfig();
+  tcfg.length = 8192;    // 186ms @ 11kHz minimun C2 theoretical
+  tcfg.channels = channels;
+  tcfg.sample_rate = samples_per_second;
+  tcfg.bits_per_sample = fft_bits_per_sample; // FFT expects 16-bit data after conversion
+  tcfg.callback = &fftResult;
+  fft.begin(tcfg);
+
+  Serial.println("Setup complete. Listening...");
+
 }
 
-int32_t raw_samples[SAMPLE_BUFFER_SIZE];
-void loop()
-{
-  // read from the I2S device
-  size_t bytes_read = 0;
-  i2s_read(I2S_NUM_0, raw_samples, sizeof(int32_t) * SAMPLE_BUFFER_SIZE, &bytes_read, portMAX_DELAY);
-  int samples_read = bytes_read / sizeof(int32_t);
-  
-  // Calculate dynamic range limit based on max level from last 10 seconds
-  int32_t currentMaxLevel = audioLevelTracker.getMaxLevel();
-  int32_t rangelimit = currentMaxLevel > 0 ? currentMaxLevel : DEFAULT_RANGE_LIMIT; // fallback to default if no history
-
-  // dump the samples out to the serial channel
-  for (int i = 0; i < samples_read; i++)
-  {
-    // Update the max level tracker with current sample
-    audioLevelTracker.updateMaxLevel(raw_samples[i]);
-
-    // Print range limits for plotter
-    Serial.print(rangelimit * -1);
-    Serial.print(" ");
-    Serial.print(rangelimit);
-    Serial.print(" ");
-
-    // Print the actual sample
-    Serial.printf("%ld\n", raw_samples[i]);
-  }
+void loop() {
+  copier.copy();  // Stream mic data into FFT processor
 }