Chinaunix首页 | 论坛 | 博客

野火_firege的ChinaUnix博客

首页　| 　博文目录　| 　关于我

野火_firege

  • 博客访问： 158791
  • 博文数量： 27
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 290
  • 用 户 组： 普通用户
  • 注册时间： 2016-08-26 09:45
文章分类

全部博文（27）

文章存档

2018年（27）

我的朋友
最近访客
推荐博文
相关博文
第8章 自己写库—构建库函数雏形

分类： 嵌入式

2018-06-22 10:14:25

本章参考资料：《STM32F767xx参考手册》、《STM32F767xx数据手册》

虽然我们上面用寄存器点亮了 LED，乍看一下好像代码也很简单，但是我们别侥幸以后就可以一直用寄存器开发。在用寄存器点亮 LED 的时候，我们会发现 STM32 的寄存器都是 32 位的，每次配置的时候都要对照着《STM32F767xx参考手册》中寄存器的说明，然后根据说明对每个控制的寄存器位写入特定参数，因此在配置的时候非常容易出错，而且代码还很不好理解，不便于维护。所以学习 STM32 最好的方法是用软件库，然后在软件库的基础上了解底层，学习遍所有寄存器。
8.1 什么是STM32函数库

在STM32F7之后ST官方不再支持标准的函数库，它是由ST公司针对STM32提供的函数接口，即API (Application Program Interface)，开发者可调用这些函数接口来配置STM32的寄存器，使开发人员得以脱离最底层的寄存器操作，有开发快速，易于阅读，维护成本低等优点。

当我们调用库API的时候不需要挖空心思去了解库底层的寄存器操作，就像当年我们刚开始学习C语言的时候，用prinft()函数时只是学习它的使用格式，并没有去研究它的源码实现，但需要深入研究的时候，经过千锤百炼的库API源码就是最佳学习范例。

实际上，库是架设在寄存器与用户驱动层之间的代码，向下处理与寄存器直接相关的配置，向上为用户提供配置寄存器的接口。库开发方式与直接配置寄存器方式的区别见图 8-1。

 

图 8-1 开发方式对比图

8.2  为什么采用库来开发及学习？

在以前8位机时代的程序开发中，一般直接配置芯片的寄存器，控制芯片的工作方式，如中断，定时器等。配置的时候，常常要查阅寄存器表，看用到哪些配置位，为了配置某功能，该置1还是置0。这些都是很琐碎的、机械的工作，因为8位机的软件相对来说较简单，而且资源很有限，所以可以直接配置寄存器的方式来开发。

对于STM32，因为外设资源丰富，带来的必然是寄存器的数量和复杂度的增加，这时直接配置寄存器方式的缺陷就突显出来了：

(1) 开发速度慢

(2) 程序可读性差

(3) 维护复杂

这些缺陷直接影响了开发效率，程序维护成本，交流成本。库开发方式则正好弥补了这些缺陷。

而坚持采用直接配置寄存器的方式开发的程序员，会列举以下原因：

(1) 具体参数更直观

(2) 程序运行占用资源少

相对于库开发的方式，直接配置寄存器方式生成的代码量的确会少一点，但因为STM32有充足的资源，权衡库的优势与不足，绝大部分时候，我们愿意牺牲一点CPU资源，选择库开发。一般只有在对代码运行时间要求极苛刻的地方，才用直接配置寄存器的方式代替，如频繁调用的中断服务函数。

对于库开发与直接配置寄存器的方式，就好比编程是用汇编好还是用 C 好一样。在STM32F1系列刚推出函数库时引起程序员的激烈争论，但是，随着ST库的完善与大家对库的了解，更多的程序员选择了库开发。现在全新的HAL库几乎全平台兼容，上层API是通用的，STM32F4系列和STM32F7系列函数库相互移植改动非常小。而如果要移植用寄存器写的程序，我只想说：“呵呵”。

用库来进行开发，市场已有定论，用户群说明了一切，但对于STM32的学习仍然有人认为用寄存器好，而且汇编不是还没退出大学教材么？认为这种方法直观，能够了解到是配置了哪些寄存器，怎样配置寄存器。事实上，库函数的底层实现恰恰是直接配置寄存器方式的最佳例子，它代替我们完成了寄存器配置的工作，而想深入了解芯片是如何工作的话，只要直接查看库函数的最底层实现就能理解，相信你会为它严谨、优美的实现方式而陶醉，要想修炼C语言，就从ST的库开始吧。所以在以后的章节中，使用软件库是我们的重点，而且我们通过讲解库API去高效地学习STM32的寄存器，并不至于因为用库学习，就不会用寄存器控制STM32芯片。

8.3  实验：构建库函数雏形

虽然库的优点多多，但很多人对库还是很忌惮，因为一开始用库的时候有很多代码，很多文件，不知道如何入手。不知道您是否认同这么一句话：一切的恐惧都来源于认知的空缺。我们对库忌惮那是因为我们不知道什么是库，不知道库是怎么实现的。

接下来，我们在寄存器点亮 LED 的代码上继续完善，把代码一层层封装，实现库的最初的雏形，相信经过这一步的学习后，您对库的运用会游刃有余。这里我们只讲如何实现GPIO函数库，其他外设的我们直接参考ST的HAL库学习即可，不必自己写。

下面请打开本章配套例程“构建库函数雏形”来阅读理解，该例程是在上一章的基础上修改得来的。

8.3.1  修改寄存器地址封装

上一章中我们在操作寄存器的时候，操作的是都寄存器的绝对地址，如果每个外设寄存器都这样操作，那将非常麻烦。我们考虑到外设寄存器的地址都是基于外设基地址的偏移地址，都是在外设基地址上逐个连续递增的，每个寄存器占 32 个或者 16 个字节，这种方式跟结构体里面的成员类似。所以我们可以定义一种外设结构体，结构体的地址等于外设的基地址，结构体的成员等于寄存器，成员的排列顺序跟寄存器的顺序一样。这样我们操作寄存器的时候就不用每次都找到绝对地址，只要知道外设的基地址就可以操作外设的全部寄存器，即操作结构体的成员即可。

在工程中的“stm32f767xx.h”文件中，我们使用结构体封装GPIO及RCC外设的的寄存器，见代码清单 8-1。结构体成员的顺序按照寄存器的偏移地址从低到高排列，成员类型跟寄存器类型一样。如不理解C语言对寄存器的封的语法原理，请参考小节。

代码清单 8-1 封装寄存器列表


点击(此处)折叠或打开

  1. 1 //volatile表示易变的变量，防止编译器优化，
  2.  2
  3.  3 #define __IO volatile
  4.  4
  5.  5 typedef unsigned int uint32_t;
  6.  6
  7.  7 typedef unsigned short uint16_t;
  8.  8
  9.  9 typedef unsigned char uint8_t;
  10. 10
  11. 11 /* GPIO寄存器列表 */
  12. 12 typedef struct
  13. 13
  14. 14 {
  15. 15 __IO uint32_t MODER; /*GPIO模式寄存器 地址偏移: 0x00 */
  16. 16
  17. 17 __IO uint32_t OTYPER; /*GPIO输出类型寄存器 地址偏移: 0x04 */
  18. 18
  19. 19 __IO uint32_t OSPEEDR; /*GPIO输出速度寄存器 地址偏移: 0x08 */
  20. 20
  21. 21 __IO uint32_t PUPDR; /*GPIO上拉/下拉寄存器 地址偏移: 0x0C */
  22. 22
  23. 23 __IO uint32_t IDR; /*GPIO输入数据寄存器 地址偏移: 0x10 */
  24. 24
  25. 25 __IO uint32_t ODR; /*GPIO输出数据寄存器 地址偏移: 0x14 */
  26. 26
  27. 27 __IO uint32_t BSRR; /*GPIO置位/复位寄存器 地址偏移: 0x18 */
  28. 28
  29. 29 __IO uint32_t LCKR; /*GPIO配置锁定寄存器 地址偏移: 0x1C */
  30. 30
  31. 31 __IO uint32_t AFR[2]; /*GPIO复用功能配置寄存器 地址偏移: 0x20-0x24 */
  32. 32
  33. 33 } GPIO_TypeDef;
  34. 34 /*RCC寄存器列表*/
  35. 35
  36. 36 typedef struct
  37. 37
  38. 38 {
  39. 39
  40. 40__IO uint32_t CR; /*!< RCC 时钟控制寄存器,地址偏移: 0x00 */
  41. 41
  42. 42__IO uint32_t PLLCFGR; /*!< RCC PLL配置寄存器,地址偏移: 0x04 */
  43. 43
  44. 44 __IO uint32_t CFGR; /*!< RCC 时钟配置寄存器,地址偏移: 0x08 */
  45. 45
  46. 46 __IO uint32_t CIR; /*!< RCC 时钟中断寄存器,地址偏移: 0x0C */
  47. 47
  48. 48 __IO uint32_t AHB1RSTR; /*!< RCC AHB1 外设复位寄存器,地址偏移: 0x10 */
  49. 49
  50. 50 __IO uint32_t AHB2RSTR; /*!< RCC AHB2 外设复位寄存器, 地址偏移: 0x14 */
  51. 51
  52. 52 __IO uint32_t AHB3RSTR; /*!< RCC AHB3 外设复位寄存器, 地址偏移: 0x18 */
  53. 53
  54. 54 __IO uint32_t RESERVED0; /*!< 保留,地址偏移：0x1C */
  55. 55
  56. 56 __IO uint32_t APB1RSTR; /*!< RCC APB1 外设复位寄存器,地址偏移: 0x20 */
  57. 57
  58. 58 __IO uint32_t APB2RSTR; /*!< RCC APB2 外设复位寄存器, 地址偏移: 0x24 */
  59. 59
  60. 60 __IO uint32_t RESERVED1[2]; /*!< 保留,地址偏移：0x28-0x2C*/
  61. 61
  62. 62 __IO uint32_t AHB1ENR; /*!< RCC AHB1 外设时钟寄存器, 地址偏移: 0x30 */
  63. 63
  64. 64 __IO uint32_t AHB2ENR; /*!< RCC AHB2 外设时钟寄存器, 地址偏移: 0x34 */
  65. 65
  66. 66 __IO uint32_t AHB3ENR; /*!< RCC AHB3 外设时钟寄存器, 地址偏移: 0x38 */
  67. 67 uint32_t RESERVED2; /*!< 预留, 0x3C */
  68. 68 __IO uint32_t APB1ENR; /*!< RCC APB1 外设时钟寄存器,地址偏移: 0x40 */
  69. 69 __IO uint32_t APB2ENR; /*!< RCC APB2 外设时钟寄存器,地址偏移: 0x44 */
  70. 70 /*RCC后面还有很多寄存器，此处省略*/
  71. 71
  72. 72 } RCC_TypeDef

这段代码在每个结构体成员前增加了一个“__IO”前缀，它的原型在这段代码的第一行，代表了C语言中的关键字“volatile”，在C语言中该关键字用于表示变量是易变的，要求编译器不要优化。这些结构体内的成员，都代表着寄存器，而寄存器很多时候是由外设或STM32芯片状态修改的，也就是说即使CPU不执行代码修改这些变量，变量的值也有可能被外设修改、更新，所以每次使用这些变量的时候，我们都要求CPU去该变量的地址重新访问。若没有这个关键字修饰，在某些情况下，编译器认为没有代码修改该变量，就直接从CPU的某个缓存获取该变量值，这时可以加快执行速度，但该缓存中的是陈旧数据，与我们要求的寄存器最新状态可能会有出入。

8.3.2  定义访问外设的结构体指针

以结构体的形式定义好了外设寄存器后，使用结构体前还需要给结构体的首地址赋值，才能访问到需要的寄存器。为方便操作，我们给每个外设都定义好指向它地址的结构体指针，见代码清单 8-2。

代码清单 8-2 指向外设首地址的结构体指针


点击(此处)折叠或打开

  1. 1 /*定义GPIOA-H 寄存器结构体指针*/
  2.  2 #define GPIOA ((GPIO_TypeDef *) GPIOA_BASE)
  3.  3 #define GPIOB ((GPIO_TypeDef *) GPIOB_BASE)
  4.  4 #define GPIOC ((GPIO_TypeDef *) GPIOC_BASE)
  5.  5 #define GPIOD ((GPIO_TypeDef *) GPIOD_BASE)
  6.  6 #define GPIOE ((GPIO_TypeDef *) GPIOE_BASE)
  7.  7 #define GPIOF ((GPIO_TypeDef *) GPIOF_BASE)
  8.  8 #define GPIOG ((GPIO_TypeDef *) GPIOG_BASE)
  9.  9 #define GPIOH ((GPIO_TypeDef *) GPIOH_BASE)
  10. 10
  11. 11 /*定义RCC外设 寄存器结构体指针*/
  12. 12 #define RCC ((RCC_TypeDef *) RCC_BASE)


这些宏通过强制把外设的基地址转换成GPIO_TypeDef类型的地址，从而得到GPIOA、GPIOB等直接指向对应外设的指针，通过结构体的指针操作，即可访问对应外设的寄存器。

利用这些指针访问寄存器，我们把main文件里对应的代码修改掉，见代码清单 8-3。

代码清单 8-3 使用结构体指针方式控制LED灯


点击(此处)折叠或打开

  1. 1 /**
  2.  2 * 主函数
  3.  3 */
  4.  4 int main(void)
  5.  5 {
  6.  6 /*开启 GPIOH 时钟，使用外设时都要先开启它的时钟*/
  7.  7 RCC_AHB1ENR |= (1<<7);
  8.  8
  9.  9 /* LED 端口初始化 */
  10. 10
  11. 11 /*GPIOH MODER10清空*/
  12. 12 GPIOH_MODER &= ~( 0x03<< (2*10));
  13. 13 /*PH10 MODER10 = 01b 输出模式*/
  14. 14 GPIOH_MODER |= (1<<2*10);
  15. 15
  16. 16 /*GPIOH OTYPER10清空*/
  17. 17 GPIOH_OTYPER &= ~(1<<1*10);
  18. 18 /*PH10 OTYPER10 = 0b 推挽模式*/
  19. 19 GPIOH_OTYPER |= (0<<1*10);
  20. 20
  21. 21 /*GPIOH OSPEEDR10清空*/
  22. 22 GPIOH_OSPEEDR &= ~(0x03<<2*10);
  23. 23 /*PH10 OSPEEDR10 = 0b 速率2MHz*/
  24. 24 GPIOH_OSPEEDR |= (0<<2*10);
  25. 25
  26. 26 /*GPIOH PUPDR10清空*/
  27. 27 GPIOH_PUPDR &= ~(0x03<<2*10);
  28. 28 /*PH10 PUPDR10 = 01b 上拉模式*/
  29. 29 GPIOH_PUPDR |= (1<<2*10);
  30. 30
  31. 31 /*PH10 BSRR寄存器的 BR10置1，使引脚输出低电平*/
  32. 32 GPIOH_BSRR |= (1<<16<<10);
  33. 33
  34. 34 /*PH10 BSRR寄存器的 BS10置1，使引脚输出高电平*/
  35. 35 //GPIOH_BSRR |= (1<<10);
  36. 36
  37. 37 while (1);
  38. 38
  39. 39 }


打好了地基，下面我们就来建高楼。接下来使用函数来封装GPIO的基本操作，方便以后应用的时候不需要再查询寄存器，而是直接通过调用这里定义的函数来实现。我们把针对GPIO外设操作的函数及其宏定义分别存放在“stm32f7xx_hal_gpio.c”和“stm32f7xx_hal_gpio”文件中。

定义位操作函数

在“stm32f7xx_hal_gpio.c”文件定义引脚电平操作函数，分别用于控制引脚输出高电平和低电平，见代码清单 8-4。

代码清单 8-4 GPIO设置引脚电平函数的定义


点击(此处)折叠或打开

  1. 1 /**
  2.  2 * 函数功能：设置引脚电平
  3.  3 * 参数说明：GPIOx: 该参数为GPIO_TypeDef类型的指针，指向GPIO端口的地址
  4.  4 * GPIO_Pin: 选择要设置的GPIO端口引脚，可输入宏GPIO_Pin_0-15，
  5.  5 * 表示GPIOx端口的0-15号引脚
  6.  6 * PinState: 设置所选引脚的电平
  7.  7 * @arg GPIO_PIN_RESET:设置低电平
  8.  8 * @arg GPIO_PIN_SET: 设置高电平
  9.  9 * 返回值： 无
  10. 10 */
  11. 11 void HAL_GPIO_WritePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState)
  12. 12 {
  13. 13 /*设置GPIOx端口BSRR寄存器的低16位对应第GPIO_Pin位，使其输出高电平*/
  14. 14 /*设置GPIOx端口BSRR寄存器的高16位对应第GPIO_Pin位，使其输出低电平*/
  15. 15/*因为BSRR寄存器写0不影响，GPIO_Pin只是对应位为1，其它位均为0，所以可以直接赋值*/
  16. 16
  17. 17 if (PinState != GPIO_PIN_RESET) {
  18. 18 GPIOx->BSRR = GPIO_Pin;
  19. 19 } else {
  20. 20 GPIOx->BSRR = (uint32_t)GPIO_Pin << 16;
  21. 21 }
  22. 22 }


函数体内根据需要的电平，对GPIOx的BSRR寄存器低16位或者高16位赋值，从而设置引脚为高电平或低电平。其中GPIOx是一个指针变量，通过函数的输入参数我们可以修改它的值，如给它赋予GPIOA、GPIOB、GPIOH等结构体指针值，这个函数就可以控制相应的GPIOA、GPIOB、GPIOH等端口的输出。

对比我们前面对BSRR寄存器的赋值，都是用“|=”操作来防止对其它数据位产生干扰的，为何此函数里的操作却直接用“=”号赋值，这样不怕干扰其它数据位吗？见代码清单 8-5。

代码清单 8-5 赋值方式对比


点击(此处)折叠或打开

  1. 1 /*使用 “|=” 来赋值*/
  2. 2 GPIOH->BSRR |= (1<<10);
  3. 3 /*直接使用 "=" 号赋值*/
  4. 4 GPIOx->BSRR = GPIO_Pin

根据BSRR寄存器的特性，对它的数据位写“0”，是不会影响输出的，只有对它的数据位写“1”，才会控制引脚输出。对低16位写“1”输出高电平，对高16位写“1”输出低电平。也就是说，假如我们对BSRR(高16位)直接用“=”操作赋二进制值“0000 0000 0000 0001 b”，它会控制GPIO的引脚0输出低电平，赋二进制值“0000 0000 0001 0000 b”，它会控制GPIO引脚4输出低电平，而其它数据位由于是0，所以不会受到干扰。同理，对BSRR (低16位)直接赋值也是如此，数据位为1的位输出高电平。代码清单 8-6 中的两种方式赋值，功能相同。

代码清单 8-6 BSRR寄存器赋值等效代码


点击(此处)折叠或打开

  1. 1 /*使用 “|=” 来赋值*/
  2. 2 GPIOH->BSRR |= (uint16_t)(1<<10);
  3. 3 /*直接使用“=” 来赋值，二进制数(0000 0100 0000 0000)*/
  4. 4 GPIOH->BSRR = (uint16_t)(1<<10)


这两行代码功能等效，都把BSRR的bit10设置为1，控制引脚10输出低电平，且其它引脚状态不变。但第二个语句操作效率是比较高的，因为“|=”号包含了读写操作，而“=”号只需要一个写操作。因此在定义位操作函数中我们使用后者。

利用这两个位操作函数，就可以方便地操作各种GPIO的引脚电平了，控制各种端口引脚的范例见代码清单 8-7。

代码清单 8-7 位操作函数使用范例


点击(此处)折叠或打开

  1. 1
  2.  2 /*控制GPIOH的引脚10输出高电平*/
  3.  3 HAL_GPIO_WritePin(GPIOH,(uint16_t)(1<<10), GPIO_PIN_SET);
  4.  4 /*控制GPIOH的引脚10输出低电平*/
  5.  5 HAL_GPIO_WritePin(GPIOH,(uint16_t)(1<<10), GPIO_PIN_RESET);
  6.  6
  7.  7 /*控制GPIOH的引脚10、引脚11输出高电平，使用“|”同时控制多个引脚*/
  8.  8 HAL_GPIO_WritePin(GPIOH,(uint16_t)(1<<10)| (uint16_t)(1<<11), GPIO_PIN_SET);
  9.  9 /*控制GPIOH的引脚10、引脚11输出低电平*/
  10. 10 HAL_GPIO_WritePin(GPIOH,(uint16_t)(1<<10)| (uint16_t)(1<<11), GPIO_PIN_RESET);
  11. 11
  12. 12 /*控制GPIOA的引脚8输出高电平*/
  13. 13 HAL_GPIO_WritePin(GPIOA,(uint16_t)(1<<8), GPIO_PIN_SET);
  14. 14 /*控制GPIOB的引脚9输出低电平*/
  15. 15 HAL_GPIO_WritePin(GPIOB,(uint16_t)(1<<9), GPIO_PIN_RESET);


  1. 使用以上函数输入参数，设置引脚号时，还是稍感不便，为此我们把表示16个引脚的操作数都定义成宏，见代码清单 8-8。
  2. 代码清单 8-8 选择引脚参数的宏

  3. 点击(此处)折叠或打开

    1. 使用以上函数输入参数，设置引脚号时，还是稍感不便，为此我们把表示16个引脚的操作数都定义成宏，见代码清单 88。
    2. 代码清单 88 选择引脚参数的宏
    3. 1 /*GPIO引脚号定义*/
    4.  2 #define GPIO_PIN_0 (uint16_t)0x0001) /*!< 选择Pin0 (1<<0) */
    5.  3 #define GPIO_PIN_1 ((uint16_t)0x0002) /*!< 选择Pin1 (1<<1)*/
    6.  4 #define GPIO_PIN_2 ((uint16_t)0x0004) /*!< 选择Pin2 (1<<2)*/
    7.  5 #define GPIO_PIN_3 ((uint16_t)0x0008) /*!< 选择Pin3 (1<<3)*/
    8.  6 #define GPIO_PIN_4 ((uint16_t)0x0010) /*!< 选择Pin4 */
    9.  7 #define GPIO_PIN_5 ((uint16_t)0x0020) /*!< 选择Pin5 */
    10.  8 #define GPIO_PIN_6 ((uint16_t)0x0040) /*!< 选择Pin6 */
    11.  9 #define GPIO_PIN_7 ((uint16_t)0x0080) /*!< 选择Pin7 */
    12. 10 #define GPIO_PIN_8 ((uint16_t)0x0100) /*!< 选择Pin8 */
    13. 11 #define GPIO_PIN_9 ((uint16_t)0x0200) /*!< 选择Pin9 */
    14. 12 #define GPIO_PIN_10 ((uint16_t)0x0400) /*!< 选择Pin10 */
    15. 13 #define GPIO_PIN_11 ((uint16_t)0x0800) /*!< 选择Pin11 */
    16. 14 #define GPIO_PIN_12 ((uint16_t)0x1000) /*!< 选择Pin12 */
    17. 15 #define GPIO_PIN_13 ((uint16_t)0x2000) /*!< 选择Pin13 */
    18. 16 #define GPIO_PIN_14 ((uint16_t)0x4000) /*!< 选择Pin14 */
    19. 17 #define GPIO_PIN_15 ((uint16_t)0x8000) /*!< 选择Pin15 */
    20. 18 #define GPIO_PIN_All ((uint16_t)0xFFFF) /*!< 选择全部引脚 */



这些宏代表的参数是某位置“1”其它位置“0”的数值，其中最后一个“GPIO_Pin_ALL”是所有数据位都为“1”，所以用它可以一次控制设置整个端口的0-15所有引脚。利用这些宏， GPIO的控制代码可改为代码清单 8-9。

代码清单 8-9 使用位操作函数及宏控制GPIO


点击(此处)折叠或打开

  1. 1
  2.  2 /*控制GPIOH的引脚10输出高电平*/
  3.  3 HAL_GPIO_WritePin(GPIOH, GPIO_PIN_10, GPIO_PIN_SET);
  4.  4 /*控制GPIOH的引脚10输出低电平*/
  5.  5 HAL_GPIO_WritePin(GPIOH, GPIO_PIN_10, GPIO_PIN_RESET);
  6.  6
  7.  7 /*控制GPIOH的引脚10、引脚11输出高电平，使用“|”，同时控制多个引脚*/
  8.  8 HAL_GPIO_WritePin(GPIOH, GPIO_PIN_10| GPIO_PIN_11, GPIO_PIN_SET);
  9.  9 /*控制GPIOH的引脚10、引脚11输出低电平*/
  10. 10 HAL_GPIO_WritePin(GPIOH, GPIO_PIN_10| GPIO_PIN_11, GPIO_PIN_RESET);
  11. 11 /*控制GPIOH的所有输出低电平*/
  12. 12 HAL_GPIO_WritePin(GPIOH, GPIO_PIN_All, GPIO_PIN_RESET);
  13. 13
  14. 14 /*控制GPIOA的引脚8输出高电平*/
  15. 15 HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
  16. 16 /*控制GPIOB的引脚9输出低电平*/
  17. 17 HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, GPIO_PIN_RESET)


使用以上代码控制GPIO，我们就不需要再看寄存器了，直接从函数名和输入参数就可以直观看出这个语句要实现什么操作。(英文中“Set”表示“置位”，即高电平，“Reset”表示“复位”，即低电平)

8.3.3  定义初始化结构体GPIO_InitTypeDef

定义位操作函数后，控制GPIO输出电平的代码得到了简化，但在控制GPIO输出电平前还需要初始化GPIO引脚的各种模式，这部分代码涉及的寄存器有很多，我们希望初始化GPIO也能以如此简单的方法去实现。为此，我们先根据GPIO初始化时涉及到的初始化参数以结构体的形式封装起来，声明一个名为GPIO_InitTypeDef的结构体类型，见代码清单 8-10。

代码清单 8-10 定义GPIO初始化结构体


点击(此处)折叠或打开

  1. 1 /**
  2.  2 * @brief GPIO初始化结构体类型定义
  3.  3 */
  4.  4 typedef struct {
  5.  5 uint32_t Pin; /*指定要配置的GPIO引脚 */
  6.  6
  7.  7 uint32_t Mode; /*指定所选引脚的工作模式*/
  8.  8
  9.  9 uint32_t Pull; /*指定所选引脚的上拉或下拉激活 */
  10. 10
  11. 11 uint32_t Speed; /*指定所选引脚的速度 */
  12. 12
  13. 13 uint32_t Alternate; /*要连接到所选引脚的外设*/
  14. 14 } GPIO_InitTypeDef

这个结构体中包含了初始化GPIO所需要的信息，包括引脚号、工作模式、输出速率、输出类型以及上/下拉模式。设计这个结构体的思路是：初始化GPIO前，先定义一个这样的结构体变量，根据需要配置GPIO的模式，对这个结构体的各个成员进行赋值，然后把这个变量作为“GPIO初始化函数”的输入参数，该函数能根据这个变量值中的内容去配置寄存器，从而实现初始化GPIO。

8.3.4  定义引脚模式的枚举类型

上面定义的结构体很直接，美中不足的是在对结构体中各个成员赋值时还需要看具体哪个模式对应哪个数值，如GPIO_Mode成员的“输入/输出/复用/模拟”模式对应二进制值“00 、01、 10、 11”，我们不希望每次用到都要去查找这些索引值，所以使用C语言中的枚举语法定义这些参数，见代码清单 8-11。

代码清单 8-11 GPIO配置参数的宏定义


点击(此处)折叠或打开

  1. 1 #define GPIO_MODE_INPUT ((uint32_t)0x00000000U) /*!< 浮空输入*/
  2.  2 #define GPIO_MODE_OUTPUT_PP ((uint32_t)0x00000001U) /*!< 推挽输出 */
  3.  3 #define GPIO_MODE_OUTPUT_OD ((uint32_t)0x00000011U) /*!< 开漏输出 */
  4.  4 #define GPIO_MODE_AF_PP ((uint32_t)0x00000002U) /*!< 推挽复用输出*/
  5.  5 #define GPIO_MODE_AF_OD ((uint32_t)0x00000012U) /*!< 开漏复用输出*/
  6.  6
  7.  7 #define GPIO_MODE_ANALOG ((uint32_t)0x00000003U) /*!< 模拟模式*/
  8.  8
  9.  9 #define GPIO_SPEED_FREQ_LOW ((uint32_t)0x00000000U) /*!< 低速*/
  10. 10 #define GPIO_SPEED_FREQ_MEDIUM ((uint32_t)0x00000001U) /*!< 中速*/
  11. 11 #define GPIO_SPEED_FREQ_HIGH ((uint32_t)0x00000002U) /*!< 快速*/
  12. 12 #define GPIO_SPEED_FREQ_VERY_HIGH ((uint32_t)0x00000003U) /*!< 高速*/
  13. 13
  14. 14 #define GPIO_NOPULL ((uint32_t)0x00000000U) /*!< 无上下拉 */
  15. 15 #define GPIO_PULLUP ((uint32_t)0x00000001U) /*!< 上拉 */
  16. 16 #define GPIO_PULLDOWN ((uint32_t)0x00000002U) /*!< 下拉 */


有了这些宏定义，我们的GPIO_InitTypeDef结构体也可以使用枚举类型来限定输入了，代码清单 8-13。

代码清单 8-12 使用枚举类型定义的GPIO_InitTypeDef结构体成员


点击(此处)折叠或打开

  1. 1 /**
  2.  2 * @brief GPIO初始化结构体类型定义
  3.  3 */
  4.  4 typedef struct {
  5.  5 uint32_t Pin; /*指定要配置的GPIO引脚 */
  6.  6
  7.  7 uint32_t Mode; /*指定所选引脚的工作模式*/
  8.  8
  9.  9 uint32_t Pull; /*指定所选引脚的上拉或下拉激活 */
  10. 10
  11. 11 uint32_t Speed; /*指定所选引脚的速度 */
  12. 12
  13. 13 uint32_t Alternate; /*要连接到所选引脚的外设*/
  14. 14 } GPIO_InitTypeDef


如果不使用枚举类型，仍使用“uint8_t”类型来定义结构体成员，那么成员值的范围就是0-255了，而实际上这些成员都只能输入几个数值。所以使用枚举类型可以对结构体成员起到限定输入的作用，只能输入相应已定义的枚举值。

利用这些枚举定义，给GPIO_InitTypeDef结构体类型赋值配置就非常直观了，范例见代码清单 8-13。

代码清单 8-13 给GPIO_InitTypeDef初始化结构体赋值范例


点击(此处)折叠或打开

  1. 1 GPIO_InitTypeDef InitStruct;
  2.  2
  3.  3 /* LED 端口初始化 */
  4.  4
  5.  5 /*初始化PH10引脚*/
  6.  6 /*选择要控制的GPIO引脚*/
  7.  7 InitStruct.Pin = GPIO_PIN_10;
  8.  8 /*设置引脚的输出类型为推挽输出*/
  9.  9 InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  10. 10 /*设置引脚为上拉模式*/
  11. 11 InitStruct.Pull = GPIO_PULLUP;
  12. 12 /*设置引脚速率为低速模式 */
  13. 13 InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  14. 14 /*调用库函数，使用上面配置的GPIO_InitStructure初始化GPIO*/
  15. 15 HAL_GPIO_Init(GPIOH, &InitStruct)


8.3.5  定义GPIO初始化函数
接着前面的思路，对初始化结构体赋值后，把它输入到GPIO初始化函数，由它来实现寄存器配置。我们的GPIO初始化函数实现见代码清单 8-14，

代码清单 8-14 GPIO初始化函数


点击(此处)折叠或打开

  1. 1 /**
  2.  2 *函数功能：初始化引脚模式
  3.  3 *参数说明：GPIOx，该参数为GPIO_TypeDef类型的指针，指向GPIO端口的地址
  4.  4 * GPIO_InitTypeDef:GPIO_InitTypeDef结构体指针，指向初始化变量
  5.  5 */
  6.  6 void HAL_GPIO_Init(GPIO_TypeDef *GPIOx, GPIO_InitTypeDef *GPIO_Init)
  7.  7 {
  8.  8 uint32_t position = 0x00;
  9.  9 uint32_t ioposition = 0x00;
  10. 10 uint32_t iocurrent = 0x00;
  11. 11 uint32_t temp = 0x00;
  12. 12
  13. 13 /* Configure the port pins */
  14. 14 for (position = 0; position < 16; position++) {
  15. 15 /*以下运算是为了通过 GPIO_InitStruct->GPIO_Pin 算出引脚号0-15*/
  16. 16 /*经过运算后pos的pinpos位为1，其余为0，与GPIO_Pin_x宏对应。pinpos变量每次循环加1，*/
  17. 17 ioposition = ((uint32_t)0x01) << position;
  18. 18 /* pos与GPIO_InitStruct->Pin做 & 运算，若运算结果currentpin == pos，
  19. 19 则表示GPIO_InitStruct->Pin的pinpos位也为1，
  20. 20 从而可知pinpos就是GPIO_InitStruct->Pin对应的引脚号：0-15*/
  21. 21 iocurrent = (uint32_t)(GPIO_Init->Pin) & ioposition;
  22. 22
  23. 23 if (iocurrent == ioposition) {
  24. 24 /*------------- GPIO Mode Configuration -----------------*/
  25. 25 /* 在复用功能模式选择的情况下 */
  26. 26 if ((GPIO_Init->Mode == GPIO_MODE_AF_PP) || (GPIO_Init->Mode == GPIO_MODE_AF_OD)) {
  27. 27 /* 配置与当前IO映射的备用功能 */
  28. 28 temp = GPIOx->AFR[position >> 3];
  29. 29temp &= ~((uint32_t)0xF << ((uint32_t)(position & (uint32_t)0x07) * 4)) ;
  30. 30temp |= ((uint32_t)(GPIO_Init->Alternate) << (((uint32_t)position & (uint32_t)0x07) * 4));
  31. 31 GPIOx->AFR[position >> 3] = temp;
  32. 32 }
  33. 33
  34. 34 /* 配置IO方向模式（输入，输出，复用或模拟） */
  35. 35 temp = GPIOx->MODER;
  36. 36 temp &= ~(GPIO_MODER_MODER0 << (position * 2));
  37. 37 temp |= ((GPIO_Init->Mode & GPIO_MODE) << (position * 2));
  38. 38 GPIOx->MODER = temp;
  39. 39
  40. 40 /* 在输出或复用功能模式选择的情况下 */
  41. 41 if ((GPIO_Init->Mode == GPIO_MODE_OUTPUT_PP) || (GPIO_Init->Mode == GPIO_MODE_AF_PP) ||
  42. 42 (GPIO_Init->Mode == GPIO_MODE_OUTPUT_OD) || (GPIO_Init->Mode == GPIO_MODE_AF_OD)) {
  43. 43
  44. 44 /* 配置速度参数 */
  45. 45 temp = GPIOx->OSPEEDR;
  46. 46 temp &= ~(GPIO_OSPEEDER_OSPEEDR0 << (position * 2));
  47. 47 temp |= (GPIO_Init->Speed << (position * 2));
  48. 48 GPIOx->OSPEEDR = temp;
  49. 49
  50. 50 /* 配置IO输出类型 */
  51. 51 temp = GPIOx->OTYPER;
  52. 52 temp &= ~(GPIO_OTYPER_OT_0 << position) ;
  53. 53 temp |= (((GPIO_Init->Mode & GPIO_OUTPUT_TYPE) >> 4) << position);
  54. 54 GPIOx->OTYPER = temp;
  55. 55 }
  56. 56
  57. 57 /* 激活当前IO的上拉或下拉电阻 */
  58. 58 temp = GPIOx->PUPDR;
  59. 59 temp &= ~(GPIO_PUPDR_PUPDR0 << (position * 2));
  60. 60 temp |= ((GPIO_Init->Pull) << (position * 2));
  61. 61 GPIOx->PUPDR = temp;
  62. 62 }
  63. 63 }
  64. 64 }


这个函数有GPIOx和GPIO_InitStruct两个输入参数，分别是GPIO外设指针和GPIO初始化结构体指针。分别用来指定要初始化的GPIO端口及引脚的工作模式。

函数实现主要分两个环节：

(1) 利用for循环，根据GPIO_InitStruct的结构体成员GPIO_Pin计算出要初始化的引脚号。这段看起来复杂的运算实际上可以这样理解：它要通过宏“GPIO_PIN_x”的参数计算出x值(宏的参数值是第x数据位为1，其余为0，参考代码清单 88)，计算得的引脚号结果存储在pinpos变量中。

(2) 得到引脚号pinpos后，利用初始化结构体各个成员的值，对相应寄存器进行配置，这部分与我们前面直接配置寄存器的操作是类似的，先对引脚号pinpos相应的配置位清空，后根据结构体成员对配置位赋值(Mode成员对应MODER寄存器的配置， Speed成员对应OSPEEDR寄存器的配置等)。区别是这里的寄存器配置值及引脚号都是由变量存储的。

8.3.6  全新面貌，使用函数点亮LED灯

完成以上的准备后，我们就可以自己定义的函数来点亮LED灯了，见代码清单 8-15。

代码清单 8-15 使用函数点亮LED灯


点击(此处)折叠或打开

  1. 1 void Delay( uint32_t nCount);
  2.  2 /**
  3.  3 * 主函数
  4.  4 */
  5.  5 int main(void)
  6.  6 {
  7.  7 GPIO_InitTypeDef InitStruct;
  8.  8
  9.  9 /*开启 GPIOH 时钟，使用外设时都要先开启它的时钟*/
  10. 10 RCC->AHB1ENR |= (1<<7);
  11. 11
  12. 12 /* LED 端口初始化 */
  13. 13
  14. 14 /*初始化PH10引脚*/
  15. 15 /*选择要控制的GPIO引脚*/
  16. 16 InitStruct.Pin = GPIO_PIN_10;
  17. 17 /*设置引脚的输出类型为推挽输出*/
  18. 18 InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  19. 19 /*设置引脚为上拉模式*/
  20. 20 InitStruct.Pull = GPIO_PULLUP;
  21. 21 /*设置引脚速率为低速模式 */
  22. 22 InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  23. 23 /*调用库函数，使用上面配置的GPIO_InitStructure初始化GPIO*/
  24. 24 HAL_GPIO_Init(GPIOH, &InitStruct);
  25. 25
  26. 26 /*使引脚输出低电平,点亮LED1*/
  27. 27 HAL_GPIO_WritePin(GPIOH,GPIO_PIN_10,GPIO_PIN_RESET);
  28. 28
  29. 29 /*延时一段时间*/
  30. 30 Delay(0xFFFFFF);
  31. 31
  32. 32 /*使引脚输出高电平，关闭LED1*/
  33. 33 HAL_GPIO_WritePin(GPIOH,GPIO_PIN_10,GPIO_PIN_SET);
  34. 34
  35. 35 /*初始化PH11引脚*/
  36. 36 InitStruct.Pin = GPIO_PIN_11;
  37. 37 HAL_GPIO_Init(GPIOH,&InitStruct);
  38. 38
  39. 39 /*使引脚输出低电平，点亮LED2*/
  40. 40 HAL_GPIO_WritePin(GPIOH,GPIO_PIN_11,GPIO_PIN_RESET);
  41. 41
  42. 42 while (1);
  43. 43
  44. 44 }
  45. 45
  46. 46 //简单的延时函数，让cpu执行无意义指令，消耗时间
  47. 47 //具体延时时间难以计算，以后我们可使用定时器精确延时
  48. 48 void Delay( uint32_t nCount)
  49. 49 {
  50. 50 for (; nCount != 0; nCount--);
  51. 51 }
  52. 52 // 函数为空，目的是为了骗过编译器不报错
  53. 53 void SystemInit(void)
  54. 54 {
  55. 55 }


现在看起来，使用函数来控制LED灯与之前直接控制寄存器已经有了很大的区别：main函数中先定义了一个初始化结构体变量InitStruct，然后对该变量的各个成员按点亮LED灯所需要的GPIO配置模式进行赋值，赋值后，调用HAL_GPIO_Init函数，让它根据结构体成员值对GPIO寄存器写入控制参数，完成GPIO引脚初始化。控制电平时，直接使用HAL_GPIO_WritePin函数控制输出。如若对其它引脚进行不同模式的初始化，只要修改初始化结构体InitStruct的成员值，把新的参数值输入到HAL_GPIO_Init函数再调用即可。

代码中新增的Delay函数，主要功能是延时，让我们可以看清楚实验现象(不延时的话指令执行太快，肉眼看不出来)，它的实现原理是让CPU执行无意义的指令，消耗时间，在此不要纠结它的延时时间，写一个大概输入参数值，下载到实验板实测，觉得太久了就把参数值改小，短了就改大即可。需要精确延时的时候我们会用STM32的定时器外设进行精确延时的。

8.3.7  下载验证

把编译好的程序下载到开发板并复位，可看到板子上的灯先亮红色(LED1)，后亮绿色(LED2)。

8.3.8 总结

什么是ST软件库？这就是。

我们从寄存器映像开始，把内存跟寄存器建立起一一对应的关系，然后操作寄存器点亮 LED，再把寄存器操作封装成一个个函数。一步一步走来，我们实现了库最简单的雏形，如果我们不断地增加操作外设的函数，并且把所有的外设都写完，一个完整的库就实现了。

本章中的GPIO相关库函数及结构体定义，实际上都是从ST的HAL库搬过来的。这样分析它纯粹是为了满足自己的求知欲，学习其编程的方式、思想，这对提高我们的编程水平是很有好处的，顺便感受一下ST库设计的严谨性，我认为这样的代码不仅严谨且华丽优美，不知您是否也有这样的感受。

与直接配置寄存器相比，从执行效率上看会有额外的消耗：初始化变量赋值的过程、库函数在被调用的时候要耗费调用时间；在函数内部，对输入参数转换所需要的额外运算也消耗一些时间(如GPIO中运算求出引脚号时)。而其它的宏、枚举等解释操作是作编译过程完成的，这部分并不消耗内核的时间。那么函数库的优点呢？是我们可以快速上手STM32控制器；配置外设状态时，不需要再纠结要向寄存器写入什么数值；交流方便，查错简单。这就是我们选择库的原因。

现在的处理器的主频是越来越高，我们不需要担心CPU耗费那么多时间来干活会不会被累倒，库主要应用是在初始化过程，而初始化过程一般是芯片刚上电或在核心运算之前的执行的，这段时间的等待是0.02us还是0.01us在很多时候并没有什么区别。相对来说，我们还是担心一下如果都用寄存器操作，每行代码都要查《STM32F7xx规格书》中的说明，自己会不会被累倒吧。

在以后开发的工程中，一般不会去分析ST的库函数的实现了。因为外设的库函数是很类似的，库外设都包含初始化结构体，以及特定的宏或枚举标识符，这些封装被库函数这些转化成相应的值，写入到寄存器之中，函数内部的具体实现是十分枯燥和机械的工作。如果您有兴趣，在您掌握了如何使用外设的库函数之后，可以查看一下它的源码实现。

通常我们只需要通过了解每种外设的“初始化结构体”就能够通过它去了解STM32的外设功能及控制了。


阅读(1474) | 评论(0) | 转发(0) |
0

上一篇：第7章 使用寄存器点亮LED灯

下一篇：第9章 初识HAL固件库

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6