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

STM32CubeIDE开发(九)， 定时器TIM与外部中断NVIC实践案例_cubeidex 配置定时器

作者：小舞很执着 | 2024-06-20 08:21:50

赞

踩

cubeidex 配置定时器

目录

一、定时器功能

         1.1 定时器分类

        1.2 定时时间计算

         1.3 中断功能

 二、工程创建及配置

        2.1 cubeMX图形配置

        2.2 代码设计

三、添加定时器及中断功能

        3.1 GPIO外设中断

         3.2 TIM2通用定时器，轮询

         3.3 TIM3通用定时器，辅助lpuart1通信

         3.4  TIM4通用定时器，PWM输出

四、定时器及中断功能代码设计

        4.1 GPIO中断功能 

         4.2 TIM2的定时轮询功能

        4.3 TIM4的计数功能

        4.4 TIM4定时器支持PWM输出功能实现

          4.5 功能调用及实现

五、编译及测试

        5.1 编译程序及下载

         5.2 测试

一、定时器功能

         1.1 定时器分类

        STM32 的定时器分为高级定时器、 通用定时器 、基本定时器三种。

        这三个定时器成上下级的关系，即基本定时器有的功能通用定时器都有，而且还增加了向下、向上/向下计数器、PWM生成、输出比较、输入捕获等功能；而高级定时器又包含了通用定时器的所有功能，另外还增加了死区互补输出、刹车信号。

        例如本文采用的STM32L496VGT6芯片中，高级定时器（TIM1、TIM8）、 通用定时器（TIM2、TIM3、TIM4、TIM5、TIM15，另外TIM5、TIM15亦有些许差异） 、基本定时器（TIM6、TIM7、TIM16、TIM17），高级定时器、 通用定时器 、基本定时器在STM32CubeMX配置界面中是不一样的：

        高级定时器（TIM1）：

        通用定时器（TIM2）：

        或通用定时器（TIM5）：

         基本定时器（TIM6）：

         在通用定时器，每个定时器都有一个16位的自动加载递增/递减计数器，一个16位的预分频器和4个独立通道，每个通道可用于输入捕获、输出比较、PWM和单脉冲模式输出。而TIM1、TIM8高级定时，其通道更是支持到6个通道，在一些高级芯片中支持到的通道会更多。

        每个定时器都支持外部中断机制，还可以结合计数功能或时钟功能，实现轮询策略；每个定时器也支持独立的DMA请求机制。

        通用定时器可以利用GPIO引脚进行脉冲输出，在配置为比较输出、PWM输出功能时，捕获/比较寄存器TIMx_CCR被用作比较功能。

        1.2 定时时间计算

        定时器输出时间间隔(us)=(分频系数+1)*(计数周期+1)÷输入定时器时钟频率(MHz,APB*)，如下图所示。

         1.3 中断功能

        通常STM32芯片支持所有GPIO设置为外部中断输入，外部IO可以由电平上升、电平下降、高低电平三种方式的中断触发或事件触发。定时器作为外设之一，同样支持到外部中断或事件触发。

 二、工程创建及配置

        2.1 cubeMX图形配置

        本文基于STM32L496VGT6芯片创建工程，创建时钟、开启lpuart1串口，以及三个LED灯和按键KEY，配置如下：

        【1】系统配置

         【2】RCC功能开启外部高速时钟（默认参数配置）及时钟树设置

         时钟树设置，STM32L496VGT6支持最大输出频率80MHz，本文直接拉满

         【3】lpuart1串口开启

         开启lpuart1中断功能及按开发板引脚说明调整引脚：

         【4】配置三个按键及LED

         完成基本配置后，生成输出代码（每个外设独立的.h/.c文件）

        2.2 代码设计

        【1】禁用syscalls.c源文件

         【2】在工程目录下，创建源文件夹ICore文件目录，

         【2】并在ICore目录下创建led、key、print、usart目录。

         【3】在print目录创建print.h和print.c源文件，将用来实现将printf标准函数输出映射到lpuart1串口的驱动程序。

        print.h

  1. #ifndef INC_RETARGET_H_
  2. #define INC_RETARGET_H_
  3.  
  4. #include "stm32l4xx_hal.h"
  5. #include "stdio.h"//用于printf函数串口重映射
  6. #include <sys/stat.h>
  7.  
  8. void ResetPrintInit(UART_HandleTypeDef  *huart);
  9.  
  10. int _isatty(int fd);
  11. int _write(int fd, char* ptr, int len);
  12. int _close(int fd);
  13. int _lseek(int fd, int ptr, int dir);
  14. int _read(int fd, char* ptr, int len);
  15. int _fstat(int fd, struct stat* st);
  16.  
  17. #endif /* INC_RETARGET_H_ */

         print.c

  1. #include <_ansi.h>
  2. #include <_syslist.h>
  3. #include <errno.h>
  4. #include <sys/time.h>
  5. #include <sys/times.h>
  6. #include <limits.h>
  7. #include <signal.h>
  8. #include <stdint.h>
  9. #include <stdio.h>
  10.  
  11. #include "print.h"
  12.  
  13. #if !defined(OS_USE_SEMIHOSTING)
  14. #define STDIN_FILENO  0
  15. #define STDOUT_FILENO 1
  16. #define STDERR_FILENO 2
  17.  
  18. UART_HandleTypeDef *gHuart;
  19.  
  20. void ResetPrintInit(UART_HandleTypeDef *huart)  {
  21.   gHuart = huart;
  22.   /* Disable I/O buffering for STDOUT  stream, so that
  23.    * chars are sent out as soon as they are  printed. */
  24.   setvbuf(stdout, NULL, _IONBF, 0);
  25. }
  26. int _isatty(int fd) {
  27.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
  28.     return 1;
  29.   errno = EBADF;
  30.   return 0;
  31. }
  32. int _write(int fd, char* ptr, int len) {
  33.   HAL_StatusTypeDef hstatus;
  34.   if (fd == STDOUT_FILENO || fd ==  STDERR_FILENO) {
  35.     hstatus = HAL_UART_Transmit(gHuart,  (uint8_t *) ptr, len, HAL_MAX_DELAY);
  36.     if (hstatus == HAL_OK)
  37.       return len;
  38.     else
  39.       return EIO;
  40.   }
  41.   errno = EBADF;
  42.   return -1;
  43. }
  44. int _close(int fd) {
  45.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
  46.     return 0;
  47.   errno = EBADF;
  48.   return -1;
  49. }
  50. int _lseek(int fd, int ptr, int dir) {
  51.   (void) fd;
  52.   (void) ptr;
  53.   (void) dir;
  54.   errno = EBADF;
  55.   return -1;
  56. }
  57. int _read(int fd, char* ptr, int len) {
  58.   HAL_StatusTypeDef hstatus;
  59.   if (fd == STDIN_FILENO) {
  60.     hstatus = HAL_UART_Receive(gHuart,  (uint8_t *) ptr, 1, HAL_MAX_DELAY);
  61.     if (hstatus == HAL_OK)
  62.       return 1;
  63.     else
  64.       return EIO;
  65.   }
  66.   errno = EBADF;
  67.   return -1;
  68. }
  69. int _fstat(int fd, struct stat* st) {
  70.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO) {
  71.     st->st_mode = S_IFCHR;
  72.     return 0;
  73.   }
  74.   errno = EBADF;
  75.   return 0;
  76. }
  77.  
  78. #endif //#if !defined(OS_USE_SEMIHOSTING)

        【3】在led目录创建led.h和led.c源文件，将用来实现LED等状态控制的驱动程序。

        led.h

  1. #ifndef LED_H_
  2. #define LED_H_
  3. #include "main.h"
  4. #include "gpio.h"
  5.  
  6. void Toggle_led0();
  7. void Toggle_led1();
  8. void Toggle_led2();
  9.  
  10. void set_led0_val(GPIO_PinState PinState);
  11. void set_led1_val(GPIO_PinState PinState);
  12. void set_led2_val(GPIO_PinState PinState);
  13.  
  14. #endif /* LED_H_ */

        led.c

  1. #include "led.h"
  2.  
  3. void Toggle_led0()
  4. {
  5. 	HAL_GPIO_TogglePin(LED0_GPIO_Port,LED0_Pin);
  6. }
  7.  
  8. void Toggle_led1()
  9. {
  10. 	HAL_GPIO_TogglePin(LED1_GPIO_Port,LED1_Pin);
  11. }
  12.  
  13. void Toggle_led2()
  14. {
  15. 	HAL_GPIO_TogglePin(LED2_GPIO_Port,LED2_Pin);
  16. }
  17.  
  18. void set_led0_val(GPIO_PinState PinState)
  19. {
  20. 	HAL_GPIO_WritePin(LED0_GPIO_Port,LED0_Pin,PinState);
  21. };
  22.  
  23. void set_led1_val(GPIO_PinState PinState)
  24. {
  25. 	HAL_GPIO_WritePin(LED1_GPIO_Port,LED1_Pin,PinState);
  26. };
  27.  
  28. void set_led2_val(GPIO_PinState PinState)
  29. {
  30. 	HAL_GPIO_WritePin(LED2_GPIO_Port,LED2_Pin,PinState);
  31. };

        【4】在key目录创建key.h和key.c源文件，将用来实现KEY控制的驱动程序。

        key.h

  1. #ifndef KEY_H_
  2. #define KEY_H_
  3.  
  4. #include "main.h"
  5. #include "gpio.h"
  6.  
  7. GPIO_PinState get_key0_val();
  8. GPIO_PinState get_key1_val();
  9. GPIO_PinState get_key2_val();
  10.  
  11. uint8_t KEY_0(void);
  12. uint8_t KEY_1(void);
  13. uint8_t KEY_2(void);
  14.  
  15. #endif /* KEY_H_ */

        key.c

  1. #include "key.h"
  2.  
  3. GPIO_PinState get_key0_val()
  4. {
  5. 	return HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin);
  6. };
  7.  
  8. GPIO_PinState get_key1_val()
  9. {
  10. 	return HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin);
  11. };
  12.  
  13. GPIO_PinState get_key2_val()
  14. {
  15. 	return HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin);
  16. };
  17.  
  18. uint8_t KEY_0(void)
  19. {
  20. 	uint8_t a;
  21. 	a=0;//如果未进入按键处理，则返回0
  22. 	if(HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin)==GPIO_PIN_RESET){//读按键接口的电平
  23. 		HAL_Delay(20);//延时去抖动
  24. 		if(HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
  25. 			a=1;//进入按键处理，返回1
  26. 		}
  27. 	}
  28. 	while(HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin)==GPIO_PIN_RESET); //等待按键松开
  29. 	return a;
  30. }
  31.  
  32. uint8_t KEY_1(void)
  33. {
  34. 	uint8_t a;
  35. 	a=0;//如果未进入按键处理，则返回0
  36. 	if(HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin)==GPIO_PIN_RESET){//读按键接口的电平
  37. 		HAL_Delay(20);//延时去抖动
  38. 		if(HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
  39. 			a=1;//进入按键处理，返回1
  40. 		}
  41. 	}
  42. 	while(HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin)==GPIO_PIN_RESET); //等待按键松开
  43. 	return a;
  44. }
  45.  
  46. uint8_t KEY_2(void)
  47. {
  48. 	uint8_t a;
  49. 	a=0;//如果未进入按键处理，则返回0
  50. 	if(HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin)==GPIO_PIN_RESET){//读按键接口的电平
  51. 		HAL_Delay(20);//延时去抖动
  52. 		if(HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
  53. 			a=1;//进入按键处理，返回1
  54. 		}
  55. 	}
  56. 	while(HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin)==GPIO_PIN_RESET); //等待按键松开
  57. 	return a;
  58. }

        【4】在usart目录创建usart.h和usart.c源文件，将用来实现lpuart1驱动程序。

        usart.h

  1. #ifndef INC_USART_H_
  2. #define INC_USART_H_
  3.  
  4. #include "stm32l4xx_hal.h" //HAL库文件声明
  5. #include <string.h>//用于字符串处理的库
  6. #include "../print/print.h"//用于printf函数串口重映射
  7.  
  8. extern UART_HandleTypeDef hlpuart1;//声明LPUSART的HAL库结构体
  9.  
  10. #define HLPUSART_REC_LEN  256//定义LPUSART最大接收字节数
  11.  
  12. extern uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
  13. extern uint16_t HLPUSART_RX_STA;//接收状态标记
  14. extern uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
  15.  
  16.  
  17. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
  18.  
  19. #endif /* INC_USART_H_ */

        usart.c

  1. #include "usart.h"
  2.  
  3. uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
  4. /*
  5.  * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
  6.  * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
  7.  * bit13:预留
  8.  * bit12:预留
  9.  * bit11~0：接收到的有效字节数目(0~4095)
  10.  */
  11. uint16_t HLPUSART_RX_STA=0;接收状态标记//bit15：接收完成标志，bit14：接收到回车(0x0d)，bit13~0：接收到的有效字节数目
  12. uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
  13.  
  14. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
  15. {
  16. 	if(huart ==&hlpuart1)//判断中断来源（串口1：USB转串口）
  17.     {
  18. 		if(HLPUSART_NewData==0x0d){//回车标记
  19.      	  HLPUSART_RX_STA|=0x8000;//标记接到回车
  20. 		}else{
  21. 			if((HLPUSART_RX_STA&0X0FFF)<HLPUSART_REC_LEN){
  22. 				HLPUSART_RX_BUF[HLPUSART_RX_STA&0X0FFF]=HLPUSART_NewData; //将收到的数据放入数组
  23. 				HLPUSART_RX_STA++;  //数据长度计数加1
  24. 			}else{
  25. 				HLPUSART_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
  26. 			}
  27.         }
  28.        HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData,1); //再开启接收中断
  29.     }
  30. }

        【5】在main.c文件中加入各驱动文件的头文件

  1. /* USER CODE BEGIN Includes */
  2. #include "../../ICore/key/key.h"
  3. #include "../../ICore/led/led.h"
  4. #include "../../ICore/print/print.h"
  5. #include "../../ICore/usart/usart.h"
  6. /* USER CODE END Includes */

        在主函数中，初始化lpuart1

  1.   /* USER CODE BEGIN 2 */
  2.   ResetPrintInit(&hlpuart1);
  3.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
  4.   HLPUSART_RX_STA = 0;
  5.   /* USER CODE END 2 */

        在主函数循环体中，实现lpuart1输入返回测试及按键时LED灯状态反转。

  1.  /* USER CODE BEGIN WHILE */
  2.   while (1)
  3.   {
  4. 	  if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
  5.   		  printf("receive:%.*s\r\n",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
  6.   		  HLPUSART_RX_STA=0;//接收错误,重新开始
  7.   		  HAL_Delay(100);//等待
  8.   	  }
  9.       if(KEY_0())
  10. 	  {
  11.         Toggle_led0();//LED0等状态反转一次
  12. 	  }
  13.   	  if(KEY_1())
  14. 	  {
  15.         Toggle_led1();//LED1等状态反转一次
  16. 	  }
  17.   	  if(KEY_2())
  18. 	  {
  19.   		  Toggle_led2();//LED2等状态反转一次
  20. 	  }
  21.     /* USER CODE END WHILE */

        【6】配置输出文件格式支持，然后编译代码

        【7】配置调试及下载支持

         运行下载烧写程序到开发板，完成基本功能开发。

三、添加定时器及中断功能

        3.1 GPIO外设中断

        打开.ioc进入cubeMX配置界面，将KEY0按钮调整为GPIO_EXTI类型

        并开启KEY0（PE11）的中断支持

         3.2 TIM2通用定时器，轮询

        添加TIM2通用定时器功能实现定时轮询功能

         并开启 TIM2的中断功能

         3.3 TIM3通用定时器，辅助lpuart1通信

        添加TIM3通用定时器功能实现间隔计时，辅助lpuart1串口在没有结束标记情况下实现超时（100ms）通知

         并开启TIM3的中断功能支持

         3.4  TIM4通用定时器，PWM输出

        添加TIM4通用定时器功能，开启其通道4对PWM输出功能支持，将KEY2（PD15）调整为TIM_CH4类型。PWM是定时器扩展出来的一个功能(本质上是使用一个比较计数器的功能)，配置过程一般为选定定时器、复用GPIO口、选择通道(传入比较值)、使能相应系统时钟、设定相应的预分频、计数周期、PWM模式(有两种)、电平极性等。

        并开启TIM4的中断功能支持

         配置KEY2（PD15）GPIO引脚为交替推免GPIO模式，如下图。

         上述配置完成后输出生成代码。

四、定时器及中断功能代码设计

        4.1 GPIO中断功能 

        已经配置了KEY0（PE11）为GPIO_EXTI模式，并开启其中断支持，现需要重新实现stm32l4xx_hal_gpio.c文件中的HAL_GPIO_EXTI_Callback函数来实现GPIO外部中断回调功能。

         在main.c文件中，重新实现HAL_GPIO_EXTI_Callback函数，覆盖stm32l4xx_hal_gpio.c文件中HAL_GPIO_EXTI_Callback弱函数。

  1. /* USER CODE BEGIN 0 */
  2. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
  3. {
  4. 	if(GPIO_Pin==KEY0_Pin)
  5. 	{
  6. 		static uint32_t key0_count = 0;
  7. 		printf("this is %lu count for HAL_GPIO_EXTI_Callback!\r\n",key0_count++);
  8. 		Toggle_led0();//LED0等状态反转一次
  9. 	}
  10. }
  11. /* USER CODE END 0 */

         4.2 TIM2的定时轮询功能

          已经配置了TIM2，并开启其中断支持，现需要重新实现stm32l4xx_hal_tim.c文件中的当计数溢出时调用的回调函数HAL_TIM_PeriodElapsedCallback。

         在mian.c文件中，重新实现HAL_TIM_PeriodElapsedCallback函数，覆盖stm32l4xx_hal_tim.c文件中的同名弱函数。

  1. /* USER CODE BEGIN 0 */
  2. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
  3. {
  4. 	if(GPIO_Pin==KEY0_Pin)
  5. 	{
  6. 		static uint32_t key0_count = 0;
  7. 		printf("this is %lu count for HAL_GPIO_EXTI_Callback!\r\n",key0_count++);
  8. 		Toggle_led0();//LED0等状态反转一次
  9. 	}
  10. }
  11.  
  12. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
  13. {
  14. 	if(htim==&htim2)
  15. 	{
  16. 		static uint32_t key1_count = 0;
  17. 		printf("this is %lu count for HAL_TIM_PeriodElapsedCallback!\r\n",key1_count++);
  18. 		Toggle_led1();//LED1等状态反转一次
  19. 	}
  20. }
  21. /* USER CODE END 0 */

        4.3 TIM4的计数功能

       同样已经配置了TIM4，并开启其中断支持，现需要重新实现stm32l4xx_hal_tim.c文件中的当计数溢出时调用的回调函数HAL_TIM_PeriodElapsedCallback，在计数结束时，改写lpuart1的接收标记。

  1. /* USER CODE BEGIN 0 */
  2. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
  3. {
  4. 	if(GPIO_Pin==KEY0_Pin)
  5. 	{
  6. 		static uint32_t key0_count = 0;
  7. 		printf("this is %lu count for HAL_GPIO_EXTI_Callback!\r\n",key0_count++);
  8. 		Toggle_led0();//LED0等状态反转一次
  9. 	}
  10. }
  11.  
  12. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
  13. {
  14. 	if(htim==&htim2)
  15. 	{
  16. 		static uint32_t key1_count = 0;
  17. 		printf("this is %lu count for HAL_TIM_PeriodElapsedCallback!\r\n",key1_count++);
  18. 		Toggle_led1();//LED1等状态反转一次
  19. 	}
  20. 	if(htim ==&htim3)//判断是否是定时器3中断（定时器到时表示一组字符串接收结束）
  21.     {
  22. 		HLPUSART_RX_BUF[HLPUSART_RX_STA&0X0FFF]=0;//添加结束符
  23. 		HLPUSART_RX_STA|=0x8000;//接收标志位最高位置1表示接收完成
  24. 		__HAL_TIM_CLEAR_FLAG(&htim3,TIM_EVENTSOURCE_UPDATE );//清除TIM3更新中断标志
  25. 		__HAL_TIM_DISABLE(&htim3);//关闭定时器3
  26.     }
  27. }
  28. /* USER CODE END 0 */

         同时在usart.h增加对TIM3的引入

  1. #ifndef INC_USART_H_
  2. #define INC_USART_H_
  3.  
  4. #include "stm32l4xx_hal.h" //HAL库文件声明
  5. #include <string.h>//用于字符串处理的库
  6. #include "../print/print.h"//用于printf函数串口重映射
  7.  
  8. extern TIM_HandleTypeDef htim3;	//定时器3辅助串口接收数据
  9.  
  10. extern UART_HandleTypeDef hlpuart1;//声明LPUSART的HAL库结构体
  11.  
  12. #define HLPUSART_REC_LEN  256//定义LPUSART最大接收字节数
  13.  
  14. extern uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
  15. extern uint16_t HLPUSART_RX_STA;//接收状态标记
  16. extern uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
  17.  
  18.  
  19. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
  20.  
  21. #endif /* INC_USART_H_ */

        在usart.c中串口回调函数的lpuart1接收实现方式，通过htim3(TIM3)计数周期通知来告知lpuart1结束数据接收。

  1. #include "usart.h"
  2.  
  3. uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
  4. /*
  5.  * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
  6.  * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
  7.  * bit13:预留
  8.  * bit12:预留
  9.  * bit11~0：接收到的有效字节数目(0~4095)
  10.  */
  11. uint16_t HLPUSART_RX_STA=0;接收状态标记//bit15：接收完成标志，bit14：接收到回车(0x0d)，bit13~0：接收到的有效字节数目
  12. uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
  13.  
  14. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
  15. {
  16. //	if(huart ==&hlpuart1)//判断中断来源（串口1：USB转串口）
  17. //    {
  18. //		if(HLPUSART_NewData==0x0d){//回车标记
  19. //     	  HLPUSART_RX_STA|=0x8000;//标记接到回车
  20. //		}else{
  21. //			if((HLPUSART_RX_STA&0X0FFF)<HLPUSART_REC_LEN){
  22. //				HLPUSART_RX_BUF[HLPUSART_RX_STA&0X0FFF]=HLPUSART_NewData; //将收到的数据放入数组
  23. //				HLPUSART_RX_STA++;  //数据长度计数加1
  24. //			}else{
  25. //				HLPUSART_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
  26. //			}
  27. //        }
  28. //       HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData,1); //再开启接收中断
  29. //    }
  30.     //调整,通过htim3计数来通知接收数据结束
  31. 	if(huart ==&hlpuart1)//判断中断来源（串口lpuart1）//接收完的一批数据,还没有被处理,则不再接收其他数据
  32. 	{
  33. 		if(HLPUSART_RX_STA<HLPUSART_REC_LEN)//还可以接收数据
  34. 		{
  35. 			__HAL_TIM_SET_COUNTER(&htim3,0); //计数器清空
  36. 			if(HLPUSART_RX_STA==0) //使能定时器2的中断
  37. 			{
  38. 				__HAL_TIM_ENABLE(&htim3); //使能定时器3
  39. 			}
  40. 			HLPUSART_RX_BUF[HLPUSART_RX_STA++] = HLPUSART_NewData;//最新接收数据放入数组
  41. 		}else
  42. 		{
  43. 			HLPUSART_RX_STA|=0x8000;//强制标记接收完成
  44. 		}
  45.  
  46. 		HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData,1); //再开启串口1接收中断
  47. 	}
  48. }

        4.4 TIM4定时器支持PWM输出功能实现

        TIM4定时器已经开启了通道4，向LED2（PD15）交替输出递减电压实现LED灯状态由亮变暗直至熄灭的循环，首选需要通过HAL_TIM_PWM_Start开启PWM功能，然后通过__HAL_TIM_SetCompare来设置占空比来实现输出信号调节。

        PWM输出工作过程：若配置脉冲计数器TIMx_CNT为向上计数，而重载寄存器TIMx_ARR被配置为N，即TIMx_CNT的当前计数值数值X在TIMxCLK时钟源的驱动下不断累加，当TIMx_CNT的数值X（对应下面代码的a）大于N（对应cubeMX配置的ARR值，即99）时，会重置TIMx_CNT数值为0重新计数 。

  1. HAL_TIM_PWM_Start(&htim4,TIM_CHANNEL_4);
  2. uint8_t a = ;
  3. while(1){
  4.     __HAL_TIM_SetCompare(&htim4,TIM_CHANNEL_4,a);
  5.   	a++;//占空比值加1
  6.   	if(a>=99)a=0;
  7.     HAL_Delay(10);
  8. }

          4.5 功能调用及实现

        在main.c函数中，初始化及启动TIM定时器

  1.   /* USER CODE BEGIN 2 */
  2.   ResetPrintInit(&hlpuart1);
  3.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
  4.   HLPUSART_RX_STA = 0;
  5.   HAL_TIM_Base_Start_IT(&htim2);//开启定时器2中断（必须开启才能进入中断处理回调函数）
  6.   HAL_TIM_Base_Start_IT(&htim3);//开启定时器3中断（必须开启才能进入中断处理回调函数）,辅助lpuart1接收数据
  7.   HAL_TIM_PWM_Start(&htim4,TIM_CHANNEL_4);
  8.   uint8_t memu = 0;    //用来标记按键KEY2按下,来开启或关闭TIM4的PWM功能
  9.   uint16_t a = 0;      //占空比值
  10.   /* USER CODE END 2 */

        在main函数循环中，实现如下：

  1.  /* USER CODE BEGIN WHILE */
  2.   while (1)
  3.   {
  4. 	  if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
  5.   		  printf("receive:%.*s\r\n",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
  6.   		  HLPUSART_RX_STA=0;//接收错误,重新开始
  7.   		  HAL_Delay(100);//等待
  8.   	  }
  9.   	  if(KEY_1())
  10. 	  {
  11. 	  }
  12.   	  if(KEY_2())
  13. 	  {
  14.   		  memu=!memu;
  15.   		  printf("TIM4_PWM is runing!\r\n");
  16. 	  }
  17.   	  if(memu)
  18.   	  {
  19.   		  __HAL_TIM_SetCompare(&htim4,TIM_CHANNEL_4,a);
  20.   		  a++;//占空比值加1
  21.   		  if(a>=99)
  22.   		  {
  23.   			  printf("TIM4_PWM finish cycle!\r\n");
  24.   			  a=0;
  25.   		  }
  26.   		  HAL_Delay(10);//等待
  27.   	  }
  28.     /* USER CODE END WHILE */

五、编译及测试

        5.1 编译程序及下载

         5.2 测试

        【1】测试log输出

         【2】注释掉相关打印输出，测试lpuart1输入数据无回车时（lpuart1的HAL_UART_Receive_IT调用后，TIM3每100毫秒通知其结束接收），能成功收到返回数据，如下图。

         【3】LED等状态情况

        按键KEY0顺利切换LED0的状态，LED1灯周期切换状态（TIM2），按键KEY2开启TIM4的PWM输出功能，LED2灯周期由亮到灭切换状态（TIM4）。

        https://live.csdn.net/v/263027

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

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

  

闽ICP备14008679号