• 零基础入门学用Arduino 第三部分（三）

    重要的内容写在前面：

    1. 该系列是以up主太极创客的零基础入门学用Arduino教程为基础制作的学习笔记。
    2. 个人把这个教程学完之后，整体感觉是很好的，如果有条件的可以先学习一些相关课程，学起来会更加轻松，相关课程有数字电路（强烈推荐先学数电，不然可能会有一些地方理解起来很困难）、模拟电路等，然后就是C++（注意C++是必学的）。
    3. 文章中的代码都是跟着老师边学边敲的，不过比起老师的版本我还把注释写得详细了些，并且个人认为重要的地方都有详细的分析。
    4. 一些函数的介绍有参考太极创客官网给出的中文翻译，为了便于现查现用，把个人认为重要的部分粘贴了过来并做了一些修改。
    5. 如有错漏欢迎指正。

    视频链接：3-0 本章介绍_哔哩哔哩_bilibili

    太极创客官网：太极创客 – Arduino, ESP8266物联网的应用、开发和学习资料

    三、LED灯带

    1、FastLED库的安装

            需要说明的是，在后面FastLED库的介绍中并不会详细介绍FastLED库的全部函数，仅展示部分函数的基本使用方法，另外不必深究一些弄不清的语法。

    2、WS2812 LED灯带

    （1）配合RGB-LED控制芯片，Arduino只需一个数字输入/输出引脚即可控制一个RGB-LED，如果将若干个RGB-LED控制芯片串联，那么Arduino只需一个数字输入/输出引脚即可控制若干个RGB-LED。

    （2）将RGB-LED控制芯片与RGB-LED集成在一起，就是数字RGB-LED，虽然它与普通的RGB-LED一样有四个引脚，但二者的功能却不一样，数字RGB-LED的引脚功能取决于集成在它内部的芯片型号。下图所示的是WS2812(B) LED示意图，图中未说明的两个引脚，较短的一个接5V电源，较长的一个接GND，灯带中灯珠的供电电路连接方式为并联，控制信号电路的连接方式为串联，每一个WS2812 LED灯珠需60mA的电流才能达到最大亮度。

    （3）下图所示的是WS2812(B) LED灯带实物。当不需要太长的灯带时，可以沿着灯带上的切割线（有一个剪刀图标）进行剪裁，然后自行在裁剪处焊接插针，不会影响灯带的正常使用。

    3、使用Arduino控制LED灯带的电路

    （1）开发时的Arduino控制LED电路如下图所示。

    （2）使用时的Arduino控制LED电路（当USB未连接电脑时，Arduino可通过+5V引脚由电源模块进行供电）如下图所示。

    4、FastLED库使用——基本点灯操作

    （1）单个灯珠闪烁：

    1. #include "FastLED.h"            //此程序需要使用FastLED库
    2.  
    3. #define NUM_LEDS 30             //LED灯珠数量
    4. #define DATA_PIN 9              //Arduino输出控制信号引脚
    5. #define LED_TYPE WS2812         //LED灯带型号
    6. #define COLOR_ORDER GRB         //RGB灯珠中红色、绿色、蓝色LED的排列顺序
    7. uint8_t max_bright = 128;       //LED亮度控制变量，可使用数值为0～255，数值越大，光带亮度越高
    8.  
    9. CRGB leds[NUM_LEDS];            //为每个LED灯珠建立对象，将它们存放在数组leds中
    10.  
    11. void setup() 
    12. { 
    13.   Serial.begin(9600);           //启动串行通讯
    14.   delay(1000);                  //稳定性等待
    15.   LEDS.addLeds(leds, NUM_LEDS);  //初始化灯带对象（不必纠结C++语法） 
    16.   FastLED.setBrightness(max_bright);                              //设置灯带亮度 
    17. }
    18.  
    19. void loop() 
    20. { 
    21.   leds[0] = CRGB::Red;      //设置灯带中第一个灯珠颜色为红色，leds[0]为第一个灯珠，leds[1]为第二个灯珠
    22.   FastLED.show();           //更新LED色彩
    23.   delay(500);               //等待500毫秒
    24.  
    25.   leds[0] = CRGB::Black;    //设置灯带中第一个灯珠颜色为黑色，leds[0]为第一个灯珠，leds[1]为第二个灯珠
    26.   FastLED.show();           //更新LED色彩
    27.   delay(500);               //等待500毫秒  
    28. }

    ①首先使用addLeds函数对灯带数组leds进行初始化，其中尖括号中的参数依次是灯带型号、输出灯带控制信号的Arduino引脚号、RGB灯珠中红绿蓝三种颜色的LED排列顺序，小括号中的参数依次是灯珠对象数组和灯珠数量；然后使用setBrightness函数设置灯带亮度，这个函数的作用不是点灯，而是设置当灯被点亮后的亮度参数。

    ②颜色参数的表示方式为“CRGB::<颜色名>”（Black表示熄灭灯珠），可以直接将颜色参数赋值给灯珠对象，然后使用show函数更新灯带的显示。

    ③对于灯珠对象数组，leds[0]控制灯带的第一个灯珠，leds[1]控制灯带的第二个灯珠，以此类推，通过反复让leds[0]在红色和黑色之间徘徊，可实现第一个灯珠闪烁的效果。

    （2）一个光点顺着灯带“运动”：

    1. #include "FastLED.h"            //此程序需要使用FastLED库
    2.  
    3. #define NUM_LEDS 30             //LED灯珠数量
    4. #define DATA_PIN 9              //Arduino输出控制信号引脚
    5. #define LED_TYPE WS2812         //LED灯带型号
    6. #define COLOR_ORDER GRB         //RGB灯珠中红色、绿色、蓝色LED的排列顺序
    7. uint8_t max_bright = 128;       //LED亮度控制变量，可使用数值为0～255， 数值越大则光带亮度越高
    8.  
    9. CRGB leds[NUM_LEDS];            //为每个LED灯珠建立对象，将它们存放在数组leds中
    10.  
    11. void setup() 
    12. { 
    13.   Serial.begin(9600);           //启动串行通讯
    14.   delay(1000);                  //稳定性等待
    15.   LEDS.addLeds(leds, NUM_LEDS);  //初始化灯带对象
    16.   FastLED.setBrightness(max_bright);                              //设置灯带亮度
    17. }
    18.  
    19. void loop() 
    20. { 
    21.   //依次点亮和熄灭灯带中灯珠，产生"光点移动"效果
    22.   for (int i = 0; i <= NUM_LEDS; i++) 
    23.   {
    24.     leds[i] = CRGB::Red;
    25.     FastLED.show();     //第i个灯珠显示红色
    26.     delay(50);
    27.     leds[i] = CRGB::Black;
    28.     FastLED.show();     //第i个灯珠熄灭
    29.     delay(50);    
    30.   }
    31.   delay(500);
    32. }

    ①首先使用addLeds函数对灯带数组leds进行初始化，其中尖括号中的参数依次是灯带型号、输出灯带控制信号的Arduino引脚号、RGB灯珠中红绿蓝三种颜色的LED排列顺序，小括号中的参数依次是灯珠对象数组和灯珠数量；然后使用setBrightness函数设置灯带亮度，这个函数的作用不是点灯，而是设置当灯被点亮后的亮度参数。

    ②颜色参数的表示方式为“CRGB::<颜色名>”（Black表示熄灭灯珠），可以直接将颜色参数赋值给灯珠对象，然后使用show函数更新灯带的显示。

    ③对于灯珠对象数组，leds[0]控制灯带的第一个灯珠，leds[1]控制灯带的第二个灯珠，以此类推，使用for循环顺序遍历leds数组，每轮循环都仅控制一个灯珠的亮灭，由此可以实现依次点亮和熄灭灯带中灯珠，产生“光点移动”效果。

    （3）一个变色的光点顺着灯带“运动”：

    1. #include "FastLED.h"            //此程序需要使用FastLED库
    2.  
    3. #define NUM_LEDS 30             //LED灯珠数量
    4. #define DATA_PIN 9              //Arduino输出控制信号引脚
    5. #define LED_TYPE WS2812         //LED灯带型号
    6. #define COLOR_ORDER GRB         //RGB灯珠中红色、绿色、蓝色LED的排列顺序
    7. uint8_t max_bright = 128;       //LED亮度控制变量，可使用数值为0～255， 数值越大则光带亮度越高
    8.  
    9. CRGB leds[NUM_LEDS];            //为每个LED灯珠建立对象，将它们存放在数组leds中
    10.  
    11. void setup() 
    12. { 
    13.   Serial.begin(9600);           //启动串行通讯
    14.   delay(1000);                  //稳定性等待
    15.   LEDS.addLeds(leds, NUM_LEDS);  //初始化灯带对象
    16.   FastLED.setBrightness(max_bright);                              //设置灯带亮度
    17. }
    18.  
    19. void loop() 
    20. { 
    21.   //依次使用不同色彩点亮单个LED灯珠
    22.   for (int i = 0; i <= NUM_LEDS; i++) 
    23.   {
    24.     leds[i] = CRGB::Red;
    25.     FastLED.show();         //第i个灯珠显示红色
    26.     delay(20);
    27.     leds[i] = CRGB::Green;
    28.     FastLED.show();         //第i个灯珠显示绿色
    29.     delay(20);   
    30.     leds[i] = CRGB::Blue;
    31.     FastLED.show();         //第i个灯珠显示蓝色
    32.     delay(20);      
    33.     leds[i] = CRGB::Black;
    34.     FastLED.show();         //第i个灯珠熄灭
    35.     delay(20);    
    36.   }
    37.   delay(500);
    38. }

    ①首先使用addLeds函数对灯带数组leds进行初始化，其中尖括号中的参数依次是灯带型号、输出灯带控制信号的Arduino引脚号、RGB灯珠中红绿蓝三种颜色的LED排列顺序，小括号中的参数依次是灯珠对象数组和灯珠数量；然后使用setBrightness函数设置灯带亮度，这个函数的作用不是点灯，而是设置当灯被点亮后的亮度参数。

    ②颜色参数的表示方式为“CRGB::<颜色名>”（Black表示熄灭灯珠），可以直接将颜色参数赋值给灯珠对象，然后使用show函数更新灯带的显示。

    ③对于灯珠对象数组，leds[0]控制灯带的第一个灯珠，leds[1]控制灯带的第二个灯珠，以此类推，使用for循环顺序遍历leds数组，每轮循环都仅控制一个灯珠多次变色，由此可以实现变色光点在灯带上“移动”的效果。

    （4）三个连续的变色光点顺着灯带“运动”：

    1. #include "FastLED.h"            //此程序需要使用FastLED库
    2.  
    3. #define NUM_LEDS 30             //LED灯珠数量
    4. #define DATA_PIN 9              //Arduino输出控制信号引脚
    5. #define LED_TYPE WS2812         //LED灯带型号
    6. #define COLOR_ORDER GRB         //RGB灯珠中红色、绿色、蓝色LED的排列顺序
    7. uint8_t max_bright = 128;       //LED亮度控制变量，可使用数值为0～255， 数值越大则光带亮度越高
    8.  
    9. CRGB leds[NUM_LEDS];            //为每个LED灯珠建立对象，将它们存放在数组leds中
    10.  
    11. void setup() 
    12. { 
    13.   Serial.begin(9600);           //启动串行通讯
    14.   delay(1000);                  //稳定性等待
    15.   LEDS.addLeds(leds, NUM_LEDS);  //初始化灯带对象
    16.   FastLED.setBrightness(max_bright);                              //设置灯带亮度
    17. }
    18.  
    19. void loop() 
    20. { 
    21.   //依次使用不同色彩点亮多个连续的LED灯珠
    22.   for (int i = 0; i <= NUM_LEDS; i++) 
    23.   {
    24.     leds[i-1] = CRGB::Red;   //第i-1个灯珠显示红色
    25.     leds[i] = CRGB::Red;     //第i个灯珠显示红色
    26.     leds[i+1] = CRGB::Red;   //第i+1个灯珠显示红色
    27.     FastLED.show();delay(50);
    28.     leds[i-1] = CRGB::Green; //第i-1个灯珠显示绿色
    29.     leds[i] = CRGB::Green;   //第i个灯珠显示绿色
    30.     leds[i+1] = CRGB::Green; //第i+1个灯珠显示绿色
    31.     FastLED.show();delay(50);   
    32.     leds[i-1] = CRGB::Blue;  //第i-1个灯珠显示蓝色
    33.     leds[i] = CRGB::Blue;    //第i个灯珠显示蓝色
    34.     leds[i+1] = CRGB::Blue;  //第i+1个灯珠显示蓝色
    35.     FastLED.show();delay(50);      
    36.     leds[i-1] = CRGB::Black; //第i-1个灯珠熄灭
    37.     leds[i] = CRGB::Black;   //第i个灯珠熄灭
    38.     leds[i+1] = CRGB::Black; //第i+1个灯珠熄灭
    39.     FastLED.show();delay(50);    
    40.   }
    41.   delay(500);
    42. }

    ①首先使用addLeds函数对灯带数组leds进行初始化，其中尖括号中的参数依次是灯带型号、输出灯带控制信号的Arduino引脚号、RGB灯珠中红绿蓝三种颜色的LED排列顺序，小括号中的参数依次是灯珠对象数组和灯珠数量；然后使用setBrightness函数设置灯带亮度，这个函数的作用不是点灯，而是设置当灯被点亮后的亮度参数。

    ②颜色参数的表示方式为“CRGB::<颜色名>”（Black表示熄灭灯珠），可以直接将颜色参数赋值给灯珠对象，然后使用show函数更新灯带的显示。

    ③对于灯珠对象数组，leds[0]控制灯带的第一个灯珠，leds[1]控制灯带的第二个灯珠，以此类推，使用for循环顺序遍历leds数组，每轮循环都控制连续的三个灯珠多次变色，由此可以实现多个连续的变色光点在灯带上“移动”的效果。

    （5）灯带的灯珠全部被点亮，然后全部被熄灭，以此往复：

    1. #include "FastLED.h"            //此程序需要使用FastLED库
    2.  
    3. #define NUM_LEDS 30             //LED灯珠数量
    4. #define DATA_PIN 9              //Arduino输出控制信号引脚
    5. #define LED_TYPE WS2812         //LED灯带型号
    6. #define COLOR_ORDER GRB         //RGB灯珠中红色、绿色、蓝色LED的排列顺序
    7. uint8_t max_bright = 128;       //LED亮度控制变量，可使用数值为0～255， 数值越大则光带亮度越高
    8.  
    9. CRGB leds[NUM_LEDS];            //为每个LED灯珠建立对象，将它们存放在数组leds中
    10.  
    11. void setup() 
    12. { 
    13.   Serial.begin(9600);           //启动串行通讯
    14.   delay(1000);                  //稳定性等待
    15.   LEDS.addLeds(leds, NUM_LEDS);  //初始化灯带对象
    16.   FastLED.setBrightness(max_bright);                              //设置灯带亮度
    17. }
    18.  
    19. void loop() 
    20. { 
    21.   //点亮灯带所有灯珠
    22.   for (int i = 0; i <= NUM_LEDS; i++) 
    23.   {    
    24.     leds[i] = CRGB::Red;FastLED.show();
    25.   }
    26.   delay(500);
    27.    //熄灭灯带所有灯珠
    28.   for (int i = 0; i <= NUM_LEDS; i++) 
    29.   {
    30.     leds[i] = CRGB::Black;FastLED.show();  
    31.   }
    32.   delay(500);
    33. }

    ①首先使用addLeds函数对灯带数组leds进行初始化，其中尖括号中的参数依次是灯带型号、灯带控制信号连接的Arduino引脚号、RGB灯珠中红绿蓝三种颜色的LED排列顺序，小括号中的参数依次是灯珠对象数组和灯珠数量。

    ②颜色参数的表示方式为“CRGB::<颜色名>”（Black表示熄灭灯珠），可以直接将颜色参数赋值给灯珠对象，然后使用show函数更新灯带的显示。

    ③对于灯珠对象数组，leds[0]控制灯带的第一个灯珠，leds[1]控制灯带的第二个灯珠，以此类推，使用for循环顺序遍历leds数组，第一次遍历将leds控制的灯珠全部点亮，第二次遍历将leds控制的灯珠全部熄灭，不过由于程序的执行本身要耗费一定时间，而show函数又被置于循环之中而不是循环之外，leds数组控制的灯珠经常还没全部被赋为红色或黑色就调用show函数，所以在视觉上灯带上的灯珠并不是同时被点亮，也不是同时被熄灭。

    5、FastLED库使用——批量点灯操作

    （1）灯带的灯珠全部同时被点亮，然后全部同时被熄灭，以此往复：

    1. #include "FastLED.h"            //此程序需要使用FastLED库
    2.  
    3. #define NUM_LEDS 30             //LED灯珠数量
    4. #define DATA_PIN 9              //Arduino输出控制信号引脚
    5. #define LED_TYPE WS2812         //LED灯带型号
    6. #define COLOR_ORDER GRB         //RGB灯珠中红色、绿色、蓝色LED的排列顺序
    7. uint8_t max_bright = 128;       //LED亮度控制变量，可使用数值为0～255， 数值越大则光带亮度越高
    8.  
    9. CRGB leds[NUM_LEDS];            //为每个LED灯珠建立对象，将它们存放在数组leds中
    10.  
    11. void setup() 
    12. { 
    13.   Serial.begin(9600);           //启动串行通讯
    14.   delay(1000);                  //稳定性等待
    15.   LEDS.addLeds(leds, NUM_LEDS);  //初始化灯带对象
    16.   FastLED.setBrightness(max_bright);                              //设置灯带亮度
    17. }
    18.  
    19. void loop () 
    20. {       
    21.  fill_solid(leds, 30, CRGB::Red);        //点亮leds控制的30个灯珠
    22.  FastLED.show();   
    23.  delay(500);
    24.  
    25.  fill_solid(leds, 30, CRGB::Black);      //熄灭leds控制的30个灯珠 
    26.  FastLED.show(); 
    27.  delay(500);       
    28. }

    ①fill_solid函数的作用是批量更改leds数组控制的灯珠的颜色，第一个参数是leds数组名，第二个参数是需要更改颜色的灯珠数量，第三个参数是更改后的颜色参数。

    ②fill_solid函数中并没有调用show函数，它仅更改leds数组的存储内容，调用show函数时才会将leds中的颜色参数落实到实物LED灯带上。

    （2）灯带头部前三个灯珠全部同时被点亮，然后全部同时被熄灭，以此往复：

    1. #include "FastLED.h"            //此程序需要使用FastLED库
    2.  
    3. #define NUM_LEDS 30             //LED灯珠数量
    4. #define DATA_PIN 9              //Arduino输出控制信号引脚
    5. #define LED_TYPE WS2812         //LED灯带型号
    6. #define COLOR_ORDER GRB         //RGB灯珠中红色、绿色、蓝色LED的排列顺序
    7. uint8_t max_bright = 128;       //LED亮度控制变量，可使用数值为0～255， 数值越大则光带亮度越高
    8.  
    9. CRGB leds[NUM_LEDS];            //为每个LED灯珠建立对象，将它们存放在数组leds中
    10.  
    11. void setup() 
    12. { 
    13.   Serial.begin(9600);           //启动串行通讯
    14.   delay(1000);                  //稳定性等待
    15.   LEDS.addLeds(leds, NUM_LEDS);  //初始化灯带对象
    16.   FastLED.setBrightness(max_bright);                              //设置灯带亮度
    17. }
    18.  
    19. void loop () 
    20. {       
    21.   //从灯带头开始，点亮熄灭3个LED
    22.   fill_solid(leds, 3, CRGB::Red);
    23.   FastLED.show();  
    24.   delay(500);
    25.   fill_solid(leds, 3, CRGB::Black);
    26.   FastLED.show();  
    27.   delay(500);              
    28. }

    ①fill_solid函数的作用是批量更改leds数组控制的灯珠的颜色，第一个参数是leds数组名，第二个参数是需要更改颜色的灯珠数量，第三个参数是更改后的颜色参数。

    ②fill_solid函数中并没有调用show函数，它仅更改leds数组的存储内容，调用show函数时才会将leds中的颜色参数落实到实物LED灯带上。

    ③fill_solid函数的作用并不仅是同时控制灯带上的所有灯珠，可以仅控制部分，当第一个参数是leds数组名时，第二个参数是从灯带头部开始往后，需要控制的灯珠数量，将其取值为3，意味着仅控制灯带头部的前3个灯珠。

    （3）灯带中部的连续三个灯珠全部同时被点亮，然后全部同时被熄灭，以此往复：

    1. #include "FastLED.h"            //此程序需要使用FastLED库
    2.  
    3. #define NUM_LEDS 30             //LED灯珠数量
    4. #define DATA_PIN 9              //Arduino输出控制信号引脚
    5. #define LED_TYPE WS2812         //LED灯带型号
    6. #define COLOR_ORDER GRB         //RGB灯珠中红色、绿色、蓝色LED的排列顺序
    7. uint8_t max_bright = 128;       //LED亮度控制变量，可使用数值为0～255， 数值越大则光带亮度越高
    8.  
    9. CRGB leds[NUM_LEDS];            //为每个LED灯珠建立对象，将它们存放在数组leds中
    10.  
    11. void setup() 
    12. { 
    13.   Serial.begin(9600);           //启动串行通讯
    14.   delay(1000);                  //稳定性等待
    15.   LEDS.addLeds(leds, NUM_LEDS);  //初始化灯带对象
    16.   FastLED.setBrightness(max_bright);                              //设置灯带亮度
    17. }
    18.  
    19. void loop () 
    20. { 
    21.   //从灯带头开始的第6个灯珠开始点亮熄灭3个LED
    22.   fill_solid(leds+5, 3, CRGB::Red);
    23.   FastLED.show();   
    24.   delay(500);
    25.   
    26.   fill_solid(leds+5, 3, CRGB::Black);
    27.   FastLED.show();
    28.   delay(500);             
    29. }

    ①fill_solid函数的作用是批量更改leds数组控制的灯珠的颜色，第一个参数是leds数组名，第二个参数是需要更改颜色的灯珠数量，第三个参数是更改后的颜色参数。

    ②fill_solid函数中并没有调用show函数，它仅更改leds数组的存储内容，调用show函数时才会将leds中的颜色参数落实到实物LED灯带上。

    ③fill_solid函数不只能从灯带头部第一个灯珠开始控制，它还可以从灯带中部的灯珠开始控制，当第一个参数是leds数组名与整型量的加法时，这里的“leds”是leds数组元素的首地址，而“leds+5”则是leds[5]的地址，那么fill_solid函数将从leds[5]开始更改leds数组的存储内容，也就是从灯带头部往后的第6个灯珠开始更改灯珠颜色参数，第二个参数为3，则fill_solid函数从第6个灯珠开始往后更改3个灯珠的颜色参数。

    （4）三个光点组成的色条在灯带上反复摆动：

    1. #include "FastLED.h"            //此程序需要使用FastLED库
    2.  
    3. #define NUM_LEDS 30             //LED灯珠数量
    4. #define DATA_PIN 9              //Arduino输出控制信号引脚
    5. #define LED_TYPE WS2812         //LED灯带型号
    6. #define COLOR_ORDER GRB         //RGB灯珠中红色、绿色、蓝色LED的排列顺序
    7. uint8_t max_bright = 128;       //LED亮度控制变量，可使用数值为0～255， 数值越大则光带亮度越高
    8.  
    9. CRGB leds[NUM_LEDS];            //为每个LED灯珠建立对象，将它们存放在数组leds中
    10.  
    11. void setup() 
    12. { 
    13.   Serial.begin(9600);           //启动串行通讯
    14.   delay(1000);                  //稳定性等待
    15.   LEDS.addLeds(leds, NUM_LEDS);  //初始化灯带对象
    16.   FastLED.setBrightness(max_bright);                              //设置灯带亮度
    17. }
    18.  
    19. void loop () 
    20. {       
    21.   for (int i = 0; i < NUM_LEDS-3; i++)  //色条正向运动
    22.   {
    23.     fill_solid(leds+i, 3, CRGB::Red);
    24.     FastLED.show();delay(50);
    25.     fill_solid(leds+i, 3, CRGB::Black); 
    26.     FastLED.show();delay(50);
    27.   }  
    28.   for (int i = NUM_LEDS-3; i > 0; i--)  //色条逆向运动
    29.   {
    30.     fill_solid(leds+i, 3, CRGB::Red);
    31.     FastLED.show();delay(50);
    32.     fill_solid(leds+i, 3, CRGB::Black); 
    33.     FastLED.show();delay(50);
    34.   }                
    35. }

    ①fill_solid函数的作用是批量更改leds数组控制的灯珠的颜色，第一个参数是leds数组名，第二个参数是需要更改颜色的灯珠数量，第三个参数是更改后的颜色参数。

    ②fill_solid函数中并没有调用show函数，它仅更改leds数组的存储内容，调用show函数时才会将leds中的颜色参数落实到实物LED灯带上。

    ③当fill_solid函数的第一个参数是leds数组名与整型量的加法时，这里的“leds”是leds数组元素的首地址，而“leds+i”则是leds[i]的地址，那么fill_solid函数将从leds[i]开始更改leds数组的存储内容，也就是从灯带头部往后的第i个灯珠开始更改灯珠颜色参数，第二个参数为3，则fill_solid函数从第i个灯珠开始往后更改3个灯珠的颜色参数。不断改变i的值，被选中的灯珠也会随之改变。

    6、FastLED库使用——自定义颜色

    （1）除了FastLED库提供的颜色参数外，程序员还可以自定义颜色，FastLED提供了两种自定义颜色的方法，分别是CRGB方法与CHSV方法：

    ①CRGB方法就是将三原色（红色、绿色、蓝色）以不同比重（或者说数值）相加在一起得到其它颜色。

    定义方式：CRGB <颜色变量名>(,,);

    1. #include "FastLED.h" 
    2.  
    3. #define NUM_LEDS 30
    4. #define LED_DT 9  
    5. #define LED_TYPE WS2812 
    6. #define COLOR_ORDER GRB 
    7. uint8_t max_bright = 128;
    8.  
    9. CRGB leds[NUM_LEDS];
    10. //CRGB方法定义颜色                        
    11. CRGB myRGBcolor(50,0,50);  //myRGBcolor（rValue，gValue，bValue）——创建RGB颜色变量
    12.                             //rValue: 红色数值 0 - 255
    13.                             //gValue: 绿色数值 0 - 255
    14.                             //bValue: 蓝色数值 0 - 255
    15. void setup() 
    16. { 
    17.   LEDS.addLeds(leds, NUM_LEDS);
    18.   FastLED.setBrightness(max_bright);
    19. }
    20. void loop () 
    21. { 
    22.   myRGBcolor.r = 0; //更改红色数值，myRGBcolor(0, 0 ,50)
    23.   myRGBcolor.b = 0; //更改蓝色数值，myRGBcolor(0, 0 ,0)
    24.   fill_solid(leds, NUM_LEDS, myRGBcolor);FastLED.show();delay(500);  
    25.  
    26.   myRGBcolor.r = 50; //更改红色数值，myRGBcolor(50, 0 ,0)
    27.   myRGBcolor.b = 50; //更改蓝色数值，myRGBcolor(50, 0 ,50)
    28.   fill_solid(leds, NUM_LEDS, myRGBcolor);FastLED.show();delay(500);   
    29. }

    ②CHSV方法同样有三个参数，它们分别为色调（H）、饱和度（S）和明亮度（V），色调的意义如下图的扇形图所示，饱和度的意义如下图右下角的渐变图所示（以色调H=0为例），明亮度的意义如下图右上角的渐变图所示（以色调H=0为例），通过不同数值的组合可以得到不同的颜色。

    定义方式：CHSV <颜色变量名>(,,);

    1. #include "FastLED.h" 
    2.  
    3. #define NUM_LEDS 30
    4. #define LED_DT 9  
    5. #define LED_TYPE WS2812 
    6. #define COLOR_ORDER GRB 
    7. uint8_t max_bright = 128;
    8.  
    9. CRGB leds[NUM_LEDS];
    10. //CHSV方法定义颜色  
    11. CHSV myHSVcolor(80,255,200);    //myHSVcolor（色调，饱和度，明亮度）——创建HSV颜色变量
    12.  
    13. void setup() 
    14. { 
    15.   LEDS.addLeds(leds, NUM_LEDS);
    16.   FastLED.setBrightness(max_bright);
    17. }
    18. void loop () 
    19. { 
    20.   myHSVcolor.h++;  //修改yHSVcolor.h，即myHSVcolor的色调数值      
    21.   fill_solid(leds, NUM_LEDS, myHSVcolor);FastLED.show();delay(10);       
    22. }

    （2）将下面的程序下载到开发板中，可以看见灯带全部被点亮，而且有一个“变色段”在灯带上运动，凡是“变色段”经过的地方，都会变成“变色段”所带有的颜色，而且“变色段”本身也在不断变色。

    1. #include "FastLED.h" 
    2.  
    3. #define NUM_LEDS 30
    4. #define LED_DT 9  
    5. #define LED_TYPE WS2812 
    6. #define COLOR_ORDER GRB 
    7. uint8_t max_bright = 128;
    8.  
    9. CRGB leds[NUM_LEDS];
    10. //CHSV方法定义颜色  
    11. CHSV myHSVcolor(80,255,200);    //myHSVcolor（色调，饱和度，明亮度）——创建HSV颜色变量
    12.  
    13. void setup() 
    14. { 
    15.   LEDS.addLeds(leds, NUM_LEDS);
    16.   FastLED.setBrightness(max_bright);
    17. }
    18.  
    19. void loop () 
    20. { 
    21.   for (int i = 0; i < NUM_LEDS-3; i++)  //变色段正向运动
    22.   {
    23.     myHSVcolor.h++;  //修改色调
    24.     fill_solid(leds+i, 3, myHSVcolor);  //leds+i~leds+1+3是变色段
    25.     FastLED.show();
    26.     delay(50);
    27.   }  
    28.   for (int i = NUM_LEDS-3; i >= 0; i--)  //变色段逆向运动
    29.   {
    30.     myHSVcolor.h++;  //修改色调
    31.     fill_solid(leds+i, 3, myHSVcolor);  //leds+i~leds+1+3是变色段
    32.     FastLED.show();
    33.     delay(50);
    34.   }     
    35. }

    （3）将下面的程序下载到开发板中，可以看见灯带有一个“变色段”在灯带上运动，“变色段”以外的灯珠全部熄灭。

    1. #include "FastLED.h" 
    2.  
    3. #define NUM_LEDS 30
    4. #define LED_DT 9  
    5. #define LED_TYPE WS2812 
    6. #define COLOR_ORDER GRB 
    7. uint8_t max_bright = 128;
    8.  
    9. CRGB leds[NUM_LEDS];
    10. //CHSV方法定义颜色  
    11. CHSV myHSVcolor(80,255,200);    //myHSVcolor（色调，饱和度，明亮度）——创建HSV颜色变量
    12.  
    13. void setup() 
    14. { 
    15.   LEDS.addLeds(leds, NUM_LEDS);
    16.   FastLED.setBrightness(max_bright);
    17. }
    18.  
    19. void loop () 
    20. {
    21.   for (int i = 0; i < NUM_LEDS-3; i++)   //变色段正向运动
    22.   {
    23.     myHSVcolor.h++;  //修改色调
    24.     fill_solid(leds+i, 3, myHSVcolor);
    25.     FastLED.show();delay(50);
    26.  
    27.     fill_solid(leds+i, 3, CRGB::Black); 
    28.     FastLED.show();    
    29.   }  
    30.  
    31.   for (int i = NUM_LEDS-3; i >= 0; i--)   //变色段逆向运动
    32.   {
    33.     myHSVcolor.h++;   //修改色调
    34.     fill_solid(leds+i, 3, myHSVcolor);
    35.     FastLED.show();delay(50);
    36.  
    37.     fill_solid(leds+i, 3, CRGB::Black); 
    38.     FastLED.show();        
    39.   }     
    40. }

    7、FastLED库使用——色调渐变灯带

    （1）fill_rainbow函数有四个参数，其中最后一个参数可选，第一个参数是灯带对象的数组名，第二个参数是从第一个参数对应的灯珠开始往后需要控制的灯珠数量，第三个参数是起始色调值：

    ①若放弃可选参数，fill_rainbow函数会将选中的第一个灯珠颜色设置为起始色调，往后的灯珠色调呈递增趋势，递增值取决于需要控制的灯珠数量，最后所选的全部灯珠将呈现渐变的彩虹色。

    ②若采用可选参数，fill_rainbow函数会将选中的第一个灯珠颜色设置为起始色调，往后的灯珠色调呈递增趋势，递增值取决于可选参数值，如下图所示。

    1. #include "FastLED.h"    
    2.  
    3. #define NUM_LEDS 30        
    4. #define LED_DT 9            
    5. #define LED_TYPE WS2812 
    6. #define COLOR_ORDER GRB     
    7.  
    8. uint8_t max_bright = 128;   
    9.  
    10. CRGB leds[NUM_LEDS];   
    11.  
    12. uint8_t beginHue;
    13.  
    14. void setup() 
    15. { 
    16.   LEDS.addLeds(leds, NUM_LEDS); 
    17.   FastLED.setBrightness(max_bright);    
    18. }
    19.  
    20. void loop () 
    21. {  
    22.   beginHue++;    //初始色调改变
    23.   fill_rainbow(leds, NUM_LEDS, beginHue, 9);   //色调递增值取9
    24.   FastLED.show();
    25.   delay(25); 
    26. }

    （2）fill_gradient_RGB函数有5个参数，第一个参数是灯带对象的数组名，第二个参数是第一个需要控制的灯珠在数组中的下标，第三个参数是起始RGB颜色（可用FastLED库提供的颜色参数，也可用CRGB方法自定义颜色变量），第四个参数是最后一个需要控制的灯珠在数组中的下标，第五个参数是结束RGB颜色（可用FastLED库提供的颜色参数，也可用CRGB方法自定义颜色变量），fill_gradient_RGB函数将会把选中的灯珠按起始和结束RGB颜色进行渐变设置，第一个灯珠设置为起始RGB颜色，最后一个灯珠设置为结束RGB颜色。

    1. #include "FastLED.h"    
    2.  
    3. #define NUM_LEDS 30        
    4. #define LED_DT 9            
    5. #define LED_TYPE WS2812 
    6. #define COLOR_ORDER GRB     
    7.  
    8. uint8_t max_bright = 128;   
    9.  
    10. CRGB leds[NUM_LEDS];   
    11.  
    12. void setup() 
    13. { 
    14.   LEDS.addLeds(leds, NUM_LEDS); 
    15.   FastLED.setBrightness(max_bright);    
    16. }
    17.  
    18. void loop () 
    19. {       
    20.   fill_gradient_RGB(leds, 0, CRGB::Red, 29, CRGB::Blue); 
    21.   FastLED.show();
    22.   delay(50);
    23. }

    （3）fill_gradient函数有6个参数，第一个参数是灯带对象的数组名，第二个参数是第一个需要控制的灯珠在数组中的下标，第三个参数是起始颜色（可用FastLED库提供的颜色参数，也可用CRGB或者CHSV方法自定义颜色变量），第四个参数是最后一个需要控制的灯珠在数组中的下标，第五个参数是结束颜色（可用FastLED库提供的颜色参数，也可用CRGB或者CHSV方法自定义颜色变量），第六个参数是渐变方向，fill_gradient函数将会把选中的灯珠按起始和结束颜色进行渐变设置，第一个灯珠设置为起始颜色，最后一个灯珠设置为结束颜色，另外从一个颜色渐变到另外一个颜色有两个渐变方向，在灯珠数量相同的前提下，一个方向的色调变化值较大，对应参数“LONGEST_HUES”，另一个方向的色调变化值较小，对应参数“SHORTEST_HUES”。

    1. #include "FastLED.h"    
    2.  
    3. #define NUM_LEDS 30        
    4. #define LED_DT 9            
    5. #define LED_TYPE WS2812 
    6. #define COLOR_ORDER GRB     
    7.  
    8. uint8_t max_bright = 128;   
    9.  
    10. CRGB leds[NUM_LEDS];   
    11.  
    12. uint8_t beginHue;
    13.  
    14. void setup() 
    15. { 
    16.   LEDS.addLeds(leds, NUM_LEDS); 
    17.   FastLED.setBrightness(max_bright);    
    18. }
    19.  
    20. void loop () 
    21. {       
    22.   fill_gradient(leds, 0, CHSV(50, 255,255) , 29, CHSV(150,255,255), LONGEST_HUES);
    23.   FastLED.show();
    24.   delay(50);
    25. }

    8、FastLED库使用——从调色板取色点灯

    （1）下图所示的是FastLED库预设的其中两个调色板（截止3.7.0版本，预设的调色板共有8种），Arduino可以根据颜色序号从调色板上获取相应的颜色，当然，除了FastLED库预设的调色板，程序员也可自定义调色板然后使用之。

    （2）fill_palette函数有7个参数，依次是灯带数组名、灯珠数量、起始颜色序号、相邻光珠的颜色序号差、调色板名（可以是库预设的，也可以是自定义的）、亮度值及线性渐变（LINEARBLEND）/非线性渐变（NOBLEND），其作用就是按照颜色序号将指定调色板上的颜色依次赋予灯带上的各个灯珠，若采用线性渐变，第一个灯珠的颜色对应起始颜色序号在调色板上的取色，再往后颜色序号将按照相邻光珠的颜色序号差进行递增，当颜色序号大于255时，大于255的部分从0开始继续递增。

    （3）使用库预设的调色板CloudColors_p：在fill_palette函数中直接传入调色板名即可。

    1. #include "FastLED.h"  
    2.  
    3. #define NUM_LEDS 30     
    4. #define LED_DT 9       
    5. #define LED_TYPE WS2812 
    6. #define COLOR_ORDER GRB  
    7.  
    8. uint8_t max_bright = 128; 
    9.  
    10. CRGB leds[NUM_LEDS];                                   
    11.  
    12. uint8_t colorIndex;
    13.  
    14. void setup() 
    15. {                                           
    16.   LEDS.addLeds(leds, NUM_LEDS);  
    17.   FastLED.setBrightness(max_bright);             
    18. }
    19.  
    20. void loop () 
    21. {     
    22.   colorIndex++;    //每次给灯珠上色前，起始颜色序号都递增1
    23.   fill_palette (leds, NUM_LEDS, colorIndex, 8, CloudColors_p, 255, LINEARBLEND);
    24.   FastLED.show();
    25.   delay(25);
    26. }

    （4）使用CRGBPalette16自定义调色板：这种方法需要16个RGB颜色参数，其中第一个参数对应调色板上颜色序号0-15的颜色，第二个参数对应调色板上颜色序号16-31的颜色，以此类推。

    定义方式：CRGBPalette16 <调色板名> = CRGBPalette16(<16个逗号分隔的RGB颜色参数>);

    1. #include "FastLED.h"  
    2.  
    3. #define NUM_LEDS 30     
    4. #define LED_DT 9       
    5. #define LED_TYPE WS2812 
    6. #define COLOR_ORDER GRB  
    7.  
    8. uint8_t max_bright = 128; 
    9.  
    10. CRGBPalette16 myColorPalette = CRGBPalette16(
    11.                             CRGB::Green,  CRGB::Green,  CRGB::Black,  CRGB::Black, 
    12.                             CRGB::Purple, CRGB::Purple, CRGB::Black,  CRGB::Black,
    13.                             CRGB::Green,  CRGB::Green,  CRGB::Black,  CRGB::Black,
    14.                             CRGB::Purple, CRGB::Purple, CRGB::Black,  CRGB::Black);
    15.  
    16. CRGB leds[NUM_LEDS];                                   
    17.  
    18. uint8_t colorIndex;
    19.  
    20. void setup() 
    21. {                                           
    22.   LEDS.addLeds(leds, NUM_LEDS);  
    23.   FastLED.setBrightness(max_bright);             
    24. }
    25.  
    26. void loop () 
    27. {     
    28.   colorIndex++;    //每次给灯珠上色前，起始颜色序号都递增1
    29.   fill_palette (leds, NUM_LEDS, colorIndex, 8, myColorPalette, 255, LINEARBLEND);
    30.   FastLED.show();
    31.   delay(25);
    32. }

    （5）使用CHSVPalette16自定义调色板：这种方法需要16个HSV颜色参数，其中第一个参数对应调色板上颜色序号0-15的颜色，第二个参数对应调色板上颜色序号16-31的颜色，以此类推。

    定义方式：CHSVPalette16 <调色板名> = CHSVPalette16(<16个逗号分隔的HSV颜色参数>);

    1. #include "FastLED.h"  
    2.  
    3. #define NUM_LEDS 30     
    4. #define LED_DT 9       
    5. #define LED_TYPE WS2812 
    6. #define COLOR_ORDER GRB  
    7.  
    8. uint8_t max_bright = 128; 
    9.  
    10. CHSVPalette16 myHSVColorPalette = CHSVPalette16(
    11.        CHSV(0, 255, 200),  CHSV(15, 255, 200),  CHSV(31, 255, 200), CHSV(47, 255, 200),
    12.        CHSV(0, 255, 0),   CHSV(15, 255, 0),   CHSV(31, 255, 0),  CHSV(47, 255, 0),
    13.        CHSV(0, 255, 200),  CHSV(15, 255, 200),  CHSV(31, 255, 200), CHSV(47, 255, 200),
    14.        CHSV(0, 0, 200),   CHSV(15, 0, 200),   CHSV(31, 0, 200),  CHSV(47, 0, 200));
    15.  
    16. CRGB leds[NUM_LEDS];                                   
    17.  
    18. uint8_t colorIndex;
    19.  
    20. void setup() 
    21. {                                           
    22.   LEDS.addLeds(leds, NUM_LEDS);  
    23.   FastLED.setBrightness(max_bright);             
    24. }
    25.  
    26. void loop () 
    27. {     
    28.   colorIndex++;    //每次给灯珠上色前，起始颜色序号都递增1
    29.   fill_palette (leds, NUM_LEDS, colorIndex, 8, myHSVColorPalette, 255, LINEARBLEND);
    30.   FastLED.show();
    31.   delay(25);
    32. }

    （6）对于自定义调色板，它由16个颜色参数进行定义，而在程序运行过程中基本不会修改调色板，那么调色板完全可以作为只读的内容，如果将其存放在SARM中将会非常浪费SARM的空间，对此可以将其存放在FLASH中，从而很好地利用存储空间。存储在FALSH中的调色板，其定义方式见下例，同样需要16个颜色参数，其中第一个参数对应调色板上颜色序号0-15的颜色，第二个参数对应调色板上颜色序号16-31的颜色，以此类推。

    1. #include "FastLED.h"  
    2.  
    3. #define NUM_LEDS 30     
    4. #define LED_DT 9       
    5. #define LED_TYPE WS2812 
    6. #define COLOR_ORDER GRB  
    7.  
    8. uint8_t max_bright = 128; 
    9.  
    10. const TProgmemPalette16 myProgmemPalette PROGMEM = {
    11.                              CRGB::Red,  CRGB::Gray,  CRGB::Blue,   CRGB::Black,
    12.                              CRGB::Red,  CRGB::Gray,  CRGB::Blue,   CRGB::Black,
    13.                              CRGB::Red,  CRGB::Red,   CRGB::Gray,   CRGB::Gray,
    14.                              CRGB::Blue, CRGB::Blue,  CRGB::Black,  CRGB::Black};   
    15.  
    16. CRGB leds[NUM_LEDS];                                   
    17.  
    18. uint8_t colorIndex;
    19.  
    20. void setup() 
    21. {                                           
    22.   LEDS.addLeds(leds, NUM_LEDS);  
    23.   FastLED.setBrightness(max_bright);             
    24. }
    25.  
    26. void loop () 
    27. {     
    28.   colorIndex++;    //每次给灯珠上色前，起始颜色序号都递增1
    29.   fill_palette (leds, NUM_LEDS, colorIndex, 8, myProgmemPalette, 255, LINEARBLEND);
    30.   FastLED.show();
    31.   delay(25);
    32. }
  • 相关阅读:
    代码与细节（一）
    安装配置 IDE
    计算机网络第五章问答题
    RocketMQ各种消息的生产与消费Demo
    CentOS安装OpenNebula（二）
    Linux：详解(yum的使用、vim编辑器命令集合以及gcc/g++编译器的使用）
    【kubernetes】Debian使用Kubeadm部署Kubernetes失败：Connection Refused
    css3自动吸附scroll-snap
    解决微信小程序回调地狱问题
    编写程序将一个子串插入到主串中
  • 原文地址：https://blog.csdn.net/Zevalin/article/details/139711789