```
/* WS2812Serial & Frequency Analyser Example
This example code is in the public domain. */
#include <WS2812Serial.h>
#include <Audio.h>
#include <Wire.h>
#include <SD.h>
#include <SPI.h>
// The display size and color to use
const unsigned int matrix_width = 60;
const unsigned int matrix_height = 12;
const unsigned int myColor = 0x400020;
// These parameters adjust the vertical thresholds
const float maxLevel = 0.5; // 1.0 = max, lower is more "sensitive"
const float dynamicRange = 40.0; // total range to display, in decibels
const float linearBlend = 0.3; // useful range is 0 to 0.7
const int numled = matrix_width * matrix_height;
const int pin = 1;
// Usable pins:
// Teensy LC: 1, 4, 5, 24
// Teensy 3.2: 1, 5, 8, 10, 20, 31
// Teensy 3.5: 1, 5, 8, 10, 20, 26, 32, 33, 48
// Teensy 3.6: 1, 5, 8, 10, 20, 26, 32, 33
byte drawingMemory[numled*3]; // 3 bytes per LED
DMAMEM byte displayMemory[numled*12]; // 12 bytes per LED
WS2812Serial leds(numled, displayMemory, drawingMemory, pin, WS2812_GRB);
//AudioInputAnalog adc1(A0); //xy=99,55
AudioInputI2S i2s2; //xy=145,131
AudioAnalyzeRMS rms1; //xy=298,42
AudioAnalyzePeak peak1; //xy=323,193
AudioAnalyzePeak peak2; //xy=327,274
AudioAnalyzeFFT256 fft256_1; //xy=422,80
AudioAnalyzeFFT1024 fft; //xy=265,75
AudioOutputI2S i2s1; //xy=515,173
AudioConnection patchCord1(i2s2, 0, i2s1, 0);
AudioConnection patchCord2(i2s2, fft);
AudioControlSGTL5000 sgtl5000_1; //xy=144,324
// This array holds the volume level (0 to 1.0) for each
// vertical pixel to turn on. Computed in setup() using
// the 3 parameters above.
float thresholdVertical[matrix_height];
// This array specifies how many of the FFT frequency bin
// to use for each horizontal pixel. Because humans hear
// in octaves and FFT bins are linear, the low frequencies
// use a small number of bins, higher frequencies use more.
int frequencyBinsHorizontal[matrix_width] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
3, 3, 3, 3, 4, 4, 4, 4, 4, 5,
5, 5, 6, 6, 6, 7, 7, 7, 8, 8,
9, 9, 10, 10, 11, 12, 12, 13, 14, 15,
15, 16, 17, 18, 19, 20, 22, 23, 24, 25
};
void setup() {
// the audio library needs to be given memory to start working
AudioMemory(12);
Serial.begin(115200);
sgtl5000_1.enable();
sgtl5000_1.volume(0.5);
sgtl5000_1.inputSelect(AUDIO_INPUT_MIC);
sgtl5000_1.micGain(40);
// compute the vertical thresholds before starting
computeVerticalLevels();
// turn on the display
leds.begin();
leds.show();
}
// A simple xy() function to turn display matrix coordinates
// into the index numbers OctoWS2811 requires. If your LEDs
// are arranged differently, edit this code...
unsigned int xy(unsigned int x, unsigned int y) {
if ((y & 1) == 0) {
// even numbered rows (0, 2, 4...) are left to right
return y * matrix_width + x;
} else {
// odd numbered rows (1, 3, 5...) are right to left
return y * matrix_width + matrix_width - 1 - x;
}
}
// Run repetitively
void loop() {
unsigned int x, y, freqBin;
float level;
if (fft.available()) {
// freqBin counts which FFT frequency data has been used,
// starting at low frequency
freqBin = 0;
for (x=0; x < matrix_width; x++) {
// get the volume for each horizontal pixel position
level = fft.read(freqBin, freqBin + frequencyBinsHorizontal[x] - 1);
// uncomment to see the spectrum in Arduino's Serial Monitor
// Serial.print(level);
// Serial.print(" ");
for (y=0; y < matrix_height; y++) {
// for each vertical pixel, check if above the threshold
// and turn the LED on or off
if (level >= thresholdVertical[y]) {
leds.setPixel(xy(x, y), myColor);
} else {
leds.setPixel(xy(x, y), 0x000000);
}
}
// increment the frequency bin count, so we display
// low to higher frequency from left to right
freqBin = freqBin + frequencyBinsHorizontal[x];
}
// after all pixels set, show them all at the same instant
leds.show();
// Serial.println();
}
}
// Run once from setup, the compute the vertical levels
void computeVerticalLevels() {
unsigned int y;
float n, logLevel, linearLevel;
for (y=0; y < matrix_height; y++) {
n = (float)y / (float)(matrix_height - 1);
logLevel = pow10f(n * -1.0 * (dynamicRange / 20.0));
linearLevel = 1.0 - n;
linearLevel = linearLevel * linearBlend;
logLevel = logLevel * (1.0 - linearBlend);
thresholdVertical[y] = (logLevel + linearLevel) * maxLevel;
}
}
```