【花雕动手做】看见声音，基于Arduino系列音乐可视器（10）
偶然心血来潮，想要做一个声音可视化的系列专题。这个专题的难度有点高，涉及面也比较广泛，相关的FFT和FHT等算法也相当复杂，不过还是打算从最简单的开始，实际动手做做试验，耐心尝试一下各种方案，逐步积累些有用的音乐频谱可视化的资料，也会争取成型一些实用好玩的音乐可视器项目。【花雕动手做】有趣好玩的音乐可视化系列小项目（10）---WS2812硬板屏
【花雕动手做】有趣好玩的音乐可视化系列小项目（10）---WS2812硬板屏
项目之四：256位全彩闪动音乐频谱灯（8x32位WS2812硬屏）
实验开源代码
/*
【花雕动手做】有趣好玩的音乐可视化系列小项目（10）---WS2812硬板屏
项目之三：六十四位闪动音乐频谱灯（8x8WS2812硬屏）
*/
#include "FastLED.h"
#define OCTAVE 1 // // Group buckets into octaves(use the log output function LOG_OUT 1)
#define OCT_NORM 0 // Don't normalise octave intensities by number of bins
#define FHT_N 256 // set to 256 point fht
#include <FHT.h> // include the library
//int noise[] = {204,188,68,73,150,98,88,68}; // noise level determined by playing pink noise and seeing levels {204,188,68,73,150,98,88,68}
// int noise[] = {204,190,108,85,65,65,55,60}; // noise for mega adk
int noise[] = {204, 195, 100, 90, 85, 80, 75, 75}; // noise for NANO
//int noise[] = {204,198,100,85,85,80,80,80};
float noise_fact[] = {15, 7, 1.5, 1, 1.2, 1.4, 1.7, 3}; // noise level determined by playing pink noise and seeing levels {204,188,68,73,150,98,88,68}
float noise_fact_adj[] = {15, 7, 1.5, 1, 1.2, 1.4, 1.7, 3}; // noise level determined by playing pink noise and seeing levels {204,188,68,73,150,98,88,68}
#define LED_PIN 6
#define LED_TYPE WS2812
#define COLOR_ORDER GRB
// Params for width and height
const uint8_t kMatrixWidth = 8;
const uint8_t kMatrixHeight = 32;//----------was 27
//#define NUM_LEDS (kMatrixWidth * kMatrixHeight)
#define NUM_LEDS 256
CRGB leds;
int counter2 = 0;
void setup() {
Serial.begin(9600);
delay(1000);
FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
FastLED.setBrightness (6);
fill_solid(leds, NUM_LEDS, CRGB::Black);
FastLED.show();
// TIMSK0 = 0; // turn off timer0 for lower jitter
ADCSRA = 0xe5; // set the adc to free running mode
ADMUX = 0x40; // use adc0
DIDR0 = 0x01; // turn off the digital input for adc0
}
void loop() {
int prev_j;
int beat = 0;
int prev_oct_j;
int counter = 0;
int prev_beat = 0;
int led_index = 0;
int saturation = 0;
int saturation_prev = 0;
int brightness = 0;
int brightness_prev = 0;
while (1) { // reduces jitter
cli();// UDRE interrupt slows this way down on arduino1.0
for (int i = 0 ; i < FHT_N ; i++) { // save 256 samples
while (!(ADCSRA & 0x10)); // wait for adc to be ready
ADCSRA = 0xf5; // restart adc
byte m = ADCL; // fetch adc data
byte j = ADCH;
int k = (j << 8) | m; // form into an int
k -= 0x0200; // form into a signed int
k <<= 6; // form into a 16b signed int
fht_input = k; // put real data into bins
}
fht_window(); // window the data for better frequency response
fht_reorder(); // reorder the data before doing the fht
fht_run(); // process the data in the fht
fht_mag_octave(); // take the output of the fhtfht_mag_log()
// every 50th loop, adjust the volume accourding to the value on A2 (Pot)
if (counter >= 50) {
ADMUX = 0x40 | (1 & 0x07); // set admux to look at Analogpin A1 - Master Volume
while (!(ADCSRA & 0x10)); // wait for adc to be ready
ADCSRA = 0xf5; // restart adc
delay(10);
while (!(ADCSRA & 0x10)); // wait for adc to be ready
ADCSRA = 0xf5; // restart adc
byte m = ADCL; // fetch adc data
byte j = ADCH;
int k = (j << 8) | m; // form into an int
float master_volume = (k + 0.1) / 1000 + .75; // so the valu will be between ~0.5 and 1.---------------------+.75 was .5
Serial.println (master_volume);
for (int i = 1; i < 8; i++) {
noise_fact_adj = noise_fact * master_volume;
}
ADMUX = 0x40 | (0 & 0x07); // set admux back to look at A0 analog pin (to read the microphone input
counter = 0;
}
sei();
counter++;
// End of Fourier Transform code - output is stored in fht_oct_out.
// i=0-7 frequency (octave) bins (don't use 0 or 1), fht_oct_out= amplitude of frequency for bin 1
// for loop a) removes background noise average and takes absolute value b) low / high pass filter as still very noisy
// c) maps amplitude of octave to a colour between blue and red d) sets pixel colour to amplitude of each frequency (octave)
for (int i = 1; i < 8; i++) {// goes through each octave. skip the first 1, which is not useful
int j;
j = (fht_oct_out - noise); // take the pink noise average level out, take the asbolute value to avoid negative numbers
if (j < 10) {
j = 0;
}
j = j * noise_fact_adj;
if (j < 10) {
j = 0;
}
else {
j = j * noise_fact_adj;
if (j > 180) {
if (i >= 7) {
beat += 2;
}
else {
beat += 1;
}
}
j = j / 30;
j = j * 30; // (force it to more discrete values)
}
prev_j = j;
// Serial.print(j);
// Serial.print(" ");
// this fills in 11 LED's with interpolated values between each of the 8 OCT values
if (i >= 2) {
led_index = 2 * i - 3;
prev_oct_j = (j + prev_j) / 2;
saturation = constrain(j + 50, 0, 255); //-----------50 was 30
saturation_prev = constrain(prev_oct_j + 50, 0, 255);
brightness = constrain(j, 0, 255);
brightness_prev = constrain(prev_oct_j, 0, 255);
if (brightness == 255) {
saturation = 50;
brightness = 200;
}
if (brightness_prev == 255) {
saturation_prev = 50;
brightness_prev = 200;
}
for (uint8_t y = 0; y < kMatrixHeight; y++) {
leds = CHSV(j + y * 30, saturation, brightness);
if (i > 2) {
prev_oct_j = (j + prev_j) / 2;
leds[ XY(led_index - 2, y)] = CHSV(prev_oct_j + y * 30, saturation_prev, brightness_prev);
}
}
}
}
if (beat >= 7) {
fill_solid(leds, NUM_LEDS, CRGB::Gray);
FastLED.setBrightness(200);
}
else {
if (prev_beat != beat) {
FastLED.setBrightness(40 + beat * beat * 5);
prev_beat = beat;
}
}
FastLED.show();
if (beat) {
counter2 += ((beat + 4) / 2 - 2);
if (counter2 < 0) {
counter2 = 1000;
}
if (beat > 3 && beat < 7) {
FastLED.delay (20);
}
beat = 0;
}
// Serial.println();
}
}
// Param for different pixel layouts
const bool kMatrixSerpentineLayout = false;
// Set 'kMatrixSerpentineLayout' to false if your pixels are
// laid out all running the same way, like this:
// Set 'kMatrixSerpentineLayout' to true if your pixels are
// laid out back-and-forth, like this:
uint16_t XY( uint8_t x, uint8_t y)
{
uint16_t i;
if ( kMatrixSerpentineLayout == false) {
i = (y * kMatrixWidth) + x;
}
if ( kMatrixSerpentineLayout == true) {
if ( y & 0x01) {
// Odd rows run backwards
uint8_t reverseX = (kMatrixWidth - 1) - x;
i = (y * kMatrixWidth) + reverseX;
} else {
// Even rows run forwards
i = (y * kMatrixWidth) + x;
}
}
i = (i + counter2) % NUM_LEDS;
return i;
}
【花雕动手做】有趣好玩的音乐可视化系列小项目（10）---WS2812硬板屏
项目之三：六十四位闪动音乐频谱灯（8x8WS2812硬屏）
实验开源代码
/*
【花雕动手做】有趣好玩的音乐可视化系列小项目（10）---WS2812硬板屏
项目之三：六十四位闪动音乐频谱灯（8x8WS2812硬屏）
*/
#include "FastLED.h"
#define OCTAVE 1 // // Group buckets into octaves(use the log output function LOG_OUT 1)
#define OCT_NORM 0 // Don't normalise octave intensities by number of bins
#define FHT_N 256 // set to 256 point fht
#include <FHT.h> // include the library
//int noise[] = {204,188,68,73,150,98,88,68}; // noise level determined by playing pink noise and seeing levels {204,188,68,73,150,98,88,68}
// int noise[] = {204,190,108,85,65,65,55,60}; // noise for mega adk
int noise[] = {204, 195, 100, 90, 85, 80, 75, 75}; // noise for NANO
//int noise[] = {204,198,100,85,85,80,80,80};
float noise_fact[] = {15, 7, 1.5, 1, 1.2, 1.4, 1.7, 3}; // noise level determined by playing pink noise and seeing levels {204,188,68,73,150,98,88,68}
float noise_fact_adj[] = {15, 7, 1.5, 1, 1.2, 1.4, 1.7, 3}; // noise level determined by playing pink noise and seeing levels {204,188,68,73,150,98,88,68}
#define LED_PIN 6
#define LED_TYPE WS2812
#define COLOR_ORDER GRB
// Params for width and height
const uint8_t kMatrixWidth = 8;
const uint8_t kMatrixHeight = 8;//----------was 27
//#define NUM_LEDS (kMatrixWidth * kMatrixHeight)
#define NUM_LEDS 64
CRGB leds;
int counter2 = 0;
void setup() {
Serial.begin(9600);
delay(1000);
FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
FastLED.setBrightness (22);
fill_solid(leds, NUM_LEDS, CRGB::Black);
FastLED.show();
// TIMSK0 = 0; // turn off timer0 for lower jitter
ADCSRA = 0xe5; // set the adc to free running mode
ADMUX = 0x40; // use adc0
DIDR0 = 0x01; // turn off the digital input for adc0
}
void loop() {
int prev_j;
int beat = 0;
int prev_oct_j;
int counter = 0;
int prev_beat = 0;
int led_index = 0;
int saturation = 0;
int saturation_prev = 0;
int brightness = 0;
int brightness_prev = 0;
while (1) { // reduces jitter
cli();// UDRE interrupt slows this way down on arduino1.0
for (int i = 0 ; i < FHT_N ; i++) { // save 256 samples
while (!(ADCSRA & 0x10)); // wait for adc to be ready
ADCSRA = 0xf5; // restart adc
byte m = ADCL; // fetch adc data
byte j = ADCH;
int k = (j << 8) | m; // form into an int
k -= 0x0200; // form into a signed int
k <<= 6; // form into a 16b signed int
fht_input = k; // put real data into bins
}
fht_window(); // window the data for better frequency response
fht_reorder(); // reorder the data before doing the fht
fht_run(); // process the data in the fht
fht_mag_octave(); // take the output of the fhtfht_mag_log()
// every 50th loop, adjust the volume accourding to the value on A2 (Pot)
if (counter >= 50) {
ADMUX = 0x40 | (1 & 0x07); // set admux to look at Analogpin A1 - Master Volume
while (!(ADCSRA & 0x10)); // wait for adc to be ready
ADCSRA = 0xf5; // restart adc
delay(10);
while (!(ADCSRA & 0x10)); // wait for adc to be ready
ADCSRA = 0xf5; // restart adc
byte m = ADCL; // fetch adc data
byte j = ADCH;
int k = (j << 8) | m; // form into an int
float master_volume = (k + 0.1) / 1000 + .75; // so the valu will be between ~0.5 and 1.---------------------+.75 was .5
Serial.println (master_volume);
for (int i = 1; i < 8; i++) {
noise_fact_adj = noise_fact * master_volume;
}
ADMUX = 0x40 | (0 & 0x07); // set admux back to look at A0 analog pin (to read the microphone input
counter = 0;
}
sei();
counter++;
// End of Fourier Transform code - output is stored in fht_oct_out.
// i=0-7 frequency (octave) bins (don't use 0 or 1), fht_oct_out= amplitude of frequency for bin 1
// for loop a) removes background noise average and takes absolute value b) low / high pass filter as still very noisy
// c) maps amplitude of octave to a colour between blue and red d) sets pixel colour to amplitude of each frequency (octave)
for (int i = 1; i < 8; i++) {// goes through each octave. skip the first 1, which is not useful
int j;
j = (fht_oct_out - noise); // take the pink noise average level out, take the asbolute value to avoid negative numbers
if (j < 10) {
j = 0;
}
j = j * noise_fact_adj;
if (j < 10) {
j = 0;
}
else {
j = j * noise_fact_adj;
if (j > 180) {
if (i >= 7) {
beat += 2;
}
else {
beat += 1;
}
}
j = j / 30;
j = j * 30; // (force it to more discrete values)
}
prev_j = j;
// Serial.print(j);
// Serial.print(" ");
// this fills in 11 LED's with interpolated values between each of the 8 OCT values
if (i >= 2) {
led_index = 2 * i - 3;
prev_oct_j = (j + prev_j) / 2;
saturation = constrain(j + 50, 0, 255); //-----------50 was 30
saturation_prev = constrain(prev_oct_j + 50, 0, 255);
brightness = constrain(j, 0, 255);
brightness_prev = constrain(prev_oct_j, 0, 255);
if (brightness == 255) {
saturation = 50;
brightness = 200;
}
if (brightness_prev == 255) {
saturation_prev = 50;
brightness_prev = 200;
}
for (uint8_t y = 0; y < kMatrixHeight; y++) {
leds = CHSV(j + y * 30, saturation, brightness);
if (i > 2) {
prev_oct_j = (j + prev_j) / 2;
leds[ XY(led_index - 2, y)] = CHSV(prev_oct_j + y * 30, saturation_prev, brightness_prev);
}
}
}
}
if (beat >= 7) {
fill_solid(leds, NUM_LEDS, CRGB::Gray);
FastLED.setBrightness(200);
}
else {
if (prev_beat != beat) {
FastLED.setBrightness(40 + beat * beat * 5);
prev_beat = beat;
}
}
FastLED.show();
if (beat) {
counter2 += ((beat + 4) / 2 - 2);
if (counter2 < 0) {
counter2 = 1000;
}
if (beat > 3 && beat < 7) {
FastLED.delay (20);
}
beat = 0;
}
// Serial.println();
}
}
// Param for different pixel layouts
const bool kMatrixSerpentineLayout = false;
// Set 'kMatrixSerpentineLayout' to false if your pixels are
// laid out all running the same way, like this:
// Set 'kMatrixSerpentineLayout' to true if your pixels are
// laid out back-and-forth, like this:
uint16_t XY( uint8_t x, uint8_t y)
{
uint16_t i;
if ( kMatrixSerpentineLayout == false) {
i = (y * kMatrixWidth) + x;
}
if ( kMatrixSerpentineLayout == true) {
if ( y & 0x01) {
// Odd rows run backwards
uint8_t reverseX = (kMatrixWidth - 1) - x;
i = (y * kMatrixWidth) + reverseX;
} else {
// Even rows run forwards
i = (y * kMatrixWidth) + x;
}
}
i = (i + counter2) % NUM_LEDS;
return i;
}
【花雕动手做】有趣好玩的音乐可视化系列小项目（10）---WS2812硬板屏
项目之五：快速哈特利变换FHT音乐反应灯板（8X8位WS2812硬屏）
实验开源代码
/*
【花雕动手做】有趣好玩的音乐可视化系列小项目（10）---WS2812硬板屏
项目之五：快速哈特利变换FHT音乐反应灯板（8X8位WS2812硬屏）
*/
#define qsubd(x, b) ((x>b)?wavebright:0) // A digital unsigned subtraction macro. if result <0, then => 0. Otherwise, take on fixed value.
#define qsuba(x, b) ((x>b)?x-b:0) // Unsigned subtraction macro. if result <0, then => 0.
#define wavebright 128 // qsubd result will be this value if subtraction is >0.
#include "FastLED.h" // FastLED library. Preferably the latest copy of FastLED 2.1.
#if FASTLED_VERSION < 3001000
#error "Requires FastLED 3.1 or later; check github for latest code."
#endif
// Fixed definitions cannot change on the fly.
#define LED_DT 6 // Data pin to connect to the strip.
//#define LED_CK 11 // Clock pin for APA102 or WS2801
#define COLOR_ORDER GRB // It's GRB for WS2812
#define LED_TYPE WS2812B // What kind of strip are you using (APA102, WS2801 or WS2812B)
#define NUM_LEDS 64 // Number of LED's.
// Initialize changeable global variables.
uint8_t max_bright = 255; // Overall brightness definition. It can be changed on the fly.
struct CRGB leds; // Initialize our LED array.
#define LOG_OUT 1
#define FHT_N 256 // Set to 256 point fht.
#define inputPin A0
//#define potPin A4
#include <FHT.h> // FHT library
uint8_t hueinc = 0; // A hue increment value to make it rotate a bit.
uint8_t micmult = 25;
uint8_t fadetime = 900;
uint8_t noiseval = 25; // Increase this to reduce sensitivity. 30 seems best for quiet
void setup() {
analogReference(EXTERNAL); // Connect 3.3V to AREF pin for any microphones using 3.3V
Serial.begin(9600); // use the serial port
LEDS.addLeds<LED_TYPE, LED_DT, COLOR_ORDER>(leds, NUM_LEDS);
//LEDS.addLeds<LED_TYPE, LED_DT, LED_CK, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(max_bright);
set_max_power_in_volts_and_milliamps(5, 300); // FastLED Power management set at 5V, 500mA.
}
void loop() {
// noiseval = map(analogRead(potPin), 0, 1023, 16, 48); // Adjust sensitivity of cutoff.
EVERY_N_MILLISECONDS(13) {
fhtsound();
}
show_at_max_brightness_for_power();
Serial.println(LEDS.getFPS(), DEC); // Display frames per second on the serial monitor.
Serial.println(" "); // Display frames per second on the serial monitor.
Serial.println(analogRead(inputPin)); // print as an ASCII-encoded decimal */
}
void fhtsound() {
// hueinc++; // A cute little hue incrementer.
GetFHT(); // Let's take FHT_N samples and crunch 'em.
for (int i = 0; i < NUM_LEDS; i++) { // Run through the LED array.
int tmp = qsuba(fht_log_out, noiseval); // Get the sample and subtract the 'quiet' normalized values, but don't go < 0.
if (tmp > (leds.r + leds.g + leds.b) / 2) // Refresh an LED only when the intensity is low
leds = CHSV((i * 4) + tmp * micmult, 255, tmp * micmult); // Note how we really cranked up the tmp value to get BRIGHT LED's. Also increment the hue for fun.
leds.nscale8(fadetime); // Let's fade the whole thing over time as well.
}
} // fhtsound()
void GetFHT() {
cli();
for (int i = 0 ; i < FHT_N ; i++) fht_input = analogRead(inputPin);
sei();
fht_window(); // Window the data for better frequency response.
fht_reorder(); // Reorder the data before doing the fht.
fht_run(); // Process the data in the fht.
fht_mag_log();
} // GetFHT()
本帖最后由 驴友花雕 于 2021-12-14 10:19 编辑
Arduino 系列传感器和执行器模块实验目录清单：
一块扩展板完成Arduino的10类37项实验（代码+图形+仿真）
https://mc.dfrobot.com.cn/thread-280845-1-1.html
连杆形式的腿机构十一种：盘点机器人行走背后的机械原理
https://mc.dfrobot.com.cn/thread-308097-1-1.html
【花雕动手做】超低成本，尝试五十元的麦克纳姆轮小车！
https://mc.dfrobot.com.cn/thread-307863-1-1.html
【花雕动手做】超迷你哦，用徽商香烟盒做个智能小车！
https://mc.dfrobot.com.cn/thread-307907-1-1.html
【花雕动手做】太搞笑啦，一支胶管制成二只蠕动机器人
https://mc.dfrobot.com.cn/thread-308046-1-1.html
【花雕动手做】快餐盒盖，极低成本搭建机器人实验平台
https://mc.dfrobot.com.cn/thread-308063-1-1.html
【花雕动手做】特别苗条，使用微波传感器控制的纤细小车
https://mc.dfrobot.com.cn/thread-308866-1-1.html
【花雕动手做】脑洞大开、五花八门的简易机器人66种
https://mc.dfrobot.com.cn/thread-307900-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（1）---LED节奏灯
https://mc.dfrobot.com.cn/thread-311167-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（2）---OLED频谱灯
https://mc.dfrobot.com.cn/thread-311174-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（3）---RGB律动灯
https://mc.dfrobot.com.cn/thread-311183-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（4）---WS2812条灯
https://mc.dfrobot.com.cn/thread-311190-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（5）---WS2812柱跳灯
https://mc.dfrobot.com.cn/thread-311192-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（6）---点阵频谱灯
https://mc.dfrobot.com.cn/thread-311201-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（7）---大方格频谱灯
https://mc.dfrobot.com.cn/thread-311364-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（8）---四位32段点阵屏
https://mc.dfrobot.com.cn/thread-311490-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（9）---X Music Spectrum
https://mc.dfrobot.com.cn/thread-311627-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（10）---WS2812硬板屏
https://mc.dfrobot.com.cn/thread-311641-1-1.html
实验一百五十八：QMC5883L电子指南针罗盘模块 三轴磁场传感器GY-271
https://mc.dfrobot.com.cn/thread-308195-1-1.html
实验一百六十三：BMI160 6轴惯性运动传感器 16位3轴加速度+超低功耗3轴陀螺仪I2C/SPI 14LGA
https://mc.dfrobot.com.cn/thread-310371-1-1.html
实验一百六十五：2.4 英寸 TFT LCD 触摸屏模块 XPT2046 PCB ILI9341 240x320 像素 8 位 SPI 串口显示器 300mA
https://mc.dfrobot.com.cn/thread-309803-1-1.html
实验一百七十六：6mm大尺寸8x8LED方块方格点阵模块 可级联 红绿蓝白色 可选8级亮度
https://mc.dfrobot.com.cn/thread-309845-1-1.html
实验一百七十九：0.66英寸OLED显示模块 液晶屏模块IIC/I2C接口 64*48像素 SSD1306驱动芯片
https://mc.dfrobot.com.cn/thread-311179-1-1.html
实验一百八十一：1.3寸OLED液晶屏I2C IIC通信 4针模块 1106/1306驱动 128*64像素
https://mc.dfrobot.com.cn/thread-311123-1-1.html
实验一百八十三：GY-530 VL53L0X 激光测距 ToF测距 飞行时间测距传感器模块 IIC通信协议
https://mc.dfrobot.com.cn/thread-310273-1-1.html
实验一百八十五：MAX4466声音传感器 驻极体话筒放大器 麦克风可调功放模块 microphone
https://mc.dfrobot.com.cn/thread-310193-1-1.html
实验一百八十九：TDA1308 硅麦克风 数字咪头放大模块 拾音器放大板 楼氏SUNLEPHANT
https://mc.dfrobot.com.cn/thread-310246-1-1.html
实验一百九十三：TCS34725颜色识别传感器 RGB IIC明光感应模块 ColorSensor
https://mc.dfrobot.com.cn/thread-310209-1-1.html
实验二百：RCWL-0515微波雷达感应开关 人体感应 智能感应探测传感器 12-15米远距离2.7G微波检测模块
https://mc.dfrobot.com.cn/thread-310313-1-1.html
实验二百零一：OPT101模拟光照传感器 TEMT6000光强度模块 单片光电二极管 YourCee
https://mc.dfrobot.com.cn/thread-311164-1-1.html
实验二百零三：Air724UG合宙 Cat14G模块 DTU物联网UART串口通信数据TCP透传 核心板组合套餐
https://mc.dfrobot.com.cn/thread-310342-1-1.html
实验二百零七：I2C红色8*8LED点阵模块ht16k33驱动1088BS树莓派物联网可扩展编程
https://mc.dfrobot.com.cn/thread-310951-1-1.html
实验二百零九：Gravity: I2C & UART BC20 NB-IoT & GNSS通信模块 NB-IoT广域低功耗无线通信 GPS/北斗精准定位
https://mc.dfrobot.com.cn/thread-310433-1-1.html
实验二百一十七：2.9寸epd电子纸屏模块 spi电纸屏黑白红三色eink墨水屏QYEG0290BNS800F6
https://mc.dfrobot.com.cn/thread-311306-1-1.html#pid498640
【花雕测评】【AI】尝试搭建Maixduino几种开发环境
https://makelog.dfrobot.com.cn/article-311383.html
【花雕测评】【AI】MaixPy基本使用、显示文字及摄像机的22个小项目
https://makelog.dfrobot.com.cn/article-311389.html
【花雕测评】【AI】Mind+图片文字显示、呼吸灯和网络应用的22项小实验
https://makelog.dfrobot.com.cn/article-311386.html
【花雕测评】【AI】MaixPy机器视觉与Color识别的8个尝试
https://makelog.dfrobot.com.cn/article-311393.html
【花雕测评】【AI】Mind+机器视觉之数字图像处理和显示的22种小测试
https://makelog.dfrobot.com.cn/article-311405.html
【花雕测评】【AI】MaixPy之神经网络KPU与人脸识别的初步体验
https://makelog.dfrobot.com.cn/article-311400.html
【花雕测评】【AI】Mind+机器视觉之颜色、维码与形状识别的8个小实验
https://makelog.dfrobot.com.cn/article-311417.html
WS2812B主要特点
智能反接保护，电源反接不会损坏IC。
IC控制电路与LED点光源公用一个电源。
控制电路与RGB芯片集成在一个5050封装的元器件中，构成一个完整的外控像素点。
内置信号整形电路，任何一个像素点收到信号后经过波形整形再输出，保证线路波形畸变不会累加。
内置上电复位和掉电复位电路。
每个像素点的三基色颜色可实现256级亮度显示，完成16777216种颜色的全真色彩显示，扫描频率不低于400Hz/s。
串行级联接口，能通过一根信号线完成数据的接收与解码。
任意两点传传输距离在不超过5米时无需增加任何电路。
当刷新速率30帧/秒时，级联数不小于1024点。
数据发送速度可达800Kbps。
光的颜色高度一致，性价比高。
主要应用领域
LED全彩发光字灯串,LED全彩模组， LED全彩软灯条硬灯条,LED护栏管。
LED点光源,LED像素屏,LED异形屏，各种电子产品，电器设备跑马灯。
WS2812模块电原理图
MAX9814
是一款低成本高性能麦克风放大器，具有自动增益控制(AGC)和低噪声麦克风偏置。器件具有低噪声前端放大器、可变增益放大(VGA)、输出放大器、麦克风偏置电压发生器和AGC控制电路。
●自动增益控制(AGC)
●3种增益设置(40dB、50dB、60dB)
●可编程动作时间
●可编程动作和释放时间比
●电源电压范围2.7V～5.5V
●低THD：0.04% (典型值)
●低功耗关断模式
●内置2V低噪声麦克风偏置
搜索并安装Adafruit_NeoPixel库：
https://github.com/adafruit/Adafruit_NeoPixel
【花雕动手做】有趣好玩的音乐可视化系列小项目（10）---WS2812硬板屏
项目之一：使用Adafruit_NeoPixel库的音乐可视化多彩节奏灯
实验开源代码
/*
【花雕动手做】有趣好玩的音乐可视化系列小项目（10）---WS2812硬板屏
项目之一：使用Adafruit_NeoPixel库的音乐可视化多彩节奏灯
*/
#include <Adafruit_NeoPixel.h>
#define MIC A0 // 麦克风与A0相连接
#define LED_PIN 6 // LED are connected to D6
#define N_PIXELS 16 // Number of LED
#define N 100 //样本数
#define fadeDelay 10 // 淡出量
#define noiseLevel 40 // 降噪下限
Adafruit_NeoPixel strip = Adafruit_NeoPixel(N_PIXELS, LED_PIN, NEO_GRB + NEO_KHZ800);
int samples; // 存储样本
int periodFactor = 0; // 用于周期计算
int t1 = -1;
int T;
int slope;
byte periodChanged = 0;
void setup() {
// Serial.begin(9600);
strip.begin();
ledsOff();
delay(500);
displayColor(Wheel(100));
strip.show();
delay(500);
}
void loop() {
Samples();
}
void Samples() {
for (int i = 0; i < N; i++) {
samples = analogRead(0);
if (i > 0) {
slope = samples - samples;
}
else {
slope = samples - samples;
}
if (abs(slope) > noiseLevel) {
if (slope < 0) {
calculatePeriod(i);
if (periodChanged == 1) {
displayColor(getColor(T));
}
}
}
else {
ledsOff();
}
periodFactor += 1;
delay(1);
}
}
void calculatePeriod(int i) {
if (t1 == -1) {
t1 = i;
}
else {
int period = periodFactor * (i - t1);
periodChanged = T == period ? 0 : 1;
T = period;
// Serial.println(T);
t1 = i;
periodFactor = 0;
}
}
uint32_t getColor(int period) {
if (period == -1)
return Wheel(0);
else if (period > 400)
return Wheel(5);
else
return Wheel(map(-1 * period, -400, -1, 50, 255));
}
void fadeOut()
{
for (int i = 0; i < 5; i++) {
strip.setBrightness(110 - i * 20);
strip.show(); // Update strip
delay(fadeDelay);
periodFactor += fadeDelay;
}
}
void fadeIn() {
strip.setBrightness(100);
strip.show();
for (int i = 0; i < 5; i++) {
//strip.setBrightness(20*i + 30);
//strip.show();
delay(fadeDelay);
periodFactor += fadeDelay;
}
}
void ledsOff() {
fadeOut();
for (int i = 0; i < N_PIXELS; i++) {
strip.setPixelColor(i, 0, 0, 0);
}
}
void displayColor(uint32_t color) {
for (int i = 0; i < N_PIXELS; i++) {
strip.setPixelColor(i, color);
}
fadeIn();
}
uint32_t Wheel(byte WheelPos) {
// Serial.println(WheelPos);
if (WheelPos < 85) {
return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}
else if (WheelPos < 170) {
WheelPos -= 85;
return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
}
else {
WheelPos -= 170;
return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
}
}
实验场景图
【花雕动手做】有趣好玩的音乐可视化系列小项目（10）---WS2812硬板屏
项目之一：使用Adafruit_NeoPixel库的多彩节奏灯
实验视频剪辑
https://v.youku.com/v_show/id_XNTgyNzM2MTM2NA==.html?spm=a2hcb.playlsit.page.1
https://v.youku.com/v_show/id_XNTgyNzM2MTM2NA==.html?spm=a2hcb.playlsit.page.1
实验场景动态图
【花雕动手做】有趣好玩的音乐可视化系列小项目（10）---WS2812硬板屏
项目之二：音乐反应式 LED 灯板（4x4位）
实验开源代码
/*
【花雕动手做】有趣好玩的音乐可视化系列小项目（10）---WS2812硬板屏
项目之二：音乐反应式 LED 灯板
*/
#include <Adafruit_NeoPixel.h>
#include <math.h>
#define N_PIXELS16
#define MIC_PIN A0
#define LED_PIN 6
#define SAMPLE_WINDOW4
#define PEAK_HANG 24
#define PEAK_FALL 4
#define INPUT_FLOOR 10
#define INPUT_CEILING 50
byte peak = 16;
unsigned int sample;
byte Count = 0;
byte HangCount = 0;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(N_PIXELS, LED_PIN, NEO_GRB + NEO_KHZ800);
void setup() {
Serial.begin(9600);
analogReference(EXTERNAL);
strip.setBrightness(22);
strip.show();
strip.begin();
}
float fscale( float originalMin, float originalMax, float newBegin, float newEnd, float inputValue, float curve) {
float OriginalRange = 0;
float NewRange = 0;
float zeroRefCurVal = 0;
float normalizedCurVal = 0;
float rangedValue = 0;
boolean invFlag = 0;
if (curve > 10) curve = 10;
if (curve < -10) curve = -10;
curve = (curve * -.1) ;
curve = pow(10, curve);
if (inputValue < originalMin) {
inputValue = originalMin;
}
if (inputValue > originalMax) {
inputValue = originalMax;
}
OriginalRange = originalMax - originalMin;
if (newEnd > newBegin) {
NewRange = newEnd - newBegin;
}
else
{
NewRange = newBegin - newEnd;
invFlag = 1;
}
zeroRefCurVal = inputValue - originalMin;
normalizedCurVal=zeroRefCurVal / OriginalRange; // normalize to 0 - 1 float
Serial.print(OriginalRange, DEC);
Serial.print(" ");
Serial.print(NewRange, DEC);
Serial.print(" ");
Serial.println(zeroRefCurVal, DEC);
Serial.println();
delay(10);
if (originalMin > originalMax ) {
return 0;
}
if (invFlag == 0) {
rangedValue =(pow(normalizedCurVal, curve) * NewRange) + newBegin;
}
else
{
rangedValue =newBegin - (pow(normalizedCurVal, curve) * NewRange);
}
return rangedValue;
}
void loop() {
unsigned long startMillis = millis();
float peakToPeak = 0;
unsigned int signalMax = 0;
unsigned int signalMin = 1023;
unsigned int c, y;
while (millis() - startMillis < SAMPLE_WINDOW)
{
sample = analogRead(MIC_PIN);
if (sample < 1024)
{
if (sample > signalMax)
{
signalMax = sample;
}
else if (sample < signalMin)
{
signalMin = sample;
}
}
}
peakToPeak = signalMax - signalMin;
for (int i = 0; i <= strip.numPixels() - 1; i++) {
strip.setPixelColor(i, Wheel(map(i, 0, strip.numPixels() - 1, 30, 150)));
}
c = fscale(INPUT_FLOOR, INPUT_CEILING, strip.numPixels(), 0, peakToPeak, 2);
if (c < peak) {
peak = c;
HangCount = 0;
}
if (c <= strip.numPixels()) {
drawLine(strip.numPixels(), strip.numPixels() - c, strip.Color(0, 0, 0));
}
y = strip.numPixels() - peak;
strip.setPixelColor(y - 1, Wheel(map(y, 0, strip.numPixels() - 1, 30, 150)));
strip.show();
if (HangCount > PEAK_HANG) {
if (++Count >= PEAK_FALL) {
peak++;
Count = 0;
}
}
else {
HangCount++;
}
}
void drawLine(uint8_t from, uint8_t to, uint32_t c) {
uint8_t fromTemp;
if (from > to) {
fromTemp = from;
from = to;
to = fromTemp;
}
for (int i = from; i <= to; i++) {
strip.setPixelColor(i, c);
}
}
uint32_t Wheel(byte WheelPos) {
if (WheelPos < 85) {
return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}
else if (WheelPos < 170) {
WheelPos -= 85;
return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
}
else {
WheelPos -= 170;
return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
}
}
【花雕动手做】有趣好玩的音乐可视化系列小项目（10）---WS2812硬板屏
项目之二：音乐反应式 LED 灯板（4x4位）
实验视频剪辑
https://v.youku.com/v_show/id_XNTgyNzQwNjIyOA==.html?spm=a2hcb.playlsit.page.1
https://v.youku.com/v_show/id_XNTgyNzQwNjIyOA==.html?spm=a2hcb.playlsit.page.1
实验场动态图
【花雕动手做】有趣好玩的音乐可视化系列小项目（10）---WS2812硬板屏
项目之三：六十四位闪动音乐频谱灯（8x8位WS2812硬屏）
实验视频剪辑
https://v.youku.com/v_show/id_XNTgyNzExNzAyOA==.html?spm=a2hcb.playlsit.page.1
https://v.youku.com/v_show/id_XNTgyNzExNzAyOA==.html?spm=a2hcb.playlsit.page.1
实验场景动态图
实验场景图
【花雕动手做】有趣好玩的音乐可视化系列小项目（10）---WS2812硬板屏
项目之四：256位全彩闪动音乐频谱灯（8x32位WS2812硬屏）
实验视频剪辑
https://v.youku.com/v_show/id_XNTgyNzE0MTM3Mg==.html?spm=a2hcb.playlsit.page.1
https://v.youku.com/v_show/id_XNTgyNzE0MTM3Mg==.html?spm=a2hcb.playlsit.page.1
实验场景动态图