零知开源——玩转WS2812B灯条模块

eefocus_4087784

WS2812RGB灯带

  通过零知标准开发板平台上驱动WS2812RGB灯珠，包括WS2812B的供电电压、接线和代码实现。通过创建延时函数和设置级联数据，实现对RGB灯珠的控制，展示了从关闭到开启不同颜色以及跑马灯、呼吸灯和彩虹灯等效果。

一、工具原料

电脑、Windows系统

零知开发板

Micro-usb线

WS2812RGB灯

二、硬件连接

零知标准开发板	WS2812B
5V	VCC
GND	GND
11	Din

硬件连接示意图
实际连接

三、方法步骤

1、打开零知实验室软件开发工具，然后新建项目，输入代码
2、将库文件解压放到库文件存放的目录下
3、选择端口进行编译，然后上传到开发板中。

引用库文件WS2812B.h

1. ​
   
2. #include <WS2812B.h>  // 引入用于控制WS2812B LED灯带的库
   
3. 
   
4. #define NUM_LEDS 9  // 定义灯带上的LED数量
   
5. #define DELAYVAL 500 // 定义延迟时间（单位：毫秒），用于在不同效果之间的暂停时间
   
6. /*
   
7. * 注意：该库使用SPI1进行数据传输
   
8. * 将WS2812B的数据信号输入引脚连接到开发板的MOSI引脚。
   
9. */
   
10. WS2812B strip = WS2812B(NUM_LEDS);  // 创建一个WS2812B对象，用于控制灯带
    

复制代码

设置SPI、点亮不同效果的RGB灯

1. ​// 请注意。库中并不真正支持Gamma，它只是在本例中使用的一些函数需要Gamma时才包含
   
2. uint8_t LEDGamma[] = {
   
3.     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   
4.     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,
   
5.     1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,
   
6.     2,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  5,  5,  5,
   
7.     5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9, 10,
   
8.    10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16,
   
9.    17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25,
   
10.    25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36,
    
11.    37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50,
    
12.    51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68,
    
13.    69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89,
    
14.    90, 92, 93, 95, 96, 98, 99,101,102,104,105,107,109,110,112,114,
    
15.   115,117,119,120,122,124,126,127,129,131,133,135,137,138,140,142,
    
16.   144,146,148,150,152,154,156,158,160,162,164,167,169,171,173,175,
    
17.   177,180,182,184,186,189,191,193,196,198,200,203,205,208,210,213,
    
18.   215,218,220,223,225,228,231,233,236,239,241,244,247,249,252,255 };
    
19. 
    
20. void setup()
    
21. {
    
22. strip.begin();// 设置SPI
    
23. strip.show();// 清除strip，因为默认情况下条带数据设置为所有LED关闭。
    
24. // strip.setBrightness(8);
    
25. }
    
26. 
    
27. void loop() {
    
28. // 实现不同的灯光效果
    
29. colorWipe(strip.Color(0, 255, 0), 20);  // 使用绿色逐个点亮灯带
    
30. colorWipe(strip.Color(255, 0, 0), 20); // 使用红色逐个点亮灯带
    
31. colorWipe(strip.Color(0, 0, 255), 20); // 使用蓝色逐个点亮灯带
    
32. rainbow(10);                          // 显示彩虹渐变效果
    
33. rainbowCycle(10);  // 显示循环的彩虹效果
    
34. 
    
35. theaterChase(strip.Color(255, 0, 0), 20);  
    
36. theaterChase(strip.Color(0, 255, 0), 20);
    
37. theaterChase(strip.Color(0, 0, 255), 20);  
    
38. theaterChaseRainbow(10);               
    
39. 
    
40. whiteOverRainbow(20, 75, 5);  // 白光覆盖在彩虹效果上
    
41. fullWhite();                  // 将灯带上的所有LED点亮为白光
    
42. delay(250);                   // 暂停250毫秒
    
43. rainbowFade2White(3, 3, 1);   // 彩虹效果逐渐过渡到白光
    
44. theaterChaseWhiteAndOff(DELAYVAL); // 实现白光追逐与关闭的效果
    
45. delay(250);
    
46. 
    
47. flowingLight(100); // 实现流动光效果，速度为100ms
    
48. breathLight(255, 50); // PWM呼吸灯效果
    
49. }

复制代码

将呼吸灯、彩虹灯和流水灯等功能的库函数封装

1. ​
   
2. void breathLight(uint8_t maxBrightness, uint8_t speed) {
   
3. // 实现PWM呼吸灯效果
   
4. for (uint8_t brightness = 0; brightness <= maxBrightness; brightness++) {
   
5. for (uint16_t i = 0; i < strip.numPixels(); i++) {
   
6. // 设置每个LED的颜色，使用伽马校正后的亮度值
   
7. strip.setPixelColor(i, strip.Color(LEDGamma[brightness], LEDGamma[brightness], LEDGamma[brightness]));
   
8.         }
   
9. strip.show();
   
10. delay(speed); // 延迟以实现亮度变化
    
11.     }
    
12. for (uint8_t brightness = maxBrightness; brightness > 0; brightness--) {
    
13. for (uint16_t i = 0; i < strip.numPixels(); i++) {
    
14. strip.setPixelColor(i, strip.Color(LEDGamma[brightness], LEDGamma[brightness], LEDGamma[brightness]));
    
15.         }
    
16. strip.show();
    
17. delay(speed);
    
18. }
    
19. }
    
20. 
    
21. void flowingLight(uint8_t speed) {
    
22. // 实现流动光效果
    
23. uint16_t index = 0;        // 记录当前流动的索引
    
24. uint8_t currentColor = 0;  // 记录当前的颜色（红、绿、蓝）
    
25. 
    
26. while (true) {
    
27. for (uint16_t i = 0; i < NUM_LEDS; i++) {
    
28. // 根据当前索引计算目标索引
    
29. uint16_t targetIndex = (i + index) % NUM_LEDS;
    
30.      
    
31. switch (currentColor) {
    
32. case 0:
    
33. strip.setPixelColor(targetIndex, strip.Color(255, 0, 0)); //  设置为红色
    
34. break;
    
35. case 1:
    
36. strip.setPixelColor(targetIndex, strip.Color(0, 255, 0)); //  设置为绿色
    
37. break;
    
38. case 2:
    
39. strip.setPixelColor(targetIndex, strip.Color(0, 0, 255)); //  设置为蓝色
    
40. break;
    
41.       }
    
42. 
    
43. strip.setPixelColor(i, strip.Color(0, 0, 0)); // 将之前的LED关闭
    
44.      
    
45. strip.show();
    
46. delay(speed);// 设置流动光的速度
    
47.     }
    
48.    
    
49. // 切换到下一个颜色
    
50. currentColor = (currentColor + 1) % 3;
    
51.    
    
52. // 增加索引，实现流动效果
    
53. index++;
    
54. if (index >= NUM_LEDS) {
    
55. index = 0; //重置索引 }
    
56. }
    
57. }
    
58. 
    
59. void theaterChaseWhiteAndOff(uint8_t wait) {
    
60. for (int j = 0; j < 10; j++) {  // 10 cycles of chasing
    
61. for (int q = 0; q < 3; q++) {
    
62. for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {
    
63. strip.setPixelColor(i + q, (j % 2 == 0 ? strip.Color(128, 0, 128) : 0));
    
64.       }
    
65. strip.show();
    
66. delay(wait);
    
67. for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {
    
68. strip.setPixelColor(i + q, 0);  // Turn every third pixel off
    
69.    }
    
70.   }
    
71. }
    
72. }
    
73. 
    
74. // Fill the dots one after the other with a color
    
75. void colorWipe(uint32_t c, uint8_t wait)
    
76. {
    
77. for(uint16_t i=0; i<strip.numPixels(); i++)
    
78. {
    
79. strip.setPixelColor(i, c);
    
80. strip.show();
    
81. delay(wait);
    
82. }
    
83. }
    
84. 
    
85. // rainbow 函数: 实现彩虹效果的灯带动画
    
86. // 参数:
    
87. //   wait: 每次更新彩虹效果的等待时间（毫秒）
    
88. void rainbow(uint8_t wait) {
    
89. uint16_t i, j;
    
90. 
    
91. // 外层循环控制彩虹的移动效果
    
92. for(j = 0; j < 256; j++) {
    
93. // 内层循环逐个像素更新颜色
    
94. for(i = 0; i < strip.numPixels(); i++) {
    
95. // 通过 Wheel 函数生成彩虹颜色
    
96. strip.setPixelColor(i, Wheel((i + j) & 255));
    
97.         }
    
98. strip.show(); // 更新灯带显示
    
99. delay(wait);  // 等待一段时间
    
100. }
     
101. }
     
102. 
     
103. // rainbowCycle 函数: 实现彩虹效果循环播放，每个像素显示的颜色均匀分布
     
104. // 参数:
     
105. //   wait: 每次更新动画的等待时间（毫秒）
     
106. void rainbowCycle(uint8_t wait) {
     
107. uint16_t i, j;
     
108. 
     
109. // 外层循环控制彩虹的循环次数，5次完整循环
     
110. for(j = 0; j < 256 * 5; j++) {
     
111. // 内层循环更新每个像素的颜色
     
112. for(i = 0; i < strip.numPixels(); i++) {
     
113. // 使用 Wheel 函数计算彩虹颜色，保证均匀分布
     
114. strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
     
115.         }
     
116. strip.show(); // 更新灯带显示
     
117. delay(wait);  // 等待一段时间
     
118. }
     
119. }
     
120. 
     
121. // Wheel 函数: 根据输入值生成渐变的 RGB 颜色
     
122. // 参数:
     
123. //   WheelPos: 输入值（范围 0-255），表示颜色的渐变位置
     
124. // 返回值:
     
125. //   对应的 RGB 颜色值（以 32 位整数形式表示）
     
126. uint32_t Wheel(byte WheelPos) {
     
127. if(WheelPos < 85) {
     
128. // 红色逐渐变为绿色
     
129. return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
     
130. } else if(WheelPos < 170) {
     
131. // 绿色逐渐变为蓝色
     
132. WheelPos -= 85;
     
133. return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
     
134. } else {
     
135. // 蓝色逐渐变为红色
     
136. WheelPos -= 170;
     
137. return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
     
138. }
     
139. }
     
140. 
     
141. // theaterChase 函数: 实现戏剧风格的爬行灯效果，每三个像素作为一个循环
     
142. // 参数:
     
143. //   c: 颜色值（RGB 格式）
     
144. //   wait: 每次更新动画的等待时间（毫秒）
     
145. void theaterChase(uint32_t c, uint8_t wait) {
     
146. // 外层循环控制效果的整体循环次数
     
147. for(int j = 0; j < 10; j++) {
     
148. // 中间循环负责调整动画的偏移量
     
149. for(int q = 0; q < 3; q++) {
     
150. // 内层循环设置每第三个像素的颜色
     
151. for(uint16_t i = 0; i < strip.numPixels(); i += 3) {
     
152. strip.setPixelColor(i + q, c); // 设置当前像素为指定颜色
     
153.             }
     
154. strip.show(); // 更新灯带显示
     
155. delay(wait);  // 等待一段时间
     
156. 
     
157. // 关闭每第三个像素
     
158. for(uint16_t i = 0; i < strip.numPixels(); i += 3) {
     
159. strip.setPixelColor(i + q, 0);
     
160.    }
     
161.   }
     
162. }
     
163. }
     
164. 
     
165. // theaterChaseRainbow 函数: 实现戏剧风格的彩虹爬行灯效果
     
166. // 参数:
     
167. //   wait: 每次更新动画的等待时间（毫秒）
     
168. void theaterChaseRainbow(uint8_t wait) {
     
169. // 外层循环控制颜色的变化
     
170. for(int j = 0; j < 256; j++) {
     
171. // 中间循环控制动画的偏移
     
172. for(int q = 0; q < 3; q++) {
     
173. // 内层循环设置每第三个像素的彩虹颜色
     
174. for(uint16_t i = 0; i < strip.numPixels(); i += 3) {
     
175. strip.setPixelColor(i + q, Wheel((i + j) % 255));
     
176. }
     
177. strip.show(); // 更新灯带显示
     
178. delay(wait);  // 等待一段时间
     
179. 
     
180. // 关闭每第三个像素
     
181. for(uint16_t i = 0; i < strip.numPixels(); i += 3) {
     
182. strip.setPixelColor(i + q, 0);
     
183.    }
     
184.   }
     
185. }
     
186. }
     
187. 
     
188. void pulseWhite(uint8_t wait) {
     
189. // 功能：实现白色脉冲效果
     
190. // 参数：wait - 每次更新动画的等待时间（毫秒）
     
191. 
     
192. for(int j = 0; j < 256 ; j++){ // 亮度从0渐变至255
     
193. for(uint16_t i=0; i<strip.numPixels(); i++) {
     
194. // 设置每个LED的颜色，亮度根据j的值变化
     
195. strip.setPixelColor(i, strip.Color(LEDGamma[j],LEDGamma[j],LEDGamma[j] ) );
     
196. }  
     
197. delay(wait);
     
198. strip.show();
     
199. }
     
200. 
     
201. for(int j = 255; j >= 0 ; j--){ // 亮度从255渐变回0
     
202. for(uint16_t i=0; i<strip.numPixels(); i++) {
     
203. strip.setPixelColor(i, strip.Color(LEDGamma[j],LEDGamma[j],LEDGamma[j] ) );
     
204. }
     
205. delay(wait);
     
206. strip.show();
     
207. }
     
208. }
     
209. 
     
210. void rainbowFade2White(uint8_t wait, int rainbowLoops, int whiteLoops) {
     
211.   // 功能：先显示彩虹效果，然后逐渐过渡到白色
     
212.   // 参数：
     
213.   //   wait - 每次更新动画的等待时间（毫秒）
     
214.   //   rainbowLoops - 彩虹循环次数
     
215.   //   whiteLoops - 白色循环次数
     
216. 
     
217. float fadeMax = 100.0;
     
218. int fadeVal = 0;
     
219. uint32_t wheelVal;
     
220. int redVal, greenVal, blueVal;
     
221. 
     
222. for(int k = 0 ; k < rainbowLoops ; k ++){ // 循环执行彩虹效果
     
223. for(int j=0; j<256; j++) {
     
224. for(int i=0; i< strip.numPixels(); i++) {
     
225. wheelVal = Wheel(((i * 256 / strip.numPixels()) + j) & 255);
     
226. // 逐步调整RGB值以实现渐变效果
     
227. redVal = red(wheelVal) * float(fadeVal/fadeMax);
     
228. greenVal = green(wheelVal) * float(fadeVal/fadeMax);
     
229. blueVal = blue(wheelVal) * float(fadeVal/fadeMax);
     
230. strip.setPixelColor( i, strip.Color( redVal, greenVal, blueVal ) );
     
231. }
     
232. if(k == 0 && fadeVal < fadeMax-1) {
     
233. // 第一次循环，亮度逐渐增加
     
234. fadeVal++;
     
235. } else if(k == rainbowLoops - 1 && j > 255 - fadeMax){
     
236. // 最后一次循环，亮度逐渐减少
     
237. fadeVal--;
     
238. }
     
239. strip.show();
     
240. delay(wait);
     
241. }
     
242.   }
     
243. 
     
244. delay(500);
     
245. 
     
246. for(int k = 0 ; k < whiteLoops ; k ++){ // 循环执行白色渐变效果
     
247. for(int j = 0; j < 256 ; j++){
     
248. for(uint16_t i=0; i < strip.numPixels(); i++) {
     
249. strip.setPixelColor(i, strip.Color(LEDGamma[j],LEDGamma[j],LEDGamma[j] ) );
     
250. }
     
251. strip.show();
     
252. delay(wait);
     
253. }
     
254. delay(2000);
     
255. for(int j = 255; j >= 0 ; j--){
     
256. for(uint16_t i=0; i < strip.numPixels(); i++) {
     
257. strip.setPixelColor(i, strip.Color(LEDGamma[j],LEDGamma[j],LEDGamma[j] ) );
     
258. }
     
259. strip.show();
     
260. delay(wait);
     
261.   }
     
262. }
     
263. }
     
264. 
     
265. 
     
266. void whiteOverRainbow(uint8_t wait, uint8_t whiteSpeed, uint8_t whiteLength ) {
     
267.   // 功能：在彩虹背景上叠加白色的流动效果
     
268.   // 参数：
     
269.   //   wait - 动画更新间隔
     
270.   //   whiteSpeed - 白色流动速度
     
271.   //   whiteLength - 白色光束长度
     
272. if(whiteLength >= strip.numPixels()) whiteLength = strip.numPixels() - 1;
     
273. 
     
274.   int head = whiteLength - 1;
     
275.   int tail = 0;
     
276. 
     
277.   int loops = 3;
     
278.   int loopNum = 0;
     
279. 
     
280. static unsigned long lastTime = 0;
     
281. 
     
282. 
     
283. while(true){
     
284.   for(int j=0; j<256; j++) {
     
285.   for(uint16_t i=0; i<strip.numPixels(); i++) {
     
286.   if((i >= tail && i <= head) || (tail > head && i >= tail) || (tail > head && i <= head) ){
     
287.    // 如果在白色光束范围内，设置为白色
     
288.    strip.setPixelColor(i, strip.Color(255,255,255 ) );
     
289.    }
     
290.   else{
     
291.    // 否则，根据j值设置彩虹颜色
     
292.    strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
     
293.    }
     
294. }
     
295. 
     
296. if(millis() - lastTime > whiteSpeed) {
     
297. head++;
     
298. tail++;
     
299. if(head == strip.numPixels()){
     
300.   loopNum++;
     
301. }
     
302.   lastTime = millis();
     
303. }
     
304. 
     
305. if(loopNum == loops) return;
     
306.   head%=strip.numPixels();
     
307.   tail%=strip.numPixels();
     
308.   strip.show();
     
309.   delay(wait);
     
310.   }
     
311. }
     
312. }
     
313. 
     
314. void fullWhite() {
     
315.   // 功能：点亮所有LED为白色
     
316.   for(uint16_t i=0; i<strip.numPixels(); i++) {
     
317. strip.setPixelColor(i, strip.Color(255, 255, 255 ) );
     
318. }
     
319. strip.show();
     
320. }
     
321. 
     
322. // red 函数: 提取颜色值中的红色分量
     
323. // 参数:
     
324. //   c: RGB 颜色值（32 位整数）
     
325. // 返回值:
     
326. //   红色分量（0-255）
     
327. uint8_t red(uint32_t c) {
     
328. return (c >> 16);
     
329. }
     
330. 
     
331. // green 函数: 提取颜色值中的绿色分量
     
332. // 参数:
     
333. //   c: RGB 颜色值（32 位整数）
     
334. // 返回值:
     
335. //   绿色分量（0-255）
     
336. uint8_t green(uint32_t c) {
     
337. return (c >> 8);
     
338. }
     
339. 
     
340. // blue 函数: 提取颜色值中的蓝色分量
     
341. // 参数:
     
342. //   c: RGB 颜色值（32 位整数）
     
343. // 返回值:
     
344. //   蓝色分量（0-255）
     
345. uint8_t blue(uint32_t c) {
     
346. return (c);
     
347. }
     

复制代码

四、成果展示

将上述代码验证后上传到零知板，就可以看到测试结果，实现流水灯、彩虹灯和呼吸灯等效果

https://live.csdn.net/v/435823?spm=1001.2014.3001.5501