• stm32之GPIO库函数点灯分析

            stm32官方为了方便开发者，利用CubeMX 生成HAL库有关的C代码。HAL库就是硬件抽象层(hardware abstraction layer)，生成一系列的函数帮助我们快速生成工程，脱离复杂的寄存器配置。stm32相对于51来功能强大，但是寄存器的数量也不是一个量级，单靠配置寄存器来做项目的话，进度会非常缓慢。但是在学习阶段还是有必要研究一个寄存器配置或者说研究HAL是如何操作寄存器的。

    一、利用CubeMX 生成代码

    具体怎么操作的这里就不讲解了，网上一大堆。实验用的开发板用的led，一端接到vcc,一端接到PB9(GPIO_B的第9个引脚)，当PB9输出低电平时，led就会亮，反之则灭。

    生成的工程中，main函数内调用了MX_GPIO_Init函数，这个是GPIO_B_9引脚的初始化。

    函数示例如下：

    1. void MX_GPIO_Init(void)
    2. {
    3.  
    4.   GPIO_InitTypeDef GPIO_InitStruct = {0};
    5.  
    6.   /* GPIO Ports Clock Enable */
    7.   __HAL_RCC_GPIOD_CLK_ENABLE();
    8.   __HAL_RCC_GPIOA_CLK_ENABLE();
    9.   __HAL_RCC_GPIOB_CLK_ENABLE();
    10.  
    11.   /*Configure GPIO pin Output Level */
    12. 	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, GPIO_PIN_RESET);
    13.   /*Configure GPIO pin : PB9 */
    14.   GPIO_InitStruct.Pin = GPIO_PIN_9;
    15.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    16.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    17.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    18.   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    19.  
    20. }

    整个过程就是

    1. 配置__HAL_RCC_GPIOB_CLK_ENABLE时钟，
    2. 配置GPIO_InitTypeDef变量，
    3. 给GPIO_PIN_9进行reset操作，也是给引脚设置成0
    4. HAL_GPIO_Init进行初始化。

    1.1、 GPIO_InitTypeDef类型定义

    1. typedef struct
    2. {
    3.   uint32_t Pin;       /*!< Specifies the GPIO pins to be configured.
    4.                            This parameter can be any value of @ref GPIO_pins_define */
    5.  
    6.   uint32_t Mode;      /*!< Specifies the operating mode for the selected pins.
    7.                            This parameter can be a value of @ref GPIO_mode_define */
    8.  
    9.   uint32_t Pull;      /*!< Specifies the Pull-up or Pull-Down activation for the selected pins.
    10.                            This parameter can be a value of @ref GPIO_pull_define */
    11.  
    12.   uint32_t Speed;     /*!< Specifies the speed for the selected pins.
    13.                            This parameter can be a value of @ref GPIO_speed_define */
    14. } GPIO_InitTypeDef;

     结构体内部有四个成员变量

    • Pin: 要配置的引脚
    • Mode: 要配置的模式，输入或输出
    • Pull: 配置上拉、下拉或者两者都不
    • Speed：这里的speed暂时有三种模式，low(2MHZ), medium(10MHZ), high(50MHZ),后续会有说明

    引脚有两种状态，0或1，定义如下

    1. typedef enum
    2. {
    3.   GPIO_PIN_RESET = 0u,
    4.   GPIO_PIN_SET
    5. } GPIO_PinState;

    1.2、给GPIOB开启时钟

    在stm32中每个片上外设都有对应的时钟，所以在使用时都需要开启。GPIOB时钟开启的代码如下所示

    1. #define __HAL_RCC_GPIOB_CLK_ENABLE()   do { \
    2.                                         __IO uint32_t tmpreg; \
    3.                                         SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPBEN);\
    4.                                         /* Delay after an RCC peripheral clock enabling */\
    5.                                         tmpreg = READ_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPBEN);\
    6.                                         UNUSED(tmpreg); \
    7.                                       } while(0U)

    代码里面就是搞了一个宏进行设置的。其中__IO 也是一个宏，它的类型是volatile,意为“直接存取原始内存地址”。

    1.2.1、 SET_BIT是一个宏，作用就是将寄存器的某一个设置成1。
    #define SET_BIT(REG, BIT)     ((REG) |= (BIT))

    另外所有GPIO是挂载到APB2总线上的，

    SET_BIT的第一个参数是APB2ENR，这里就涉及到RCC_APB2ENR寄存器。

     所有外设都需要时钟驱动，这里用到的是GPIO_B, 所以要把RCC_APB2ENR中的第3位置1。

    SET_BIT的第二个参数是一个宏

    1. #define RCC_APB2ENR_IOPBEN_Pos               (3U)                              
    2. #define RCC_APB2ENR_IOPBEN_Msk               (0x1UL << RCC_APB2ENR_IOPBEN_Pos)  /*!< 0x00000008 */
    3. #define RCC_APB2ENR_IOPBEN                   RCC_APB2ENR_IOPBEN_Msk            /*!< I/O port B clock enable */

    它代表的意思是通过移位将第3位(从0开始数)变成1，其它位都是0。

    这样一来 SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPBEN) 代表的意思就是将RCC_APB2ENR寄存器中的第三位置1，也即使能GPIOB。

    另外一点是RCC_APB2ENR_IOPBEN寄存器的获取是通过RCC->APB2ENR这种形式。这里又涉及到RCC的问题。

    1.2.2、RCC相关寄存器

    RCC内部包括一系列和时钟相关的寄存器，当然也包括APB2ENR。RCC是一个宏，我把相关代码集中到一块如下所示

    1. // 所有外设的基址
    2. #define PERIPH_BASE           0x40000000UL /*!< Peripheral base address in the alias region */
    3.  
    4. // 这里AHB的基址
    5. #define AHBPERIPH_BASE        (PERIPH_BASE + 0x00020000UL)
    6.  
    7. // RCC 是挂载到AHB上的
    8. define RCC_BASE              (AHBPERIPH_BASE + 0x00001000UL)
    9.  
    10. // RCC 包括众多寄存器，这里通过C语言的结构体和指针进行操作,将RCC的地址绑定到RCC_BASE
    11. #define RCC                 ((RCC_TypeDef *)RCC_BASE)
    12.  
    13. typedef struct
    14. {
    15.   __IO uint32_t CR;
    16.   __IO uint32_t CFGR;
    17.   __IO uint32_t CIR;
    18.   __IO uint32_t APB2RSTR;
    19.   __IO uint32_t APB1RSTR;
    20.   __IO uint32_t AHBENR;
    21.   __IO uint32_t APB2ENR;
    22.   __IO uint32_t APB1ENR;
    23.   __IO uint32_t BDCR;
    24.   __IO uint32_t CSR;
    25.  
    26.  
    27. } RCC_TypeDef

    通过上面的操作，就可以利用RCC这个指针来操作各个寄存器，RCC内的变量都是按照寄存器的顺序排列的。这里再强制一点，RCC是挂载到AHB总线上的，所以它的地址是相对AHB总线进行偏移的。

    1.2.3、READ_BIT

    知道了SET_BIT, 那么READ_BIT也清楚了，采取的操作都差不多，作用就是取出指定的位。

    将要取出的位置1，其它位全部是0，这样就取出了指定位。

    #define READ_BIT(REG, BIT)    ((REG) & (BIT))

    1.3、HAL_GPIO_WritePin 

    这个函数的定义如下：

    1. void HAL_GPIO_WritePin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState)
    2. {
    3.   /* Check the parameters */
    4.   assert_param(IS_GPIO_PIN(GPIO_Pin));
    5.   assert_param(IS_GPIO_PIN_ACTION(PinState));
    6.  
    7.   if (PinState != GPIO_PIN_RESET)
    8.   {
    9.     GPIOx->BSRR = GPIO_Pin;
    10.   }
    11.   else
    12.   {
    13.     GPIOx->BSRR = (uint32_t)GPIO_Pin << 16u;
    14.   }
    15. }

    这里可以看到主要是设置寄存器BSRR。这个函数传入的第一个参数是GPIOB，GPIOB的配置和上面说的RCC采用相似的策略

    1. // 所有外设的基址
    2. #define PERIPH_BASE           0x40000000UL /*!< Peripheral base address in the alias region */
    3.  
    4. // APB2总线基址
    5. #define APB2PERIPH_BASE       (PERIPH_BASE + 0x00010000UL)
    6. // GPIOB总线基址，GPIO是挂载到APB2上的
    7. #define GPIOB_BASE            (APB2PERIPH_BASE + 0x00000C00UL)
    8. // GPIOB 包括众多寄存器，这里通过C语言的结构体和指针进行操作,将GPIOB的地址绑定到GPIOB_BASE
    9. #define GPIOB               ((GPIO_TypeDef *)GPIOB_BASE)
    10.  
    11. typedef struct
    12. {
    13.   __IO uint32_t CRL;
    14.   __IO uint32_t CRH;
    15.   __IO uint32_t IDR;
    16.   __IO uint32_t ODR;
    17.   __IO uint32_t BSRR;
    18.   __IO uint32_t BRR;
    19.   __IO uint32_t LCKR;
    20. } GPIO_TypeDef;

     BSRR寄存器定义如下：

    ODR(端口输出数据寄存器)定义如下：

    上面简单来讲

    • 给BSy设置1，ODR对应的位会输出1
    • 给BRy设置1，ODR对应的位会输出0

    所以设置将引脚设置成0时需要在BSRR高16位进行操作，输出1 时在BSRR低16位进行操作。

    1.4、HAL_GPIO_Init

    这里涉及主要的初始化配置，是重中之重。涉及的函数比较多，已经在里面添加了注释。

    1. void HAL_GPIO_Init(GPIO_TypeDef  *GPIOx, GPIO_InitTypeDef *GPIO_Init)
    2. {
    3. 	//通过这个变量遍历所有的引脚
    4.   uint32_t position = 0x00u;
    5.   uint32_t ioposition;
    6.   uint32_t iocurrent;
    7.   uint32_t temp;
    8.   uint32_t config = 0x00u;
    9. 	// 
    10.   __IO uint32_t *configregister; /* Store the address of CRL or CRH register based on pin number */
    11. 	// 引脚的偏移量（每个引脚由CNF和MODE总共4位组成）
    12.   uint32_t registeroffset;       /* offset used during computation of CNF and MODE bits placement inside CRL or CRH register */
    13.  
    14.   /* Check the parameters */
    15.   assert_param(IS_GPIO_ALL_INSTANCE(GPIOx));
    16.   assert_param(IS_GPIO_PIN(GPIO_Init->Pin));
    17.   assert_param(IS_GPIO_MODE(GPIO_Init->Mode));
    18.  
    19. 	// 判断后续是否还有引脚设置了1
    20.   while (((GPIO_Init->Pin) >> position) != 0x00u)
    21.   {
    22.     /* 获取引脚的位置 */
    23.     ioposition = (0x01uL << position);
    24.  
    25.     /* 再次能过Pin获取当前要设置的引脚 */
    26.     iocurrent = (uint32_t)(GPIO_Init->Pin) & ioposition;
    27.  
    28. 		// 两种方式求得的引脚比较如果相同才进行处理
    29.     if (iocurrent == ioposition)
    30.     {
    31.       /* Check the Alternate function parameters */
    32.       assert_param(IS_GPIO_AF_INSTANCE(GPIOx));
    33.  
    34.       /* Based on the required mode, filling config variable with MODEy[1:0] and CNFy[3:2] corresponding bits */
    35. 			// 根据模式来配置config
    36.       switch (GPIO_Init->Mode)
    37.       {
    38.         /* 推挽输出模式 */
    39.         case GPIO_MODE_OUTPUT_PP:
    40.           /* Check the GPIO speed parameter */
    41.           assert_param(IS_GPIO_SPEED(GPIO_Init->Speed));
    42.           config = GPIO_Init->Speed + GPIO_CR_CNF_GP_OUTPUT_PP;
    43.           break;
    44.  
    45.         /* 开漏输出模式 */
    46.         case GPIO_MODE_OUTPUT_OD:
    47.           /* Check the GPIO speed parameter */
    48.           assert_param(IS_GPIO_SPEED(GPIO_Init->Speed));
    49.           config = GPIO_Init->Speed + GPIO_CR_CNF_GP_OUTPUT_OD;
    50.           break;
    51.  
    52.         /* 复用推挽模式 */
    53.         case GPIO_MODE_AF_PP:
    54.           /* Check the GPIO speed parameter */
    55.           assert_param(IS_GPIO_SPEED(GPIO_Init->Speed));
    56.           config = GPIO_Init->Speed + GPIO_CR_CNF_AF_OUTPUT_PP;
    57.           break;
    58.  
    59.         /* 复用开漏输出模式  */
    60.         case GPIO_MODE_AF_OD:
    61.           /* Check the GPIO speed parameter */
    62.           assert_param(IS_GPIO_SPEED(GPIO_Init->Speed));
    63.           config = GPIO_Init->Speed + GPIO_CR_CNF_AF_OUTPUT_OD;
    64.           break;
    65.  
    66.         /* 下面是输入，要么事件输入要么中断输入 */
    67. 				// 输入悬空
    68.         case GPIO_MODE_INPUT:
    69. 				// 中断上升沿
    70.         case GPIO_MODE_IT_RISING:
    71. 				// 中断下降沿
    72.         case GPIO_MODE_IT_FALLING:
    73. 				// 中断上长或下降沿
    74.         case GPIO_MODE_IT_RISING_FALLING:
    75. 				// 事件上长沿
    76.         case GPIO_MODE_EVT_RISING:
    77. 				// 事件下降沿
    78.         case GPIO_MODE_EVT_FALLING:
    79. 				// 事件上长或下降沿
    80.         case GPIO_MODE_EVT_RISING_FALLING:
    81.           /* Check the GPIO pull parameter */
    82.           assert_param(IS_GPIO_PULL(GPIO_Init->Pull));
    83.           if (GPIO_Init->Pull == GPIO_NOPULL)
    84.           {
    85.             config = GPIO_CR_MODE_INPUT + GPIO_CR_CNF_INPUT_FLOATING;
    86.           }
    87.           else if (GPIO_Init->Pull == GPIO_PULLUP)
    88.           {
    89.             config = GPIO_CR_MODE_INPUT + GPIO_CR_CNF_INPUT_PU_PD;
    90.  
    91.             /* Set the corresponding ODR bit */
    92.             GPIOx->BSRR = ioposition;
    93.           }
    94.           else /* GPIO_PULLDOWN */
    95.           {
    96.             config = GPIO_CR_MODE_INPUT + GPIO_CR_CNF_INPUT_PU_PD;
    97.  
    98.             /* Reset the corresponding ODR bit */
    99.             GPIOx->BRR = ioposition;
    100.           }
    101.           break;
    102.  
    103.         /* 模拟输入 */
    104.         case GPIO_MODE_ANALOG:
    105.           config = GPIO_CR_MODE_INPUT + GPIO_CR_CNF_ANALOG;
    106.           break;
    107.  
    108.         /* Parameters are checked with assert_param */
    109.         default:
    110.           break;
    111.       }
    112.  
    113.       /* Check if the current bit belongs to first half or last half of the pin count number
    114.        in order to address CRH or CRL register*/
    115. 			/*
    116. 				点灯目前没有用到输入模式，只用到输出模式
    117. 			1、如果当前的引脚是低8位，那就是么对CRL的操作，否则就是对CRH的操作
    118. 			2、如果当前的引脚是低8位，将Postion向左偏移四位，操作的就是当前引脚的MODE和CNF.
    119. 				如果是高8位，将(position - 8u)向左偏移四位，操作的就是当前引脚的MODE和CNF.
    120. 			*/
    121.       configregister = (iocurrent < GPIO_PIN_8) ? &GPIOx->CRL     : &GPIOx->CRH;
    122.       registeroffset = (iocurrent < GPIO_PIN_8) ? (position << 2u) : ((position - 8u) << 2u);
    123.  
    124.       /* 清除当前引脚的配置，并设置新配置 */
    125.       MODIFY_REG((*configregister), ((GPIO_CRL_MODE0 | GPIO_CRL_CNF0) << registeroffset), (config << registeroffset));
    126.  
    127.       //  由于没有中断这里的操作是可以删除的
    128.       /*--------------------- EXTI Mode Configuration ------------------------*/
    129.       /* Configure the External Interrupt or event for the current IO */
    130.       if ((GPIO_Init->Mode & EXTI_MODE) == EXTI_MODE)
    131.       {
    132.         /* Enable AFIO Clock */
    133.         __HAL_RCC_AFIO_CLK_ENABLE();
    134.         temp = AFIO->EXTICR[position >> 2u];
    135.         CLEAR_BIT(temp, (0x0Fu) << (4u * (position & 0x03u)));
    136.         SET_BIT(temp, (GPIO_GET_INDEX(GPIOx)) << (4u * (position & 0x03u)));
    137.         AFIO->EXTICR[position >> 2u] = temp;
    138.  
    139.  
    140.         /* Enable or disable the rising trigger */
    141.         if ((GPIO_Init->Mode & RISING_EDGE) == RISING_EDGE)
    142.         {
    143.           SET_BIT(EXTI->RTSR, iocurrent);
    144.         }
    145.         else
    146.         {
    147.           CLEAR_BIT(EXTI->RTSR, iocurrent);
    148.         }
    149.  
    150.         /* Enable or disable the falling trigger */
    151.         if ((GPIO_Init->Mode & FALLING_EDGE) == FALLING_EDGE)
    152.         {
    153.           SET_BIT(EXTI->FTSR, iocurrent);
    154.         }
    155.         else
    156.         {
    157.           CLEAR_BIT(EXTI->FTSR, iocurrent);
    158.         }
    159.  
    160.         /* Configure the event mask */
    161.         if ((GPIO_Init->Mode & GPIO_MODE_EVT) == GPIO_MODE_EVT)
    162.         {
    163.           SET_BIT(EXTI->EMR, iocurrent);
    164.         }
    165.         else
    166.         {
    167.           CLEAR_BIT(EXTI->EMR, iocurrent);
    168.         }
    169.  
    170.         /* Configure the interrupt mask */
    171.         if ((GPIO_Init->Mode & GPIO_MODE_IT) == GPIO_MODE_IT)
    172.         {
    173.           SET_BIT(EXTI->IMR, iocurrent);
    174.         }
    175.         else
    176.         {
    177.           CLEAR_BIT(EXTI->IMR, iocurrent);
    178.         }
    179.       }
    180.     }
    181.  
    182. 	position++;
    183.   }
    184. }

    代码相关的解释已经写到注释里了，这里有一个比较有意思的点。

    开始是GPIO_Init->Speed设置的是GPIO_SPEED_FREQ_LOW，它其实是一个有关MODE的宏，就是和CNY对应的MODE的宏。

    1. #define GPIO_CRL_MODE0_Pos                   (0U)   
    2.                            
    3. // 这个就是50MHZ的输出模式
    4. #define GPIO_CRL_MODE0_Msk                   (0x3UL << GPIO_CRL_MODE0_Pos)      /*!< 0x00000003 */
    5. // 这个就是50MHZ的输出模式
    6. #define GPIO_CRL_MODE0                       GPIO_CRL_MODE0_Msk                /*!< MODE0[1:0] bits (Port x mode bits, pin 0) */
    7. // 这个就是1的输出模式
    8. #define GPIO_CRL_MODE0_0                     (0x1UL << GPIO_CRL_MODE0_Pos)      /*!< 0x00000001 */
    9. // 这个就是2MHZ的输出模式
    10. #define GPIO_CRL_MODE0_1                     (0x2UL << GPIO_CRL_MODE0_Pos)      /*!< 0x00000002 */
    11.  
    12.  
    13. #define  GPIO_SPEED_FREQ_LOW              (GPIO_CRL_MODE0_1) /*!< Low speed */
    14. #define  GPIO_SPEED_FREQ_MEDIUM           (GPIO_CRL_MODE0_0) /*!< Medium speed */
    15. #define  GPIO_SPEED_FREQ_HIGH             (GPIO_CRL_MODE0)   /*!< High speed */

    所以初始化的Speed其实就是设置了MODE。而对于每个输出模式，在HAL_GPIO_Init函数里都用到这样的操作

    1. // 低二位都是0,为了配合Mode
    2. #define  GPIO_CR_CNF_GP_OUTPUT_PP   0x00000000u /*!< 00: General purpose output push-pull  */
    3. // 低二位都是0,为了配合Mode
    4. #define  GPIO_CR_CNF_GP_OUTPUT_OD   0x00000004u /*!< 01: General purpose output Open-drain  */
    5. // 低二位都是0,为了配合Mode
    6. #define  GPIO_CR_CNF_AF_OUTPUT_PP   0x00000008u /*!< 10: Alternate function output Push-pull  */
    7. // 低二位都是0,为了配合Mode
    8. #define  GPIO_CR_CNF_AF_OUTPUT_OD   0x0000000Cu /*!< 11: Alternate function output Open-drain  */
    9.  
    10. // 这里就是配置CNF+Mode
    11. config = GPIO_Init->Speed + GPIO_CR_CNF_GP_OUTPUT_PP;

    其实就是将MODE和CNF结合到一块共同控制一个引脚。

    二、在main()自定义操作

    知道了库函数的操作，其实我们自己也可以将Led灯进行点亮或者熄灭，比如

    1. // 熄灭
    2. GPIOB->BSRR = GPIO_PIN_9;
    3. // 点亮
    4. GPIOB->BSRR = GPIO_PIN_9 << 16;

    其实最终就是操作的寄存器（不研究也知道操作的寄存器，哈哈哈）。

    点灯对寄存器的操作如下：

    1. 配置APB2ENR开启GPIOB时钟
    2. 配置CRL或CRH，来操作引脚的CNF和MODE，让其作为输入或输出
    3. 配置BSRR使ODR对应的位输出1或0

    通过对stm32内存映射和GPIO寄存器的分析，大致了解了HAL的一些细节，确实单独操作寄存器难度比较大，但是通过对HAL函数的研究，加深了自己对HAL操作的了解以及寄存器细节的了解。

  • 相关阅读:
    计算机基础-BAT入门进阶
    分享两个模糊照片修复方法，轻松实现照片修复
    Vue技术 props配置
    【【萌新的SOC学习之AXI-DMA环路测试】】
    【MySQL】1.索引
    JavaScript 之 Symbol 数据类型
    五年制专转本备考中如何进行有效的自我管理
    动画：面试官问我插入排序和冒泡排序哪个更牛逼？
    day2_QT
    查看linux版本是centos还是redhat linux
  • 原文地址：https://blog.csdn.net/TSC1235/article/details/132890759