蓝桥杯——定时器篇

满城烟雨DLRY

已于 2024-04-07 09:50:00 修改

阅读量1.7k

点赞数 31

分类专栏：蓝桥杯嵌入式文章标签：蓝桥杯职场和发展

于 2024-01-22 21:33:47 首次发布

本文链接：https://blog.csdn.net/qq_62725929/article/details/135706282

版权

蓝桥杯嵌入式专栏收录该内容

10 篇文章 0 订阅

订阅专栏

本篇主要介绍：

①基础定时器的定时功能 ②PWM生成和方波生成 ③普通输入捕获模式 ④PWM输入模式

1.定时器

1.1理论

配置的时钟树SYSCLK频率为80MHZ。

$time=\frac{PSC+1}{SYSCLK(Freq)}(Counter+1)$

PSC:预分频系数，预分频80的话，要写79也就是80-1的由来

Counter：自动重装载计数器的值，记2500，要写2499.

按上图配置系数进行计算：分频后计数器每记一个数用时 $\frac{1}{10000}s$ ，也就是0.1毫秒，计数2500，即为250毫秒。

1.2相关函数

①启动定时器2（TIM2）的基本定时器模式，并开启中断。

 HAL_TIM_Base_Start_IT(&htim2);

在这个函数里，有打开时钟中断和开启时钟的函数，而不带IT的那个函数是没有开时钟中断的。

②关闭中断

 HAL_TIM_Base_Stop_IT(&htim2);//定时器中断默认是常开的

③清除中断更新标志（加在初始化函数最后）

 __HAL_TIM_CLEAR_FLAG(&htim2, TIM_IT_UPDATE);//去更新中断标志

④设置 TIM2 的计数器值为 0。

__HAL_TIM_SetCounter(&htim2,0);

⑤初始化函数

 MX_TIM2_Init();

⑥溢出回调函数，定时器计时结束计数器发生溢出，调用这个函数，用于完成定时器功能，比如每秒某个变量加一并显示在LCD。

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{


}

如果想实现进入某个状态或触发了某个操作就计时，并且这触发计时是连续多次的可以使用下面函数搭配上面的时钟中断开启函数：

__HAL_TIM_SET_COUNTER(&htim1,0);
__HAL_TIM_CLEAR_FLAG(&htim1, TIM_IT_UPDATE);//去更新中断标志
HAL_TIM_Base_Start_IT(&htim1);

使用代码见这个链接的按键部分，用于判断单双击：按键代码

2.PWM生成与方波生成

2.1.PWM生成

在开发板上有两个信号生成器，对应引脚PA15和PB4可以通过旋钮调节频率，但是占空比的固定的为50%，还可以使用时钟生成PWM，这里的PWM可以改变频率和占空比，需使用函数来改变，接下来会讲，一个定时器可以输出多路PWM，他们可以是不同占空比，但周期一定相同。与方波对比，方波顾名思义是一系列占空比50%的波，但是方波可以直接改变频率，具体在方波部分讲。

借着cubemx来讲吧：

使用TIM15来生成PWM波，别的也行，稍后给出配置

对时钟分频的配置（PSC）和定时器计时中断时用的一样，现在计数器每记一个数压迫1微秒。我将ARR 设置为200，也就是一个pwm周期为计数200次，那频率就是1000000/200=5000HZ。

计数模式（Counter Mode）默认为UP，向上计数。

接下来我们对每一路PWM波进行配置：

这里的PWM mode 1是什么呢？看下图：截自STM32G431控制器参考手册

对PWM mode 1，在向上计数时，当时钟的计数值小于捕获/比较寄存器的值（这个值在这里就是上图的Pulse：下图）输出为有效电平（注意有效电平，可没说是高电平，这与下面的一个选项：极性有关），这也就设置了占空比（这里周期200，我在设置了pulse为120，而且是向上计数极性为High也就是正，所以占空比为120/200=0.6，也就是60%）

然后解释一下极性，高极性（有的叫正极）就是指高电平为有效电平，低级性就相反，低电平为有效电平。

2.2.方波生成

这个方波和PWM类似，一般用于步进电机，不过在cubemx里要用输出比较模式：

这个mode的选择就选图中的，在到达比较值时翻转电平，还有一些其他的：

下图取自STM32F103的中文手册（对应上面一部分）：

对了方波的中断是这个函数：

void HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim);

初始函数：

 MX_TIM4_Init();
HAL_TIM_Base_Start(&htim4);
HAL_TIM_OC_Start_IT(&htim4 , TIM_CHANNEL_1);	//启动定时器4开启通道1输出比较模式并开启中断
HAL_TIM_OC_Start_IT(&htim4 , TIM_CHANNEL_2);	//启动定时器4开启通道2输出比较模式并开启中断

3.输入捕获

3.1普通输入捕获

普通输入捕获测量不了占空比，只能测量频率。

这里选择Reset mode，这个模式会在检测到上升沿（因为我们配置了Rising Edge）后将计数器清零。也就是说它能够计数AC之间的数字，这样也就能算出AC之间这段PWM波的频率。

3.2PWM输入模式

这是我们平常测PWM波的常用方式们可以测量频率和占空比

手册是这样解释的：

这段话什么意思呢，首先我们要先选择一个信号作为触发信号（上图的cubemx的配置中，我们选择了TI1FP1），这个触发信号就是开始捕获采集的信号（在我们的配置中就是上升沿为开始采集,就是下图的A沿），然后配置TI1FP2的触发信号极性为下降沿触发，在下图的B沿触发，在通道二触发捕获中断，接下来在C沿触发通道1的捕获中断。我们通过提取两个通道的计数值来计算占空比和频率，在A沿开始采集，计数为0，在B沿触发通道二中断获得计数值：B_Count，在C沿触发通道一的中断获得C_Count。按照我们的分频配置寄一个数是1/1000000秒，那么频率就是： $\frac{1000000}{C_Count}$ ，而占空比就是(B_Count/C_Count)*100%，当然这是我们在配置PWM波时选择向上计数、PWM模式1和高极性（正极）的情况，有其他的不同配置就按照实际的情况修改捕获的配置（捕获触发信号、极性）。

在上面这张图里，我们使用通道一采集，通道一就选直接采集，而通道二实际上没有参加直接捕获，他采集的是TI1FP2信号的这部分，然后触发相应中断，在中断里获取此时的计数值来进行计算。

4.测试案例

下面的代码功能为测量PA15和PB4生成的PWM波，使用TIM4测量由TIM15生成的PWM波，以及使用TIM1每100ms计数加一。（捕获记得开中断）

时钟的一些初始函数：

void PWM_OC_IC_Iint()
{
	HAL_TIM_Base_Start_IT(&htim1);//开启定时器1
	
	HAL_TIM_Base_Start(&htim15);//开启定时器15
	HAL_TIM_PWM_Start(&htim15,TIM_CHANNEL_1);//开启TIM15通道1的PWM生成
	HAL_TIM_PWM_Start(&htim15,TIM_CHANNEL_2);//开启TIM15通道2的PWM生成
	
	HAL_TIM_Base_Start(&htim2);//开启定时器2
	HAL_TIM_IC_Start_IT(&htim2,TIM_CHANNEL_1);//启动定时器2开启通道1输入捕获并开启中断
	HAL_TIM_IC_Start_IT(&htim2,TIM_CHANNEL_2);//启动定时器2开启通道2输入捕获并开启中断
	
	HAL_TIM_Base_Start(&htim3);//开启定时器3
	HAL_TIM_IC_Start_IT(&htim3,TIM_CHANNEL_1);//启动定时器3开启通道1输入捕获并开启中断
	HAL_TIM_IC_Start_IT(&htim3,TIM_CHANNEL_2);//启动定时器3开启通道2输入捕获并开启中断
	
	HAL_TIM_Base_Start(&htim4);//开启定时器4
	HAL_TIM_IC_Start_IT(&htim4,TIM_CHANNEL_1);//启动定时器4开启通道1输入捕获并开启中断
	HAL_TIM_IC_Start_IT(&htim4,TIM_CHANNEL_2);//启动定时器4开启通道2输入捕获并开启中断
	

	
}

相关的变量：

//TIM2捕获PA15pwm波的变量
uint32_t pwm_pa15_period_count ;
uint32_t pwm_pa15_duty_count ;
uint16_t pwm_pa15_period;
float pwm_pa15_duty;
//TIM3捕获PB4pwm波的变量
uint32_t pwm_pb4_period_count ;
uint32_t pwm_pb4_duty_count ;
uint16_t pwm_pb4_period;
float pwm_pb4_duty;
//TIM4捕获来自TIM15pwm波/方波的变量
uint32_t pwm_tim15_period_count ;
uint32_t pwm_tim15_duty_count ;
uint16_t pwm_tim15_period;
float pwm_tim15_duty;
uint16_t TIM1_100MS_Count=0;

TIM1的中断函数：

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	
	if(htim->Instance==TIM1)
	{
		TIM1_100MS_Count++;
	}
}

捕获的中断函数：

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
	
	//定时器2的输入捕获：PWM输入模式
	if(htim->Instance==TIM2)
	{   //计算来自于PA15的PWM波的周期
		
		if(htim->Channel==HAL_TIM_ACTIVE_CHANNEL_1)
		{
			pwm_pa15_period_count=HAL_TIM_ReadCapturedValue(htim,TIM_CHANNEL_1)+1;
			
			pwm_pa15_period=1000000/pwm_pa15_period_count;
			
			
		}
		//计算来自于PA15的PWM波的占空比
		if(htim->Channel==HAL_TIM_ACTIVE_CHANNEL_2)
		{
			pwm_pa15_duty_count=HAL_TIM_ReadCapturedValue(htim,TIM_CHANNEL_2)+1;
			pwm_pa15_duty=((float)pwm_pa15_duty_count/pwm_pa15_period_count)*100;
		}
	}
	
	if(htim->Instance==TIM3)
	{
		if(htim->Channel==HAL_TIM_ACTIVE_CHANNEL_1)
		{
			pwm_pb4_period_count=HAL_TIM_ReadCapturedValue(&htim3,TIM_CHANNEL_1);
			pwm_pb4_period=1000000/pwm_pb4_period_count;
		}
		
		if(htim->Channel==HAL_TIM_ACTIVE_CHANNEL_2)
		{
			pwm_pb4_duty_count=HAL_TIM_ReadCapturedValue(&htim3,TIM_CHANNEL_2);
			pwm_pb4_duty=((float)pwm_pb4_duty_count/pwm_pb4_period_count)*100;
			
		}
	}
	
	if(htim->Instance==TIM4)
	{
		if(htim->Channel==HAL_TIM_ACTIVE_CHANNEL_1)
		{
			pwm_tim15_period_count=HAL_TIM_ReadCapturedValue(&htim4,TIM_CHANNEL_1);
			pwm_tim15_period=1000000/pwm_tim15_period_count;
		}
		
		if(htim->Channel==HAL_TIM_ACTIVE_CHANNEL_2)
		{
			pwm_tim15_duty_count=HAL_TIM_ReadCapturedValue(&htim4,TIM_CHANNEL_2);
			pwm_tim15_duty=((float)pwm_tim15_duty_count/pwm_tim15_period_count)*100;
			
		}
		
		
	}
	
	
  }

这里要注意的是TIM_CHANNEL_1和HAL_TIM_ACTIVE_CHANNEL_1的区别，前者是函数参数，后者是结构体变量：

if(htim->Channel==HAL_TIM_ACTIVE_CHANNEL_1)
		{
			pwm_tim15_period_count=HAL_TIM_ReadCapturedValue(&htim4,TIM_CHANNEL_1);
			pwm_tim15_period=1000000/pwm_tim15_period_count;
		}

看下图：

LCD的显示函数：

void Lcd_Proc(void)
{
	//PA15产生的
	memset(Lcd_Disp_String,0,sizeof(Lcd_Disp_String));
    sprintf((char *)Lcd_Disp_String, "PWM1:%05dHz,%4.1f%%",pwm_pa15_period,pwm_pa15_duty);
	LCD_DisplayStringLine(Line0, Lcd_Disp_String);	
	//PB4产生的
	memset(Lcd_Disp_String,0,sizeof(Lcd_Disp_String));
	sprintf((char *)Lcd_Disp_String, "PWM2:%05dHz,%4.1f%%",pwm_pb4_period,pwm_pb4_duty);
	LCD_DisplayStringLine(Line1, Lcd_Disp_String);	
    //TIM15产生的PWM（PA2）5000HZ占空比60%PWM波（PA3）4000HZ占比25%
    //将PA2接PA11测量PWM，将PA3接PA11测量PWM
	memset(Lcd_Disp_String,0,sizeof(Lcd_Disp_String));
	sprintf((char *)Lcd_Disp_String, "TIM15:%05dHz,%4.1f%%",pwm_tim15_period,pwm_tim15_duty);
	LCD_DisplayStringLine(Line2, Lcd_Disp_String);
	 
	memset(Lcd_Disp_String,0,sizeof(Lcd_Disp_String));
	sprintf((char *)Lcd_Disp_String, "TIM1:%05d",TIM1_100MS_Count);
	LCD_DisplayStringLine(Line3, Lcd_Disp_String);
	
}

部分main.c:

/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "tim.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void Lcd_Proc(void);
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */
 LCD_Init();
	LCD_Clear(White);
  LCD_SetBackColor(White);
  LCD_SetTextColor(Blue);
  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM2_Init();
  MX_TIM3_Init();
  MX_TIM4_Init();
  MX_TIM15_Init();
  MX_TIM1_Init();
  /* USER CODE BEGIN 2 */
  PWM_OC_IC_Iint();
  
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
	  Lcd_Proc();
  }
  /* USER CODE END 3 */

完整的tim.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    tim.c
  * @brief   This file provides code for the configuration
  *          of the TIM instances.
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2024 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "tim.h"

/* USER CODE BEGIN 0 */
//TIM2捕获PA15pwm波的变量
uint32_t pwm_pa15_period_count ;
uint32_t pwm_pa15_duty_count ;
uint16_t pwm_pa15_period;
float pwm_pa15_duty;
//TIM3捕获PB4pwm波的变量
uint32_t pwm_pb4_period_count ;
uint32_t pwm_pb4_duty_count ;
uint16_t pwm_pb4_period;
float pwm_pb4_duty;
//TIM4捕获来自TIM15pwm波/方波的变量
uint32_t pwm_tim15_period_count ;
uint32_t pwm_tim15_duty_count ;
uint16_t pwm_tim15_period;
float pwm_tim15_duty;
uint16_t TIM1_100MS_Count=0;

/* USER CODE END 0 */

TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim2;
TIM_HandleTypeDef htim3;
TIM_HandleTypeDef htim4;
TIM_HandleTypeDef htim15;

/* TIM1 init function */
void MX_TIM1_Init(void)
{

  /* USER CODE BEGIN TIM1_Init 0 */

  /* USER CODE END TIM1_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM1_Init 1 */

  /* USER CODE END TIM1_Init 1 */
  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 7999;
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 999;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.RepetitionCounter = 0;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM1_Init 2 */

  /* USER CODE END TIM1_Init 2 */

}
/* TIM2 init function */
void MX_TIM2_Init(void)
{

  /* USER CODE BEGIN TIM2_Init 0 */

  /* USER CODE END TIM2_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_SlaveConfigTypeDef sSlaveConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_IC_InitTypeDef sConfigIC = {0};

  /* USER CODE BEGIN TIM2_Init 1 */

  /* USER CODE END TIM2_Init 1 */
  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 80-1;
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 65535;
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_IC_Init(&htim2) != HAL_OK)
  {
    Error_Handler();
  }
  sSlaveConfig.SlaveMode = TIM_SLAVEMODE_RESET;
  sSlaveConfig.InputTrigger = TIM_TS_TI1FP1;
  sSlaveConfig.TriggerPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
  sSlaveConfig.TriggerFilter = 0;
  if (HAL_TIM_SlaveConfigSynchro(&htim2, &sSlaveConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
  sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
  sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
  sConfigIC.ICFilter = 0;
  if (HAL_TIM_IC_ConfigChannel(&htim2, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_FALLING;
  sConfigIC.ICSelection = TIM_ICSELECTION_INDIRECTTI;
  if (HAL_TIM_IC_ConfigChannel(&htim2, &sConfigIC, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM2_Init 2 */

  /* USER CODE END TIM2_Init 2 */

}
/* TIM3 init function */
void MX_TIM3_Init(void)
{

  /* USER CODE BEGIN TIM3_Init 0 */

  /* USER CODE END TIM3_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_SlaveConfigTypeDef sSlaveConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_IC_InitTypeDef sConfigIC = {0};

  /* USER CODE BEGIN TIM3_Init 1 */

  /* USER CODE END TIM3_Init 1 */
  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 80-1;
  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim3.Init.Period = 65535;
  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_IC_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  sSlaveConfig.SlaveMode = TIM_SLAVEMODE_RESET;
  sSlaveConfig.InputTrigger = TIM_TS_TI1FP1;
  sSlaveConfig.TriggerPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
  sSlaveConfig.TriggerFilter = 0;
  if (HAL_TIM_SlaveConfigSynchro(&htim3, &sSlaveConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
  sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
  sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
  sConfigIC.ICFilter = 0;
  if (HAL_TIM_IC_ConfigChannel(&htim3, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_FALLING;
  sConfigIC.ICSelection = TIM_ICSELECTION_INDIRECTTI;
  if (HAL_TIM_IC_ConfigChannel(&htim3, &sConfigIC, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM3_Init 2 */

  /* USER CODE END TIM3_Init 2 */

}
/* TIM4 init function */
void MX_TIM4_Init(void)
{

  /* USER CODE BEGIN TIM4_Init 0 */

  /* USER CODE END TIM4_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_SlaveConfigTypeDef sSlaveConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_IC_InitTypeDef sConfigIC = {0};

  /* USER CODE BEGIN TIM4_Init 1 */

  /* USER CODE END TIM4_Init 1 */
  htim4.Instance = TIM4;
  htim4.Init.Prescaler = 80-1;
  htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim4.Init.Period = 65535;
  htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_IC_Init(&htim4) != HAL_OK)
  {
    Error_Handler();
  }
  sSlaveConfig.SlaveMode = TIM_SLAVEMODE_RESET;
  sSlaveConfig.InputTrigger = TIM_TS_TI1FP1;
  sSlaveConfig.TriggerPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
  sSlaveConfig.TriggerFilter = 0;
  if (HAL_TIM_SlaveConfigSynchro(&htim4, &sSlaveConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
  sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
  sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
  sConfigIC.ICFilter = 0;
  if (HAL_TIM_IC_ConfigChannel(&htim4, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_FALLING;
  sConfigIC.ICSelection = TIM_ICSELECTION_INDIRECTTI;
  if (HAL_TIM_IC_ConfigChannel(&htim4, &sConfigIC, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM4_Init 2 */

  /* USER CODE END TIM4_Init 2 */

}
/* TIM15 init function */
void MX_TIM15_Init(void)
{

  /* USER CODE BEGIN TIM15_Init 0 */

  /* USER CODE END TIM15_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_OC_InitTypeDef sConfigOC = {0};
  TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};

  /* USER CODE BEGIN TIM15_Init 1 */

  /* USER CODE END TIM15_Init 1 */
  htim15.Instance = TIM15;
  htim15.Init.Prescaler = 80-1;
  htim15.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim15.Init.Period = 200;
  htim15.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim15.Init.RepetitionCounter = 0;
  htim15.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim15) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim15, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_Init(&htim15) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim15, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 120;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  if (HAL_TIM_PWM_ConfigChannel(&htim15, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.Pulse = 50;
  if (HAL_TIM_PWM_ConfigChannel(&htim15, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
  sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
  sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
  sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
  sBreakDeadTimeConfig.DeadTime = 0;
  sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
  sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
  sBreakDeadTimeConfig.BreakFilter = 0;
  sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
  if (HAL_TIMEx_ConfigBreakDeadTime(&htim15, &sBreakDeadTimeConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM15_Init 2 */

  /* USER CODE END TIM15_Init 2 */
  HAL_TIM_MspPostInit(&htim15);

}

void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(tim_baseHandle->Instance==TIM1)
  {
  /* USER CODE BEGIN TIM1_MspInit 0 */

  /* USER CODE END TIM1_MspInit 0 */
    /* TIM1 clock enable */
    __HAL_RCC_TIM1_CLK_ENABLE();

    /* TIM1 interrupt Init */
    HAL_NVIC_SetPriority(TIM1_BRK_TIM15_IRQn, 3, 0);
    HAL_NVIC_EnableIRQ(TIM1_BRK_TIM15_IRQn);
    HAL_NVIC_SetPriority(TIM1_UP_TIM16_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(TIM1_UP_TIM16_IRQn);
  /* USER CODE BEGIN TIM1_MspInit 1 */

  /* USER CODE END TIM1_MspInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM2)
  {
  /* USER CODE BEGIN TIM2_MspInit 0 */

  /* USER CODE END TIM2_MspInit 0 */
    /* TIM2 clock enable */
    __HAL_RCC_TIM2_CLK_ENABLE();

    __HAL_RCC_GPIOA_CLK_ENABLE();
    /**TIM2 GPIO Configuration
    PA15     ------> TIM2_CH1
    */
    GPIO_InitStruct.Pin = GPIO_PIN_15;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* TIM2 interrupt Init */
    HAL_NVIC_SetPriority(TIM2_IRQn, 2, 0);
    HAL_NVIC_EnableIRQ(TIM2_IRQn);
  /* USER CODE BEGIN TIM2_MspInit 1 */

  /* USER CODE END TIM2_MspInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM3)
  {
  /* USER CODE BEGIN TIM3_MspInit 0 */

  /* USER CODE END TIM3_MspInit 0 */
    /* TIM3 clock enable */
    __HAL_RCC_TIM3_CLK_ENABLE();

    __HAL_RCC_GPIOB_CLK_ENABLE();
    /**TIM3 GPIO Configuration
    PB4     ------> TIM3_CH1
    */
    GPIO_InitStruct.Pin = GPIO_PIN_4;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF2_TIM3;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    /* TIM3 interrupt Init */
    HAL_NVIC_SetPriority(TIM3_IRQn, 2, 0);
    HAL_NVIC_EnableIRQ(TIM3_IRQn);
  /* USER CODE BEGIN TIM3_MspInit 1 */

  /* USER CODE END TIM3_MspInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM4)
  {
  /* USER CODE BEGIN TIM4_MspInit 0 */

  /* USER CODE END TIM4_MspInit 0 */
    /* TIM4 clock enable */
    __HAL_RCC_TIM4_CLK_ENABLE();

    __HAL_RCC_GPIOA_CLK_ENABLE();
    /**TIM4 GPIO Configuration
    PA11     ------> TIM4_CH1
    */
    GPIO_InitStruct.Pin = GPIO_PIN_11;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF10_TIM4;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* TIM4 interrupt Init */
    HAL_NVIC_SetPriority(TIM4_IRQn, 3, 0);
    HAL_NVIC_EnableIRQ(TIM4_IRQn);
  /* USER CODE BEGIN TIM4_MspInit 1 */

  /* USER CODE END TIM4_MspInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM15)
  {
  /* USER CODE BEGIN TIM15_MspInit 0 */

  /* USER CODE END TIM15_MspInit 0 */
    /* TIM15 clock enable */
    __HAL_RCC_TIM15_CLK_ENABLE();

    /* TIM15 interrupt Init */
    HAL_NVIC_SetPriority(TIM1_BRK_TIM15_IRQn, 3, 0);
    HAL_NVIC_EnableIRQ(TIM1_BRK_TIM15_IRQn);
  /* USER CODE BEGIN TIM15_MspInit 1 */

  /* USER CODE END TIM15_MspInit 1 */
  }
}
void HAL_TIM_MspPostInit(TIM_HandleTypeDef* timHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(timHandle->Instance==TIM15)
  {
  /* USER CODE BEGIN TIM15_MspPostInit 0 */

  /* USER CODE END TIM15_MspPostInit 0 */

    __HAL_RCC_GPIOA_CLK_ENABLE();
    /**TIM15 GPIO Configuration
    PA2     ------> TIM15_CH1
    PA3     ------> TIM15_CH2
    */
    GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF9_TIM15;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* USER CODE BEGIN TIM15_MspPostInit 1 */

  /* USER CODE END TIM15_MspPostInit 1 */
  }

}

void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle)
{

  if(tim_baseHandle->Instance==TIM1)
  {
  /* USER CODE BEGIN TIM1_MspDeInit 0 */

  /* USER CODE END TIM1_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM1_CLK_DISABLE();

    /* TIM1 interrupt Deinit */
  /* USER CODE BEGIN TIM1:TIM1_BRK_TIM15_IRQn disable */
    /**
    * Uncomment the line below to disable the "TIM1_BRK_TIM15_IRQn" interrupt
    * Be aware, disabling shared interrupt may affect other IPs
    */
    /* HAL_NVIC_DisableIRQ(TIM1_BRK_TIM15_IRQn); */
  /* USER CODE END TIM1:TIM1_BRK_TIM15_IRQn disable */

    HAL_NVIC_DisableIRQ(TIM1_UP_TIM16_IRQn);
  /* USER CODE BEGIN TIM1_MspDeInit 1 */

  /* USER CODE END TIM1_MspDeInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM2)
  {
  /* USER CODE BEGIN TIM2_MspDeInit 0 */

  /* USER CODE END TIM2_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM2_CLK_DISABLE();

    /**TIM2 GPIO Configuration
    PA15     ------> TIM2_CH1
    */
    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_15);

    /* TIM2 interrupt Deinit */
    HAL_NVIC_DisableIRQ(TIM2_IRQn);
  /* USER CODE BEGIN TIM2_MspDeInit 1 */

  /* USER CODE END TIM2_MspDeInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM3)
  {
  /* USER CODE BEGIN TIM3_MspDeInit 0 */

  /* USER CODE END TIM3_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM3_CLK_DISABLE();

    /**TIM3 GPIO Configuration
    PB4     ------> TIM3_CH1
    */
    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_4);

    /* TIM3 interrupt Deinit */
    HAL_NVIC_DisableIRQ(TIM3_IRQn);
  /* USER CODE BEGIN TIM3_MspDeInit 1 */

  /* USER CODE END TIM3_MspDeInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM4)
  {
  /* USER CODE BEGIN TIM4_MspDeInit 0 */

  /* USER CODE END TIM4_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM4_CLK_DISABLE();

    /**TIM4 GPIO Configuration
    PA11     ------> TIM4_CH1
    */
    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_11);

    /* TIM4 interrupt Deinit */
    HAL_NVIC_DisableIRQ(TIM4_IRQn);
  /* USER CODE BEGIN TIM4_MspDeInit 1 */

  /* USER CODE END TIM4_MspDeInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM15)
  {
  /* USER CODE BEGIN TIM15_MspDeInit 0 */

  /* USER CODE END TIM15_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM15_CLK_DISABLE();

    /* TIM15 interrupt Deinit */
  /* USER CODE BEGIN TIM15:TIM1_BRK_TIM15_IRQn disable */
    /**
    * Uncomment the line below to disable the "TIM1_BRK_TIM15_IRQn" interrupt
    * Be aware, disabling shared interrupt may affect other IPs
    */
    /* HAL_NVIC_DisableIRQ(TIM1_BRK_TIM15_IRQn); */
  /* USER CODE END TIM15:TIM1_BRK_TIM15_IRQn disable */

  /* USER CODE BEGIN TIM15_MspDeInit 1 */

  /* USER CODE END TIM15_MspDeInit 1 */
  }
}

/* USER CODE BEGIN 1 */
void PWM_OC_IC_Iint()
{
	HAL_TIM_Base_Start_IT(&htim1);//开启定时器1
	
	HAL_TIM_Base_Start(&htim15);//开启定时器15
	HAL_TIM_PWM_Start(&htim15,TIM_CHANNEL_1);//开启TIM15通道1的PWM生成
	HAL_TIM_PWM_Start(&htim15,TIM_CHANNEL_2);//开启TIM15通道2的PWM生成
	
	HAL_TIM_Base_Start(&htim2);//开启定时器2
	HAL_TIM_IC_Start_IT(&htim2,TIM_CHANNEL_1);//启动定时器2开启通道1输入捕获并开启中断
	HAL_TIM_IC_Start_IT(&htim2,TIM_CHANNEL_2);//启动定时器2开启通道2输入捕获并开启中断
	
	HAL_TIM_Base_Start(&htim3);//开启定时器3
	HAL_TIM_IC_Start_IT(&htim3,TIM_CHANNEL_1);//启动定时器3开启通道1输入捕获并开启中断
	HAL_TIM_IC_Start_IT(&htim3,TIM_CHANNEL_2);//启动定时器3开启通道2输入捕获并开启中断
	
	HAL_TIM_Base_Start(&htim4);//开启定时器4
	HAL_TIM_IC_Start_IT(&htim4,TIM_CHANNEL_1);//启动定时器4开启通道1输入捕获并开启中断
	HAL_TIM_IC_Start_IT(&htim4,TIM_CHANNEL_2);//启动定时器4开启通道2输入捕获并开启中断
	

	
}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	
	if(htim->Instance==TIM1)
	{
		TIM1_100MS_Count++;
	}
}

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
	
	//定时器2的输入捕获：PWM输入模式
	if(htim->Instance==TIM2)
	{   //计算来自于PA15的PWM波的周期
		
		if(htim->Channel==HAL_TIM_ACTIVE_CHANNEL_1)
		{
			pwm_pa15_period_count=HAL_TIM_ReadCapturedValue(htim,TIM_CHANNEL_1)+1;
			
			pwm_pa15_period=1000000/pwm_pa15_period_count;
			
			
		}
		//计算来自于PA15的PWM波的占空比
		if(htim->Channel==HAL_TIM_ACTIVE_CHANNEL_2)
		{
			pwm_pa15_duty_count=HAL_TIM_ReadCapturedValue(htim,TIM_CHANNEL_2)+1;
			pwm_pa15_duty=((float)pwm_pa15_duty_count/pwm_pa15_period_count)*100;
		}
	}
	
	if(htim->Instance==TIM3)
	{
		if(htim->Channel==HAL_TIM_ACTIVE_CHANNEL_1)
		{
			pwm_pb4_period_count=HAL_TIM_ReadCapturedValue(&htim3,TIM_CHANNEL_1);
			pwm_pb4_period=1000000/pwm_pb4_period_count;
		}
		
		if(htim->Channel==HAL_TIM_ACTIVE_CHANNEL_2)
		{
			pwm_pb4_duty_count=HAL_TIM_ReadCapturedValue(&htim3,TIM_CHANNEL_2);
			pwm_pb4_duty=((float)pwm_pb4_duty_count/pwm_pb4_period_count)*100;
			
		}
	}
	
	if(htim->Instance==TIM4)
	{
		if(htim->Channel==HAL_TIM_ACTIVE_CHANNEL_1)
		{
			pwm_tim15_period_count=HAL_TIM_ReadCapturedValue(&htim4,TIM_CHANNEL_1);
			pwm_tim15_period=1000000/pwm_tim15_period_count;
		}
		
		if(htim->Channel==HAL_TIM_ACTIVE_CHANNEL_2)
		{
			pwm_tim15_duty_count=HAL_TIM_ReadCapturedValue(&htim4,TIM_CHANNEL_2);
			pwm_tim15_duty=((float)pwm_tim15_duty_count/pwm_tim15_period_count)*100;
			
		}
		
		
	}
	
	
  }

void Lcd_Proc(void)
{
	//PA15产生的
	memset(Lcd_Disp_String,0,sizeof(Lcd_Disp_String));
    sprintf((char *)Lcd_Disp_String, "PWM1:%05dHz,%4.1f%%",pwm_pa15_period,pwm_pa15_duty);
	LCD_DisplayStringLine(Line0, Lcd_Disp_String);	
	//PB4产生的
	memset(Lcd_Disp_String,0,sizeof(Lcd_Disp_String));
	sprintf((char *)Lcd_Disp_String, "PWM2:%05dHz,%4.1f%%",pwm_pb4_period,pwm_pb4_duty);
	LCD_DisplayStringLine(Line1, Lcd_Disp_String);	
    //TIM15产生的PWM（PA2）5000HZ占空比60%PWM波（PA3）4000HZ占比25%
    //将PA2接PA11测量PWM，将PA3接PA11测量PWM
	memset(Lcd_Disp_String,0,sizeof(Lcd_Disp_String));
	sprintf((char *)Lcd_Disp_String, "TIM15:%05dHz,%4.1f%%",pwm_tim15_period,pwm_tim15_duty);
	LCD_DisplayStringLine(Line2, Lcd_Disp_String);
	 
	memset(Lcd_Disp_String,0,sizeof(Lcd_Disp_String));
	sprintf((char *)Lcd_Disp_String, "TIM1:%05d",TIM1_100MS_Count);
	LCD_DisplayStringLine(Line3, Lcd_Disp_String);
	
}

/* USER CODE END 1 */