【小安派试玩】WS2812B RGB彩灯

简介：WS2812B 是一款RGB LED驱动集成电路，常用于LED灯带、装饰灯和数字屏幕等。它包含了控制芯片、红、绿、蓝三种不同颜色的LED以及一个电源引脚。WS2812B 的最大特点是其数字信号控制方式，只需通过单根总线即可控制多个WS2812B LED。WS2812B的通信协议使用的是时间间隔调制（Time-Division Multiplexing, TDM）的方法，即为每一个数据位（bit）分配一个固定的时间，通过高低电平的变化来表示不同的数据。例如，当数据位为1时，投射出的波形为低电平持续 0.35us 后切换到高电平，再持续 0.8us，当数据位为0时，投射出的波形为低电平持续 0.8us 后切换到高电平，再持续 0.45us。通过合理的时间间隔控制，可以让WS2812B正确地解析和显示码流数据，它相较于其他LED驱动芯片的优点在于内部集成控制器、单根总线多个LED控制、高亮度丰富颜色显示和多种灯光效果实现，然而，它的缺点是对驱动电压范围的要求较严格、功率消耗较大，需要注意散热和电源供应，并且对通信协议有一定了解要求。
中文数据手册：点我点我



大家好，最近楼楼研究了如何用小安派驱动ws2812这个灯珠，不得不说一下，点灯是楼楼的众多爱好之一，在楼楼的不懈努力之下，终于使用小安派的io点亮了灯珠，分享出来供大家参考


实物展示：

· 显示图片(有没有很眼熟/滑稽)

· 显示文字(小安派yyds/超级大声)

· 一些灯效：

相信大家对于点灯这件事应该已经轻车熟路了，闭着眼都会，楼楼也不啰嗦啦，直接上代码！

代码调用流程：

· 初始化： WS2812_init(uint8_t pin, int num_leds, uint8_t brightness, uint8_t mode) ; // 引脚号，灯珠数，亮度，发送顺序(1= rgb,2 = gbr)

· 设置颜色： setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b); // 第几颗灯珠，rgb颜色

· 刷新点亮： pixel_show()；

这三步完成烧录后不出意外就可以点亮灯珠

代码：

ws2812.h，新建一个ws2812.h的文件把代码复制进去就可以啦

1. /*WS2812RGB彩灯驱动*/
   
2. 
   
3. #ifndef _WS2812_H_
   
4. #define _WS2812_H_
   
5. 
   
6. #include "bflb_mtimer.h"
   
7. #include "bflb_gpio.h"
   
8. 
   
9. typedef union {
   
10.     struct {
    
11.         uint8_t g;
    
12.         uint8_t r;
    
13.         uint8_t b;
    
14.     } simple;
    
15.     uint8_t grb[3];
    
16. } color_t;
    
17. 
    
18. typedef struct _rgb_strip_t {
    
19.     int pin_num;
    
20.     int num_leds;
    
21.     color_t *leds;
    
22. } rgb_strip_t;
    
23. 
    
24. rgb_strip_t strip;
    
25. 
    
26. struct bflb_device_s *gpio;
    
27. uint8_t _pin,_brightness,_mode;
    
28. 
    
29. 
    
30. 
    
31. // 设置亮度.
    
32. void setBrightness(uint8_t brg) {
    
33.     _brightness = brg;
    
34. }
    
35. 
    
36. 
    
37. // 引脚初始化.
    
38. /**
    
39. * @brief
    
40. *
    
41. * @param pin  引脚号
    
42. * @param num_leds  灯珠数量
    
43. * @param brightness  亮度
    
44. * @param mode rgb还是gbr顺序发送，1是RGB，2是GBR
    
45. */
    
46. void WS2812_init(uint8_t pin, int num_leds, uint8_t brightness, uint8_t mode) {
    
47. 
    
48.         if(mode==1)_mode=1;
    
49.         else if (mode == 2)_mode=2;
    
50.         else return;
    
51. 
    
52.     _pin = pin;
    
53.     strip.num_leds = num_leds;
    
54.         strip.pin_num = _pin;
    
55.         _brightness = brightness;
    
56.         strip.leds = (color_t*)malloc(sizeof(color_t) * num_leds);
    
57.     for (int i = 0; i < num_leds; i++) {
    
58.         strip.leds[i].simple.g = 0;
    
59.         strip.leds[i].simple.r = 0;
    
60.         strip.leds[i].simple.b = 0;
    
61.     }
    
62. 
    
63.     gpio = bflb_device_get_by_name("gpio");
    
64.     bflb_gpio_init(gpio, pin, GPIO_OUTPUT|GPIO_FLOAT);
    
65.     // bflb_gpio_reset(gpio, pin);
    
66.    
    
67.    
    
68. }
    
69. 
    
70. 
    
71. // RGB发送1码.
    
72. void sendOne(uint8_t GPIO_Pin) {
    
73.     bflb_gpio_set(gpio, _pin);
    
74.     //延时850ns
    
75.     for (volatile int i = 0; i < 30; i++);
    
76.     bflb_gpio_reset(gpio, _pin);
    
77.     //延时400ns
    
78.     for (volatile int i = 0; i < 20; i++);
    
79. }
    
80. 
    
81. // RGB发送0码.
    
82. void sendZero(uint8_t GPIO_Pin) {
    
83.     bflb_gpio_set(gpio, _pin);
    
84.     //延时400ns
    
85.     for (volatile int i = 0; i < 20; i++);
    
86.     bflb_gpio_reset(gpio, _pin);
    
87.     //延时850ns
    
88.     for (volatile int i = 0; i < 30; i++);
    
89. }
    
90. 
    
91. // RGB发送数据.
    
92. void sendRGB(uint8_t pin, uint8_t red, uint8_t green, uint8_t blue) {
    
93.     for (uint8_t i = 0; i < 8; i++) {
    
94.         if (green & 0x80) {
    
95.             sendOne(pin);
    
96.         } else {
    
97.             sendZero(pin);
    
98.         }
    
99.         green <<= 1;
    
100.     }
     
101. 
     
102.     for (uint8_t i = 0; i < 8; i++) {
     
103.         if (red & 0x80) {
     
104.             sendOne(pin);
     
105.         } else {
     
106.             sendZero(pin);
     
107.         }
     
108.         red <<= 1;
     
109.     }
     
110. 
     
111.     for (uint8_t i = 0; i < 8; i++) {
     
112.         if (blue & 0x80) {
     
113.             sendOne(pin);
     
114.         } else {
     
115.             sendZero(pin);
     
116.         }
     
117.         blue <<= 1;
     
118.     }
     
119. }
     
120. 
     
121. 
     
122. // 设置RGB值,如果需要点亮必须调用pixel_show()
     
123. void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b) {
     
124.     if (n >= strip.num_leds) {
     
125.         return;
     
126.     }
     
127. 
     
128.     strip.leds[n].simple.r = r;
     
129.     strip.leds[n].simple.g = g;
     
130.     strip.leds[n].simple.b = b;
     
131. }
     
132. 
     
133. // 刷新RGB.
     
134. void pixel_show(void) {
     
135.    
     
136.         for(int i=0;i<2;i++){
     
137.                 for (int i = 0; i < strip.num_leds; i++) {
     
138.                         color_t pixel = strip.leds[i];
     
139.                         uint8_t r = pixel.simple.r;
     
140.                         uint8_t g = pixel.simple.g;
     
141.                         uint8_t b = pixel.simple.b;
     
142. 
     
143.                         // 根据亮度调整RGB值
     
144.                         r = (r * _brightness) >> 8;
     
145.                         g = (g * _brightness) >> 8;
     
146.                         b = (b * _brightness) >> 8;
     
147.                         if(_mode==1)sendRGB(strip.pin_num, r, g, b);
     
148.                         else sendRGB(strip.pin_num, g, r, b);
     
149.             }
     
150.                 // 延时50us用于刷新数据
     
151.                 bflb_mtimer_delay_us(50);
     
152.         }
     
153. 
     
154. }
     
155. 
     
156. //全部写入一种颜色
     
157. void Pixel_set_all_color(uint8_t red, uint8_t green, uint8_t blue)
     
158. {
     
159. 
     
160.     for (int i = 0; i < strip.num_leds; i++)
     
161.         {
     
162.                 strip.leds[i].simple.g = green;
     
163.                 strip.leds[i].simple.r = red;
     
164.                 strip.leds[i].simple.b = blue;
     
165.         }
     
166. }
     
167. 
     
168. //关闭所有
     
169. void pixel_clear()
     
170. {
     
171.         for (int i = 0; i < strip.num_leds; i++)
     
172.         {
     
173.                 strip.leds[i].simple.g = 0;
     
174.                 strip.leds[i].simple.r = 0;
     
175.                 strip.leds[i].simple.b = 0;
     
176.         }
     
177.         pixel_show();
     
178. }
     
179. 
     
180. //=============
     
181. uint32_t color(uint8_t r, uint8_t g, uint8_t b) {
     
182.            return ((uint32_t)r << 16) | ((uint32_t)g <<  8) | b;
     
183. }
     
184. 
     
185. // 颜色转换
     
186. uint32_t wheel(uint8_t WheelPos)
     
187. {
     
188.         WheelPos = 255 - WheelPos;
     
189.           if(WheelPos < 85) {
     
190.             return color(255 - WheelPos * 3, 0, WheelPos * 3);
     
191.           }
     
192.           if(WheelPos < 170) {
     
193.             WheelPos -= 85;
     
194.             return color(0, WheelPos * 3, 255 - WheelPos * 3);
     
195.           }
     
196.           WheelPos -= 170;
     
197.           return color(WheelPos * 3, 255 - WheelPos * 3, 0);
     
198. }
     
199. // RGB写入32位颜色值
     
200. uint8_t pixel_set_color(uint16_t index, uint32_t col)
     
201. {
     
202.         uint8_t r = (uint8_t)(col >> 16);
     
203.           uint8_t g = (uint8_t)(col >>  8);
     
204.           uint8_t b = (uint8_t)col;
     
205. 
     
206.         if (index < strip.num_leds)
     
207.         {
     
208.                 strip.leds[index].simple.r = r;
     
209.                 strip.leds[index].simple.g = g;
     
210.                 strip.leds[index].simple.b = b;
     
211.         }
     
212.         else{
     
213.                 return 1;
     
214.         }
     
215.         return 0;
     
216. }
     
217. 
     
218. // 彩虹循环
     
219. void pixel_rainbow(uint8_t tim) {
     
220.   uint16_t i, j;
     
221. 
     
222.   for(j=0; j<256; j++) {
     
223.     for(i=0; i<strip.num_leds; i++) {
     
224.       pixel_set_color(i, wheel((i+j) & 255));
     
225.     }
     
226.     pixel_show();
     
227.     bflb_mtimer_delay_ms(tim);
     
228.   }
     
229. }
     
230. 
     
231. // 流光溢彩
     
232. void pixel_rainbowCycle(uint8_t tim) {
     
233.   uint16_t i, j;
     
234. 
     
235.   for(j=0; j<256*5; j++) {
     
236.     for(i=0; i< strip.num_leds; i++) {
     
237.               pixel_set_color(i, wheel(((i * 256 / strip.num_leds) + j) & 255));
     
238.     }
     
239.     pixel_show();
     
240.     bflb_mtimer_delay_ms(tim);
     
241.   }
     
242. }
     
243. 
     
244. 
     
245. 
     
246. //=====单色单灯流水
     
247. void demo_0(uint16_t R,uint8_t G,uint8_t B,uint8_t spd)
     
248. {
     
249.         
     
250. for(int b=0; b<3; b++) {
     
251.                 pixel_clear();         
     
252.                 for(int c=b; c<strip.num_leds; c += 3) {
     
253.                         setPixelColor(c, R, G, B);
     
254.                 }
     
255.                 pixel_show();
     
256.                 bflb_mtimer_delay_ms(spd);  
     
257.         }
     
258. 
     
259. }
     
260. 
     
261. //====多彩单灯流水
     
262. void demo_1(uint16_t spd)
     
263. {
     
264.         for(int b=0; b<3; b++) {
     
265.                         pixel_clear();         
     
266.                         for(int c=b; c<strip.num_leds; c += 3) {
     
267.                                 uint8_t r =rand() % 256;
     
268.                                 uint8_t g =rand() % 256;
     
269.                                 uint8_t b =rand() % 256;
     
270.                                 setPixelColor(c, r, g, b);
     
271.                         }
     
272.                         pixel_show();
     
273.                         bflb_mtimer_delay_ms(spd);
     
274.                 }
     
275. 
     
276. }
     
277. 
     
278. //=====单色扩散===
     
279. void demo_2(uint16_t spd){
     
280.         uint8_t r = rand() % 256;
     
281.         uint8_t g = rand() % 256;
     
282.         uint8_t b =rand() % 256;
     
283.         uint8_t x0 = strip.num_leds/2-1;
     
284.         uint8_t x1 = strip.num_leds/2+1;
     
285.         setPixelColor(strip.num_leds/2,r,g,b);
     
286.         for(uint8_t i=0;i<strip.num_leds/2+1;i++){
     
287.                 setPixelColor(x0,r,g,b);
     
288.                 setPixelColor(x1,r,g,b);
     
289.                 pixel_show();
     
290.                 bflb_mtimer_delay_ms(spd);
     
291.                 x0--;
     
292.                 x1++;
     
293.         }
     
294. }
     
295. 
     
296. // 13x14点阵字
     
297. void showtext(uint8_t (*letter)[13]) {
     
298.   for (int y = 0; y < 14; y++) {
     
299.     for (int x = 0; x < 13; x++) {
     
300.       if (letter[y][x]) {
     
301.         setPixelColor(y * 13 + x, 255, 255, 255);
     
302.       } else {
     
303.         setPixelColor(y * 13 + x, 0, 0, 0);
     
304.       }
     
305.         }
     
306.   }
     
307.   pixel_show();
     
308. }
     
309. 
     
310. 
     
311. #endif

复制代码

main.c文件

1. #include "WS2812.h"
   
2. #include "board.h"
   
3. 
   
4. 
   
5. float data;
   
6. int main(void)
   
7. {
   
8.     board_init();
   
9.     WS2812_init(24, 182, 5,2); // 引脚号，灯珠数，亮度，发送顺序(rgb,gbr)
   
10.     bflb_mtimer_delay_ms(100);
    
11.     while (1) {
    
12.         
    
13.         pixel_rainbow(60); //灯效
    
14.         // pixel_rainbowCycle(60);
    
15.         // demo_2(60);
    
16.         bflb_mtimer_delay_ms(1000);
    
17.     }
    
18. }

复制代码

楼楼在代码中添加了一些注释，关于灯效的话，大家可以自己研究，楼楼承认楼楼是个小菜鸟，很不专业，如果代码哪里有问题大家可以自行修改！

666

高质量帖子，感谢分享。

这个帖子质量是真的高

大佬还是持续输出 666

感谢分享

666

这是不是可以用Lightpack 连接ip:udpport 做个流光溢彩

楼主太厉害了！加油，点个赞

学习