这几天打算复**stm32有关的硬件资源，就想着从最开始做起，熟悉下当初所学的知识。学习stm32最初都基本是从流水灯开始的，今天就开始点亮流水灯。
: x- [1 Y: x1 P; s. }
) E( k1 l3 {. f' g/ e$ G首先，必须明白流水灯的硬件原理，以下是原理图：

, L* F6 u8 U, O- j: X: ~, ^
. x/ E: F8 f5 k7 p( \# H' |
它由8个管脚控制，因此首先必须进行初始化8个引脚。
. l7 h7 {3 g$ W" }9 u: y5 }
8 O- |1 P) m# N! t

1. //初始化PE8...PE15为输出口.并使能这八个口的时钟                    
     q$ X  }8 o' M& O! O
2. //LED IO初始化
   
3. void LED_Init(void)
   
4. {
   
5. 
   2 v- ~6 T; e+ ?" q
6.         GPIO_InitTypeDef  GPIO_InitStructure;
   + w+ b) D, Q8 _4 O
7. 
   * L. s" q# y6 T
8.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);                        //使能PE端口时钟
   2 M3 ?$ {2 ~1 R, F, n' U1 l# K
9. 
   
10.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;                                         //LED1-->PE.8 ...  LED8-->PE.15 端口配置
    
11.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                                                    //推挽输出
    $ k7 `/ |' \0 }) q+ s& f  N
12.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                                                 //IO口速度为50MHz
    $ R: ^8 s9 p4 s5 p" E
13.         GPIO_Init(GPIOE, &GPIO_InitStructure);                                                                         //根据设定参数初始化GPIOE
    
14.         GPIO_SetBits(GPIOE,GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);                                                                                 //PE.8 输出低
    
15. 
    ; c8 E/ w* o4 @. j
16. }

复制代码

+ w2 Z1 b( _% R7 [
这样就实现了流水灯管脚初始化的操作，剩下的操作只需要在主函数中进行相应的调用操作即可完成。
为了使程序更加完美，加入了蜂鸣器的初始化，流水灯亮的同时蜂鸣器响。
+ I6 t( |1 c3 }" ?& F" g  G7 q
! I" D5 L( J2 d- z

1. <span style="font-size:14px;"><strong>//初始化PB5为输出口.并使能这个口的时钟                    
   
2. //蜂鸣器初始化
   
3. void BEEP_Init(void)
   
4. {
   
5.         GPIO_InitTypeDef  GPIO_InitStructure;
   
6. 
   ( J# ?$ G; C' Z3 `
7.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);         //使能GPIOB端口时钟
   
8. 
   
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;                                 //BEEP-->PB.5 端口配置
   5 F! v: V0 z# s% C6 |
10.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
    8 U# N) ^6 U' R! K; v
11.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                  //速度为50MHz
    / K" J/ r! y6 C8 K7 x/ [8 p
12.         GPIO_Init(GPIOB, &GPIO_InitStructure);                                         //根据参数初始化GPIOB.5
    - o  \9 s: y; P! G4 s
13. 
    ! v5 F8 ^  H" D- Z  T. I1 S
14.         GPIO_ResetBits(GPIOB,GPIO_Pin_5);                                                //输出0，关闭蜂鸣器输出
    * y2 _4 s) m) g7 K$ Q8 E
15. }</strong></span>

复制代码

1 D8 ^. ~5 ^2 W" ?& e在流水灯操作中还有一个很关键的步骤，要想实现精确的延时，哪就要自己编写延时函数。延时有微妙、毫秒延时，可分别按自己的需求进行编写。

1. <span style="font-size:14px;">//初始化延迟函数
   / N) [3 a9 [/ Y- i. m; \8 I
2. //SYSTICK的时钟固定为HCLK时钟的1/8
   
3. //SYSCLK:系统时钟
   ' M2 p. |/ C$ h8 S8 ]% z" a+ y8 v
4. void delay_init()         
   4 x: ?: O7 [% Z9 [3 u
5. {
   ) E3 T* N% h* D  S0 U2 U8 {
6.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);        //选择外部时钟  HCLK/8
   9 M# ]+ E6 ^$ K2 ^8 M
7.         fac_us=SystemCoreClock/8000000;        //为系统时钟的1/8  
   0 ]( U& j$ m1 a. I. K1 S
8.          
   
9.         fac_ms=(u16)fac_us*1000;//非ucos下,代表每个ms需要的systick时钟数   
   4 C4 a/ H4 _7 H; G; O" ]' X$ j
10. }</span>

复制代码

毫秒函数初始化

1. //延时nms
   4 e3 m, Z) R9 G" t
2. //注意nms的范围
   ( n( S9 p8 M5 g* Z/ D, U% i# w
3. //SysTick->LOAD为24位寄存器,所以,最大延时为:
   2 L7 v- R6 L0 Y. h& S7 t6 [2 h+ `
4. //nms<=0xffffff*8*1000/SYSCLK
   
5. //SYSCLK单位为Hz,nms单位为ms
   $ w4 K& n1 A) ~6 b
6. //对72M条件下,nms<=1864
   1 S* b. J, j/ b* j
7. void delay_ms(u16 nms)
   
8. {                                    
   
9.         u32 temp;                  
   " Y  Y8 S# B5 ?/ I9 f: K( W& [
10.         SysTick->LOAD=(u32)nms*fac_ms;//时间加载(SysTick->LOAD为24bit)
    * h1 n! U' j& l) z9 N/ c' `0 d
11.         SysTick->VAL =0x00;           //清空计数器
    & K4 x% D$ s$ I7 |+ ~3 c' j( K
12.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;          //开始倒数  
    
13.         do
    
14.         {
    
15.                 temp=SysTick->CTRL;
    
16.         }
    
17.         while(temp&0x01&&!(temp&(1<<16)));//等待时间到达   
    6 p$ [( w: K# E) f# T
18.         SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;       //关闭计数器
    
19.         SysTick->VAL =0X00;       //清空计数器                     
    - S! S8 \4 Q. I' X5 G
20. }
    

复制代码

在主函数中进行调用和初始化操作
- J! r/ d% t, }& [' H. t% N; m9 q) }3 _
主函数的调用
  T" k/ P# j+ }
6 Y* M8 l6 C3 Y* Y7 u* O

1. #include "stm32f10x.h"
   : s3 L* e: g5 Q( I2 i4 h  N
2. #include "led.h"
   
3. #include "beep.h"
   ! j- ?- `6 a. k5 h7 b( \- B
4. #include "delay.h"
   
5. #include "sys.h"
   ( @+ h0 O9 N# Z
6. 
   
7. int main(void)
   
8. {
   ) U6 ?# C! h3 F+ L' |: Q, n
9.         delay_init();                //延时函数初始化
   4 d. F8 V  ~6 \$ y
10.          LED_Init();                        //LED端口初始化        
    2 d- D  T) d" D6 P
11.         BEEP_Init();        //初始化蜂鸣器端口
    
12.         
    
13.         while(1)
    / D" E+ M5 O+ G' j+ }
14.         {
    + w# P  C' b; M" b9 r; v/ t1 N
15.                 LED1 = LEDON;
    
16.                 LED2 = LEDOFF;
    1 u% B2 Q& f  s6 x0 g& N
17.                 LED3 = LEDOFF;
    
18.                 LED4 = LEDOFF;
    
19.                 LED5 = LEDOFF;
    2 s: A( _' q# g  y* Z. g  }' k
20.                 LED6 = LEDOFF;
    , V9 D0 T5 Z# f( R+ A! X( j
21.                 LED7 = LEDOFF;
    / e3 s! s* `# {8 d3 |5 u, h
22.                 LED8 = LEDOFF;
    
23.                 BEEP = 1;
    
24.                 delay_ms(100);
    , q: k+ ?5 N7 I9 h6 n6 m( p7 w+ m* `
25.                
    4 n' Y8 K* h+ M( V% @
26.                 LED1 = LEDOFF;
    
27.                 LED2 = LEDON;
    
28.                 LED3 = LEDOFF;
    4 K* d6 C& `" v8 b& E
29.                 LED4 = LEDOFF;
    2 H8 L& Y6 ^7 a4 Y! g, A# y9 A5 t
30.                 BEEP = BEEPOFF;
    - n) F$ J8 e7 ^1 z7 m( r
31.                 LED5 = LEDOFF;
    / x5 d1 ?+ j8 b# ?9 m' d( E
32.                 LED6 = LEDOFF;
    
33.                 LED7 = LEDOFF;
    5 ~! O2 e6 l6 @
34.                 LED8 = LEDOFF;
    
35.                 delay_ms(100);
    
36.                
    2 \& ?6 v; Y8 N( G
37.                 LED1 = LEDOFF;
    ) l6 p. {' q, h0 v: E
38.                 LED2 = LEDOFF;
    
39.                 LED3 = LEDON;
    # W  Q- m, s! V1 u3 X& x
40.                 LED4 = LEDOFF;
    
41.           LED5 = LEDOFF;
    
42.                 LED6 = LEDOFF;
    
43.                 LED7 = LEDOFF;
      R- T' h  c1 F" v0 s1 Z
44.                 LED8 = LEDOFF;               
    
45.                 delay_ms(100);
    
46.                
    
47.                 LED1 = LEDOFF;
    
48.                 LED2 = LEDOFF;
    
49.                 LED3 = LEDOFF;
    
50.                 LED4 = LEDON;
    7 d1 X2 [; C+ K7 d5 W! |
51.                 LED5 = LEDOFF;
    
52.                 LED6 = LEDOFF;
    ! T- g( R" \; S% d9 q& a" y3 m
53.                 LED7 = LEDOFF;
    
54.                 LED8 = LEDOFF;               
    ! O3 m% l8 |8 u6 R: q$ d
55.                 delay_ms(100);
    
56.                
    2 F! B  V; @- V& h
57.                 LED1 = LEDOFF;
    
58.                 LED2 = LEDOFF;
    
59.                 LED3 = LEDOFF;
    0 a2 t& X6 b% x3 t: W1 m3 G" u% v* x
60.                 LED4 = LEDOFF;
    ( ^1 e4 d4 D1 ?! l& g
61.                 LED5 = LEDON;
    % T; S# v) @  {- p4 l; ~
62.                 LED6 = LEDOFF;
    . e8 v8 `* G( k2 k7 W
63.                 LED7 = LEDOFF;
    
64.                 LED8 = LEDOFF;
    
65.                 delay_ms(100);
    - t5 O  y5 i$ k: F1 j
66.                
    
67.                 LED1 = LEDOFF;
    
68.                 LED2 = LEDOFF;
    % I$ b4 l( v" j+ o
69.                 LED3 = LEDOFF;
    
70.                 LED4 = LEDOFF;
    9 `5 n8 [" [7 K4 {1 k: V
71.                 LED5 = LEDOFF;
      Q& ]$ K2 I* y( o4 N( O
72.                 LED6 = LEDON;
    + p' Y% ?: X: \7 B% Q6 D) y  H
73.                 LED7 = LEDOFF;
    # w9 B" ]4 Y" a& K' l2 w, Y0 z: B4 J
74.                 LED8 = LEDOFF;
    # [) H5 H0 I' O" A3 |
75.                 delay_ms(100);
    
76.                
    
77.                 LED1 = LEDOFF;
    
78.                 LED2 = LEDOFF;
    
79.                 LED3 = LEDOFF;
    
80.                 LED4 = LEDOFF;
    
81.                 LED5 = LEDOFF;
    
82.                 LED6 = LEDOFF;
    
83.                 LED7 = LEDON;
    $ n) v  f" h  ^' A/ l& [5 O- `3 |! C
84.                 LED8 = LEDOFF;
    / P) l) h4 d, ~2 W3 M% z5 G3 G
85.                 delay_ms(100);
    3 q- d) F. }4 U8 T" d8 \5 k8 u
86.                
    5 y+ R/ t- J0 u2 F
87.                 LED1 = LEDOFF;
    ' _* }5 f8 E( M* v8 Z
88.                 LED2 = LEDOFF;
      a' e' E4 `7 s0 x/ D- G& i
89.                 LED3 = LEDOFF;
    
90.                 LED4 = LEDOFF;
    4 Y  b& l' t# Y3 V) D# W" {. [
91.                 LED5 = LEDOFF;
    ) r- G/ R% }! \7 }- z; u7 {+ O$ w
92.                 LED6 = LEDOFF;
    ( ~- S6 g0 j$ A) E( x9 m6 R  N
93.                 LED7 = LEDOFF;
    * h& }6 D; E# C
94.                 LED8 = LEDON;
    + X. X1 b& k6 T; S' \. J
95.                 delay_ms(100);
    0 U- F& {) k$ m  O8 {' g4 P5 H
96.                
    4 Y# ~: P0 M3 Y8 ]  u" v
97.         }         
    
98. }

复制代码

- I. j4 ~  \6 p1 J' d5 }       主函数中写的其实是最简单理解的程序，也是很多初学者很容易编写出的程序。原理是依次让每个灯亮，每个灯之间添加延时函数，以实现流水的效果，具体延时多少看自己的个人爱好，想让它变化多快在延时函数里面实现。
# @% S' N6 u* j7 g) z8 T) E4 n一下是实验的最终结果。其实还很好看。（在以后做东西的时候可以将流水灯加上去，效果很好看的，比如加在小车上，或者四轴飞行器上，这样的话看起来挺酷的！）

一切都得从最基础开始，小的实验室为了以后做更大项目。
  N4 V6 `  R& q9 c

6 Q+ }, I( P- j! q9 J

4 \# f! C  i8 e4 A* `; Y
4 a! e! t4 a5 k% F

! h4 E2 V. I8 |) p- e- [2 H2 y