1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
// LED Audio Spectrum Analyzer Display
//
// Creates an impressive LED light show to music input
// using Teensy 3.1 with the OctoWS2811 adaptor board
// http://www.pjrc.com/store/teensy31.html
// http://www.pjrc.com/store/octo28_adaptor.html
//
// Line Level Audio Input connects to analog pin A3
// Recommended input circuit:
// http://www.pjrc.com/teensy/gui/?info=AudioInputAnalog
//
// This example code is in the public domain.
#define USE_OCTOWS2811
#include <OctoWS2811.h>
#include <FastLED.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 = 32;
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
CRGB leds[matrix_width * matrix_height];
// Audio library objects
AudioInputAnalog adc1(A3); //xy=99,55
AudioAnalyzeFFT1024 fft; //xy=265,75
AudioConnection patchCord1(adc1, fft);
// 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
};
// Run setup once
void setup() {
// the audio library needs to be given memory to start working
AudioMemory(12);
// compute the vertical thresholds before starting
computeVerticalLevels();
// turn on the display
FastLED.addLeds<OCTOWS2811>(leds,(matrix_width * matrix_height) / 8);
}
// 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[xy(x,y)] = CRGB(myColor);
} else {
leds[xy(x,y)] = CRGB::Black;
}
}
// 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
FastLED.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;
}
}
|
