devbox
喵喵爱编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

STM32HAL库定时器中断、按键中断、串口中断、按键消抖和低通滤波算法详解

作者：喵喵爱编程 | 2024-06-20 08:18:47

赞

踩

hal库定时器中断

本文将详细介绍STM32HAL库中的定时器中断、按键中断、串口中断的使用方法，以及按键消抖和低通滤波算法的实现。希望能对您的STM32开发提供帮助。

目录

1. 定时器中断

2. 按键中断

3. 串口中断

4. 按键消抖

5. 低通滤波算法

一、定时器中断

定时器中断是STM32开发中常用的一种中断方式，主要用于定时执行某些任务，例如按键消抖、定时更新显示等。以下为创建定时器中断的步骤：

1. 配置定时器

首先，在STM32CubeMX中配置相应的定时器，并设置对应的时钟和预分频系数。

 2. 初始化定时器

在main.c文件中，调用HAL_TIM_Base_MspInit()函数初始化定时器。

  1. ```c
  2.  
  3. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base)
  4.  
  5. {
  6.  
  7.   if(htim_base->Instance == TIMx)
  8.  
  9.   {
  10.  
  11.     /* TIMx clock enable */
  12.  
  13.     __HAL_RCC_TIMx_CLK_ENABLE();
  14.  
  15.   
  16.  
  17.     /* TIMx interrupt Init */
  18.  
  19.     HAL_NVIC_SetPriority(TIMx_IRQn, 0, 0);
  20.  
  21.     HAL_NVIC_EnableIRQ(TIMx_IRQn);
  22.  
  23.   }
  24.  
  25. }
  26.  
  27. ```
  28.  
  29.  3. 启动定时器
  30.  
  31. 在main函数中，调用HAL_TIM_Base_Start_IT()函数启动定时器。
  32.  
  33. ```c
  34.  
  35. HAL_TIM_Base_Start_IT(&htimx);
  36.  
  37. ```
  38.  
  39. 4. 编写定时器中断回调函数
  40.  
  41. 在stm32fxxx_it.c文件中，编写定时器中断回调函数。
  42.  
  43. ```c
  44.  
  45. void TIMx_IRQHandler(void)
  46.  
  47. {
  48.  
  49.   HAL_TIM_IRQHandler(&htimx);
  50.  
  51. }
  52.  
  53.  
  54.  
  55. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
  56.  
  57. {
  58.  
  59.   if (htim->Instance == TIMx)
  60.  
  61.   {
  62.  
  63.     // 在这里添加定时任务代码
  64.  
  65.   }
  66.  
  67. }
  68.  
  69. ```

二、 按键中断

按键中断是STM32开发中常用的一种中断方式，主要用于检测按键动作。以下为创建按键中断的步骤：

1. 配置按键引脚

首先，在STM32CubeMX中配置按键引脚，并设置为外部中断模式。

 2. 初始化按键引脚

  1. 在main.c文件中，调用HAL_GPIO_EXTI_MspInit()函数初始化按键引脚。
  2.  
  3. ```c
  4.  
  5. void HAL_GPIO_EXTI_MspInit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
  6.  
  7. {
  8.  
  9.   if(GPIOx == KEY_GPIO_Port && GPIO_Pin == KEY_Pin)
  10.  
  11.   {
  12.  
  13.     /* GPIO clock enable */
  14.  
  15.     __HAL_RCC_GPIOx_CLK_ENABLE();
  16.  
  17.  
  18.  
  19.     /* EXTI interrupt Init */
  20.  
  21.     HAL_NVIC_SetPriority(EXTIx_IRQn, 0, 0);
  22.  
  23.     HAL_NVIC_EnableIRQ(EXTIx_IRQn);
  24.  
  25.   }
  26.  
  27. }
  28.  
  29. ```
  30.  
  31. 3. 启动按键中断
  32.  
  33. 在main函数中，调用HAL_GPIO_EXTI_IRQHandler()函数启动按键中断。
  34.  
  35. ```c
  36.  
  37. HAL_GPIO_EXTI_IRQHandler(KEY_Pin);
  38.  
  39. ```

 4. 编写按键中断回调函数

在stm32fxxx_it.c文件中，编写按键中断回调函数。

  1. ```c
  2.  
  3. void EXTIx_IRQHandler(void)
  4.  
  5. {
  6.  
  7.   HAL_GPIO_EXTI_IRQHandler(KEY_Pin);
  8.  
  9. }
  10.  
  11.  
  12.  
  13. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
  14.  
  15. {
  16.  
  17.   if (GPIO_Pin == KEY_Pin)
  18.  
  19.   {
  20.  
  21.     // 在这里添加按键动作代码
  22.  
  23.   }
  24.  
  25. }
  26.  
  27. ```

三、 串口中断

串口中断是STM32开发中常用的一种中断方式，主要用于实现串口通信。以下为创建串口中断的步骤：

 1. 配置串口

首先，在STM32CubeMX中配置相应的串口，并设置对应的波特率、数据位、停止位等参数。

 2. 初始化串口

在main.c文件中，调用HAL_UART_MspInit()函数初始化串口。

  1. ```c
  2.  
  3. void HAL_UART_MspInit(UART_HandleTypeDef* huart)
  4.  
  5. {
  6.  
  7.   if(huart->Instance == USARTx)
  8.  
  9.   {
  10.  
  11.     /* USARTx clock enable */
  12.  
  13.     __HAL_RCC_USARTx_CLK_ENABLE();
  14.  
  15.   
  16.  
  17.     /* USARTx interrupt Init */
  18.  
  19.     HAL_NVIC_SetPriority(USARTx_IRQn, 0, 0);
  20.  
  21.     HAL_NVIC_EnableIRQ(USARTx_IRQn);
  22.  
  23.   }
  24.  
  25. }
  26.  
  27. ```

 3. 启动串口接收中断

在main函数中，调用HAL_UART_Receive_IT()函数启动串口接收中断。

  1. ```c
  2.  
  3. uint8_t rx_data;
  4.  
  5. HAL_UART_Receive_IT(&huartx, &rx_data, 1);
  6.  
  7. ```
  8.  
  9.  4. 编写串口中断回调函数
  10.  
  11. 在stm32fxxx_it.c文件中，编写串口中断回调函数。
  12.  
  13. ```c
  14.  
  15. void USARTx_IRQHandler(void)
  16.  
  17. {
  18.  
  19.   HAL_UART_IRQHandler(&huartx);
  20.  
  21. }
  22.  
  23.  
  24.  
  25. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
  26.  
  27. {
  28.  
  29.   if (huart->Instance == USARTx)
  30.  
  31.   {
  32.  
  33.     // 在这里添加串口接收处理代码
  34.  
  35.  
  36.  
  37.     // 持续接收
  38.  
  39.     HAL_UART_Receive_IT(huart, &rx_data, 1);
  40.  
  41.   }
  42.  
  43. }
  44.  
  45. ```

四、 按键消抖

按键消抖是为了消除按键在按下和松开时，由于机械原因产生的抖动现象。以下为实现按键消抖的方法：

1. 定时器中断法：通过定时器中断定时检测按键状态，若连续多次检测到按键状态一致，则认为按键有效。

2. 软件滤波法：通过软件记录按键状态，当按键状态改变时开始计数，若计数达到预设值，则认为按键有效。

示例：定时器中断法实现按键消抖

  1. ```c
  2.  
  3. #define KEY_DEBOUNCE_DELAY 20 // 按键消抖延时
  4.  
  5.  
  6.  
  7. uint8_t key_state = 0; // 按键状态
  8.  
  9. uint8_t key_cnt = 0; // 按键计数
  10.  
  11.  
  12.  
  13. // 定时器中断回调函数
  14.  
  15. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
  16.  
  17. {
  18.  
  19.   if (htim->Instance == TIMx)
  20.  
  21.   {
  22.  
  23.     // 读取按键状态
  24.  
  25.     uint8_t current_key_state = HAL_GPIO_ReadPin(KEY_GPIO_Port, KEY_Pin);
  26.  
  27.  
  28.  
  29.     // 判断按键状态是否改变
  30.  
  31.     if (current_key_state != key_state)
  32.  
  33.     {
  34.  
  35.       // 计数加1
  36.  
  37.       key_cnt++;
  38.  
  39.  
  40.  
  41.       // 判断计数是否达到预设值
  42.  
  43.       if (key_cnt >= KEY_DEBOUNCE_DELAY)
  44.  
  45.       {
  46.  
  47.         key_state = current_key_state; // 更新按键状态
  48.  
  49.         key_cnt = 0; // 清零计数
  50.  
  51.  
  52.  
  53.         // 按键动作处理
  54.  
  55.         if (key_state == GPIO_PIN_SET)
  56.  
  57.         {
  58.  
  59.           // 按键按下处理
  60.  
  61.         }
  62.  
  63.         else
  64.  
  65.         {
  66.  
  67.           // 按键松开处理
  68.  
  69.         }
  70.  
  71.       }
  72.  
  73.     }
  74.  
  75.     else
  76.  
  77.     {
  78.  
  79.       // 清零计数
  80.  
  81.       key_cnt = 0;
  82.  
  83.     }
  84.  
  85.   }
  86.  
  87. }
  88.  
  89. ```

五、低通滤波算法

低通滤波算法是一种常用的数字滤波方法，主要用于消除高频噪声。以下为实现低通滤波的方法：

1. 移动平均法：通过计算一段时间内的数据平均值，达到滤波效果。

2. 指数加权移动平均法：通过计算当前数据与历史数据的加权平均值，达到滤波效果。

 示例：移动平均法实现低通滤波

  1. ```c
  2.  
  3. #define FILTER_N 10 // 滤波数据长度
  4.  
  5.  
  6.  
  7. float data_buf[FILTER_N]; // 数据缓存
  8.  
  9. uint8_t buf_index = 0; // 缓存索引
  10.  
  11.  
  12.  
  13. // 将新数据添加到缓存中
  14.  
  15. void add_data_to_buffer(float data)
  16.  
  17. {
  18.  
  19.   data_buf[buf_index] = data;
  20.  
  21.   buf_index = (buf_index + 1) %
  22. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/喵喵爱编程/article/detail/739167
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号