Sounds like great progress!
I have a project where I can swap out another mic, and compare results. I'm using an electret wired to the mic and gnd pins of the audio shield, and using I2S for input.
This design needs to connect to an analog input of the Teensy and it probably won't work connecting to the mic input of the audio board. My guess is that the audio board amplifies the electret mic itself.
Here is my test code - sorry for the length!!
// Spectrum Analyzer using a Teensy 3.2 & the Adafruit 1.8" TFT module w/ ST7735S chip
// Test microphone is connected to A3
// Adding some Neopixel code to test interaction
//*********************************************************************************** INIT
//
#define TFT_SCLK 14 // SCLK can also use pin 13
#define TFT_MOSI 7 // MOSI can also use pin 11
#define TFT_CS 10 // CS & DC can use pins 2, 6, 9, 10, 15, 20, 21, 22, 23
#define TFT_DC 20 // but certain pairs must NOT be used: 2+10, 6+9, 20+23, 21+22
#define TFT_RST 8 // RST can use any pin
#define SD_CS 4 // CS for SD card, can use any pin
#define MIC_GAIN 2 // multiplier for the specific mic
#include <Adafruit_GFX.h> // Core graphics library
#include <ST7735_t3.h> // Hardware-specific library for the ST7735 LCD controller
#include <Audio.h>
#include <Wire.h>
#include <SPI.h>
#include <SerialFlash.h>
#include <Adafruit_NeoPixel.h>
// create the LCD object
ST7735_t3 tft = ST7735_t3(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);
// Assign human-readable names to some common 16-bit color values:
#define WHITE 0xFFFF
#define BLACK 0x0000
#define GREEN 0x07E0
//Set-up the audio library functions
AudioInputAnalog adc1(A3); //default for adc1 is A2
AudioAnalyzeFFT1024 fft1024_1;
AudioConnection patchCord1(adc1, fft1024_1);
// An array to hold the 16 frequency bands
float level[16];
#define LEDPIN 2 // digital output pin for the LEDs
#define NUMLEDS 45 // number of LEDs
#define LEDBRIGHTNESS 64 // display brightness
byte colorMap = 160; // the offset position for the color map
byte colorScale = 2; // the variation in the color map - 0=one color, 4=full spectrum
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMLEDS, LEDPIN, NEO_GRB + NEO_KHZ800);
//*********************************************************************************** SETUP
void setup() {
strip.begin();
strip.show(); // Initialize all pixels to 'off'
strip.setBrightness(LEDBRIGHTNESS);
tft.initR(INITR_BLACKTAB); // initialize a ST7735S chip, black tab
tft.fillScreen(ST7735_BLACK);
tft.setRotation(1); // 1=270
tft.setTextColor(WHITE);
tft.setTextSize(1);
tft.print("TFT Spectrum Analyzer ");
// Audio connections require memory to work.
AudioMemory(12);
// Configure the window algorithm to use
fft1024_1.windowFunction(AudioWindowHanning1024);
}
//*********************************************************************************** LOOP
void loop() {
byte pColor; // a color map position
byte Channel; // specific frequency channel
byte Red1; // temporary Red value
byte Green1; // temporary Green value
byte Blue1; // temporary Blue value
//****************************************************************************** INPUT
if (fft1024_1.available()) {
// each time new FFT data is available, bin it into 16 channels
// Note- response doesn't seem flat so each is normalized <experimenting!
// Note- these calculations go very fast!!
level[0] = fft1024_1.read(0) * 1.21 * MIC_GAIN;
level[1] = fft1024_1.read(1) * 1.18 * MIC_GAIN;
level[2] = fft1024_1.read(2, 3) * 1.15 * MIC_GAIN;
level[3] = fft1024_1.read(4, 6) * 1.12 * MIC_GAIN;
level[4] = fft1024_1.read(7, 10) * 1.09 * MIC_GAIN;
level[5] = fft1024_1.read(11, 15) * 1.06 * MIC_GAIN;
level[6] = fft1024_1.read(16, 22) * 1.03 * MIC_GAIN;
level[7] = fft1024_1.read(23, 32) * 1.00 * MIC_GAIN;
level[8] = fft1024_1.read(33, 46) * 0.96 * MIC_GAIN;
level[9] = fft1024_1.read(47, 66) * 0.93 * MIC_GAIN;
level[10] = fft1024_1.read(67, 93) * 0.90 * MIC_GAIN;
level[11] = fft1024_1.read(94, 131) * 0.87 * MIC_GAIN;
level[12] = fft1024_1.read(132, 184) * 0.84 * MIC_GAIN;
level[13] = fft1024_1.read(185, 257) * 0.81 * MIC_GAIN;
level[14] = fft1024_1.read(258, 359) * 0.78 * MIC_GAIN;
level[15] = fft1024_1.read(360, 511) * 0.75 * MIC_GAIN;
//****************************************************************************** LED OUTPUT
for (int i = 0; i < NUMLEDS; i++){ // cycle through all the LEDs
pColor = i * colorScale * 4 + colorMap; // this results in a color map position
Channel = i/3 ; // there are 16 frequency bands - not perfect - needs better math
Red1 = (WheelR(pColor) * level[Channel]) ; // brightness proportionally to the loudness
Green1 = (WheelG(pColor) * level[Channel]) ; // of the individual channel
Blue1 = (WheelB(pColor) * level[Channel]) ;
strip.setPixelColor(i, Red1, Green1, Blue1); // color the pixel with the given color
}
strip.show(); //show the new strip colors - FYI - takes rough 4.66 milliseconds on the Uno
//****************************************************************************** LCD OUTPUT
for (byte i = 0; i < 16; i++){ // cycle through the 16 channels
// takes about 1.66msec on a Teensy 3.2 to draw two fillRect 9-pixels wide - one
// black to erase any old information and one for the new data
// takes about 190usec per line on a Teensy 3.2 to draw the two drawFastVLines
// needed to erase the old information and draw a new line
int line1 = level
* 100;
if (line1 > 100){
line1 = 100;
}
tft.fillRect( i*10, 10, 10, 128-line1, BLACK); //erase old information
tft.drawRect( i*10, 128-line1, 10, line1, WHITE); //paint new bar
for (byte j = 1; j < 9; j++){ // draw muliple lines to create the bar
//tft.drawFastVLine( i*10 + j, 10, 128-line1, BLACK);
tft.drawFastVLine( i*10 + j, 128-line1, line1, Wheel565(i * 15 + 60));
}
}
}
}
//*******************************************************************************************/
// Wheel565: standard color look-up routine - Input a value 0 to 255 to get an RGB color value.
// NOTE: The colors are a transition Green (0) to Red (85) to Blue (170) back to Green
// RGB565 format!!
// R4-R3-R2-R1-R0-G5-G4-G3-G2-G1-G0-B4-B3-B2-B1-B0 Bits
// |-----------|-----------|-----------|-----------| Bytes
//*******************************************************************************************/
long Wheel565(byte WheelPos) {
if(WheelPos < 85) {
return ((((WheelPos * 3) / 8) * 0x0800) + ((63 - ((WheelPos * 3) / 4)) * 0x0020));
} else if(WheelPos < 170) {
WheelPos -= 85;
return (((31 - ((WheelPos * 3) / 8)) * 0x0800) + (0 * 0x0020) + (WheelPos * 3 / 8));
} else {
WheelPos -= 170;
return ((((WheelPos * 3) / 4) * 0x0020) + (31 - ((WheelPos * 3) / 8)));
}
}
//******************************************************************************************/
// WheelR: Neopixel RGB color wheel - returns the Red byte (not the entire RGB word)
byte WheelR(byte WheelPos) {
if(WheelPos < 85) {
return WheelPos * 3;
}
else if(WheelPos < 170) {
WheelPos -= 85;
return 255 - WheelPos * 3;
} else {
return 0;
}
}
//*******************************************************************************************/
// WheelG: same as above but just returns the Green byte
byte WheelG(byte WheelPos) {
if(WheelPos < 85) {
return 255 - WheelPos * 3;
} else if(WheelPos < 170) {
return 0;
} else {
WheelPos -= 170;
return WheelPos * 3;
}
}
//*******************************************************************************************/
// WheelB: same as above but just returns the Blue byte
byte WheelB(byte WheelPos) {
if(WheelPos < 85) {
return 0;
} else if(WheelPos < 170) {
WheelPos -= 85;
return WheelPos * 3;
} else {
WheelPos -= 170;
return 255 - WheelPos * 3;
}
}
. It leads the wide dynamic range which is theoretically possible with digital recording "ad absurdum" as the Romans said. Background noise captured by the microphone risks to be artificially blown up when your desired signal is weak and most of what you do for having a sophisticated musical expression when playing will be leveled out in the recording by the AGC. I'd rather go for a classic volume potentiometer partially replacing R5 and add some simple code lighting a LED when the sampled values reach the sampling extremes with a distance of ~4dB, thus > 3348 or < 748 when working with a 12bit resolution.
