创建自己的函数库

创建自己的函数库

  • 前言
  • 一、什么是STM32标准函数库
    • 1.定义:
    • 2.作用:
    • 3.对比:
  • 二、构建库函数
    • 1.修改寄存器地址封装
    • 2.定义访问的结构体指针和引脚
    • 3.创建封装函数
      • 3.1创建拉低引脚函数
      • 3.2创建引脚初始化函数
  • 总结


前言

回顾一下,前面点亮led灯我们都进行了哪些操作。

首先需要看电路图,然后找到led灯的控制引脚,然后了解了控制引脚的方法是通过操作相应的物理地址,接着知道了可以映射物理地址也就是寄存器,通过寄存器来去配置,最后我们通过去查找芯片手册,了解各个寄存器的功能,对需要的寄存器进行配置,实现点亮led灯的功能。

到这里,我们成功将一大串的地址转化成可读性更好的寄存器,但是寄存器的操作相对于大部分人来说仍然是太复杂,大部分人只需要点亮灯,并不想知道它需要用到哪些寄存器,更不想去进行复杂的位操作,大家更希望能将寄存器的这些功能再一次进行封装打包,最好是进行一些简单的传参就可以将这个引脚配置好,所以库函数诞生了。库函数的作用,就是将寄存器根据其功能封装成一个个更加易于调用的函数接口,从而使代码的开发效率更高,可读性更好,更加易于维护。


一、什么是STM32标准函数库

1.定义:

他是ST公司针对stm32设计的一系列函数接口,即API(Application Program Interface)。

2.作用:

让开发者可调用这些函数接口来配置 STM32的寄存器,使开发人员得以脱离最底层的寄存器操作。
创建自己的函数库_第1张图片

3.对比:

直接代码对比,第一个main函数和第二个main函数所实现的功能是一样的,但是第一个无论是否是开发者本人,都能很清楚明白的看明白代码在干嘛。而第二个main函数,只怕是开发者本人,时间长了也要回头挨条去查一下自己配置这些是在干嘛,一对比,高下立现。

int main(void)
{	
	led_init();
	LED_RED=ON;
	while(1);
}
int main(void)
{	

	RCC_AHB1ENR |= (1<<7);	

	GPIOH_MODER  &= ~( 0x03<< (2*10));	

	GPIOH_MODER |= (1<<2*10);
	
	GPIOH_OTYPER &= ~(1<<1*10);

	GPIOH_OTYPER |= (0<<1*10);
	
	GPIOH_OSPEEDR &= ~(0x03<<2*10);

	GPIOH_OSPEEDR |= (0<<2*10);
	
	GPIOH_PUPDR &= ~(0x03<<2*10);

	GPIOH_PUPDR |= (1<<2*10);
	
	GPIOH_BSRR |= (1<<16<<10);

	while(1);}

到这里,想说的话已经基本说完,后面的构建自己函数库,是否能搞懂其实并不重要,你只需要会用官方固件库即可。对于新手来说,我觉得一定要注意的是:所有的一切是围绕着目标去展开。 无论是地址,还是寄存器,亦或是库函数,都只是我们控制单片机的手段,能把这些全搞懂,很好很牛;只懂库函数操作去完成目标,也很好很牛。

二、构建库函数

1.修改寄存器地址封装

首先我们要知道,寄存器地址是基于物理地址的偏移地址,他们是连续的,和结构体的成员变量关系类似,所以我们可以通过结构体的形势来进行封装,将寄存器映射为结构体变量,再通过结构体变量,宏定义等方式来实现可读性的提升。

代码如下(示例):

1 //volatile 表示易变的变量,防止编译器优化
2 #define __IO volatile
3 typedef unsigned int uint32_t;
4 typedef unsigned short uint16_t;
5 
6 /* GPIO 寄存器列表 */
7 typedef struct {
8 __IO uint32_t MODER; /*GPIO 模式寄存器 地址偏移: 0x00 */
9 __IO uint32_t OTYPER; /*GPIO 输出类型寄存器 地址偏移: 0x04 */
10 __IO uint32_t OSPEEDR; /*GPIO 输出速度寄存器 地址偏移: 0x08 */
11 __IO uint32_t PUPDR; /*GPIO 上拉/下拉寄存器 地址偏移: 0x0C */
12 __IO uint32_t IDR; /*GPIO 输入数据寄存器 地址偏移: 0x10 */
13 __IO uint32_t ODR; /*GPIO 输出数据寄存器 地址偏移: 0x14 */
14 __IO uint16_t BSRRL; /*GPIO 置位/复位寄存器低 16 位部分 地址偏移: 0x18 */
15 __IO uint16_t BSRRH; /*GPIO 置位/复位寄存器 高 16 位部分地址偏移: 0x1A */
16 __IO uint32_t LCKR; /*GPIO 配置锁定寄存器 地址偏移: 0x1C */
17 __IO uint32_t AFR[2]; /*GPIO 复用功能配置寄存器 地址偏移: 0x20-0x24 */
18 } GPIO_TypeDef;
19 
20 /*RCC 寄存器列表*/
21 typedef struct {
22 __IO uint32_t CR; /*!< RCC 时钟控制寄存器,地址偏移: 0x00 */
23 __IO uint32_t PLLCFGR; /*!< RCC PLL 配置寄存器,地址偏移: 0x04 */
24 __IO uint32_t CFGR; /*!< RCC 时钟配置寄存器,地址偏移: 0x08 */
25 __IO uint32_t CIR; /*!< RCC 时钟中断寄存器,地址偏移: 0x0C */
26 __IO uint32_t AHB1RSTR; /*!< RCC AHB1 外设复位寄存器,地址偏移: 0x10 */
27 __IO uint32_t AHB2RSTR; /*!< RCC AHB2 外设复位寄存器,地址偏移: 0x14 */
28 __IO uint32_t AHB3RSTR; /*!< RCC AHB3 外设复位寄存器,地址偏移: 0x18 */
29 __IO uint32_t RESERVED0; /*!< 保留, 地址偏移:0x1C */
30 __IO uint32_t APB1RSTR; /*!< RCC APB1 外设复位寄存器,地址偏移: 0x20 */
31 __IO uint32_t APB2RSTR; /*!< RCC APB2 外设复位寄存器,地址偏移: 0x24*/
32 __IO uint32_t RESERVED1[2]; /*!< 保留,地址偏移:0x28-0x2C*/
33 __IO uint32_t AHB1ENR; /*!< RCC AHB1 外设时钟寄存器,地址偏移: 0x30 */
34 __IO uint32_t AHB2ENR; /*!< RCC AHB2 外设时钟寄存器,地址偏移: 0x34 */
35 __IO uint32_t AHB3ENR; /*!< RCC AHB3 外设时钟寄存器,地址偏移: 0x38 */
36 /*RCC 后面还有很多寄存器,此处省略*/
37 } RCC_TypeDef;

简单分析一下代码,前面几行将volatile,unsigned int,unsigned short这几种关键字进行了宏定义,接着用这些宏定义后的关键字创建了一个名字为GPIO_TypeDef结构体和一个名字为RCC_TypeDef的结构体。

看到这,先提出几个问题,为什么不直接用C语言所支持的关键字而将其进行宏定义后,再用宏定义配置?后面创建的结构体所依据的是什么,成员变量定义的依据是什么?

先说第一个,我认为是方便移植更新,c语言中的关键字在其它语言中可能并不能生效,这样做的好处是,如果volatile,int这些类型在别的平台是叫别的名字,那么只需要将这个地方一替换那么整个代码都将会替换掉,这样可以很好地移植或者更新。相反如果你直接用的是关键字,那么则要将所有用到这个关键字的地方全部替换掉。从这里我们应该学到一个很重要的经验,对于一些高频用到的又可能有改动的变量,关键字等等,用宏定义去定义一下再去使用,可以在你修改代码时十分方便。

第二个结构体的创建所依据的是芯片手册,而变量的名字,排序及其大小都是按照芯片手册中寄存器的名字,排序,及其大小去设计的。

创建自己的函数库_第2张图片

2.定义访问的结构体指针和引脚

代码如下(示例):

1 /*定义 GPIOA-H 寄存器结构体指针*/
2 #define GPIOA ((GPIO_TypeDef *) GPIOA_BASE)
3 #define GPIOB ((GPIO_TypeDef *) GPIOB_BASE)
4 #define GPIOC ((GPIO_TypeDef *) GPIOC_BASE)
5 #define GPIOD ((GPIO_TypeDef *) GPIOD_BASE)
6 #define GPIOE ((GPIO_TypeDef *) GPIOE_BASE)
7 #define GPIOF ((GPIO_TypeDef *) GPIOF_BASE)
8 #define GPIOG ((GPIO_TypeDef *) GPIOG_BASE)
9 #define GPIOH ((GPIO_TypeDef *) GPIOH_BASE)
10 
11 /*定义 RCC 外设 寄存器结构体指针*/
12 #define RCC ((RCC_TypeDef *) RCC_BASE)
1 /*GPIO 引脚号定义*/
2 #define GPIO_Pin_0 (uint16_t)0x0001) /*!< 选择 Pin0 (1<<0) */
3 #define GPIO_Pin_1 ((uint16_t)0x0002) /*!< 选择 Pin1 (1<<1)*/
4 #define GPIO_Pin_2 ((uint16_t)0x0004) /*!< 选择 Pin2 (1<<2)*/
5 #define GPIO_Pin_3 ((uint16_t)0x0008) /*!< 选择 Pin3 (1<<3)*/
6 #define GPIO_Pin_4 ((uint16_t)0x0010) /*!< 选择 Pin4 */
7 #define GPIO_Pin_5 ((uint16_t)0x0020) /*!< 选择 Pin5 */
8 #define GPIO_Pin_6 ((uint16_t)0x0040) /*!< 选择 Pin6 */
9 #define GPIO_Pin_7 ((uint16_t)0x0080) /*!< 选择 Pin7 */
10 #define GPIO_Pin_8 ((uint16_t)0x0100) /*!< 选择 Pin8 */
11 #define GPIO_Pin_9 ((uint16_t)0x0200) /*!< 选择 Pin9 */
12 #define GPIO_Pin_10 ((uint16_t)0x0400) /*!< 选择 Pin10 */
13 #define GPIO_Pin_11 ((uint16_t)0x0800) /*!< 选择 Pin11 */
14 #define GPIO_Pin_12 ((uint16_t)0x1000) /*!< 选择 Pin12 */
15 #define GPIO_Pin_13 ((uint16_t)0x2000) /*!< 选择 Pin13 */
16 #define GPIO_Pin_14 ((uint16_t)0x4000) /*!< 选择 Pin14 */
17 #define GPIO_Pin_15 ((uint16_t)0x8000) /*!< 选择 Pin15 */
18 #define GPIO_Pin_All ((uint16_t)0xFFFF) /*!< 选择全部引脚 */

有了这两组定义,接下来就可以写封装函数了。

3.创建封装函数

3.1创建拉低引脚函数

代码如下(示例):

void GPIO_ResetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
{
 	GPIOx->BSRRH = GPIO_Pin;
}

创建的函数有两个传参,一个是GPIO类型,一个是引脚号。也就是说我们想将某一个引脚拉低,只需要调用这个函数,将对应引脚的类型和引脚号填写上即可。比如我们之前控制PH10引脚。

代码如下(示例):

GPIO_ResetBits(GPIOH,GPIO_Pin_10);

3.2创建引脚初始化函数

接下来创建一个复杂一点的端口初始化函数,首先根据上一篇我们知道了要配置一个端口,需要对引脚号、工作模式、输出速率、输出类型以及上/下拉模式这些进行配置。那么我们就以此创建结构体。
代码如下:

1 typedef uint8_t unsigned char;
2 /**
3 * GPIO 初始化结构体类型定义
4 */
5 typedef struct {
6 uint32_t GPIO_Pin; /*!< 选择要配置的 GPIO 引脚
7 可输入 GPIO_Pin_ 定义的宏 */
8 
9 uint8_t GPIO_Mode; /*!< 选择 GPIO 引脚的工作模式
10 可输入二进制值: 00 、01、 10、 11
11 表示输入/输出/复用/模拟 */
12 
13 uint8_t GPIO_Speed; /*!< 选择 GPIO 引脚的速率
14 可输入二进制值: 00 、01、 10、 11
15 表示 2/25/50/100MHz */
16 
17 uint8_t GPIO_OType; /*!< 选择 GPIO 引脚输出类型
18 可输入二进制值: 0 、1
19 表示推挽/开漏 */
20 
21 uint8_t GPIO_PuPd; /*!<选择 GPIO 引脚的上/下拉模式
22 可输入二进制值: 00 、01、 10
23 表示浮空/上拉/下拉*/
24 } GPIO_InitTypeDef;

如果这样配置的话,那么每个变量赋值仍然是要进行位操作赋值,依旧很不好识别,所以我们可以通过创建枚举来解决这个问题。

代码如下:

 typedef enum {
5 GPIO_Mode_IN = 0x00, /*!< 输入模式 */
6 GPIO_Mode_OUT = 0x01, /*!< 输出模式 */
7 GPIO_Mode_AF = 0x02, /*!< 复用模式 */
8 GPIO_Mode_AN = 0x03 /*!< 模拟模式 */
9 } GPIOMode_TypeDef;
10 
11 /**
12 * GPIO 输出类型枚举定义
13 */
14 typedef enum {
15 GPIO_OType_PP = 0x00, /*!< 推挽模式 */
16 GPIO_OType_OD = 0x01 /*!< 开漏模式 */
17 } GPIOOType_TypeDef;
18 
19 /**
20 * GPIO 输出速率枚举定义
21 */
22 typedef enum {
23 GPIO_Speed_2MHz = 0x00, /*!< 2MHz */
24 GPIO_Speed_25MHz = 0x01, /*!< 25MHz */
25 GPIO_Speed_50MHz = 0x02, /*!< 50MHz */
26 GPIO_Speed_100MHz = 0x03 /*!<100MHz */
27 } GPIOSpeed_TypeDef;
28 
29 /**
30 *GPIO 上/下拉配置枚举定义
31 */
32 typedef enum {
33 GPIO_PuPd_NOPULL = 0x00,/*浮空*/
34 GPIO_PuPd_UP = 0x01, /*上拉*/
35 GPIO_PuPd_DOWN = 0x02 /*下拉*/
36 } GPIOPuPd_TypeDef;

然后通过这些枚举去定义开始的结构体成员。

代码如下:

 typedef struct {
5 uint32_t GPIO_Pin; /*!< 选择要配置的 GPIO 引脚
6 可输入 GPIO_Pin_ 定义的宏 */
7 
8 GPIOMode_TypeDef GPIO_Mode; /*!< 选择 GPIO 引脚的工作模式
9 可输入 GPIOMode_TypeDef 定义的枚举值*/
10 
11 GPIOSpeed_TypeDef GPIO_Speed; /*!< 选择 GPIO 引脚的速率
12 可输入 GPIOSpeed_TypeDef 定义的枚举值 */
13 
14 GPIOOType_TypeDef GPIO_OType; /*!< 选择 GPIO 引脚输出类型
15 可输入 GPIOOType_TypeDef 定义的枚举值*/
16 
17 GPIOPuPd_TypeDef GPIO_PuPd; /*!<选择 GPIO 引脚的上/下拉模式
18 可输入 GPIOPuPd_TypeDef 定义的枚举值*/
19 } GPIO_InitTypeDef;

这样,在我们配置时,只需要给变量附上对应的枚举值就好了。

代码如下:

1 GPIO_InitTypeDef InitStruct;
2 
3 /* LED 端口初始化 */
4 /*选择要控制的 GPIO 引脚*/
5 InitStruct.GPIO_Pin = GPIO_Pin_10;
6 /*设置引脚模式为输出模式*/
7 InitStruct.GPIO_Mode = GPIO_Mode_OUT;
8 /*设置引脚的输出类型为推挽输出*/
9 InitStruct.GPIO_OType = GPIO_OType_PP;
10 /*设置引脚为上拉模式*/
11 InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
12 /*设置引脚速率为 2MHz */
13 InitStruct.GPIO_Speed = GPIO_Speed_2MHz;

这样,我们将InitStruct这个结构体的各个成员都赋上值了,接着就是创建一个函数,来处理这个结构体的值。

代码如下:

1 
2 /**
3 *函数功能:初始化引脚模式
4 *参数说明:GPIOx,该参数为 GPIO_TypeDef 类型的指针,指向 GPIO 端口的地址
5 * GPIO_InitTypeDef:GPIO_InitTypeDef 结构体指针,指向初始化变量
6 */
7 void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct)
8 {
9 uint32_t pinpos = 0x00, pos = 0x00 , currentpin = 0x00;
10 
11 /*-- GPIO Mode Configuration --*/
12 for (pinpos = 0x00; pinpos < 16; pinpos++) {
13 /*以下运算是为了通过 GPIO_InitStruct->GPIO_Pin 算出引脚号 0-15*/
14 
15 /*经过运算后 pos 的 pinpos 位为 1,其余为 0,与 GPIO_Pin_x 宏对应。
16 pinpos 变量每次循环加 1,*/
17 pos = ((uint32_t)0x01) << pinpos;
18 
19 /* pos 与 GPIO_InitStruct->GPIO_Pin 做 & 运算,
20 若运算结果 currentpin == pos,
21 则表示 GPIO_InitStruct->GPIO_Pin 的 pinpos 位也为 1,
22 从而可知 pinpos 就是 GPIO_InitStruct->GPIO_Pin 对应的引脚号:0-15*/
23 currentpin = (GPIO_InitStruct->GPIO_Pin) & pos;
24 
25 /*currentpin == pos 时执行初始化*/
26 if (currentpin == pos) {
27 /*GPIOx 端口,MODER 寄存器的 GPIO_InitStruct->GPIO_Pin 对应的引脚,
28 MODER 位清空*/
29 GPIOx->MODER &= ~(3 << (2 *pinpos));
30 
31 /*GPIOx 端口,MODER 寄存器的 GPIO_Pin 引脚,
32 MODER 位设置"输入/输出/复用输出/模拟"模式*/
33 GPIOx->MODER |= (((uint32_t)GPIO_InitStruct->GPIO_Mode) << (2 *pinpos));
34 
35 /*GPIOx 端口,PUPDR 寄存器的 GPIO_Pin 引脚,
36 PUPDR 位清空*/
37 GPIOx->PUPDR &= ~(3 << ((2 *pinpos)));
38 
39 /*GPIOx 端口,PUPDR 寄存器的 GPIO_Pin 引脚,
40 PUPDR 位设置"上/下拉"模式*/
41 GPIOx->PUPDR |= (((uint32_t)GPIO_InitStruct->GPIO_PuPd) << (2 *pinpos));
42 
43 /*若模式为"输出/复用输出"模式,则设置速度与输出类型*/
44 if ((GPIO_InitStruct->GPIO_Mode == GPIO_Mode_OUT) ||
45 (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_AF)) {
46 /*GPIOx 端口,OSPEEDR 寄存器的 GPIO_Pin 引脚,
47 OSPEEDR 位清空*/
48 GPIOx->OSPEEDR &= ~(3 << (2 *pinpos));
49 /*GPIOx 端口,OSPEEDR 寄存器的 GPIO_Pin 引脚,
50 OSPEEDR 位设置输出速度*/
51 GPIOx->OSPEEDR |= ((uint32_t)(GPIO_InitStruct->GPIO_Speed)<<(2 *pinpos));
52 
53 /*GPIOx 端口,OTYPER 寄存器的 GPIO_Pin 引脚,
54 OTYPER 位清空*/
55 GPIOx->OTYPER &= ~(1 << (pinpos)) ;
56 /*GPIOx 端口,OTYPER 位寄存器的 GPIO_Pin 引脚,
57 OTYPER 位设置"推挽/开漏"输出类型*/
58 GPIOx->OTYPER |= (uint16_t)(( GPIO_InitStruct->GPIO_OType)<< (pinpos));
59 }
60 }
61 }

读一下这个函数,有两个传参,第一个是端口类型,也就是之前我们创建的那些GPIOx指针(x=A…H),第二个就是我们刚刚赋值的结构体,然后函数内部将结构体变量的值传给对应寄存器,最终控制电路板实现端口初始化。

我们要想实现拉低PH10引脚,只需要调用这两个函数便能实现。

代码如下:

12 int main(void)
13 {
14 GPIO_InitTypeDef InitStruct;
15 
16 /*开启 GPIOH 时钟,使用外设时都要先开启它的时钟*/
17 RCC->AHB1ENR |= (1<<7);
18 
19 /* LED 端口初始化 */
20 
21 /*初始化 PH10 引脚*/
22 /*选择要控制的 GPIO 引脚*/
23 InitStruct.GPIO_Pin = GPIO_Pin_10;
24 /*设置引脚模式为输出模式*/
25 InitStruct.GPIO_Mode = GPIO_Mode_OUT;
26 /*设置引脚的输出类型为推挽输出*/
27 InitStruct.GPIO_OType = GPIO_OType_PP;
28 /*设置引脚为上拉模式*/
29 InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
30 /*设置引脚速率为 2MHz */
31 InitStruct.GPIO_Speed = GPIO_Speed_2MHz;
32 /*调用库函数,使用上面配置的 GPIO_InitStructure 初始化 GPIO*/
33 GPIO_Init(GPIOH, &InitStruct);
34 
35 /*使引脚输出低电平,点亮 LED1*/
36 GPIO_ResetBits(GPIOH,GPIO_Pin_10);
51 while (1);
52 
53 }

总结

这一篇主要篇幅比较长,主要想分享为什么要有库函数,以及库函数为什么要这么去写,这么写的好处是什么,在今后的应用中,我们很少需要自己去写库函数,标准库函数已经满足我们绝大部分的需求了,我们只需要去调用。不过相对于学习本身,我更希望分享如何去学习,这样才能举一反三,在这个科技与狠活快速更新的年代,始终跟的上脚步。

你可能感兴趣的:(#,C语言,单片机,#,STM32,单片机)