基于Arduino的音乐动感节奏灯

1、音乐动感节奏灯是个什么东西？

　　前段时间听音乐觉得无聊，便想着音乐光听也没意思啊，能不能 “看见” 音乐呢？于是谷歌了一番，发现还真有人做了将音乐可视化的东西，那就是音乐节奏灯。说的简单点就是LED灯光颜色亮度等随着音乐的节奏而发生变化，看了下他们的实现方法有很多，不过大都比较复杂，而且灯只能够做节奏灯也比较浪费，于是我便动手做了一个既可以当作普通台灯使用，又可以随着音乐而闪烁的动感节奏灯，一举两得。

2、做这个东西需要准备哪些材料？

　　工欲善其事，必先利其器。那么做这样一个音乐动感节奏等需要准备哪些材料呢？

• 　　Arduino UNO 开发板
• 声音传感器（最好买Arduino专用的）
• BLE蓝牙4.0模块
• WS2812B彩色灯带
• 灯罩
• 3D打印底座
• 电源线和杜邦线若干

以上材料可以在淘宝买到，灯罩和3D打印的底座可以按照自己的实际需求来进行自己选择，为了防止打广告的嫌疑我就不放购买链接了，可以自行设计打印~

3、做这个东西需该怎么做？

　　准备好上述的材料之后，我们就可以开始进行灯的制作啦~，节奏灯的主要结构如下图：

我们使用Arduino UNO作为主要的计算和处理模块，蓝牙4.0模块和手机进行通信，利用手机APP来选择模式（后续会讲），在节奏灯的模式下，通过声音传感器来采集声音，通过得到的声音来控制灯带的颜色和闪烁，在彩色灯的模式下，利用手机来控制灯的颜色，理论上的有160万可调颜色。接下来介绍下详细的步骤。

3.1 安装开发环境

　　Arduino UNO 开发的环境为Arduino IDE,软件下载地址为 https://www.arduino.cn/thread-5838-1-1.html ，默认安装为最新版即可。安装完IDE之后还需要安装第三方的库。

　　1） WS2812B的库 FastLED, 选择 项目->加载库->管理库，然后在输入栏输入FastLED,选择最新的版本安装,FastLED库的更多使用方法可以参考 http://www.taichi-maker.com/homepage/reference-index/arduino-library-index/fastled-library/

　　2)  物联网开发平台库 Blinker, 在Blinker 官网https://doc.blinker.app 页面下载最新的Blinker库，然后：

　　　　Window：将下载好的blinker库解压到 我的电脑>文档>Arduino>libraries 文件夹中
　　　　Mac OS：将下载好的blinker库解压到
文稿>Arduino>libraries 文件夹中

　　　　可以在文件->示例 查看库是否安装成功。

3.2 连接线路

　　具体的线路图由于时间原因没有画，所以直接按照后续的代码可以找到每个模块的连接方式，当然这些连接方式都可以自定义，然后在代码内做简单修改即可。需要注意的是蓝牙模块采用软串口连接，即RX,TX连接在ARDUINO UNO的2 和 3 号脚，而不是0和1 号脚，这个在BLINKER的网站上会说明，如果你代码烧录不了，查查是不是这个原因。

3.3 代码编写

 #define BLINKER_PRINT Serial
 #define BLINKER_BLE

 #include <FastLED.h>
 #include <Blinker.h>

 /** BASIC CONFIGURATION  **/

 //The amount of LEDs in the setup
 #define NUM_LEDS 100
 //The pin that controls the LEDs
 #define LED_PIN 6
 //The pin that we read sensor values form
 #define ANALOG_READ 0

 //Confirmed microphone low value, and max value
 #define MIC_LOW 0.0
 #define MIC_HIGH 300.0
 /** Other macros */
 //How many previous sensor values effects the operating average?
 #define AVGLEN 5
 //How many previous sensor values decides if we are on a peak/HIGH (e.g. in a song)
 #define LONG_SECTOR 20

 //Mneumonics
 #define HIGH 3
 #define NORMAL 2

 //How long do we keep the "current average" sound, before restarting the measuring
 #define CYCLES 30 * 1000

 float fscale( float originalMin, float originalMax, float newBegin, float newEnd, float inputValue, float curve);
 void insert(int val, int *avgs, int len);
 int compute_average(int *avgs, int len);
 void visualize_music();

 //How many LEDs to we display
 int curshow = NUM_LEDS;

 /*Not really used yet. Thought to be able to switch between sound reactive
 mode, and general gradient pulsing/static color*/
 int mode = ;

 //Showing different colors based on the mode.
 int songmode = NORMAL;

 //Average sound measurement the last CYCLES
 unsigned long song_avg;

 //The amount of iterations since the song_avg was reset
 int iter = ;

 //The speed the LEDs fade to black if not relit
 float fade_scale = 1.2;

 //Led array
 CRGB leds[NUM_LEDS];

 /*Short sound avg used to "normalize" the input values.
 We use the short average instead of using the sensor input directly */
 int avgs[AVGLEN] = {-};

 //Longer sound avg
 int long_avg[LONG_SECTOR] = {-};

 // LED Model 1/Music LED 2/Color LED
 int LED_Model = ;

 //Keeping track how often, and how long times we hit a certain mode
 struct time_keeping {
   unsigned long times_start;
   short times;
 };

 //How much to increment or decrement each color every cycle
 struct color {
   int r;
   int g;
   int b;
 };

 struct time_keeping high;
 struct color Color;
 // when you use the MusicLED as a Color LED
 CRGB LEDColor(,,);
 uint8_t Bright = ;

 // declare the button
 BlinkerRGB RGB1("RGBKey");
 BlinkerButton Button1("switch");

 // rgb1_callback
 void rgb1_callback(uint8_t r_value, uint8_t g_value, uint8_t b_value, uint8_t bright_value)
 {
   // change the color of strip by your set on Blinker
       LEDColor.r = r_value;
       LEDColor.g = g_value;
       LEDColor.b = b_value;
       Bright = bright_value;
       fill_solid(leds,NUM_LEDS,LEDColor);

   FastLED.show();
 }

 void button1_callback(const String & state) {
   if(LED_Model == )
   {
     LEDColor.r = ;
     LEDColor.g = ;
     LEDColor.b = ;
     Bright = ;
     fill_solid(leds,NUM_LEDS,LEDColor);
     BLINKER_LOG2("strip_state: ","OFF");
     LED_Model = ;
   }
   else if(LED_Model == )
   {
     LED_Model = ;
   }
   FastLED.show();
 }

 void setup() {
   Serial.begin();
   //Set all lights to make sure all are working as expected
   FastLED.addLeds<NEOPIXEL, LED_PIN>(leds, NUM_LEDS);
   for (int i = ; i < NUM_LEDS; i++)
     leds[i] = CRGB(, , );
   FastLED.show();
   delay();  

   //bootstrap average with some low values
   for (int i = ; i < AVGLEN; i++) {
     insert(, avgs, AVGLEN);
   }

   //Initial values
   high.times = ;
   high.times_start = millis();
   Color.r = ;
   Color.g = ;
   Color.b = ;

     Blinker.begin();
     //attach the RGB1 SlidersRGB
     RGB1.attach(rgb1_callback);
     Button1.attach(button1_callback);
 }

 /*With this we can change the mode if we want to implement a general
 lamp feature, with for instance general pulsing. Maybe if the
 sound is low for a while? */
 void loop() {
   Blinker.run();

   if(LED_Model == )
     visualize_music();

   delay();       // delay in between reads for stability
 }

 /**Funtion to check if the lamp should either enter a HIGH mode,
 or revert to NORMAL if already in HIGH. If the sensors report values
 that are higher than 1.1 times the average values, and this has happened
 more than 30 times the last few milliseconds, it will enter HIGH mode.
 TODO: Not very well written, remove hardcoded values, and make it more
 reusable and configurable.  */
 void check_high(int avg) {
   if (avg > (song_avg/iter * 1.1))  {
     if (high.times != ) {
       if (millis() - high.times_start > 200.0) {
         high.times = ;
         songmode = NORMAL;
       } else {
         high.times_start = millis();
         high.times++;
       }
     } else {
       high.times++;
       high.times_start = millis();

     }
   }
   if (high.times >  && millis() - high.times_start < 50.0)
     songmode = HIGH;
   else if (millis() - high.times_start > ) {
     high.times = ;
     songmode = NORMAL;
   }
 }

 //Main function for visualizing the sounds in the lamp
 void visualize_music() {
   int sensor_value, mapped, avg, longavg;

   //Actual sensor value
   sensor_value = analogRead(ANALOG_READ);
   Serial.println(sensor_value);

   //If 0, discard immediately. Probably not right and save CPU.
   if (sensor_value == )
     return;

   //Discard readings that deviates too much from the past avg.
   mapped = (float)fscale(MIC_LOW, MIC_HIGH, MIC_LOW, (float)MIC_HIGH, (float)sensor_value, 2.0);
   avg = compute_average(avgs, AVGLEN);

   if (((avg - mapped) > avg*0.8)) //|| ((avg - mapped) < -avg*0.8))
     return;

   //Insert new avg. values
   insert(mapped, avgs, AVGLEN);
   insert(avg, long_avg, LONG_SECTOR); 

   //Compute the "song average" sensor value
   song_avg += avg;
   iter++;
   if (iter > CYCLES) {
     song_avg = song_avg / iter;
     iter = ;
   }

   longavg = compute_average(long_avg, LONG_SECTOR);

   //Check if we enter HIGH mode
   check_high(longavg);  

   if (songmode == HIGH) {
     fade_scale = ;
     Color.r = ;
     Color.g = ;
     Color.b = -;
   }
   else if (songmode == NORMAL) {
     fade_scale = ;
     Color.r = -;
     Color.b = ;
     Color.g = ;
   }

   //Decides how many of the LEDs will be lit
   curshow = fscale(MIC_LOW, MIC_HIGH, 0.0, (float)NUM_LEDS, (float)avg, -);

   /*Set the different leds. Control for too high and too low values.
           Fun thing to try: Dont account for overflow in one direction,
     some interesting light effects appear! */
   for (int i = ; i < NUM_LEDS; i++)
     //The leds we want to show
     if (i < curshow) {
       if (leds[i].r + Color.r > )
         leds[i].r = ;
       else if (leds[i].r + Color.r < )
         leds[i].r = ;
       else
         leds[i].r = leds[i].r + Color.r;

       if (leds[i].g + Color.g > )
         leds[i].g = ;
       else if (leds[i].g + Color.g < )
         leds[i].g = ;
       else
         leds[i].g = leds[i].g + Color.g;

       if (leds[i].b + Color.b > )
         leds[i].b = ;
       else if (leds[i].b + Color.b < )
         leds[i].b = ;
       else
         leds[i].b = leds[i].b + Color.b;  

     //All the other LEDs begin their fading journey to eventual total darkness
     } else {
       leds[i] = CRGB(leds[i].r/fade_scale, leds[i].g/fade_scale, leds[i].b/fade_scale);
     }
   FastLED.show();
 }
 //Compute average of a int array, given the starting pointer and the length
 int compute_average(int *avgs, int len) {
   int sum = ;
   for (int i = ; i < len; i++)
     sum += avgs[i];

   return (int)(sum / len);

 }

 //Insert a value into an array, and shift it down removing
 //the first value if array already full
 void insert(int val, int *avgs, int len) {
   for (int i = ; i < len; i++) {
     if (avgs[i] == -) {
       avgs[i] = val;
       return;
     }
   }

   for (int i = ; i < len; i++) {
     avgs[i - ] = avgs[i];
   }
   avgs[len - ] = val;
 }

 //Function imported from the arduino website.
 //Basically map, but with a curve on the scale (can be non-uniform).
 float fscale( float originalMin, float originalMax, float newBegin, float
     newEnd, float inputValue, float curve){

   float OriginalRange = ;
   float NewRange = ;
   float zeroRefCurVal = ;
   float normalizedCurVal = ;
   float rangedValue = ;
   boolean invFlag = ;

   // condition curve parameter
   // limit range

   if (curve > ) curve = ;
   if (curve < -) curve = -;

   curve = (curve * -.) ; // - invert and scale - this seems more intuitive - postive numbers give more weight to high end on output
   curve = pow(, curve); // convert linear scale into lograthimic exponent for other pow function

   // Check for out of range inputValues
   if (inputValue < originalMin) {
     inputValue = originalMin;
   }
   if (inputValue > originalMax) {
     inputValue = originalMax;
   }

   // Zero Refference the values
   OriginalRange = originalMax - originalMin;

   if (newEnd > newBegin){
     NewRange = newEnd - newBegin;
   }
   else
   {
     NewRange = newBegin - newEnd;
     invFlag = ;
   }

   zeroRefCurVal = inputValue - originalMin;
   normalizedCurVal  =  zeroRefCurVal / OriginalRange;   // normalize to 0 - 1 float

   // Check for originalMin > originalMax  - the math for all other cases i.e. negative numbers seems to work out fine
   if (originalMin > originalMax ) {
     return ;
   }

   if (invFlag == ){
     rangedValue =  (pow(normalizedCurVal, curve) * NewRange) + newBegin;

   }
   else     // invert the ranges
   {
     rangedValue =  newBegin - (pow(normalizedCurVal, curve) * NewRange);
   }

   return rangedValue;
 }

上述代码编译无误后上传到Arduino UNO即可。

3.4 下载并使用Blinker软件连接

　　Blinker软件的安装包可以在官网上找到：

安装好之后注册账号，登陆，在主页面右上角选择-->添加设备-->Arduino-->蓝牙接入，然后会自动发现我们的蓝牙，连接上之后，如图。

上面表示是否已经连接，现在表示已连接。然后添加上面的两个组件，编辑组件参数如下：

完成之后便可以通过RGB滑条来控制颜色，通过模式按钮来控制灯的模式。

3.5 灯的组装

　　我是自己在网上买的灯罩，然后根据自己的需求3D打印的底座，大家可以发挥自己的想象力来创作出不一样的外观~

　然后来一波安装完成的照片：

最后更新一波实测视频（由于不能同时录像和控制，所以只放了节奏灯效果）：

地址：https://www.bilibili.com/video/av38471827/