这几天打算复**stm32有关的硬件资源，就想着从最开始做起，熟悉下当初所学的知识。学习stm32最初都基本是从流水灯开始的，今天就开始点亮流水灯。
$ K$ u4 b* P  F6 W5 [
首先，必须明白流水灯的硬件原理，以下是原理图：


$ H' }  p0 x$ @  n
( u" b* i+ ]) ^. I' e9 @它由8个管脚控制，因此首先必须进行初始化8个引脚。
1 `! V8 m/ ~7 g: l
5 v. f) U; q0 @( P

1. //初始化PE8...PE15为输出口.并使能这八个口的时钟                    
   
2. //LED IO初始化
   2 A: Q1 O+ u+ n: o# }) C+ f5 o6 \
3. void LED_Init(void)
   + ~( s4 x, D% z( g9 G5 W9 F0 M
4. {
   
5. 
   - S; G! @& x# H$ w0 O- O  p
6.         GPIO_InitTypeDef  GPIO_InitStructure;
   / s( E$ }  {) |1 M, |
7. 
     ~# u6 F) ^( F: r* Z. y: ]
8.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);                        //使能PE端口时钟
   
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 端口配置
    * T' z6 K9 b$ G- i' Z
11.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                                                    //推挽输出
    
12.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                                                 //IO口速度为50MHz
    
13.         GPIO_Init(GPIOE, &GPIO_InitStructure);                                                                         //根据设定参数初始化GPIOE
    1 T$ ]3 r: ~2 R* k1 L* G2 f! _( U
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 输出低
    ' z% H7 ?& F, p) F: x
15. 
    2 D! {8 o- ]& l) _- M
16. }

复制代码

3 u8 u; U! I' g
这样就实现了流水灯管脚初始化的操作，剩下的操作只需要在主函数中进行相应的调用操作即可完成。
为了使程序更加完美，加入了蜂鸣器的初始化，流水灯亮的同时蜂鸣器响。
4 q4 r3 c* {5 I* G7 R) j

1. <span style="font-size:14px;"><strong>//初始化PB5为输出口.并使能这个口的时钟                    
   
2. //蜂鸣器初始化
   , o( X8 a" \! w
3. void BEEP_Init(void)
   
4. {
     ]( g1 Z* L9 Z2 _4 l
5.         GPIO_InitTypeDef  GPIO_InitStructure;
   
6. 
   ! ~" e+ R: N, o/ E, b
7.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);         //使能GPIOB端口时钟
   ' B8 R/ s( p( Y" _
8. 
   0 j2 k2 O4 p$ @6 `8 ]  ?
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;                                 //BEEP-->PB.5 端口配置
   
10.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
    
11.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                  //速度为50MHz
    # G, A" u- J* d+ D
12.         GPIO_Init(GPIOB, &GPIO_InitStructure);                                         //根据参数初始化GPIOB.5
    
13. 
    1 x4 A3 |" K* o, n8 m
14.         GPIO_ResetBits(GPIOB,GPIO_Pin_5);                                                //输出0，关闭蜂鸣器输出
    
15. }</strong></span>

复制代码

在流水灯操作中还有一个很关键的步骤，要想实现精确的延时，哪就要自己编写延时函数。延时有微妙、毫秒延时，可分别按自己的需求进行编写。
! N' J: ?- m9 K1 m' {: c) V
+ A1 d& d$ D" j" V

1. <span style="font-size:14px;">//初始化延迟函数
   
2. //SYSTICK的时钟固定为HCLK时钟的1/8
   ) g$ V# e" H4 s( _
3. //SYSCLK:系统时钟
   
4. void delay_init()         
   
5. {
   ! v3 x- {) m2 y$ P* b2 f8 Z
6.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);        //选择外部时钟  HCLK/8
   * {/ F3 Y8 [1 ]8 R
7.         fac_us=SystemCoreClock/8000000;        //为系统时钟的1/8  
   2 i) p: f- f2 z$ Z! x# Y: R
8.          
     g' r2 P) U# q6 D* O
9.         fac_ms=(u16)fac_us*1000;//非ucos下,代表每个ms需要的systick时钟数   
   
10. }</span>

复制代码

毫秒函数初始化

" r  C, a1 [3 k2 t* P. o

1. //延时nms
     o: q  r0 ~* ~8 w: Q( @
2. //注意nms的范围
   0 T& C# @& I. W
3. //SysTick->LOAD为24位寄存器,所以,最大延时为:
   & f$ p6 C. V& ^: f, F* V  {8 Z
4. //nms<=0xffffff*8*1000/SYSCLK
   8 H+ z' X" |$ }
5. //SYSCLK单位为Hz,nms单位为ms
   ' d0 i  G$ l3 z2 \6 K0 X
6. //对72M条件下,nms<=1864
   
7. void delay_ms(u16 nms)
   4 A: z/ l- x  F; a+ e2 Y: n
8. {                                    
   7 O8 j% p' D% J2 C
9.         u32 temp;                  
   
10.         SysTick->LOAD=(u32)nms*fac_ms;//时间加载(SysTick->LOAD为24bit)
    
11.         SysTick->VAL =0x00;           //清空计数器
    8 Y9 h, w' l5 W- e" z, ~+ a5 j% C
12.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;          //开始倒数  
    1 c2 |5 A/ h& t7 M- c. P0 O
13.         do
    ' n" S5 o, V2 j2 I
14.         {
    
15.                 temp=SysTick->CTRL;
    ; |" V( F: v/ L
16.         }
    6 X" b2 m' }1 [3 C' i6 c
17.         while(temp&0x01&&!(temp&(1<<16)));//等待时间到达   
    
18.         SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;       //关闭计数器
    
19.         SysTick->VAL =0X00;       //清空计数器                     
    6 t6 R4 {! ]4 _+ F7 \( d
20. }
    

复制代码

在主函数中进行调用和初始化操作
" E0 T  f7 J8 |9 N* u# N% e
主函数的调用

4 V! \- E0 R0 L& K! Z

1. #include "stm32f10x.h"
   
2. #include "led.h"
   
3. #include "beep.h"
   + K* E: x9 q- t- v6 Q
4. #include "delay.h"
   : s# V/ H6 v! j1 j7 o
5. #include "sys.h"
   5 n2 T4 b. v- }7 J/ J: S
6. 
   + d  M" V9 E- s% s* u
7. int main(void)
   3 {6 Z5 o4 b# `* G! o
8. {
   $ J/ P" G2 H! x
9.         delay_init();                //延时函数初始化
   , H4 w9 f2 h1 m
10.          LED_Init();                        //LED端口初始化        
    
11.         BEEP_Init();        //初始化蜂鸣器端口
    
12.         
    & x( k3 O: D2 @5 @5 y
13.         while(1)
    
14.         {
    + S, K6 L* R  \2 B* k
15.                 LED1 = LEDON;
    5 c# g, f8 I  Z0 M& _/ d" w6 W. D
16.                 LED2 = LEDOFF;
    ! C3 W/ S/ ~5 B3 A6 y
17.                 LED3 = LEDOFF;
    
18.                 LED4 = LEDOFF;
    
19.                 LED5 = LEDOFF;
    & m; C5 G  }! L, v( N# N5 {
20.                 LED6 = LEDOFF;
    . O, H, {: \6 Q; |; _& `
21.                 LED7 = LEDOFF;
    
22.                 LED8 = LEDOFF;
    
23.                 BEEP = 1;
    
24.                 delay_ms(100);
    
25.                
    / |/ Z' Q9 T2 S' S9 D3 Y- p8 V* ?
26.                 LED1 = LEDOFF;
    & y6 N* B( T8 E" |% f# @/ S* b
27.                 LED2 = LEDON;
    4 G6 J3 r- ~2 G6 [
28.                 LED3 = LEDOFF;
    - L  W3 y" ^! M: [3 F
29.                 LED4 = LEDOFF;
    
30.                 BEEP = BEEPOFF;
    
31.                 LED5 = LEDOFF;
    
32.                 LED6 = LEDOFF;
    4 ^1 T' f' t( ~& ?  V
33.                 LED7 = LEDOFF;
    . I; a; v1 \+ S$ |
34.                 LED8 = LEDOFF;
    3 O' b7 h6 I1 D9 f
35.                 delay_ms(100);
    
36.                
    ( r2 ~, K6 }7 C4 g2 O
37.                 LED1 = LEDOFF;
    
38.                 LED2 = LEDOFF;
    
39.                 LED3 = LEDON;
    
40.                 LED4 = LEDOFF;
    
41.           LED5 = LEDOFF;
    " J/ Z- o5 V! y+ H& N) q) v& t6 Z' t$ L
42.                 LED6 = LEDOFF;
    + ?, p; [) C# Z+ O  ~9 F
43.                 LED7 = LEDOFF;
    + K- C& j0 w& Y7 V- y7 S
44.                 LED8 = LEDOFF;               
    ! P; f* N% x* y3 n
45.                 delay_ms(100);
    3 f7 n, s9 a  N& ]  R. ^
46.                
    
47.                 LED1 = LEDOFF;
    
48.                 LED2 = LEDOFF;
      P* o4 ^  V2 G! I
49.                 LED3 = LEDOFF;
    % t& A( T/ ]$ X
50.                 LED4 = LEDON;
    
51.                 LED5 = LEDOFF;
    
52.                 LED6 = LEDOFF;
    
53.                 LED7 = LEDOFF;
    
54.                 LED8 = LEDOFF;               
    
55.                 delay_ms(100);
    
56.                
    
57.                 LED1 = LEDOFF;
    
58.                 LED2 = LEDOFF;
    
59.                 LED3 = LEDOFF;
    4 w! K/ f) P5 o8 M
60.                 LED4 = LEDOFF;
    ) j8 y0 F) n- ~% H) b* t4 P+ W
61.                 LED5 = LEDON;
    
62.                 LED6 = LEDOFF;
    
63.                 LED7 = LEDOFF;
    4 S' p3 P; {9 X
64.                 LED8 = LEDOFF;
    
65.                 delay_ms(100);
    
66.                
    , g% Q' h- ~2 g
67.                 LED1 = LEDOFF;
    
68.                 LED2 = LEDOFF;
    , _& {* L* d$ `7 ^! ?4 \0 P
69.                 LED3 = LEDOFF;
    
70.                 LED4 = LEDOFF;
    2 C3 \$ E' t3 n/ M5 {& ?0 }
71.                 LED5 = LEDOFF;
    
72.                 LED6 = LEDON;
    
73.                 LED7 = LEDOFF;
    9 B: Y; a$ ^% p- Q) K
74.                 LED8 = LEDOFF;
    % s* T% `4 K4 A4 V: T9 M& a( b. I, b: r$ y
75.                 delay_ms(100);
    
76.                
    
77.                 LED1 = LEDOFF;
    
78.                 LED2 = LEDOFF;
    
79.                 LED3 = LEDOFF;
    ) H! c* C, q2 a/ y, C* p$ Q
80.                 LED4 = LEDOFF;
    9 e0 x; P1 D& u: U* T3 D, m$ m
81.                 LED5 = LEDOFF;
    2 Q5 b7 H- x" E# L2 }/ T
82.                 LED6 = LEDOFF;
    
83.                 LED7 = LEDON;
    8 N1 ~3 _, S( H" G" f) b) [
84.                 LED8 = LEDOFF;
    
85.                 delay_ms(100);
    2 J2 `8 y$ ]4 t) P( Q4 k
86.                
    
87.                 LED1 = LEDOFF;
    
88.                 LED2 = LEDOFF;
    ) y. l; R0 G: ^$ w
89.                 LED3 = LEDOFF;
    
90.                 LED4 = LEDOFF;
    ' ^9 P+ t7 _) f5 e, q
91.                 LED5 = LEDOFF;
    , ?5 |% x4 ]; O. |
92.                 LED6 = LEDOFF;
    / x7 N7 L, W8 a9 w( o+ m5 J  k
93.                 LED7 = LEDOFF;
    % }2 i+ A6 R8 Y% D
94.                 LED8 = LEDON;
    0 O! v2 w' h1 w% [+ `8 U# A7 r" W
95.                 delay_ms(100);
    
96.                
    ) j6 s5 R3 t- Q; F7 `4 u5 @' H
97.         }         
    4 W/ [+ h8 i4 }
98. }

复制代码

       主函数中写的其实是最简单理解的程序，也是很多初学者很容易编写出的程序。原理是依次让每个灯亮，每个灯之间添加延时函数，以实现流水的效果，具体延时多少看自己的个人爱好，想让它变化多快在延时函数里面实现。
4 E$ {1 L  F3 K3 [# u- d- p一下是实验的最终结果。其实还很好看。（在以后做东西的时候可以将流水灯加上去，效果很好看的，比如加在小车上，或者四轴飞行器上，这样的话看起来挺酷的！）
- U( j2 x1 ^1 N' }
一切都得从最基础开始，小的实验室为了以后做更大项目。
( G8 \8 n9 U: n  b2 I; S2 h
: h5 ]) Q. e. y! e
; \; L0 B+ t: x* I$ t. e' s) S& e
8 c- A# Y" t" ^; R
6 Z4 Q7 A+ V; M) `* `$ Z5 [; H

. Z" ?& y* W/ S