• PY32F003F18的GPIO函数

    PY32F003F18的HAL_GPIO_Init()函数功能强大。

    1、HAL_GPIO_Init(GPIO_TypeDef  *GPIOx, GPIO_InitTypeDef *GPIO_Init)

    这个函数把将引脚配置为"输入，输出,模拟或AF辅助功能"，以及外部中断中断和中断事件使能都放在里面，还包括了中断线连接。功能强大，有点难理解。

    源函数：

    1. //函数功能:根据GPIO_Init结构指针所指向的参数初始化GPIOx的外设寄存器
    2. void HAL_GPIO_Init(GPIO_TypeDef  *GPIOx, GPIO_InitTypeDef *GPIO_Init)
    3. {
    4.   uint32_t position = 0x00u;
    5.   uint32_t iocurrent;
    6.   uint32_t temp;
    7.  
    8.   /* Check the parameters */
    9.   assert_param(IS_GPIO_ALL_INSTANCE(GPIOx));
    10.   assert_param(IS_GPIO_PIN(GPIO_Init->Pin));
    11.   assert_param(IS_GPIO_MODE(GPIO_Init->Mode));
    12.   assert_param(IS_GPIO_PULL(GPIO_Init->Pull));
    13.  
    14.   /* Configure the port pins */
    15.   while (((GPIO_Init->Pin) >> position) != 0x00u)
    16.   {
    17.     iocurrent = (GPIO_Init->Pin) & (1uL << position);
    18. 		//获取引脚位置,Get current io position
    19.  
    20.     if (iocurrent != 0x00u)//这个引脚需要配置
    21.     {
    22.       /*--------------------- GPIO Mode Configuration ------------------------*/
    23.       /* In case of Alternate function mode selection */
    24.       if ((GPIO_Init->Mode == GPIO_MODE_AF_PP) || (GPIO_Init->Mode == GPIO_MODE_AF_OD))
    25.       {//复用功能推挽模式,复用功能开漏极模式
    26. 				//将外设连接选择的引脚,Peripheral to be connected to the selected pins
    27.         /* Check the Alternate function parameters */
    28.         assert_param(IS_GPIO_AF_INSTANCE(GPIOx));
    29.         assert_param(IS_GPIO_AF(GPIO_Init->Alternate));
    30.  
    31.         /* Configure Alternate function mapped with the current IO */
    32.         temp = GPIOx->AFR[position >> 3u];
    33. 				//当position<8时,表示GPIOx->AFR[0],读"GPIO复用功能寄存器(low)GPIOx_AFRL"
    34. 				//当position>7时,表示GPIOx->AFR[1],读"GPIO复用功能寄存器(high)GPIOx_AFRH"
    35.         temp &= ~(0xFu << ((position & 0x07u) * 4u));//将第position个AF值清除
    36.         temp |= ((GPIO_Init->Alternate) << ((position & 0x07u) * 4u));//修改第position个AF值
    37.         GPIOx->AFR[position >> 3u] = temp;
    38. 				//当position<8时,表示GPIOx->AFR[0],将temp写入"GPIO复用功能寄存器(low)GPIOx_AFRL"
    39. 				//当position>7时,表示GPIOx->AFR[1],将temp写入读"GPIO复用功能寄存器(high)GPIOx_AFRH"
    40.       }
    41.  
    42.       /* Configure IO Direction mode (Input, Output, Alternate or Analog) */
    43.       temp = GPIOx->MODER;//读"GPIO端口模式寄存器GPIOx_MODER",x=A,B,F
    44.       temp &= ~(GPIO_MODER_MODE0 << (position * 2u));
    45.       temp |= ((GPIO_Init->Mode & GPIO_MODE) << (position * 2u));
    46. 			//GPIO_Init->Mode=00B: 输入模式
    47. 			//GPIO_Init->Mode=01B: 通用输出模式
    48. 			//GPIO_Init->Mode=10B: 复用功能模式
    49. 			//GPIO_Init->Mode=11B: 模拟模式(CPU复位时的状态)
    50.       GPIOx->MODER = temp;//将temp写入"GPIO端口模式寄存器GPIOx_MODER",x=A,B,F
    51.  
    52.       /* In case of Output or Alternate function mode selection */
    53.       if ((GPIO_Init->Mode == GPIO_MODE_OUTPUT_PP) || (GPIO_Init->Mode == GPIO_MODE_AF_PP) ||
    54.           (GPIO_Init->Mode == GPIO_MODE_OUTPUT_OD) || (GPIO_Init->Mode == GPIO_MODE_AF_OD))
    55.       {//推挽输出方式,输出开漏极模式,复用功能推挽模式,复用功能开漏极模式
    56.         /* Check the Speed parameter */
    57.         assert_param(IS_GPIO_SPEED(GPIO_Init->Speed));
    58.         /* Configure the IO Speed */
    59.         temp = GPIOx->OSPEEDR;//读"GPIO端口输出速度寄存器GPIOx_OSPEEDR"
    60.         temp &= ~(GPIO_OSPEEDR_OSPEED0 << (position * 2u));
    61.         temp |= (GPIO_Init->Speed << (position * 2u));
    62. 				//GPIO_Init->Speed=00B：IO口的输出速度为非常低
    63. 				//GPIO_Init->Speed=01B：IO口的输出速度为低速
    64. 				//GPIO_Init->Speed=10B：IO口的输出速度为高速
    65. 				//GPIO_Init->Speed=11B：IO口的输出速度为非常高
    66.         GPIOx->OSPEEDR = temp;//将temp写入"GPIO端口输出速度寄存器GPIOx_OSPEEDR"
    67.  
    68.         /* Configure the IO Output Type */
    69.         temp = GPIOx->OTYPER;//读"GPIO端口输出类型寄存器GPIOx_OTYPER"
    70.         temp &= ~(GPIO_OTYPER_OT0 << position) ;
    71.         temp |= (((GPIO_Init->Mode & GPIO_OUTPUT_TYPE) >> 4u) << position);
    72. 				//GPIO_Init->Mode=0B: 推挽输出(CPU复位时的状态)
    73. 				//GPIO_Init->Mode=1B: 开漏输出
    74.         GPIOx->OTYPER = temp;//将temp写入"GPIO端口输出类型寄存器GPIOx_OTYPER"
    75.       }
    76.  
    77.       /* Activate the Pull-up or Pull down resistor for the current IO */
    78.       temp = GPIOx->PUPDR;//读"GPIO 端口上下拉寄存器GPIOx_PUPDR",x=A,B,F
    79.       temp &= ~(GPIO_PUPDR_PUPD0 << (position * 2u));
    80.       temp |= ((GPIO_Init->Pull) << (position * 2u));
    81. 			//GPIO_Init->Pull=00B: 无上下拉
    82. 			//GPIO_Init->Pull=01B: 上拉
    83. 			//GPIO_Init->Pull=10B: 下拉
    84. 			//GPIO_Init->Pull=11B: 保留
    85.       GPIOx->PUPDR = temp;//将temp写入"GPIO 端口上下拉寄存器GPIOx_PUPDR",x=A,B,F
    86.  
    87.       /*--------------------- EXTI Mode Configuration ------------------------*/
    88.       /* Configure the External Interrupt or event for the current IO */
    89.       if ((GPIO_Init->Mode & EXTI_MODE) == EXTI_MODE)
    90.       {
    91.         temp = EXTI->EXTICR[position >> 2u];//读"外部中断选择寄存器"
    92. 				//外部中断选择寄存器1(EXTI_EXTICR1)
    93. 				//外部中断选择寄存器2(EXTI_EXTICR2)
    94. 				//外部中断选择寄存器3(EXTI_EXTICR3)
    95.         temp &= ~(0x0FuL << (8u * (position & 0x03u)));
    96.         temp |= (GPIO_GET_INDEX(GPIOx) << (8u * (position & 0x03u)));
    97.         EXTI->EXTICR[position >> 2u] = temp;//将temp写入"外部中断选择寄存器"
    99.         /* Clear EXTI line configuration */
    100.         temp = EXTI->IMR;//读"中断屏蔽寄存器EXTI_IMR"
    101.         temp &= ~(iocurrent);//不使能引脚建立中断标志
    102.         if ((GPIO_Init->Mode & GPIO_MODE_IT) == GPIO_MODE_IT)
    103.         {
    104.           temp |= iocurrent;//允许引脚在外部触发时建立中断标志
    105.         }
    106.         EXTI->IMR = temp;//将temp值写入"中断屏蔽寄存器EXTI_IMR"
    107.  
    108.         temp = EXTI->EMR;//读"事件屏蔽寄存器EXTI_EMR"
    109.         temp &= ~(iocurrent);//不使能引脚建立事件标志
    110.         if ((GPIO_Init->Mode & GPIO_MODE_EVT) == GPIO_MODE_EVT)
    111.         {
    112.           temp |= iocurrent;//允许引脚在外部触发时建立事件标志
    113.         }
    114.         EXTI->EMR = temp;//将temp值写入"事件屏蔽寄存器EXTI_EMR"
    115.  
    116.         /* Clear Rising Falling edge configuration */
    117.         temp = EXTI->RTSR;//读"上升沿触发选择寄存器EXTI_RTSR"
    118.         temp &= ~(iocurrent);
    119.         if ((GPIO_Init->Mode & RISING_EDGE) == RISING_EDGE)
    120.         {
    121.           temp |= iocurrent;
    122.         }
    123.         EXTI->RTSR = temp;//将temp值写入"上升沿触发选择寄存器EXTI_RTSR"
    124.  
    125.         temp = EXTI->FTSR;//读"下降沿触发选择寄存器EXTI_FTSR"
    126.         temp &= ~(iocurrent);
    127.         if ((GPIO_Init->Mode & FALLING_EDGE) == FALLING_EDGE)
    128.         {
    129.           temp |= iocurrent;
    130.         }
    131.         EXTI->FTSR = temp;//将temp值写入"下降沿触发选择寄存器EXTI_FTSR"
    132.       }
    133.     }
    134.  
    135.     position++;
    136.   }
    137. }

    2、函数分解：

    如果把它们搬开，需要下面这几个函数才能实现其一个函数的功能。

    void Configure_Alternate_function_mapped_with_Pin(GPIO_TypeDef *GPIOx,uint32_t Pin,uint32_t alternate);
    void Configure_Pin_Direction_mode(GPIO_TypeDef *GPIOx,uint32_t Pin,uint32_t mode);
    void Configure_Pin_Speed(GPIO_TypeDef *GPIOx,uint32_t Pin,uint32_t speed);
    void Configure_Pin_Output_Type(GPIO_TypeDef *GPIOx,uint32_t Pin,uint32_t mode);
    void Activate_Pull_up_or_Pull_down_for_Pin(GPIO_TypeDef *GPIOx,uint32_t Pin,uint32_t pull);
    void Select_External_Interrupt_Line(GPIO_TypeDef *GPIOx,uint32_t Pin);
    void Set_EXTI_line_X_InterruptSwitch(uint32_t Pin,uint32_t mode);
    void Set_EXTI_line_X_EventSwitch(uint32_t Pin,uint32_t mode);
    void Set_Rising_And_Falling_Mode(uint32_t Pin,uint32_t mode);

    1. #include "MyGPIO.h"
    2.  
    3. void Configure_Alternate_function_mapped_with_Pin(GPIO_TypeDef *GPIOx,uint32_t Pin,uint32_t alternate);
    4. void Configure_Pin_Direction_mode(GPIO_TypeDef *GPIOx,uint32_t Pin,uint32_t mode);
    5. void Configure_Pin_Speed(GPIO_TypeDef *GPIOx,uint32_t Pin,uint32_t speed);
    6. void Configure_Pin_Output_Type(GPIO_TypeDef *GPIOx,uint32_t Pin,uint32_t mode);
    7. void Activate_Pull_up_or_Pull_down_for_Pin(GPIO_TypeDef *GPIOx,uint32_t Pin,uint32_t pull);
    8. void Select_External_Interrupt_Line(GPIO_TypeDef *GPIOx,uint32_t Pin);
    9. void Set_EXTI_line_X_InterruptSwitch(uint32_t Pin,uint32_t mode);
    10. void Set_EXTI_line_X_EventSwitch(uint32_t Pin,uint32_t mode);
    11. void Set_Rising_And_Falling_Mode(uint32_t Pin,uint32_t mode);
    12.  
    13. GPIO模式配置开始,GPIO Mode Configuration
    14. //函数功能:当引脚配置为"AF复用功能时,需要将外设映射到引脚上
    15. //alternate=GPIO_AF0_USART1,将引脚复用为USART1
    16. //alternate=GPIO_AF1_USART1,将引脚复用为USART1
    17. //alternate=GPIO_AF3_USART1,将引脚复用为USART1
    18. //alternate=GPIO_AF3_USART2,将引脚复用为USART2
    19. //alternate=GPIO_AF4_USART2,将引脚复用为USART2
    20. //alternate=GPIO_AF5_USART2,将引脚复用为USART2
    21. //alternate=GPIO_AF9_USART2,将引脚复用为USART2
    22. void Configure_Alternate_function_mapped_with_Pin(GPIO_TypeDef *GPIOx,uint32_t Pin,uint32_t alternate)
    23. {
    24. 	uint32_t temp;
    25. 	uint32_t position;
    26. 	uint32_t iocurrent;
    27.  
    28. 	position=0;
    29. 	while( (Pin >> position) != 0x00u )
    30. 	{
    31. 		iocurrent = (Pin) & (1uL << position);//获取引脚位置,Get current io position
    32. 		if(iocurrent != 0x00u)//这个引脚需要配置
    33. 		{
    34.         temp = GPIOx->AFR[position >> 3u];
    35. 				//当position<8时,表示GPIOx->AFR[0],读"GPIO复用功能寄存器(low)GPIOx_AFRL"
    36. 				//当position>7时,表示GPIOx->AFR[1],读"GPIO复用功能寄存器(high)GPIOx_AFRH"
    37.         temp &= ~(0xFu << ((position & 0x07u) * 4u));//将第position个AF值清除
    38.         temp |= ( alternate << ((position & 0x07u) * 4u) );//修改第position个AF值
    39.         GPIOx->AFR[position >> 3u] = temp;
    40. 				//当position<8时,表示GPIOx->AFR[0],将temp写入"GPIO复用功能寄存器(low)GPIOx_AFRL"
    41. 				//当position>7时,表示GPIOx->AFR[1],将temp写入读"GPIO复用功能寄存器(high)GPIOx_AFRH"
    42. 		}
    43. 		position++;
    44. 	}
    45. }
    46.  
    47. //函数功能:将引脚配置为"输入，输出,模拟或AF辅助功能"
    48. //mode=00B: 输入模式
    49. //mode=01B: 通用输出模式
    50. //mode=10B: 复用功能模式
    51. //mode=11B: 模拟模式(CPU复位时的状态)
    52. //mode=GPIO_MODE_INPUT,输入
    53. //mode=GPIO_MODE_IT_RISING,输入
    54. //mode=GPIO_MODE_IT_FALLING,输入
    55. //mode=GPIO_MODE_IT_RISING_FALLING,输入
    56. //mode=GPIO_MODE_EVT_RISING,输入
    57. //mode=GPIO_MODE_EVT_FALLING,输入
    58. //mode=GPIO_MODE_EVT_RISING_FALLING,输入
    59. //mode=GPIO_MODE_OUTPUT_PP,输出
    60. //mode=GPIO_MODE_OUTPUT_OD,输出
    61. //mode=GPIO_MODE_AF_PP,AF复用功能模式
    62. //mode=GPIO_MODE_AF_OD,AF复用功能模式
    63. //mode=GPIO_MODE_ANALOG,模拟模式
    64. //外部引脚边沿检测事件属于输入事件,不属于AF复用功能模式
    65. void Configure_Pin_Direction_mode(GPIO_TypeDef *GPIOx,uint32_t Pin,uint32_t mode)
    66. {
    67. 	uint32_t temp;
    68. 	uint32_t position;
    69. 	uint32_t iocurrent;
    70.  
    71. 	position=0;
    72. 	while( (Pin >> position) != 0x00u )
    73. 	{
    74. 		iocurrent = (Pin) & (1uL << position);//获取引脚位置,Get current io position
    75. 		if(iocurrent != 0x00u)//这个引脚需要配置
    76. 		{
    77.       temp = GPIOx->MODER;//读"GPIO端口模式寄存器GPIOx_MODER",x=A,B,F
    78.       temp &= ~(GPIO_MODER_MODE0 << (position * 2u));
    79.       temp |= ((mode & 0x00000003) << (position * 2u));
    80. 			//mode=00B: 输入模式
    81. 			//mode=01B: 通用输出模式
    82. 			//mode=10B: 复用功能模式
    83. 			//mode=11B: 模拟模式(CPU复位时的状态)
    84.       GPIOx->MODER = temp;//将temp写入"GPIO端口模式寄存器GPIOx_MODER",x=A,B,F
    85. 		}
    86. 		position++;
    87. 	}
    88. }
    89.  
    90. //函数功能:在"引脚为输出或AF复用功能"时,需要配置引脚工作速度,输入和模拟不需要配置速度
    91. //speed=GPIO_SPEED_FREQ_LOW,IO口的输出速度为非常低
    92. //speed=GPIO_SPEED_FREQ_MEDIUM,IO口的输出速度为低速
    93. //speed=GPIO_SPEED_FREQ_HIGH,IO口的输出速度为高速
    94. //speed=GPIO_SPEED_FREQ_VERY_HIGH,IO口的输出速度为非常高
    95. void Configure_Pin_Speed(GPIO_TypeDef *GPIOx,uint32_t Pin,uint32_t speed)
    96. {
    97. 	uint32_t temp;
    98. 	uint32_t position;
    99. 	uint32_t iocurrent;
    100.  
    101. 	position=0;
    102. 	while( (Pin >> position) != 0x00u )
    103. 	{
    104. 		iocurrent = (Pin) & (1uL << position);//获取引脚位置,Get current io position
    105. 		if(iocurrent != 0x00u)//这个引脚需要配置
    106. 		{
    107. 			temp = GPIOx->OSPEEDR;//读"GPIO端口输出速度寄存器GPIOx_OSPEEDR"
    108. 			temp &= ~(GPIO_OSPEEDR_OSPEED0 << (position * 2u));
    109. 			temp |= (speed << (position * 2u));
    110. 			//speed=00B：IO口的输出速度为非常低
    111. 			//speed=01B：IO口的输出速度为低速
    112. 			//speed=10B：IO口的输出速度为高速
    113. 			//speed=11B：IO口的输出速度为非常高
    114. 			GPIOx->OSPEEDR = temp;//将temp写入"GPIO端口输出速度寄存器GPIOx_OSPEEDR"
    115. 		}
    116. 		position++;
    117. 	}
    118. }
    119.  
    120. //函数功能:在"引脚为输出或AF复用功能"时,需要配置"引脚输出模式",输入和模拟不需要配置速度
    121. //mode=0B: 推挽输出(CPU复位时的状态)
    122. //mode=1B: 开漏输出
    123. //mode=GPIO_MODE_OUTPUT_PP,推挽输出
    124. //mode=GPIO_MODE_OUTPUT_OD,开漏输出
    125. //mode=GPIO_MODE_AF_PP,AF复用功能推挽输出模式
    126. //mode=GPIO_MODE_AF_OD,AF复用功能开漏输出模式
    127. void Configure_Pin_Output_Type(GPIO_TypeDef *GPIOx,uint32_t Pin,uint32_t mode)
    128. {
    129. 	uint32_t temp;
    130. 	uint32_t position;
    131. 	uint32_t iocurrent;
    132.  
    133. 	position=0;
    134. 	while( (Pin >> position) != 0x00u )
    135. 	{
    136. 		iocurrent = (Pin) & (1uL << position);//获取引脚位置,Get current io position
    137. 		if(iocurrent != 0x00u)//这个引脚需要配置
    138. 		{
    139. 			temp = GPIOx->OTYPER;//读"GPIO端口输出类型寄存器GPIOx_OTYPER"
    140. 			temp &= ~(GPIO_OTYPER_OT0 << position) ;
    141. 			temp |= ( ( (mode & 0x00000010) >> 4u) << position );
    142. 			//mode=0B: 推挽输出(CPU复位时的状态)
    143. 			//mode=1B: 开漏输出
    144. 			GPIOx->OTYPER = temp;//将temp写入"GPIO端口输出类型寄存器GPIOx_OTYPER"
    145. 		}
    146. 		position++;
    147. 	}
    148. }
    149.  
    150. //函数功能:输入时,可配置"无上下拉,上拉,下拉";模拟功能配置为"无上下拉"
    151. //pull=GPIO_NOPULL: 无上下拉
    152. //pull=GPIO_PULLUP: 上拉
    153. //pull=GPIO_PULLDOWN: 下拉
    154. //pull=11B: 保留
    155. void Activate_Pull_up_or_Pull_down_for_Pin(GPIO_TypeDef *GPIOx,uint32_t Pin,uint32_t pull)
    156. {
    157. 	uint32_t temp;
    158. 	uint32_t position;
    159. 	uint32_t iocurrent;
    160.  
    161. 	position=0;
    162. 	while( (Pin >> position) != 0x00u )
    163. 	{
    164. 		iocurrent = (Pin) & (1uL << position);//获取引脚位置,Get current io position
    165. 		if(iocurrent != 0x00u)//这个引脚需要配置
    166. 		{
    167.       temp = GPIOx->PUPDR;//读"GPIO 端口上下拉寄存器GPIOx_PUPDR",x=A,B,F
    168.       temp &= ~(GPIO_PUPDR_PUPD0 << (position * 2u));
    169.       temp |= ( pull << (position * 2u) );
    170. 			//pull=00B: 无上下拉
    171. 			//pull=01B: 上拉
    172. 			//pull=10B: 下拉
    173. 			//pull=11B: 保留
    174.       GPIOx->PUPDR = temp;//将temp写入"GPIO 端口上下拉寄存器GPIOx_PUPDR",x=A,B,F
    175. 		}
    176. 		position++;
    177. 	}
    178. }
    179. GPIO模式配置开始,GPIO Mode Configuration
    180.  
    181. 外部模式配置开始,EXTI Mode Configuration
    182. //函数功能:连接引脚和EXTI中断线
    183. void Select_External_Interrupt_Line(GPIO_TypeDef *GPIOx,uint32_t Pin)
    184. {
    185. 	uint32_t temp;
    186. 	uint32_t position;
    187. 	uint32_t iocurrent;
    188. 	uint32_t port_x;
    189.  
    190. 	position=0;
    191. 	while( (Pin >> position) != 0x00u )
    192. 	{
    193. 		iocurrent = (Pin) & (1uL << position);//获取引脚位置,Get current io position
    194. 		if(iocurrent != 0x00u)//这个引脚需要配置
    195. 		{
    196. 			temp = EXTI->EXTICR[position >> 2u];//读"外部中断选择寄存器"
    197. 			//外部中断选择寄存器1(EXTI_EXTICR1)
    198. 			//外部中断选择寄存器2(EXTI_EXTICR2)
    199. 			//外部中断选择寄存器3(EXTI_EXTICR3)
    200. 			temp &= ~(0x0FuL << (8u * (position & 0x03u)));
    201. 			port_x=GPIO_GET_INDEX(GPIOx);
    202. 			//当GPIOx=GPIOA,port_x=00B,映射到PA[position]引脚
    203. 			//当GPIOx=GPIOB,port_x=01B,映射到PB[position]引脚
    204. 			//当GPIOx=GPIOF,port_x=10B,映射到PF[position]引脚
    205. 			temp |= ( port_x << (8u * (position & 0x03u)));
    206. 			EXTI->EXTICR[position >> 2u] = temp;//将temp写入"外部中断选择寄存器"
    207. 		}
    208. 		position++;
    209. 	}
    210. }
    211.  
    212. //函数功能:设置中断线x的中断开关
    213. //mode=GPIO_MODE_IT_RISING,输入
    214. //mode=GPIO_MODE_IT_FALLING,输入
    215. //mode=GPIO_MODE_IT_RISING_FALLING,输入
    216. //外部引脚边沿检测事件属于输入事件
    217. void Set_EXTI_line_X_InterruptSwitch(uint32_t Pin,uint32_t mode)
    218. {
    219. 	uint32_t temp;
    220. 	uint32_t position;
    221. 	uint32_t iocurrent;
    222.  
    223. 	position=0;
    224. 	while( (Pin >> position) != 0x00u )
    225. 	{
    226. 		iocurrent = (Pin) & (1uL << position);//获取引脚位置,Get current io position
    227. 		if(iocurrent != 0x00u)//这个引脚需要配置
    228. 		{
    229. 			temp = EXTI->IMR;//读"中断屏蔽寄存器EXTI_IMR"
    230. 			temp &= ~(iocurrent);//不使能引脚建立中断标志
    231. 			if( (mode & 0x00010000) == 0x00010000 )
    232. 			{
    233. 				temp |= iocurrent;//允许引脚在外部触发时建立中断标志
    234. 			}
    235. 			EXTI->IMR = temp;//将temp值写入"中断屏蔽寄存器EXTI_IMR"
    236. 		}
    237. 		position++;
    238. 	}
    239. }
    240.  
    241. //函数功能:设置中断线x的事件开关
    242. //mode=GPIO_MODE_EVT_RISING,输入
    243. //mode=GPIO_MODE_EVT_FALLING,输入
    244. //mode=GPIO_MODE_EVT_RISING_FALLING,输入
    245. //外部引脚边沿检测事件属于输入事件
    246. void Set_EXTI_line_X_EventSwitch(uint32_t Pin,uint32_t mode)
    247. {
    248. 	uint32_t temp;
    249. 	uint32_t position;
    250. 	uint32_t iocurrent;
    251.  
    252. 	position=0;
    253. 	while( (Pin >> position) != 0x00u )
    254. 	{
    255. 		iocurrent = (Pin) & (1uL << position);//获取引脚位置,Get current io position
    256. 		if(iocurrent != 0x00u)//这个引脚需要配置
    257. 		{
    258. 			temp = EXTI->EMR;//读"事件屏蔽寄存器EXTI_EMR"
    259. 			temp &= ~(iocurrent);//不使能引脚建立事件标志
    260. 			if (( mode & 0x00020000) == 0x00020000 )
    261. 			{
    262. 				temp |= iocurrent;//允许引脚在外部触发时建立事件标志
    263.       }
    264.       EXTI->EMR = temp;//将temp值写入"事件屏蔽寄存器EXTI_EMR"
    265. 		}
    266. 		position++;
    267. 	}
    268. }
    269.  
    270. //函数功能:设置引脚边沿检测模式
    271. //mode=GPIO_MODE_IT_RISING,输入
    272. //mode=GPIO_MODE_IT_FALLING,输入
    273. //mode=GPIO_MODE_IT_RISING_FALLING,输入
    274. //mode=GPIO_MODE_EVT_RISING,输入
    275. //mode=GPIO_MODE_EVT_FALLING,输入
    276. //mode=GPIO_MODE_EVT_RISING_FALLING,输入
    277. //外部引脚边沿检测事件属于输入事件,不属于AF复用功能模式
    278. void Set_Rising_And_Falling_Mode(uint32_t Pin,uint32_t mode)
    279. {
    280. 	uint32_t temp;
    281. 	uint32_t position;
    282. 	uint32_t iocurrent;
    283.  
    284. 	position=0;
    285. 	while( (Pin >> position) != 0x00u )
    286. 	{
    287. 		iocurrent = (Pin) & (1uL << position);//获取引脚位置,Get current io position
    288. 		if(iocurrent != 0x00u)//这个引脚需要配置
    289. 		{
    290. 			temp = EXTI->RTSR;//读"上升沿触发选择寄存器EXTI_RTSR"
    291.       temp &= ~(iocurrent);
    292.       if ((mode & 0x00100000) == 0x00100000)
    293.       {
    294.         temp |= iocurrent;
    295.       }
    296.       EXTI->RTSR = temp;//将temp值写入"上升沿触发选择寄存器EXTI_RTSR"
    297.  
    298.       temp = EXTI->FTSR;//读"下降沿触发选择寄存器EXTI_FTSR"
    299.       temp &= ~(iocurrent);
    300.       if ((mode & 0x00200000) == 0x00200000)
    301.       {
    302.         temp |= iocurrent;
    303.       }
    304.       EXTI->FTSR = temp;//将temp值写入"下降沿触发选择寄存器EXTI_FTSR"
    305. 		}
    306. 		position++;
    307. 	}
    308. }
    309. 外部模式配置结束,EXTI Mode Configuration
    310. /*
    311. HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
    312. //这个回调函数没啥用,用户可根据需要修改,建议不用,用了后反而不方便程序移植和管理
    313. HAL_GPIO_EXTI_IRQHandler(uint16_t GPIO_Pin)
    314. 用处不大,若"中断服务程序"需要调用该函数,就需要修改HAL_GPIO_EXTI_Callback()
    316. 设置中断源的中断优先级:
    317. NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
    318. 将IRQn中断源的中断优先级设置为priority
    319. HAL_NVIC_SetPriority(IRQn_Type IRQn, uint32_t PreemptPriority, uint32_t SubPriority)
    320. 它是通过调用NVIC_SetPriority()来实现的
    321. 将IRQn中断源的中断优先级设置为PreemptPriority,SubPriority在程序中不使用
    322. 0<=PreemptPriority<=3,值越大,表示中断优先级越低
    324. 允许中断源产生中断:
    325. NVIC_EnableIRQ(IRQn_Type IRQn)
    326. 允许中断源IRQn在中断标志建立时能够产生中断
    327. HAL_NVIC_EnableIRQ(IRQn_Type IRQn)
    328. 它是通过调用NVIC_EnableIRQ()来实现的
    329. 允许中断源IRQn在中断标志建立时能够产生中断
    331. 不允许中断源产生中断:
    332. NVIC_DisableIRQ(IRQn_Type IRQn)
    333. 不允许中断源IRQn在中断标志建立时能够产生中断
    334. HAL_NVIC_DisableIRQ(IRQn_Type IRQn)
    335. 它是通过调用NVIC_DisableIRQ()来实现的
    336. 不允许中断源IRQn在中断标志建立时能够产生中断
    338. 读取中断源的中断标志位:
    339. NVIC_GetPendingIRQ(IRQn_Type IRQn)
    340. 读取IRQn中断源的中断标志位
    342. 将中断源的中断标志位置位:
    343. NVIC_SetPendingIRQ(IRQn_Type IRQn)
    344. 将IRQn中断源的中断标志位置1,使其产生中断
    346. 清除中断源的中断标志位:
    347. NVIC_ClearPendingIRQ(IRQn_Type IRQn)
    348. //清除IRQn中断源的中断标志位,使其不产生中断
    350. 清除事件标志位:
    351. __HAL_GPIO_EXTI_CLEAR_FLAG(GPIO_PIN_X)和__HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_X)
    352. 这两个功能相同
    353. 根据GPIO_PIN_x,清除"外部中断挂起寄存器EXTI_PR中的PRx位",
    354. 取消引脚产生的上升沿,下降沿或软件触发产生事件标志位;
    355. 清除事件标志位
    357. 读事件标志位:
    358. __HAL_GPIO_EXTI_GET_FLAG(GPIO_PIN_X)和__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_X)
    359. 这两个功能相同
    360. 读"GPIO_PIN_X外部中断线建立的事件标志位"
    362. 在某个外部中断线上上升沿触发事件:
    363. __HAL_GPIO_EXTI_GENERATE_SWIT(GPIO_PIN_X)
    364. 根据GPIO_PIN_x,将"外部软件中断事件寄存器EXTI_SWIER中的SWx位"置1,
    365. 使其产生EXTI line_x上升沿触发事件,进而产生中断,该位由硬件清零;
    367. 普通GPIO功能:
    368. __HAL_RCC_GPIOA_CLK_ENABLE();//使能GPIOA时钟
    369. __HAL_RCC_GPIOB_CLK_ENABLE();//使能GPIOB时钟
    370. __HAL_RCC_GPIOF_CLK_ENABLE();//使能GPIOF时钟
    371. HAL_GPIO_Init(GPIO_TypeDef  *GPIOx, GPIO_InitTypeDef *GPIO_Init)
    372. 根据GPIO_InitTypeDef型结构变量指定的参数初始化GPIOx的外设寄存器
    373. HAL_GPIO_WritePin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState)
    374. PinState=0,GPIOx端口的GPIO_Pin引脚输出低电平;PinState=1,GPIOx端口的GPIO_Pin引脚输出高电平
    375. HAL_GPIO_TogglePin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)
    376. GPIOx端口的GPIO_Pin的输出电平翻转
    377. HAL_GPIO_ReadPin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)
    378. 读取"GPIOx端口的第GPIO_Pin引脚"输入的电平值
    379. HAL_GPIO_DeInit(GPIO_TypeDef  *GPIOx, uint32_t GPIO_Pin)
    380. 将"GPIOx端口的GPIO_Pin引脚"的外设寄存器恢复到"复位时的默认值"
    382. HAL_GPIO_LockPin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)
    383. 锁定GPIO引脚GPIO_Pin的配置;当GPIO_Pin执行了"锁键的写入时序"后,在下次系统复位前将不能再更改端口位的配置;
    384. //这个回调函数没啥用
    385. */

    3、经过测试，可以使用

    1. #include "LED.h"
    2. #include "MyGPIO.h"
    3.  
    4. void MCU_LED_Init(void);
    5.  
    6. //函数功能:MCU_LED灯引脚初始化,并配置为关灯
    7. void MCU_LED_Init(void)
    8. {
    9. /*
    10.   GPIO_InitTypeDef  GPIO_InitStructure;
    11.  
    12.   __HAL_RCC_GPIOB_CLK_ENABLE();//使能GPIOB时钟
    13.  
    14.   //初始化GPIOB5
    15.   GPIO_InitStructure.Pin = GPIO_PIN_5;                  //选择第5脚
    16.   GPIO_InitStructure.Pull = GPIO_PULLUP;                //引脚上拉被激活
    17.   GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_VERY_HIGH; //配置GPIO速度为极高
    18. 	GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;        //设置引脚工作模式为推挽输出方式
    19.  
    20.   HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
    21. 	//根据GPIO_InitStructure结构变量指定的参数初始化GPIOB的外设寄存器
    22. */
    23.  
    24. 	__HAL_RCC_GPIOB_CLK_ENABLE();//使能GPIOB时钟
    25. 	Configure_Pin_Direction_mode(GPIOB,GPIO_PIN_5,GPIO_MODE_OUTPUT_PP);
    26. 	Activate_Pull_up_or_Pull_down_for_Pin(GPIOB,GPIO_PIN_5,GPIO_PULLUP);
    27.  
    28. 	MCU_LED_Off();
    29. }

  • 相关阅读:
    ubuntu 22.04通过apt-get安装的apache2将http改造为https的方法
    数字藏品NFT“无聊猿”BAYC的内忧与外患
    阿斯达年代记三强争霸开服 游戏下载安装+账号注册教程一览
    软件测试 08功能自动化 08 基于Python语言的Selenium基础
    初识manim
    【Arduino27】DHT11温湿度传感器模拟值实验
    面试中的情商考察：如何展示你的人际理解能力
    STM32 CubeMX配置USB HID功能，及安装路径
    Ubuntu 20.04 设置开机自启脚本
    Docker数据集与自定义镜像：构建高效容器的关键要素
  • 原文地址：https://blog.csdn.net/weixin_42550185/article/details/132718443