这几天打算复**stm32有关的硬件资源，就想着从最开始做起，熟悉下当初所学的知识。学习stm32最初都基本是从流水灯开始的，今天就开始点亮流水灯。

首先，必须明白流水灯的硬件原理，以下是原理图：



它由8个管脚控制，因此首先必须进行初始化8个引脚。

1. //初始化PE8...PE15为输出口.并使能这八个口的时钟                    
   
2. //LED IO初始化
   
3. void LED_Init(void)
   
4. {
   
5. 
   
6.         GPIO_InitTypeDef  GPIO_InitStructure;
   
7. 
   
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 端口配置
    
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
    
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. 
    
16. }

复制代码

这样就实现了流水灯管脚初始化的操作，剩下的操作只需要在主函数中进行相应的调用操作即可完成。
为了使程序更加完美，加入了蜂鸣器的初始化，流水灯亮的同时蜂鸣器响。

1. <span style="font-size:14px;"><strong>//初始化PB5为输出口.并使能这个口的时钟                    
   
2. //蜂鸣器初始化
   
3. void BEEP_Init(void)
   
4. {
   
5.         GPIO_InitTypeDef  GPIO_InitStructure;
   
6. 
   
7.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);         //使能GPIOB端口时钟
   
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
    
12.         GPIO_Init(GPIOB, &GPIO_InitStructure);                                         //根据参数初始化GPIOB.5
    
13. 
    
14.         GPIO_ResetBits(GPIOB,GPIO_Pin_5);                                                //输出0，关闭蜂鸣器输出
    
15. }</strong></span>

复制代码

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

1. <span style="font-size:14px;">//初始化延迟函数
   
2. //SYSTICK的时钟固定为HCLK时钟的1/8
   
3. //SYSCLK:系统时钟
   
4. void delay_init()         
   
5. {
   
6.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);        //选择外部时钟  HCLK/8
   
7.         fac_us=SystemCoreClock/8000000;        //为系统时钟的1/8  
   
8.          
   
9.         fac_ms=(u16)fac_us*1000;//非ucos下,代表每个ms需要的systick时钟数   
   
10. }</span>

复制代码

毫秒函数初始化

1. //延时nms
   
2. //注意nms的范围
   
3. //SysTick->LOAD为24位寄存器,所以,最大延时为:
   
4. //nms<=0xffffff*8*1000/SYSCLK
   
5. //SYSCLK单位为Hz,nms单位为ms
   
6. //对72M条件下,nms<=1864
   
7. void delay_ms(u16 nms)
   
8. {                                    
   
9.         u32 temp;                  
   
10.         SysTick->LOAD=(u32)nms*fac_ms;//时间加载(SysTick->LOAD为24bit)
    
11.         SysTick->VAL =0x00;           //清空计数器
    
12.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;          //开始倒数  
    
13.         do
    
14.         {
    
15.                 temp=SysTick->CTRL;
    
16.         }
    
17.         while(temp&0x01&&!(temp&(1<<16)));//等待时间到达   
    
18.         SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;       //关闭计数器
    
19.         SysTick->VAL =0X00;       //清空计数器                     
    
20. }
    

复制代码

在主函数中进行调用和初始化操作

主函数的调用

1. #include "stm32f10x.h"
   
2. #include "led.h"
   
3. #include "beep.h"
   
4. #include "delay.h"
   
5. #include "sys.h"
   
6. 
   
7. int main(void)
   
8. {
   
9.         delay_init();                //延时函数初始化
   
10.          LED_Init();                        //LED端口初始化        
    
11.         BEEP_Init();        //初始化蜂鸣器端口
    
12.         
    
13.         while(1)
    
14.         {
    
15.                 LED1 = LEDON;
    
16.                 LED2 = LEDOFF;
    
17.                 LED3 = LEDOFF;
    
18.                 LED4 = LEDOFF;
    
19.                 LED5 = LEDOFF;
    
20.                 LED6 = LEDOFF;
    
21.                 LED7 = LEDOFF;
    
22.                 LED8 = LEDOFF;
    
23.                 BEEP = 1;
    
24.                 delay_ms(100);
    
25.                
    
26.                 LED1 = LEDOFF;
    
27.                 LED2 = LEDON;
    
28.                 LED3 = LEDOFF;
    
29.                 LED4 = LEDOFF;
    
30.                 BEEP = BEEPOFF;
    
31.                 LED5 = LEDOFF;
    
32.                 LED6 = LEDOFF;
    
33.                 LED7 = LEDOFF;
    
34.                 LED8 = LEDOFF;
    
35.                 delay_ms(100);
    
36.                
    
37.                 LED1 = LEDOFF;
    
38.                 LED2 = LEDOFF;
    
39.                 LED3 = LEDON;
    
40.                 LED4 = LEDOFF;
    
41.           LED5 = LEDOFF;
    
42.                 LED6 = LEDOFF;
    
43.                 LED7 = LEDOFF;
    
44.                 LED8 = LEDOFF;               
    
45.                 delay_ms(100);
    
46.                
    
47.                 LED1 = LEDOFF;
    
48.                 LED2 = LEDOFF;
    
49.                 LED3 = LEDOFF;
    
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;
    
60.                 LED4 = LEDOFF;
    
61.                 LED5 = LEDON;
    
62.                 LED6 = LEDOFF;
    
63.                 LED7 = LEDOFF;
    
64.                 LED8 = LEDOFF;
    
65.                 delay_ms(100);
    
66.                
    
67.                 LED1 = LEDOFF;
    
68.                 LED2 = LEDOFF;
    
69.                 LED3 = LEDOFF;
    
70.                 LED4 = LEDOFF;
    
71.                 LED5 = LEDOFF;
    
72.                 LED6 = LEDON;
    
73.                 LED7 = LEDOFF;
    
74.                 LED8 = LEDOFF;
    
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;
    
84.                 LED8 = LEDOFF;
    
85.                 delay_ms(100);
    
86.                
    
87.                 LED1 = LEDOFF;
    
88.                 LED2 = LEDOFF;
    
89.                 LED3 = LEDOFF;
    
90.                 LED4 = LEDOFF;
    
91.                 LED5 = LEDOFF;
    
92.                 LED6 = LEDOFF;
    
93.                 LED7 = LEDOFF;
    
94.                 LED8 = LEDON;
    
95.                 delay_ms(100);
    
96.                
    
97.         }         
    
98. }

复制代码

       主函数中写的其实是最简单理解的程序，也是很多初学者很容易编写出的程序。原理是依次让每个灯亮，每个灯之间添加延时函数，以实现流水的效果，具体延时多少看自己的个人爱好，想让它变化多快在延时函数里面实现。
一下是实验的最终结果。其实还很好看。（在以后做东西的时候可以将流水灯加上去，效果很好看的，比如加在小车上，或者四轴飞行器上，这样的话看起来挺酷的！）

一切都得从最基础开始，小的实验室为了以后做更大项目。