野火学习笔记(5) —— GPIO 输出—使用固件库点亮 LED

最新推荐文章于 2024-03-10 15:35:24 发布

没霖好叫咩

最新推荐文章于 2024-03-10 15:35:24 发布

阅读量4.2k

点赞数 2

分类专栏： STM32-固件库文章标签： stm32

本文链接：https://blog.csdn.net/small_ash/article/details/118676412

版权

STM32-固件库专栏收录该内容

15 篇文章 40 订阅

订阅专栏

文章目录

1. 硬件设计
2. 软件设计
3. STM32 标准库补充知识

1. 硬件设计

在本教程中 STM32 芯片与 LED 灯的连接见图 12-1，这是一个 RGB 灯，里面由红蓝绿三个小灯构成，使用 PWM 控制时可以混合成 256 不同的颜色。

在这里插入图片描述
图 12-1 LED 硬件原理图

这些 LED 灯的阴极都是连接到 STM32 的 GPIO 引脚，只要我们控制 GPIO 引脚的电平输出状态，即可控制 LED 灯的亮灭。若您使用的实验板 LED 灯的连接方式或引脚不一样，只需根据我们的工程修改引脚即可，程序的控制原理相同。

2. 软件设计

为了使工程更加有条理，我们把 LED 灯控制相关的代码独立分开存储，方便以后移植。在“工程模板”之上新建 “bsp_led.c” 及 “ bsp_led.h” 文件，其中的 “bsp” 即 Board Support Packet 的缩写(板级支持包)，这些文件也可根据您的喜好命名，这些文件不属于 STM32 标准库的内容，是由我们自己根据应用需要编写的。

2.1 编程要点

① 使能 GPIO 端口时钟；

② 初始化 GPIO 目标引脚为推挽输出模式；

③ 编写简单测试程序，控制 GPIO 引脚输出高、低电平。

2.2 代码分析

2.2.1 LED 灯引脚宏定义

在编写应用程序的过程中，要考虑更改硬件环境的情况，例如 LED 灯的控制引脚与当前的不一样，我们希望程序只需要做最小的修改即可在新的环境正常运行。这个时候一般把硬件相关的部分使用宏来封装，若更改了硬件环境，只修改这些硬件相关的宏即可，这些定义一般存储在头文件，即本例子中的 “bsp_led.h” 文件中，见代码清单 12-1。

代码清单 12-1 LED 控制引脚相关的宏

// R-红色
#define LED1_GPIO_PORT 	GPIOB
#define LED1_GPIO_CLK 	RCC_APB2Periph_GPIOB
#define LED1_GPIO_PIN 	GPIO_Pin_5
// G-绿色
#define LED2_GPIO_PORT 	GPIOB
#define LED2_GPIO_CLK 	RCC_APB2Periph_GPIOB
#define LED2_GPIO_PIN 	GPIO_Pin_0
// B-蓝色
#define LED3_GPIO_PORT 	GPIOB
#define LED3_GPIO_CLK 	RCC_APB2Periph_GPIOB
#define LED3_GPIO_PIN 	GPIO_Pin_1

以上代码分别把控制 LED 灯的 GPIO 端口、GPIO 引脚号以及 GPIO 端口时钟封装起来了。在实际控制的时候我们就直接用这些宏，以达到应用代码硬件无关的效果。

其中的 GPIO 时钟宏 “RCC_APB2Periph_GPIOB” 是 STM32 标准库定义的 GPIO 端口时钟相关的宏，它的作用与 “GPIO_Pin_x” 这类宏类似，是用于指示寄存器位的，方便库函数使用，下面初始化 GPIO 时钟的时候可以看到它的用法。

2.2.2 控制 LED 灯亮灭状态的宏定义

为了方便控制 LED 灯，我们把 LED 灯常用的亮、灭及状态反转的控制也直接定义成宏，见代码清单 12-2 。

代码清单 12-2 控制 LED 亮灭的宏

/* 直接操作寄存器的方法控制 IO */
#define digitalHi(p,i) 		{p->BSRR=i;} 	//输出为高电平
#define digitalLo(p,i) 		{p->BRR=i;} 	//输出低电平
#define digitalToggle(p,i) 	{p->ODR ^=i;} 	//输出反转状态

/* 定义控制 IO 的宏 */
#define LED1_TOGGLE 		digitalToggle(LED1_GPIO_PORT,LED1_GPIO_PIN)
#define LED1_OFF 			digitalHi(LED1_GPIO_PORT,LED1_GPIO_PIN)
#define LED1_ON 			digitalLo(LED1_GPIO_PORT,LED1_GPIO_PIN)

#define LED2_TOGGLE 		digitalToggle(LED2_GPIO_PORT,LED2_GPIO_PIN)
#define LED2_OFF 			digitalHi(LED2_GPIO_PORT,LED2_GPIO_PIN)
#define LED2_ON 			digitalLo(LED2_GPIO_PORT,LED2_GPIO_PIN)

#define LED3_TOGGLE 		digitalToggle(LED2_GPIO_PORT,LED3_GPIO_PIN)
#define LED3_OFF 			digitalHi(LED2_GPIO_PORT,LED3_GPIO_PIN)
#define LED3_ON 			digitalLo(LED2_GPIO_PORT,LED3_GPIO_PIN)

/* 基本混色，后面高级用法使用 PWM 可混出全彩颜色,且效果更好 */

//红
#define LED_RED \
				LED1_ON;\
				LED2_OFF\
				LED3_OFF

//绿
#define LED_GREEN \
				LED1_OFF;\
				LED2_ON\
				LED3_OFF
				
//蓝				
#define LED_BLUE \				
				LED1_OFF;\
				LED2_OFF\
                LED3_ON
                    
//黄(红+绿)     
#define LED_YELLOW \
				LED1_ON;\
				LED2_ON\
				LED3_OFF
                    
//紫(红+蓝)
#define LED_PURPLE \ 
                LED1_ON;\
                LED2_OFF\
                LED3_ON
                    
//青(绿+蓝)
#define LED_CYAN \
				LED1_OFF;\
				LED2_ON\
				LED3_ON
                    
//白(红+绿+蓝)
#define LED_WHITE \
                LED1_ON;\.
                LED2_ON\
                LED3_ON
                    
//黑(全部关闭)
#define LED_RGBOFF \
				LED1_OFF;\
				LED2_OFF\
				LED3_OFF

这部分宏控制 LED 亮灭的操作是直接向 BSRR、BRR 和 ODR 这三个寄存器写入控制指令来实现的，对 BSRR 写 1 输出高电平，对 BRR 写 1 输出低电平，对 ODR 寄存器某位进行异或操作可反转位的状态。

RGB 彩灯可以实现混色，如最后一段代码我们控制红灯和绿灯亮而蓝灯灭，可混出黄色效果。

代码中的 “\” 是 C 语言中的续行符语法，表示续行符的下一行与续行符所在的代码是同一行。代码中因为宏定义关键字“#define”只是对当前行有效，所以我们使用续行符来连接起来，以下的代码是等效的：

#define LED_YELLOW	LED1_ON; LED2_ON; LED3_OFF

应用续行符的时候要注意，在 “\” 后面不能有任何字符(包括注释、空格)，只能直接回车。

2.2.3 LED GPIO 初始化函数

利用上面的宏，编写 LED 灯的初始化函数，见代码清单 12-3 。

代码清单 12-3 LED GPIO 初始化函数

void LED_GPIO_Config(void)
{
    /*定义一个 GPIO_InitTypeDef 类型的结构体*/
    GPIO_InitTypeDef GPIO_InitStructure;
    
    /*开启 LED 相关的 GPIO 外设时钟*/
    RCC_APB2PeriphClockCmd( LED1_GPIO_CLK|
                           	LED2_GPIO_CLK|
                           	LED3_GPIO_CLK, ENABLE);
    
    /*选择要控制的 GPIO 引脚*/
    GPIO_InitStructure.GPIO_Pin = LED1_GPIO_PIN;
    /*设置引脚模式为通用推挽输出*/
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    /*设置引脚速率为 50MHz */
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    /*调用库函数，初始化 GPIO*/
    GPIO_Init(LED1_GPIO_PORT, &GPIO_InitStructure);
    
    /*选择要控制的 GPIO 引脚*/
    GPIO_InitStructure.GPIO_Pin = LED2_GPIO_PIN;
    /*调用库函数，初始化 GPIO*/
    GPIO_Init(LED2_GPIO_PORT, &GPIO_InitStructure);
    
    /*选择要控制的 GPIO 引脚*/
    GPIO_InitStructure.GPIO_Pin = LED3_GPIO_PIN;
    /*调用库函数，初始化 GPIOF*/
    GPIO_Init(LED3_GPIO_PORT, &GPIO_InitStructure);
    
    /* 关闭所有 led 灯 */
    GPIO_SetBits(LED1_GPIO_PORT, LED1_GPIO_PIN);
    /* 关闭所有 led 灯 */
    GPIO_SetBits(LED2_GPIO_PORT, LED2_GPIO_PIN);
    /* 关闭所有 led 灯 */
    GPIO_SetBits(LED3_GPIO_PORT, LED3_GPIO_PIN);
}

整个函数与“构建库函数雏形”章节中的类似，主要区别是硬件相关的部分使用宏来代替，初始化 GPIO 端口时钟时也采用了 STM32 库函数，函数执行流程如下：

使用 GPIO_InitTypeDef 定义 GPIO 初始化结构体变量，以便下面用于存储 GPIO 配置。
调用库函数 RCC_APB2PeriphClockCmd 来使能 LED 灯的 GPIO 端口时钟，在前面的章节中我们是直接向 RCC 寄存器赋值来使能时钟的，不如这样直观。该函数有两个输入参数，第一个参数用于指示要配置的时钟，如本例中的 “RCC_ APB2Periph_GPIOB” ，应用时我们使用 “|” 操作同时配置 3 个 LED 灯的时钟；函数的第二个参数用于设置状态，可输入 “Disable” 关闭或 “Enable” 使能时钟。
向 GPIO 初始化结构体赋值，把引脚初始化成推挽输出模式，其中的 GPIO_Pin 使用宏 “LEDx_GPIO_PIN” 来赋值，使函数的实现方便移植。
使用以上初始化结构体的配置，调用 GPIO_Init 函数向寄存器写入参数，完成 GPIO 的初始化，这里的 GPIO 端口使用 “LEDx_GPIO_PORT” 宏来赋值，也是为了程序移植方便。
使用同样的初始化结构体，只修改控制的引脚和端口，初始化其它 LED 灯使用的 GPIO 引脚。

使用宏控制 RGB 灯默认关闭。

2.2.4 主函数

编写完 LED 灯的控制函数后，就可以在 main 函数中测试了，见代码清单 12-4。

代码清单 12-4 控制 LED 灯， main 文件

#include "stm32f10x.h"
#include "./led/bsp_led.h"

#define SOFT_DELAY Delay(0x0FFFFF);

void Delay(__IO u32 nCount);

/**
	* @brief 主函数
	* @param 无
	* @retval 无
*/
int main(void)
{
    /* LED 端口初始化 */
    LED_GPIO_Config();
    
    while (1)
    {
        LED1_ON; // 亮
        SOFT_DELAY;
        LED1_OFF; // 灭
        
        LED2_ON; // 亮
        SOFT_DELAY;
        LED2_OFF; // 灭
        
        LED3_ON; // 亮
        SOFT_DELAY;
        LED3_OFF; // 灭
        
        /*轮流显示 红绿蓝黄紫青白 颜色*/
        LED_RED;
        SOFT_DELAY;
        
        LED_GREEN;
        SOFT_DELAY;
        
        LED_BLUE;
        SOFT_DELAY;
        
        LED_YELLOW;
        SOFT_DELAY;
        
        LED_PURPLE;
        SOFT_DELAY;
        
        LED_CYAN;
        SOFT_DELAY;
        
        LED_WHITE;
        SOFT_DELAY;
        
        LED_RGBOFF;
        SOFT_DELAY;
    }
}

void Delay(__IO uint32_t nCount) //简单的延时函数
{
    for (; nCount != 0; nCount--);
}

在 main 函数中，调用我们前面定义的 LED_GPIO_Config 初始化好 LED 的控制引脚，然后直接调用各种控制 LED 灯亮灭的宏来实现 LED 灯的控制。

以上，就是一个使用 STM32 标准软件库开发应用的流程。

2.2.5 文件整理

bsp_led.h

#ifndef __LED_H
#define	__LED_H


#include "stm32f10x.h"


/* 定义LED连接的GPIO端口, 用户只需要修改下面的代码即可改变控制的LED引脚 */
// R-红色
#define LED1_GPIO_PORT    	GPIOB			              /* GPIO端口 */
#define LED1_GPIO_CLK 	    RCC_APB2Periph_GPIOB		/* GPIO端口时钟 */
#define LED1_GPIO_PIN		GPIO_Pin_5			        /* 连接到SCL时钟线的GPIO */

// G-绿色
#define LED2_GPIO_PORT    	GPIOB			              /* GPIO端口 */
#define LED2_GPIO_CLK 	    RCC_APB2Periph_GPIOB		/* GPIO端口时钟 */
#define LED2_GPIO_PIN		GPIO_Pin_0			        /* 连接到SCL时钟线的GPIO */

// B-蓝色
#define LED3_GPIO_PORT    	GPIOB			              /* GPIO端口 */
#define LED3_GPIO_CLK 	    RCC_APB2Periph_GPIOB		/* GPIO端口时钟 */
#define LED3_GPIO_PIN		GPIO_Pin_1			        /* 连接到SCL时钟线的GPIO */


/** the macro definition to trigger the led on or off 
  * 1 - off
  *0 - on
  */
#define ON  0
#define OFF 1

/* 使用标准的固件库控制IO*/
#define LED1(a)	if (a)	\
					GPIO_SetBits(LED1_GPIO_PORT,LED1_GPIO_PIN);\
					else		\
					GPIO_ResetBits(LED1_GPIO_PORT,LED1_GPIO_PIN)

#define LED2(a)	if (a)	\
					GPIO_SetBits(LED2_GPIO_PORT,LED2_GPIO_PIN);\
					else		\
					GPIO_ResetBits(LED2_GPIO_PORT,LED2_GPIO_PIN)

#define LED3(a)	if (a)	\
					GPIO_SetBits(LED3_GPIO_PORT,LED3_GPIO_PIN);\
					else		\
					GPIO_ResetBits(LED3_GPIO_PORT,LED3_GPIO_PIN)


/* 直接操作寄存器的方法控制IO */
#define	digitalHi(p,i)		 {p->BSRR=i;}	 //输出为高电平		
#define digitalLo(p,i)		 {p->BRR=i;}	 //输出低电平
#define digitalToggle(p,i) 	 {p->ODR ^=i;} 	 //输出反转状态


/* 定义控制IO的宏 */
#define LED1_TOGGLE		 	digitalToggle(LED1_GPIO_PORT,LED1_GPIO_PIN)
#define LED1_OFF		    digitalHi(LED1_GPIO_PORT,LED1_GPIO_PIN)
#define LED1_ON			    digitalLo(LED1_GPIO_PORT,LED1_GPIO_PIN)

#define LED2_TOGGLE		 	digitalToggle(LED2_GPIO_PORT,LED2_GPIO_PIN)
#define LED2_OFF		    digitalHi(LED2_GPIO_PORT,LED2_GPIO_PIN)
#define LED2_ON			    digitalLo(LED2_GPIO_PORT,LED2_GPIO_PIN)

#define LED3_TOGGLE		 	digitalToggle(LED3_GPIO_PORT,LED3_GPIO_PIN)
#define LED3_OFF		    digitalHi(LED3_GPIO_PORT,LED3_GPIO_PIN)
#define LED3_ON			    digitalLo(LED3_GPIO_PORT,LED3_GPIO_PIN)

/* 基本混色，后面高级用法使用PWM可混出全彩颜色,且效果更好 */

//红
#define LED_RED  \
					LED1_ON;\
					LED2_OFF\
					LED3_OFF

//绿
#define LED_GREEN		\
					LED1_OFF;\
					LED2_ON\
					LED3_OFF

//蓝
#define LED_BLUE	\
					LED1_OFF;\
					LED2_OFF\
					LED3_ON

					
//黄(红+绿)					
#define LED_YELLOW	\
					LED1_ON;\
					LED2_ON\
					LED3_OFF
//紫(红+蓝)
#define LED_PURPLE	\
					LED1_ON;\
					LED2_OFF\
					LED3_ON

//青(绿+蓝)
#define LED_CYAN \
					LED1_OFF;\
					LED2_ON\
					LED3_ON
					
//白(红+绿+蓝)
#define LED_WHITE	\
					LED1_ON;\
					LED2_ON\
					LED3_ON
					
//黑(全部关闭)
#define LED_RGBOFF	\
					LED1_OFF;\
					LED2_OFF\
					LED3_OFF

void LED_GPIO_Config(void);

#endif /* __LED_H */

bsp_led.c

#include "bsp_led.h"   

 /**
  * @brief  初始化控制LED的IO
  * @param  无
  * @retval 无
  */
void LED_GPIO_Config(void)
{		
		/*定义一个GPIO_InitTypeDef类型的结构体*/
		GPIO_InitTypeDef GPIO_InitStructure;

		/*开启LED相关的GPIO外设时钟*/
		RCC_APB2PeriphClockCmd( LED1_GPIO_CLK | LED2_GPIO_CLK | LED3_GPIO_CLK, ENABLE);
		/*选择要控制的GPIO引脚*/
		GPIO_InitStructure.GPIO_Pin = LED1_GPIO_PIN;	

		/*设置引脚模式为通用推挽输出*/
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   

		/*设置引脚速率为50MHz */   
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 

		/*调用库函数，初始化GPIO*/
		GPIO_Init(LED1_GPIO_PORT, &GPIO_InitStructure);	
		
		/*选择要控制的GPIO引脚*/
		GPIO_InitStructure.GPIO_Pin = LED2_GPIO_PIN;

		/*调用库函数，初始化GPIO*/
		GPIO_Init(LED2_GPIO_PORT, &GPIO_InitStructure);
		
		/*选择要控制的GPIO引脚*/
		GPIO_InitStructure.GPIO_Pin = LED3_GPIO_PIN;

		/*调用库函数，初始化GPIOF*/
		GPIO_Init(LED3_GPIO_PORT, &GPIO_InitStructure);

		/* 关闭所有led灯	*/
		GPIO_SetBits(LED1_GPIO_PORT, LED1_GPIO_PIN);
		
		/* 关闭所有led灯	*/
		GPIO_SetBits(LED2_GPIO_PORT, LED2_GPIO_PIN);	 
    
    /* 关闭所有led灯	*/
		GPIO_SetBits(LED3_GPIO_PORT, LED3_GPIO_PIN);
}

main.c

#include "stm32f10x.h"
#include "bsp_led.h"

#define SOFT_DELAY Delay(0x0FFFFF);

void Delay(__IO u32 nCount); 

/**
  * @brief  主函数
  * @param  无  
  * @retval 无
  */
int main(void)
{	
	/* LED 端口初始化 */
	LED_GPIO_Config();	 

	while (1)
	{
		LED1_ON;			  // 亮
		SOFT_DELAY;
		LED1_OFF;		   // 灭

		LED2_ON;			 // 亮
		SOFT_DELAY;
		LED2_OFF;		   // 灭

		LED3_ON;			 // 亮
		SOFT_DELAY;
		LED3_OFF;		   // 灭	 

		/*轮流显示 红绿蓝黄紫青白 颜色*/
		LED_RED;
		SOFT_DELAY;
		
		LED_GREEN;
		SOFT_DELAY;
		
		LED_BLUE;
		SOFT_DELAY;
		
		LED_YELLOW;
		SOFT_DELAY;
		
		LED_PURPLE;
		SOFT_DELAY;
				
		LED_CYAN;
		SOFT_DELAY;
		
		LED_WHITE;
		SOFT_DELAY;
		
		LED_RGBOFF;
		SOFT_DELAY;		
	}
}

void Delay(__IO uint32_t nCount)	 //简单的延时函数
{
	for(; nCount != 0; nCount--);
}

后面了解一下就好

3. STM32 标准库补充知识

3.1 SystemInit 函数去哪了？

在前面章节中我们自己建工程的时候需要定义一个 SystemInit 空函数，但是在这个用 STM32 标准库的工程却没有这样做， SystemInit 函数去哪了呢？

这个函数在 STM32 标准库的 “system_stm32f10x.c” 文件中定义了，而我们的工程已经包含该文件。标准库中的 SystemInit 函数把 STM32 芯片的系统时钟设置成了 72MHz，即此时 AHB 时钟频率为 72MHz， APB2 为 72MHz， APB1 为 36MHz。当 STM32 芯片上电后，执行启动文件中的指令后，会调用该函数，设置系统时钟为以上状态。

3.2 断言

细心对比过前几章我们自己定义的 GPIO_Init 函数与 STM32 标准库中同名函数的读者，会发现标准库中的函数内容多了一些乱七八糟的东西，就是断言，具体见代码清单 12-5 。

void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct)
{
    uint32_t pinpos = 0x00, pos = 0x00 , currentpin = 0x00;
    
    /* Check the parameters */
    assert_param(IS_GPIO_ALL_PERIPH(GPIOx));
    assert_param(IS_GPIO_MODE(GPIO_InitStruct->GPIO_Mode));
    assert_param(IS_GPIO_PIN(GPIO_InitStruct->GPIO_Pin));
    
    /* ------- 以下内容省略，跟前面我们定义的函数内容相同----- */
}

基本上每个库函数的开头都会有这样类似的内容，这里的“assert_param”实际是一个宏，在库函数中它用于检查输入参数是否符合要求，若不符合要求则执行某个函数输出警告，“assert_param” 的定义见代码清单 12-6。

代码清单 12-6 stm32f4xx_conf.h 文件中关于断言的定义

#ifdef USE_FULL_ASSERT
/**
	* @brief assert_param 宏用于函数的输入参数检查
	* @param expr:若 expr 值为假， 则调用 assert_failed 函数
	* 报告文件名及错误行号
	* 若 expr 值为真，则不执行操作
*/
#define assert_param(expr) \
		((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
/* 错误输出函数 ------------------------------------------------------- */
void assert_failed(uint8_t* file, uint32_t line);
#else
#define assert_param(expr) ((void)0)
#endif

这段代码的意思是，假如我们不定义 “USE_FULL_ASSERT” 宏，那么 “assert_param” 就是一个空的宏( #else 与 #endif 之间的语句生效)，没有任何操作。从而所有库函数中的 assert_param 实际上都无意义，我们就当看不见好了。

假如我们定义了 “USE_FULL_ASSERT” 宏，那么 “assert_param” 就是一个有操作的语句( #if 与 #else 之间的语句生效)，该宏对参数 expr 使用 C 语言中的问号表达式进行判断，若 expr 值为真，则无操作 (void 0) ，若表达式的值为假，则调用 “assert_failed” 函数，且该函数的输入参数为 “FILE” 及 “LINE” ，这两个参数分别代表 “assert_param” 宏被调用时所在的“文件名”及“行号”。

但库文件只对 “assert_failed” 写了函数声明，没有写函数定义，实际用时需要用户来定义，我们一般会用 printf 函数来输出这些信息，见代码清单 12-7 。

代码清单 12-7 assert_failed 输出错误信息

void assert_failed(uint8_t* file, uint32_t line)
{    
	void assert_failed(uint8_t* file, uint32_t line);
}

注意在我们的这个 LED 工程中，还不支持 printf 函数(在 USART 外设章节会讲解)，想测试 assert_failed 输出的读者，可以在这个函数中做点亮红色 LED 灯的操作，作为警告输出测试。

那么为什么函数输入参数不对的时候， assert_param 宏中的 expr 参数值会是假呢？这要回到 GPIO_Init 函数，看它对 assert_param 宏的调用，它被调用时分别以 “IS_GPIO_ALL_PERIPH(GPIOx)” 、 “IS_GPIO_PIN(GPIO_InitStruct->GPIO_Pin)” 等作为输入参数，也就是说被调用时， expr 实际上是一条针对输入参数的判断表达式。例如 “IS_GPIO_PIN” 的宏定义：

#define IS_GPIO_PIN(PIN) ((PIN) != (uint32_t)0x00)

若它的输入参数 PIN 值为 0，则表达式的值为假， PIN 非 0 时表达式的值为真。我们知道用于选择 GPIO 引脚号的宏 “GPIO_Pin_x” 的值至少有一个数据位为 1，这样的输入参数才有意义，若 GPIO_InitStruct->GPIO_Pin 的值为 0，输入参数就无效了。配合 “IS_GPIO_PIN” 这句表达式，“assert_param” 就实现了检查输入参数的功能。对 assert_param 宏的其它调用方式类似，大家可以自己看库源码来研究一下。

3.3 Doxygen 注释规范

在 STM32 标准库以及我们自己编写的 “bsp_led.c” 文件中，可以看到一些比较特别的注释，类似代码清单 12-8 。

代码清单 12-8 Doxygen 注释规范

/**	
	* @brief 初始化控制 LED 的 IO	
	* @param 无	
	* @retval 无
*/

这是一种名为 “Doxygen” 的注释规范，如果在工程文件中按照这种规范去注释，可以使用 Doxygen 软件自动根据注释生成帮助文档。我们所说非常重要的库帮助文档《stm32f10x_stdperiph_lib_um.chm》，就是由该软件根据库文件的注释生成的。关于 Doxygen 注释规范本教程不作讲解，感兴趣的读者可自行搜索网络上的资料学习。

3.4 防止头文件重复包含

在 STM32 标准库的所有头文件以及我们自己编写的 “bsp_led.h” 头文件中，可看到类似代码清单 12-9 的宏定义。它的功能是防止头文件被重复包含，避免引起编译错误。

代码清单 12-9 防止头文件重复包含的宏

#ifndef __LED_H
#define __LED_H

/*此处省略头文件的具体内容*/

#endif /* end of __LED_H */

在头文件的开头，使用 “#ifndef” 关键字，判断标号 “__LED_H” 是否被定义，若没有被定义，则从 “#ifndef” 至 “#endif” 关键字之间的内容都有效，也就是说，这个头文件若被其它文件 “#include” ，它就会被包含到其该文件中了，且头文件中紧接着使用 “#define” 关键字定义上面判断的标号 “__LED_H” 。当这个头文件被同一个文件第二次 “#include” 包含的时候，由于有了第一次包含中的 “#define __LED_H” 定义，这时再判断 “#ifndef __LED_H” ，判断的结果就是假了，从 “#ifndef” 至 “#endif” 之间的内容都无效，从而防止了同一个头文件被包含多次，编译时就不会出现 “redefine（重复定义）” 的错误了。

一般来说，我们不会直接在 C 的源文件写两个 “#include” 来包含同一个头文件，但可能因为头文件内部的包含导致重复，这种代码主要是避免这样的问题。如 “ bsp_led.h” 文件中使用了 “ #include ―stm32f10x.h‖ ” 语句，按习惯，可能我们写主程序的时候会在 main 文件写 “#include ―bsp_led.h‖ 及 #include ―stm32f10x.h‖” ，这个时候 “stm32f10x.h” 文件就被包含两次了，如果没有这种机制，就会出错。

至于为什么要用两个下划线来定义 “__LED_H” 标号，其实这只是防止它与其它普通宏定义重复了，如我们用 “GPIO_PIN_0” 来代替这个判断标号，就会因为 stm32f10x.h 已经定义了 GPIO_PIN_0，结果导致 “bsp_led.h” 文件无效了， “bsp_led.h” 文件一次都没被包含。

摘抄自：
[野火EmbedFire]《STM32库开发实战指南——基于野火霸道开发板》.pdf