正好手里有个ws2812的灯环，全彩模式开始。
7 P# f& U- G8 i. ~# SWS2812特点：
1.WS2812灯珠内置控制电路与RGB芯片，集成在一个5050封装的元器件中，构成一个完整的外控像素点。
2.每个像素点的三基色可实现256级亮度显示，完成16777216种颜色的全真色彩显示，扫描频率不低于400Hz/s。
3.串行级联接口，能通过一根信号线完成数据的接收与解码。
+ z4 |0 r; @- T6 {3 L' K7 P4.当刷新速率30帧/秒时，低速模式级联数不小于512点，高速模式不小于1024点。
) o: U2 q) j4 A2 z+ S+ H$ w& S. b) o8 a5.数据发送速度可达800Kbps。
& |3 t- N" s1 w: r* S数据传输：
ws2812的每颗灯珠的控制需要24位数据，分为8位绿色+8位红色+8位蓝色，每个像素点的三基色颜色可实现256级亮度显示，完成16777216种颜色的全真色彩显示。灯珠之间采用串行级联，在上电复位以后，控制器可向灯带发送一串24bit的数据，比如需要点亮10颗灯，我们发送10个24bit的数据到第一个灯，第一个灯的DIN端接受控制器发过来的24bit数据，第一个灯珠会提取第一个24bit数据后会将该数据送进数据锁存器，剩余的数据经过内部整形电路向下传送，直到所有的灯都获取一个24bit数据。这10个24bit数据的发送间隔不能超过50us，否则会导致下一次的颜色数据被第一个重新锁存，就无法完成完整的点亮。
8 `% ]$ |+ J8 e3 }" }7 [这里需要着重点一下时序相关的知识，先看时序波形图和数据传输时间表：

根据上面两个图可以看到ws2812的电**转是纳秒级别的，所以在使用单片机外设时我们需要对单片机的外设的传输速度进行控制，速度慢了根本无法点亮。
7 m& ~/ L) H$ Y- Q, Q: X操作开始：
8 J' ]) k+ V& k# s在驱动ws2812的时候一般采用PWM或者SPI的方式，这两个速度较快，比直接使用IO口进行电**转要方便，且控制效果更好。这里我们采用SPI的方式，因为在点灯是的数据发送间隔时间的约束，如果我们使用SPI发送的数据较多，中途遇到中断可能会打断我们的点灯，所以我这里使用SPI的DMA进行控制，不怕被其他影响。
4 S; k: i* L( d8 K( @
* Y. p. ]3 D# A0 |: e通过硬件SPI我们模拟WS2812的通信时序。单片机选用STM32F103，主频72M，SPI1分频设置为8，这样SPI1的通信频率为9M。时间很充足，如果使用SPI2，则需要减小分频系数，否则无法点亮。我这里采用的便是SPI2，4分频，因为SPI1被我的屏幕占用了。
.h文件只要定义了灯珠的个数和0码1码。不同的灯珠数量只需修改PIXEL_NUM 的值。

1. #ifndef __WS2812_H
   % A4 s# J$ H6 L- O! j5 v7 T
2. 
   
3. #define __WS2812_H
   3 y$ p" T' o8 E5 i6 P
4. 
   
5. 
   : v& a+ F* W7 s# a3 G
6. 
   
7. #include "stm32f10x.h"
   
8. 
   
9. 
   
10. 
    
11. #define PIXEL_NUM 24
    
12. 
    1 L' P+ r: ^# Z9 [
13. 
    3 S2 @; u* R: d# Q; N" {' l
14. 
    8 E& e# f8 |: G2 t" M& U6 x$ q
15. //硬件spi模拟ws2811时序（用spi的8位数据模拟ws281x的一位数据）
    
16. 
    0 u  d2 o+ _- W  b* Y4 `
17. //要将系统时钟设置为56M，分频数设置为8，则SPI的通信频率为7M，传输一位数据的时间约为143纳秒（ns）
    - `  t" L) y1 R; t9 f! d
18. 
    3 F$ L: P& ~* K
19. //3*143 = 429ns   5*143 = 715ns  符合WS281X芯片的通信时序。
    ' j; y8 O8 G. }$ v* U+ P- ^/ z2 [
20. 
    : Z/ R6 W, {5 ?* g; m
21. //  _____   
    
22. 
    2 |* S- ~6 X3 Y  f/ }: Y& P& m' {
23. // |     |___|   11111000  high level
    , C8 ^2 y' I' ]. t: I& R" Q4 L
24. 
    7 P# n) c, }9 [7 i) s9 ^) h
25. //  ___         
    
26. 
    
27. // |   |_____|   11100000  low level
    
28. 
    
29. 
    * m- T: Z& Z1 d7 }$ C: _8 i* L4 F
30. 
    2 O' k/ O0 i: h
31. #define WS_HIGH 0XF8
    
32. 
    
33. #define WS_LOW  0XE0
    , H5 R/ `3 G' A7 ^% n
34. 
    ' C' [6 Y* J6 C( O! {
35. 
    
36. 
    & U# p: o8 ]% }6 i7 B( q7 X* n% X
37. void ws281x_init(void);
    
38. 
    ( e% F; q$ M' i/ C
39. void ws281x_closeAll(void);
    . V& y& |4 L+ L/ }1 s! U3 F  n; L
40. 
    
41. void ws281x_rainbowCycle(uint8_t wait);
    
42. 
    $ y$ e; o: g" m0 F" x" J
43. uint32_t ws281x_color(uint8_t red, uint8_t green, uint8_t blue);
    
44. 
    " ~/ b" \% w" a  J: Y/ Y
45. void ws281x_setPixelColor(uint16_t n ,uint32_t GRBcolor);
    
46. 
    
47. void ws281x_show(void);
      n( S1 o/ J1 w4 u" m
48. 
    6 b" |. G$ |7 m
49. 
      r* }' t1 ^  c9 f7 \2 v3 O
50. 
    . y- G6 k, M! P$ v0 n
51. void ws281x_theaterChase(uint32_t c, uint8_t wait);
    
52. 
    
53. void ws281x_colorWipe(uint32_t c, uint8_t wait);
    
54. 
    
55. void ws281x_rainbow(uint8_t wait);
    
56. 
    1 K3 M& |' N. S$ \. k/ \4 Z- s
57. void ws281x_theaterChaseRainbow(uint8_t wait);
    
58. 
    + `* t* S- Q2 C) t+ W/ _# ?2 Y
59. 
    9 M& b8 W+ f1 X+ N$ i9 D9 ~! |
60. 
    ' Q$ w0 h5 a$ P9 I
61. #endif /* __WS2812_H */

复制代码

1. #include "../BOARD/ws2812/ws2812.h"
   * }; `5 h( C& l
2. 
   
3. #include "usart.h"
   7 ?% a' p  R+ ]" e2 t" n
4. 
   2 i$ o- m$ O4 _2 \5 H
5. #include "delay.h"
   
6. 
   
7. 
   
8. 
   3 f9 {$ G$ t. k/ z' M5 _) o! c' T
9. uint8_t pixelBuffer[PIXEL_NUM][24] ;
   6 |" J4 X  [  h; Y
10. 
    
11. 
    
12. 
    
13. 
    ( i2 R$ v1 v; p/ D% V7 ~, P
14. 
    2 g' C4 c- [& n6 \$ h' R
15. void ws281x_init(void)
    5 U- V0 e/ |) @  y
16. 
    + d5 C7 l0 v: ]- m
17. {
    & d6 R, `3 r$ R8 _/ c( y; r
18. 
    
19.   GPIO_InitTypeDef GPIO_InitStructure;
    
20. 
    ! J0 O& e: `& k. c% k* A
21.   SPI_InitTypeDef  SPI_InitStructure;
    - I& e+ n. q4 Y  P: ?& p1 J
22. 
    3 |0 ?% B" I5 V" Y6 |$ j9 ]  }
23.   DMA_InitTypeDef DMA_InitStructure;
    , K. B: p. S3 o- H* ?; W5 j) j
24. 
    
25. 
    7 M: q( B; J% g+ Z1 Q0 ]; ^
26. 
    
27.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); //PORTA时钟使能
    
28. 
    ( M  i9 O! p7 X0 t, @" U/ G
29.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE); //SPI1时钟使能         
    
30. 
    
31.         RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);        //使能DMA传输
    $ a4 d& G: O5 U( G  P+ a
32. 
    
33. 
    $ c, q, A, D; P. J$ S7 ?6 ]
34. 
    
35. 
    # |/ H( I$ b! f1 y! N0 x, `% L
36. 
    & ?( ^# P! i8 _. O! x" r
37.   /* PA7  SPI1_MOSI */
    
38. 
    ; l0 U6 S, y- i/ X
39.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;
    # r) e4 _3 }5 H! `* F
40. 
    
41.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PA7复用推挽输出 SPI
    : _' j3 f( R6 [& w" J, q% _6 O: `
42. 
    
43.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
44. 
    . O- C8 U3 |/ [  g& G& r8 Q
45.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOA
    % s: B9 g' y( h- s
46. 
    & d- L' {1 L* l7 e# Z
47. 
    
48. 
    5 z, r0 X. w( E& ?. M4 R
49.         SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    
50. 
    4 s* j8 u5 m: N7 B, s! w
51.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
    ' x* z' }& N$ ?0 t0 U6 c+ }) A1 ]
52. 
    . ?+ W; ^2 c$ H
53.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                //设置SPI的数据大小:SPI发送接收8位帧结构
    
54. 
    
55.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;                //串行同步时钟的空闲状态为低电平
    6 a  T4 h( z" y8 z7 }/ w
56. 
    . X0 R/ ]+ Y6 j6 J& n1 e5 Q# S6 Q2 G! n
57.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;        //串行同步时钟的第2个跳变沿（上升或下降）数据被采样
    
58. 
    
59.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    
60. 
    
61.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;                //定义波特率预分频的值:波特率预分频值为16
    ) `4 Y8 p3 U- y4 S. v- W3 F8 I
62. 
    
63.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    
64. 
    
65.         SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    
66. 
    6 D9 C3 C/ C) K" o" s" F) w
67.         SPI_Init(SPI2, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    
68. 
    
69. 
    
70. 
    3 s& l/ z, c4 A# \2 _  x/ l6 M: Z
71.         SPI_Cmd(SPI2, ENABLE); //使能SPI外设
    6 L" b1 }# U7 d6 d3 m6 z3 o& m
72. 
    
73.   SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);
    ( y% U- }8 j; R2 L2 G0 K
74. 
    ) ^8 O0 a2 M5 d
75.   
    
76. 
    ; `; i9 f; q8 t7 C5 R' e) o4 X
77.         DMA_DeInit(DMA1_Channel5);   //将DMA的通道1寄存器重设为缺省值
    7 N+ n; T! U$ c8 ~7 L, x; {" M
78. 
    / U/ o. _6 i, B  @
79.         DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t) &(SPI2 -> DR); //cpar;  //DMA外设ADC基地址
    
80. 
    
81.         DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)pixelBuffer; //cmar;  //DMA内存基地址
    
82. 
    / h; ^/ s6 c* t; c, o+ T) g  F
83.         DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;  //数据传输方向，从内存读取发送到外设
    # z1 [" n* o; a5 m$ D# Y
84. 
    
85.         DMA_InitStructure.DMA_BufferSize = PIXEL_NUM * 24; //cndtr;  //DMA通道的DMA缓存的大小
    6 ^7 ]$ ?# g# w  y; |
86. 
    5 c# k5 ]( }0 y9 o. B
87.         DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;  //外设地址寄存器不变
    
88. 
    5 s7 \: u; b5 E9 M% |. A$ G
89.         DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;  //内存地址寄存器递增
    8 a+ a2 M0 @0 Y: h" r& {
90. 
    + B3 g, Q4 v' l, Y# j
91.         DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;  //数据宽度为8位
    
92. 
    
93.         DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //数据宽度为8位
    
94. 
    - I# D0 y; @. j+ b9 O
95.         DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;  //工作在正常缓存模式
    1 l3 h9 c( e( F+ t; w+ x. a
96. 
    ( \+ v, U: D/ j* l
97.         DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; //DMA通道 x拥有中优先级
    
98. 
    ) |" e/ h! Y, o! }' f- b8 [
99.         DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;  //DMA通道x没有设置为内存到内存传输
    4 l# ?- G1 ^: s5 N* t
100. 
     2 q: Z( Z0 n3 A  B6 P. l! s
101.         DMA_Init(DMA1_Channel5, &DMA_InitStructure);  //根据DMA_InitStruct中指定的参数初始化DMA的通道USART1_Tx_DMA_Channel所标识的寄存器
     
102. 
     
103.   
     
104. 
     
105.   ws281x_closeAll();  //关闭全部的灯
     ) y0 V4 L+ i6 T# T) N  U
106. 
     ' Z% Q6 y) w$ M" f( ~% B! g
107.   delay_ms(100); //关闭全部的灯需要一定的时间  
     
108. 
     
109. }
     & s' H7 n0 D4 Y. g3 t
110. 
     ! r6 a8 O% u1 X1 I
111. 
     
112. 
     
113. void ws281x_closeAll(void)
     
114. 
     
115. {
     * t7 O! h0 ^0 v/ m8 S" j9 h% `( Z
116. 
       o2 Z8 K5 F! }
117.   uint16_t i;
       B) M7 u- Y3 U. j
118. 
     5 \! \: F+ J( y. @4 N7 O9 V
119.   uint8_t j;
     
120. 
     ) O0 e' ]  x4 G1 j' N5 }, w
121.   
     : o, O5 W* L3 V4 Q* j) g- M$ ]
122. 
     
123.   for(i = 0; i < PIXEL_NUM; ++i)
     6 ?: i$ m+ l0 J! e0 Y& q+ A5 q; o
124. 
     
125.   {
     
126. 
     
127.     for(j = 0; j < 24; ++j)
     
128. 
     5 v3 Z1 [! p+ l# r( [
129.     {
     $ q% |5 H7 J% j6 s& Z" o5 ?8 V
130. 
     
131.       pixelBuffer[i][j] = WS_LOW;
     
132. 
     
133.     }
     2 R" u" X$ e2 _& [
134. 
     8 r5 `+ y5 A: Z, j: b
135.   }
     
136. 
     
137.   ws281x_show();
     
138. 
     4 v# ?5 u: n$ l
139. }
     
140. 
     
141. 
     5 b% E' L( F# q: l* r: r. G1 n
142. 
     : @. k+ c; E/ V$ e9 H; |- x+ V
143. uint32_t ws281x_color(uint8_t red, uint8_t green, uint8_t blue)
     
144. 
     ! G4 r% E# S* Q$ c9 O. ]  v
145. {
     9 l) M+ C0 B  p5 R
146. 
     . d( C( @3 k: Q3 J5 h: {4 S. g6 C
147.   return green << 16 | red << 8 | blue;
     
148. 
     
149. }
     
150. 
     
151. 
     9 y4 o1 ~" T8 n
152. 
     
153. void ws281x_setPixelColor(uint16_t n ,uint32_t GRBcolor)
     
154. 
     / u; _8 \( A& U8 F8 x& _  d  _
155. {
     6 c7 C  {. S9 `: p
156. 
     ! ?$ e9 ]5 k5 k8 j8 w
157.   uint8_t i;
     : G- j( q! n$ U; t& F3 n8 L
158. 
     3 L" }: Z# Z( A$ F" B6 N- |
159.   if(n < PIXEL_NUM)
     5 d- z% f# c( d+ V
160. 
     
161.   {
     ! L$ [/ D; |1 P7 e* `* `
162. 
     
163.     for(i = 0; i < 24; ++i)
     
164. 
     
165.     {
     9 g2 R4 ^6 Q- W, O# F! B' i$ J
166. 
     
167.       pixelBuffer[n][i] = (((GRBcolor << i) & 0X800000) ? WS_HIGH : WS_LOW);
     " G6 c! y8 v& W7 ?" z( e5 G
168. 
     + }  f$ U& Z8 ^9 g- [$ p0 H1 }
169.     }
     8 X/ _. U6 T+ [& H9 }' K; }
170. 
     6 E) c  C" f( S! M5 F, K
171.   }
     3 G" Q" G4 ?6 C# s
172. 
     
173. }
     + ?7 K# p( j( @
174. 
     : N1 g8 A' k3 [$ K2 L
175. 
     / w- Z  _0 H+ ^5 P. a& ~
176. 
     
177. void ws281x_setPixelRGB(uint16_t n ,uint8_t red, uint8_t green, uint8_t blue)
     
178. 
       M: b; B' y/ T# O& `5 |) G5 X
179. {
     4 M) f" h( r4 a( k* Z8 {
180. 
     8 q2 R: x; H3 R1 C! E
181.   uint8_t i;
     . H' T- x! u5 k
182. 
     
183.   
     . I3 B5 Y: p4 _% X5 z) ]
184. 
     
185.   if(n < PIXEL_NUM)
     ) k$ q5 e6 g4 U: ~; v) e$ h  s1 ?
186. 
     
187.   {
     
188. 
     
189.     for(i = 0; i < 24; ++i)
     
190. 
     
191.     {
     
192. 
       V! O  u+ U9 P2 y0 }2 G4 p3 S1 h$ D
193.       pixelBuffer[n][i] = (((ws281x_color(red,green,blue) << i) & 0X800000) ? WS_HIGH : WS_LOW);
     , A1 _/ s- `2 ?) L
194. 
     " k+ k; V8 Z, K7 O# F( V. p' d7 M) W6 L
195.     }
     6 e; }% k  p; I$ y7 z: z
196. 
     - p& p; A  O8 g0 `5 C& Y+ z* ]
197.   }
     
198. 
     
199. }
     2 w" _, ~  l- p
200. 
     ; |: l) w7 Q$ @3 |  |& j) E4 }2 F
201. 
     7 E% d& j. m5 e5 I3 @; O
202. 
     
203. void ws281x_show(void)
     - ]$ b- Y3 R3 B8 O$ |8 L7 g
204. 
     
205. {
     
206. 
     
207.     DMA_Cmd(DMA1_Channel5, DISABLE );  //关闭USART1 TX DMA1 所指示的通道
     
208. 
     
209.     DMA_ClearFlag(DMA1_FLAG_TC5);   
     
210. 
     
211.          DMA_SetCurrDataCounter(DMA1_Channel5,24 * PIXEL_NUM );//DMA通道的DMA缓存的大小
     / u/ q. @. C& A! o! Y
212. 
     5 L, u0 k2 Z1 v" l
213.          DMA_Cmd(DMA1_Channel5, ENABLE);  //使能USART1 TX DMA1 所指示的通道
     4 d" A8 X" |# s# h) Z; {) \% y
214. 
     / f& Q, X' N! y8 b: S& |
215. }
     
216. 
     ; c, Y2 ]0 C% a' P& R* v  p, m
217. 
     
218. 
     4 S- [6 ]. b$ x! K
219. 
     
220. 
     
221. 
     
222. 
     3 J8 l. q) H- {8 o: v7 Z8 n
223. // Input a value 0 to 255 to get a color value.
     
224. 
     % w2 V7 R7 r, ~+ v& a
225. // The colours are a transition r - g - b - back to r.
     
226. 
     
227. uint32_t ws281x_wheel(uint8_t wheelPos) {
     
228. 
     ) K# |) A" ?+ S) `! K
229.   wheelPos = 255 - wheelPos;
     ' t* o: X5 @" z& h* s
230. 
     
231.   if(wheelPos < 85) {
     8 [7 }  }, _) A% r& ]' b/ ]1 E  a8 }
232. 
     
233.     return ws281x_color(255 - wheelPos * 3, 0, wheelPos * 3);
     0 z% O3 r' E2 m( n
234. 
     
235.   }
     
236. 
     & H+ X: x% d. M; j7 V: x3 R
237.   if(wheelPos < 170) {
     6 Q8 U5 y6 h1 }$ U
238. 
     
239.     wheelPos -= 85;
     
240. 
     
241.     return ws281x_color(0, wheelPos * 3, 255 - wheelPos * 3);
     
242. 
     
243.   }
     / z+ P! f- `4 L4 z" t& W; \  Q1 e# _
244. 
     8 O. M! s- {4 B* q- j( v( k1 S
245.   wheelPos -= 170;
     . d$ _0 W4 p2 t: s
246. 
     & a  B8 z) S$ |: z# m7 P
247.   return ws281x_color(wheelPos * 3, 255 - wheelPos * 3, 0);
     
248. 
     
249. }
     , F6 M- H3 g% X, M  ^- H$ O
250. 
     
251. 
     # H6 [$ t0 d4 U  o' Z2 N  y
252. 
     
253. // Fill the dots one after the other with a color
     % g8 Z+ m# o2 _6 ?
254. 
     5 b$ N8 c0 |# U) v
255. void ws281x_colorWipe(uint32_t c, uint8_t wait) {
     
256. 
     
257.   for(uint16_t i=0; i<PIXEL_NUM; i++) {
     
258. 
     : T: ^: @: B0 D' u1 R* {
259.     ws281x_setPixelColor(i, c);
     3 I) s# i6 _0 D& n) V! e
260. 
       ?% U' p$ S8 ]( P1 J+ L& i" Z
261.     ws281x_show();
     
262. 
     " F) d: Q) L; e/ r4 [
263.     delay_ms(wait);
     
264. 
     
265.   }
     
266. 
     6 m2 T& Q/ e2 j' q8 F
267. }
     , ]# [, p* T$ U/ }
268. 
     
269. 
     ; z# G+ a, s  d6 \& z3 O* ^' c# c4 Y* H
270. 
     ( `6 ]6 h9 J4 a3 J
271. void ws281x_rainbow(uint8_t wait) {
     ; `1 M' b! A/ j) ?8 I( ?
272. 
     & n" d! s* D% |6 ~" U' u/ L' x* r
273.   uint16_t i, j;
     
274. 
     
275. 
     
276. 
     
277.   for(j=0; j<256; j++) {
     ! f0 o) ]0 ]/ U/ y$ W( d
278. 
     
279.     for(i=0; i<PIXEL_NUM; i++) {
     * _7 [7 ^1 {, [$ g4 z
280. 
     
281.       ws281x_setPixelColor(i, ws281x_wheel((i+j) & 255));
     6 x. a! k- L7 A) }/ B1 S
282. 
     6 a' }; A$ ?9 O4 h
283.     }
     
284. 
     1 \1 Y) ~0 |1 Q
285.     ws281x_show();
     / v9 l3 Y% n3 h2 j8 F0 e2 I3 ?
286. 
     
287.     delay_ms(wait);
     
288. 
     ; z8 r" z) H& K- @! o3 m: N4 i
289.   }
     
290. 
       ^1 F! U$ }3 Y: L4 ~- G% {
291. }
     - a2 G4 l. x; Z7 i5 ~1 s; ?" e3 a- m
292. 
     
293. 
     
294. 
     
295. // Slightly different, this makes the rainbow equally distributed throughout
     9 n0 J8 L8 i5 Q6 V( y4 {% N. r! O( e
296. 
     2 d/ Y/ Q; @8 J# _: |
297. void ws281x_rainbowCycle(uint8_t wait) {
     
298. 
     9 T6 E+ [+ e0 {0 C  e
299.   uint16_t i, j;
     
300. 
     6 u8 V' n( k, o7 i
301. 
     
302. 
     3 i  d4 A; {' R/ d: `# i
303.   for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
     8 c2 E# {8 e* Z% e
304. 
       W. p. N- H" y" y: w: [
305.     for(i=0; i< PIXEL_NUM; i++) {
     
306. 
       d7 `1 X3 l7 ~0 X
307.       ws281x_setPixelColor(i,ws281x_wheel(((i * 256 / PIXEL_NUM) + j) & 255));
     
308. 
     
309.     }
     , f* H) b/ t7 V* k$ ^+ m
310. 
     
311.     ws281x_show();
     ! R9 M# M( P/ _9 p
312. 
     5 I) D: ^8 \6 `+ `5 S$ }$ D
313.     delay_ms(wait);
     6 }% _; A; \4 O5 X& D
314. 
     / ^! [" z3 b, ?5 h6 m! g- ^
315.   }
     $ z0 ]- j% c  a* R
316. 
     5 T# Q( l4 J: i* |( h% X& P
317. }
     2 c' q9 R2 H9 z# O
318. 
     
319. 
     ! b7 i( c! ~0 B9 R# V: c
320. 
     
321. //Theatre-style crawling lights.
     + Z5 H/ m4 u3 S6 F0 S: u1 G
322. 
     
323. void ws281x_theaterChase(uint32_t c, uint8_t wait) {
     
324. 
     
325.   for (int j=0; j<10; j++) {  //do 10 cycles of chasing
     ' M0 [( P( f8 ?$ x/ \
326. 
     
327.     for (int q=0; q < 3; q++) {
     
328. 
     ! U9 B, [4 ~! S/ K' v1 v
329.       for (uint16_t i=0; i < PIXEL_NUM; i=i+3) {
     
330. 
     3 o1 v% S# r5 L5 Y
331.         ws281x_setPixelColor(i+q, c);    //turn every third pixel on
     
332. 
     
333.       }
     
334. 
     
335.       ws281x_show();
     ! Y. z/ P- }$ }- D' C) M$ B
336. 
     
337. 
     ( i6 S, l; z" E8 ]& D
338. 
     ' ]& E% `. F1 Z1 T+ u9 B
339.       delay_ms(wait);
     * C; E( Y2 j" L* Z+ }
340. 
     
341. 
     3 j# h# f4 T- p( k
342. 
     ! L' A& N9 t  Q1 s
343.       for (uint16_t i=0; i < PIXEL_NUM; i=i+3) {
     1 d% e' \( L, m" b- {, {2 R# ]
344. 
     
345.         ws281x_setPixelColor(i+q, 0);        //turn every third pixel off
     . t  g/ y7 E$ Z' l2 [- N2 F
346. 
     4 M( ~7 Q7 Q) c6 R( ~% j
347.       }
     
348. 
     
349.     }
     3 T: R4 g3 d4 h9 m
350. 
     
351.   }
     
352. 
     ( B. i3 Z! V* q6 j! I
353. }
     
354. 
     * p0 T' g2 ?0 O/ A8 i6 p
355. 
     6 i! A. @# n3 N  E: h4 n
356. 
     
357. //Theatre-style crawling lights with rainbow effect
     & ~# ^- e4 _- `
358. 
     
359. void ws281x_theaterChaseRainbow(uint8_t wait) {
     
360. 
     3 X6 Y" L! y; a9 }1 J% f  y
361.   for (int j=0; j < 256; j++) {     // cycle all 256 colors in the wheel
     ; x8 x; V$ K: C" r# d1 |
362. 
     6 W; F6 X8 W5 E5 @% V3 ?" E/ v- G
363.     for (int q=0; q < 3; q++) {
     
364. 
     * F4 Q, y$ G  x9 {
365.       for (uint16_t i=0; i < PIXEL_NUM; i=i+3) {
     ( c  |  Y3 m1 G* Q5 v
366. 
     
367.         ws281x_setPixelColor(i+q, ws281x_wheel( (i+j) % 255));    //turn every third pixel on
     
368. 
     ( i4 s1 z* Q6 b: [
369.       }
     3 V2 j1 T. W( n
370. 
     & G- A% Z  b) G/ }
371.       ws281x_show();
       S; J7 U4 j; Z" V! B
372. 
     
373. 
     
374. 
     
375.       delay_ms(wait);
     ; H5 W7 Y5 f+ o( |% ]  D/ q" R
376. 
     " j: Y. U* a  o7 A# `5 V3 I
377. 
     - q+ J& j  z! u
378. 
     
379.       for (uint16_t i=0; i < PIXEL_NUM; i=i+3) {
     
380. 
     
381.         ws281x_setPixelColor(i+q, 0);        //turn every third pixel off
     $ F4 z5 v3 g4 J8 `1 I
382. 
     
383.       }
     
384. 
     8 q+ k0 C1 K: m- `
385.     }
     3 y5 N. b0 J! g% ^1 c. R* Q
386. 
     ! ]& w$ l: ]. s1 i' }" p  z
387.   }
     
388. 
     + I* w% P0 M; \# j2 ?  j0 Q
389. }
     
390. 
     . V3 U' @; \9 M
391. 
     

复制代码

( Q1 `2 U# g- D# }- M# z

1. const char s[5];
   8 P7 g4 i# v) u; g! u7 O; g! J
2. 
   
3. int8_t i;
   
4. 
   
5. 
   
6. 
   6 f% T! s3 s8 A2 Z2 ?9 `
7. int main(void)
   
8. 
   8 s( @5 c5 P8 d9 _
9. {
   - R% I3 ~( V: m$ I$ f) F+ }* {
10. 
    
11. //  usart1_init(115200);
    
12. 
    
13.   delay_init();
    
14. 
    
15. 
    6 l5 W# j5 V6 L1 l; d7 G1 d; o  y
16. 
    ) h7 f; r" c5 i3 F( E- C
17.   ws281x_init();
    % e/ p  V/ W! I* v1 r) E% m5 {
18. 
    
19. 
    ' M) z$ [( `- R  e' }! R+ D
20. 
    
21.   while(1)
    , D# ?; B5 u+ T( u
22. 
    3 P# p' K6 P% Y2 T& F; K
23.   {
    % C3 S  ?9 J# m# `& T0 J" L" h7 T
24. 
    
25.      // Some example procedures showing how to display to the pixels:
    
26. 
    
27.   ws281x_colorWipe(ws281x_color(255, 0, 0), 50); // Red
    
28. 
    3 N" n' L8 Y! m) u: Q4 h0 M
29.   ws281x_colorWipe(ws281x_color(0, 255, 0), 50); // Green
    
30. 
    ; T- K7 j, P% H
31.   ws281x_colorWipe(ws281x_color(0, 0, 255), 50); // Blue
    
32. 
    
33. //colorWipe(strip.Color(0, 0, 0, 255), 50); // White RGBW
    
34. 
    
35.   // Send a theater pixel chase in...
    
36. 
    
37.   ws281x_theaterChase(ws281x_color(127, 127, 127), 50); // White
    
38. 
    
39.   ws281x_theaterChase(ws281x_color(127, 0, 0), 50); // Red
    
40. 
    
41.   ws281x_theaterChase(ws281x_color(0, 0, 127), 50); // Blue
    * W. w* w* A5 ^+ k: i
42. 
    
43. 
    ) a% Y+ ]3 U6 M
44. 
    7 d3 f! }  R! y$ H, A
45.   //ws281x_rainbow(20);
    
46. 
    * @0 W4 D. n/ v# U; _3 ]/ Q
47.   ws281x_rainbowCycle(20);
    
48. 
    
49.   ws281x_theaterChaseRainbow(200);
    % t: p, U+ s. ^$ a$ n% E
50. 
    % c6 B) _$ ]7 A
51.    
    
52. 
    
53.     for(i = 0; i < PIXEL_NUM; ++i)
    
54. 
    ! c+ d$ B: Y" f- R
55.   {
    % {& t7 D5 q0 @, f9 d
56. 
    & Q2 }1 c0 H( o: u' S2 o# G- ~
57.     ws281x_setPixelColor(i, ws281x_color(0,250,0));
    & t. m" P, x- J4 e
58. 
    
59.     ws281x_show();
    
60. 
    / l' Y% c  V0 x* G( M0 S9 L
61.     delay_ms(500);
    : {5 W% x9 |) m7 i+ ^1 d
62. 
    
63.   }
    ' |& o, q+ y7 l. F1 p; e
64. 
    
65.   }
    
66. 
    8 y0 f) x' t9 z6 ^. P' s
67. }

复制代码

% w! ^1 J+ p( a

在ws2812.c移植了Adafruit_NeoPixel库的部分函数，用以实现炫酷的显示效果。
都是基础的SPI，不说废话，移植就能用。展示一下效果吧！

---------------------
' S0 F8 w; `0 B作者：呐咯密密

4 U# Q# w* ^7 j
) Q' \' K+ d' }- ~