【Arduino】108种传感器模块系列实验（131）--24位WS2812环形灯板

eagler8

37款传感器与模块的提法，在网络上广泛流传，其实Arduino能够兼容的传感器模块肯定是不止37种的。鉴于本人手头积累了一些传感器和模块，依照实践出真知（一定要动手做）的理念，以学习和交流为目的，这里准备逐一动手试试做实验，不管成功与否，都会记录下来---小小的进步或是搞不定的问题，希望能够抛砖引玉。

【Arduino】108种传感器模块系列实验（资料+代码+图形+仿真）
实验一百三十一：24位 WS2812 5050 RGB LED 内置全彩驱动彩灯 圆形开发板

eagler8

WS2812
是在寻求一种简单，可扩展和经济实惠的全彩LED的最新进展。红色，绿色和蓝色LED与驱动器芯片一起集成到通过单线控制的微小表面贴装封装中。它们可以单独使用，链接成更长的字符串或组装成更有趣的形状因数。基于WS2812的 LED 驱动器，使用单线控制协议，可分别寻址RGB彩色像素和色带。专用LED驱动器芯片的到来带来了可喜的缓解，减轻了微控制器的繁琐工作，使人们可以专注于应用与创造。

eagler8

该Adafruit NeoPixel环包含24个可单独寻址的RGB LED，这些LED以紧密间隔排列，所有这些均可通过微控制器的单个数字输出进行控制。该环的外径为2.6英寸（66毫米），可以将多个环链接在一起，使其非常适合为小型机器人或可穿戴电子项目增加光泽。

功能和规格
24个可单独寻址的RGB LED（基于SK6812-或WS2812B的NeoPixels）
圆形外径2.6英寸（66毫米），内径2.05英寸（52.5毫米）
24位色彩控制（每通道8位PWM）；每像素1680万种颜色
单线数字控制接口
工作电压：5 V
每个RGB LED在5 V时消耗大约50 mA的电流，红色，绿色和蓝色在全亮度下（环最大为1.2 A）
多个NeoPixel环可链接在一起

eagler8

24位WS2812 5050 RGB LED智能全彩RGB灯环开发板, 产品（直径）：86mm ,重量：6g ,电压：DC4-7V范围供电,通信接口：单线通讯

LED驱动芯片WS2812(集成在LED里面）
智能反接保护，电源反接不会损坏IC。
IC控制电路与LED点光源公用一个电源。
控制电路与RGB晶片集成在一个5050封装的元器件中，构成一个完整的外控图元点。
内置信号整形电路，任何一个图元点收到信号后经过波形整形再输出，保证线路波形畸变不会累加。
内置上电重定和掉电重定电路。
每个图元点的三基色颜色可实现256级亮度显示，完成16777216种颜色的全真色彩显示，扫描频率不低于400Hz/s。
串列级联介面，能通过一根信号线完成资料的接收与解码。
任意两点传传输距离在不超过5米时无需增加任何电路。
当刷新速率30帧/秒时，级联数不小于1024点。
资料发送速度可达800Kbps。
光的颜色高度一致，性价比高。

eagler8

5050高亮LED，内置控制芯片，仅需1个IO口即可控制多个LED
芯片内置整形电路，信号畸变不会累计，稳定显示
三基色256级亮度调剂，16万色真彩显示效果，扫描频率不低于400Hz/S
串行连级接口，能通过一根信号线完成数据的接收与解码
高亮LED，光色亮度一致性高
两端有连级接口(DIN DOUT)，可以串接

WS2813B是一个集控制电路与发光电路于一体的智慧外控LED光源。其外型与一个5050LED灯珠相同，每个元件即为一个图元点。图元点内部包含了智慧数位介面资料锁存信号整形放大驱动电路，还包含有高精度的内部振荡器和12V高压可编程定电流控制部分，有效保证了图元点光的颜色高度一致。
资料协定采用单线归零码的通讯方式，图元点在上电重定以后，DIN端接受从控制器传输过来的资料，首先送过来的24bit资料被第一个图元点提取后，送到图元点内部的资料锁存器，剩余的资料经过内部整形处理电路整形放大后通过DO埠开始转发输出给下一个级联的图元点，每经过一个图元点的传输，信号减少24bit。图元点采用自动整形转发技术，使得该图元点的级联个数不受信号传送的限制，仅仅受限信号传输速度要求。
LED具有低电压驱动，环保节能，亮度高，散射角度大，一致性好，超低功率，超长寿命等优点。将控制电路集成于LED上面，电路变得更加简单，体积小，安装更加简便。

eagler8

连接
LED环具有四个连接点。

标为GND的引脚为接地引脚，应连接至控制LED的微控制器的接地引脚，也应连接至电源的负极。

标有PWR + 5V的引脚是电源输入引脚，应连接到合适的电源。5 V的输入电压用于为环供电，当以全亮度输出白色时，环上的每个LED在5 V时可消耗高达50 mA的电流。这意味着该环最多可吸收约1.2 A电流。

标为“ 数据输入 ”的引脚是一个输入，用于接收控制LED的信号。该引脚应连接至基于SK6812 / WS281x的LED产品的微控制器输出引脚或信号输出引脚。

标有“ 数据输出 ”的引脚是可选的。它可以连接到另一个基于SK6812 / WS281x的LED产品的数据输入引脚，以形成一条链。

我们的0.1英寸排针可以用来连接环的四个针，也可以将导线直接焊接到板上。环并不与任何标头销或连接器发货。

如果在使用NeoPixels时未采取适当的预防措施，则很容易损坏它们。通常，对于基于SK6812 / WS2812B的产品，建议在接地线和电源线之间添加至少10 F的电容器，并在微控制器和信号输入引脚之间添加100Ω至1000Ω的电阻。

eagler8

模块电原理图

eagler8

ATTiny85与WS2812 LED环配合使用示意图

eagler8

1. /*
   
2.   【Arduino】108种传感器模块系列实验（资料+代码+图形+仿真）
   
3.   实验一百三十一：24位 WS2812 5050 RGB LED 内置全彩驱动彩灯 圆形开发板
   
4.   项目一：循环点亮24位绿色LED
   
5.   Module      UNO
   
6.   VCC   ——   5V
   
7.   GND  ——   GND
   
8.   DI    ——   D6
   
9. */
   
10. 
    
11. #include <Adafruit_NeoPixel.h>
    
12. #ifdef __AVR__
    
13. #include <avr/power.h> // Required for 16 MHz Adafruit Trinket
    
14. #endif
    
15. 
    
16. // Which pin on the Arduino is connected to the NeoPixels?
    
17. #define PIN        6 // On Trinket or Gemma, suggest changing this to 1
    
18. 
    
19. // How many NeoPixels are attached to the Arduino?
    
20. #define NUMPIXELS 24 // Popular NeoPixel ring size
    
21. 
    
22. // When setting up the NeoPixel library, we tell it how many pixels,
    
23. // and which pin to use to send signals. Note that for older NeoPixel
    
24. // strips you might need to change the third parameter -- see the
    
25. // strandtest example for more information on possible values.
    
26. Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
    
27. 
    
28. #define DELAYVAL 300 // Time (in milliseconds) to pause between pixels
    
29. 
    
30. void setup() {
    
31.   // These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
    
32.   // Any other board, you can remove this part (but no harm leaving it):
    
33. #if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
    
34.   clock_prescale_set(clock_div_1);
    
35. #endif
    
36.   // END of Trinket-specific code.
    
37. 
    
38.   pixels.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)
    
39. }
    
40. 
    
41. void loop() {
    
42.   pixels.clear(); // Set all pixel colors to 'off'
    
43. 
    
44.   // The first NeoPixel in a strand is #0, second is 1, all the way up
    
45.   // to the count of pixels minus one.
    
46.   for (int i = 0; i < NUMPIXELS; i++) { // For each pixel...
    
47. 
    
48.     // pixels.Color() takes RGB values, from 0,0,0 up to 255,255,255
    
49.     // Here we're using a moderately bright green color:
    
50.     pixels.setPixelColor(i, pixels.Color(0, 150, 0));
    
51. 
    
52.     pixels.show();   // Send the updated pixel colors to the hardware.
    
53. 
    
54.     delay(DELAYVAL); // Pause before next pass through loop
    
55.   }
    
56. }

复制代码

eagler8

eagler8

1. /*
   
2.   【Arduino】108种传感器模块系列实验（资料+代码+图形+仿真）
   
3.   实验一百三十一：24位 WS2812 5050 RGB LED 内置全彩驱动彩灯 圆形开发板
   
4.   项目二：循环快扫24位红绿蓝色LED流水灯
   
5.   Module      UNO
   
6.   VCC   ——   5V
   
7.   GND  ——   GND
   
8.   DI    ——   D6
   
9. */
   
10. 
    
11. #include <FastLED.h>
    
12. #define LED_PIN     6
    
13. #define NUM_LEDS    24
    
14. CRGB leds[NUM_LEDS];
    
15. void setup() {
    
16.   FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);
    
17. }
    
18. void loop() {
    
19.   for (int i = 0; i <= 23; i++) {
    
20.     leds[i] = CRGB ( 0, 0, 255);
    
21.     FastLED.show();
    
22.     delay(40);
    
23.   }
    
24.   for (int i = 0; i <= 23; i++) {
    
25.     leds[i] = CRGB ( 255, 0, 0);
    
26.     FastLED.show();
    
27.     delay(40);
    
28.   }
    
29.   for (int i = 0; i <= 23; i++) {
    
30.     leds[i] = CRGB ( 0, 255, 0);
    
31.     FastLED.show();
    
32.     delay(40);
    
33.   }
    
34. }

复制代码

eagler8

eagler8

1. /*
   
2.   【Arduino】108种传感器模块系列实验（资料+代码+图形+仿真）
   
3.   实验一百三十一：24位 WS2812 5050 RGB LED 内置全彩驱动彩灯 圆形开发板
   
4.   项目三：使用红色、绿色和蓝色三种参数将任何LED设置为任何颜色
   
5.   Module      UNO
   
6.   VCC   ——   5V
   
7.   GND  ——   GND
   
8.   DI    ——   D6
   
9. */
   
10. 
    
11. #include <FastLED.h>
    
12. #define LED_PIN     6
    
13. #define NUM_LEDS    24
    
14. CRGB leds[NUM_LEDS];
    
15. void setup() {
    
16.   FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);
    
17.   
    
18. }
    
19. void loop() {
    
20.   
    
21.   leds[0] = CRGB(255, 0, 0);
    
22.   FastLED.show();
    
23.   delay(500);  
    
24.   leds[1] = CRGB(0, 255, 0);
    
25.   FastLED.show();
    
26.   delay(500);
    
27.   leds[2] = CRGB(0, 0, 255);
    
28.   FastLED.show();
    
29.   delay(500);
    
30.   leds[5] = CRGB(150, 0, 255);
    
31.   FastLED.show();
    
32.   delay(500);
    
33.   leds[9] = CRGB(255, 200, 20);
    
34.   FastLED.show();
    
35.   delay(500);
    
36.   leds[14] = CRGB(85, 60, 180);
    
37.   FastLED.show();
    
38.   delay(500);
    
39.   leds[19] = CRGB(50, 255, 20);
    
40.   FastLED.show();
    
41.   delay(500);
    
42. }

复制代码

eagler8

1. /*
   
2.   【Arduino】108种传感器模块系列实验（资料+代码+图形+仿真）
   
3.   实验一百三十一：24位 WS2812 5050 RGB LED 内置全彩驱动彩灯 圆形开发板
   
4.   项目四：流水灯变幻彩虹灯
   
5.   Module      UNO
   
6.   VCC   ——   5V
   
7.   GND  ——   GND
   
8.   DI    ——   D6
   
9. */
   
10. 
    
11. #include <Adafruit_NeoPixel.h>
    
12. 
    
13. #define PIN 6
    
14. #define BRIGHTNESS 24
    
15. 
    
16. Adafruit_NeoPixel strip = Adafruit_NeoPixel(24, PIN, NEO_GRB + NEO_KHZ800);
    
17. 
    
18. void setup() {
    
19.   strip.setBrightness(BRIGHTNESS);
    
20.   strip.begin();
    
21.   strip.show();
    
22. }
    
23. 
    
24. void loop() {
    
25.   colorWipe(strip.Color(150, 0, 0), 50); // Red
    
26.   colorWipe(strip.Color(0, 150, 0), 50); // Green
    
27.   colorWipe(strip.Color(0, 0, 150), 50); // Blue
    
28.   colorWipe(strip.Color(150, 150, 150), 50); // BlueWite
    
29.   rainbowCycle(1);
    
30. 
    
31. }
    
32. 
    
33. void colorWipe(uint32_t c, uint8_t wait) {
    
34.   for (uint16_t i = 0; i < strip.numPixels(); i++) {
    
35.     strip.setPixelColor(i, c);
    
36.     strip.show();
    
37.     delay(wait);
    
38.   }
    
39. }
    
40. 
    
41. void rainbow(uint8_t wait) {
    
42.   uint16_t i, j;
    
43.   for (j = 0; j < 256; j++) {
    
44.     for (i = 0; i < strip.numPixels(); i++) {
    
45.       strip.setPixelColor(i, Wheel((i + j) & 255 ));
    
46.     }
    
47.     strip.show();
    
48.     delay(wait);
    
49.   }
    
50. }
    
51. 
    
52. void rainbowCycle(uint8_t wait) {
    
53.   uint16_t i, j;
    
54.   for (j = 0; j < 256 * 5; j++) { // 5 cycles of all colors on wheel
    
55.     for (i = 0; i < strip.numPixels(); i++) {
    
56.       strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
    
57.     }
    
58.     strip.show();
    
59.     delay(wait);
    
60.   }
    
61. }
    
62. 
    
63. uint32_t Wheel(byte WheelPos) {
    
64.   if (WheelPos < 85) {
    
65.     return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
    
66.   } else if (WheelPos < 170) {
    
67.     WheelPos -= 85;
    
68.     return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
    
69.   } else {
    
70.     WheelPos -= 170;
    
71.     return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
    
72.   }
    
73. }

复制代码

eagler8

1. /*
   
2.   【Arduino】108种传感器模块系列实验（资料+代码+图形+仿真）
   
3.   实验一百三十一：24位 WS2812 5050 RGB LED 内置全彩驱动彩灯 圆形开发板
   
4.   项目五：循环流水变幻呼吸灯
   
5.   Module      UNO
   
6.   VCC   ——   5V
   
7.   GND  ——   GND
   
8.   DI    ——   D6
   
9. */
   
10. 
    
11. // NeoPixel test program showing use of the WHITE channel for RGBW
    
12. // pixels only (won't look correct on regular RGB NeoPixel strips).
    
13. 
    
14. #include <Adafruit_NeoPixel.h>
    
15. #ifdef __AVR__
    
16. #include <avr/power.h> // Required for 16 MHz Adafruit Trinket
    
17. #endif
    
18. 
    
19. // Which pin on the Arduino is connected to the NeoPixels?
    
20. // On a Trinket or Gemma we suggest changing this to 1:
    
21. #define LED_PIN     6
    
22. 
    
23. // How many NeoPixels are attached to the Arduino?
    
24. #define LED_COUNT  24
    
25. 
    
26. // NeoPixel brightness, 0 (min) to 255 (max)
    
27. #define BRIGHTNESS 50
    
28. 
    
29. // Declare our NeoPixel strip object:
    
30. Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRBW + NEO_KHZ800);
    
31. // Argument 1 = Number of pixels in NeoPixel strip
    
32. // Argument 2 = Arduino pin number (most are valid)
    
33. // Argument 3 = Pixel type flags, add together as needed:
    
34. //   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
    
35. //   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
    
36. //   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
    
37. //   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
    
38. //   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
    
39. 
    
40. void setup() {
    
41.   // These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
    
42.   // Any other board, you can remove this part (but no harm leaving it):
    
43. #if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
    
44.   clock_prescale_set(clock_div_1);
    
45. #endif
    
46.   // END of Trinket-specific code.
    
47. 
    
48.   strip.begin();           // INITIALIZE NeoPixel strip object (REQUIRED)
    
49.   strip.show();            // Turn OFF all pixels ASAP
    
50.   strip.setBrightness(50); // Set BRIGHTNESS to about 1/5 (max = 255)
    
51. }
    
52. 
    
53. void loop() {
    
54.   // Fill along the length of the strip in various colors...
    
55.   colorWipe(strip.Color(255,   0,   0)     , 50); // Red
    
56.   colorWipe(strip.Color(  0, 255,   0)     , 50); // Green
    
57.   colorWipe(strip.Color(  0,   0, 255)     , 50); // Blue
    
58.   colorWipe(strip.Color(  0,   0,   0, 255), 50); // True white (not RGB white)
    
59. 
    
60.   whiteOverRainbow(75, 5);
    
61. 
    
62.   pulseWhite(5);
    
63. 
    
64.   rainbowFade2White(3, 3, 1);
    
65. }
    
66. 
    
67. // Fill strip pixels one after another with a color. Strip is NOT cleared
    
68. // first; anything there will be covered pixel by pixel. Pass in color
    
69. // (as a single 'packed' 32-bit value, which you can get by calling
    
70. // strip.Color(red, green, blue) as shown in the loop() function above),
    
71. // and a delay time (in milliseconds) between pixels.
    
72. void colorWipe(uint32_t color, int wait) {
    
73.   for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
    
74.     strip.setPixelColor(i, color);         //  Set pixel's color (in RAM)
    
75.     strip.show();                          //  Update strip to match
    
76.     delay(wait);                           //  Pause for a moment
    
77.   }
    
78. }
    
79. 
    
80. void whiteOverRainbow(int whiteSpeed, int whiteLength) {
    
81. 
    
82.   if(whiteLength >= strip.numPixels()) whiteLength = strip.numPixels() - 1;
    
83. 
    
84.   int      head          = whiteLength - 1;
    
85.   int      tail          = 0;
    
86.   int      loops         = 3;
    
87.   int      loopNum       = 0;
    
88.   uint32_t lastTime      = millis();
    
89.   uint32_t firstPixelHue = 0;
    
90. 
    
91.   for(;;) { // Repeat forever (or until a 'break' or 'return')
    
92.     for(int i=0; i<strip.numPixels(); i++) {  // For each pixel in strip...
    
93.       if(((i >= tail) && (i <= head)) ||      //  If between head & tail...
    
94.          ((tail > head) && ((i >= tail) || (i <= head)))) {
    
95.         strip.setPixelColor(i, strip.Color(0, 0, 0, 255)); // Set white
    
96.       } else {                                             // else set rainbow
    
97.         int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());
    
98.         strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue)));
    
99.       }
    
100.     }
     
101. 
     
102.     strip.show(); // Update strip with new contents
     
103.     // There's no delay here, it just runs full-tilt until the timer and
     
104.     // counter combination below runs out.
     
105. 
     
106.     firstPixelHue += 40; // Advance just a little along the color wheel
     
107. 
     
108.     if((millis() - lastTime) > whiteSpeed) { // Time to update head/tail?
     
109.       if(++head >= strip.numPixels()) {      // Advance head, wrap around
     
110.         head = 0;
     
111.         if(++loopNum >= loops) return;
     
112.       }
     
113.       if(++tail >= strip.numPixels()) {      // Advance tail, wrap around
     
114.         tail = 0;
     
115.       }
     
116.       lastTime = millis();                   // Save time of last movement
     
117.     }
     
118.   }
     
119. }
     
120. 
     
121. void pulseWhite(uint8_t wait) {
     
122.   for(int j=0; j<256; j++) { // Ramp up from 0 to 255
     
123.     // Fill entire strip with white at gamma-corrected brightness level 'j':
     
124.     strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));
     
125.     strip.show();
     
126.     delay(wait);
     
127.   }
     
128. 
     
129.   for(int j=255; j>=0; j--) { // Ramp down from 255 to 0
     
130.     strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));
     
131.     strip.show();
     
132.     delay(wait);
     
133.   }
     
134. }
     
135. 
     
136. void rainbowFade2White(int wait, int rainbowLoops, int whiteLoops) {
     
137.   int fadeVal=0, fadeMax=100;
     
138. 
     
139.   // Hue of first pixel runs 'rainbowLoops' complete loops through the color
     
140.   // wheel. Color wheel has a range of 65536 but it's OK if we roll over, so
     
141.   // just count from 0 to rainbowLoops*65536, using steps of 256 so we
     
142.   // advance around the wheel at a decent clip.
     
143.   for(uint32_t firstPixelHue = 0; firstPixelHue < rainbowLoops*65536;
     
144.     firstPixelHue += 256) {
     
145. 
     
146.     for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
     
147. 
     
148.       // Offset pixel hue by an amount to make one full revolution of the
     
149.       // color wheel (range of 65536) along the length of the strip
     
150.       // (strip.numPixels() steps):
     
151.       uint32_t pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());
     
152. 
     
153.       // strip.ColorHSV() can take 1 or 3 arguments: a hue (0 to 65535) or
     
154.       // optionally add saturation and value (brightness) (each 0 to 255).
     
155.       // Here we're using just the three-argument variant, though the
     
156.       // second value (saturation) is a constant 255.
     
157.       strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue, 255,
     
158.         255 * fadeVal / fadeMax)));
     
159.     }
     
160. 
     
161.     strip.show();
     
162.     delay(wait);
     
163. 
     
164.     if(firstPixelHue < 65536) {                              // First loop,
     
165.       if(fadeVal < fadeMax) fadeVal++;                       // fade in
     
166.     } else if(firstPixelHue >= ((rainbowLoops-1) * 65536)) { // Last loop,
     
167.       if(fadeVal > 0) fadeVal--;                             // fade out
     
168.     } else {
     
169.       fadeVal = fadeMax; // Interim loop, make sure fade is at max
     
170.     }
     
171.   }
     
172. 
     
173.   for(int k=0; k<whiteLoops; k++) {
     
174.     for(int j=0; j<256; j++) { // Ramp up 0 to 255
     
175.       // Fill entire strip with white at gamma-corrected brightness level 'j':
     
176.       strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));
     
177.       strip.show();
     
178.     }
     
179.     delay(1000); // Pause 1 second
     
180.     for(int j=255; j>=0; j--) { // Ramp down 255 to 0
     
181.       strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));
     
182.       strip.show();
     
183.     }
     
184.   }
     
185. 
     
186.   delay(500); // Pause 1/2 second
     
187. }

复制代码