【蓝桥杯】【嵌入式组别】第十三节：PWM输入捕获编程

PWM捕获

目的就是测量输入到特定管脚上的PWM波的频率和占空比。
下面是PWM部分的电路图：
PWM由XL555芯片产生，由滑动变阻器R40连接到PA15，滑动变阻器不同的阻值对应不同的PWM波的频率。下面一个也是一样的原理。

可以看到板子上的PA15引脚的功能分别有：TIM2_CH1和TIM8_CH1，我们在板子上就用TIM_CH1来捕获PWM。PB4引脚我们使用TIM3_CH1来捕获PWM。（都是使用基础定时器）

通过用示波器观察两个XL555产生的波形我们得到：其产生的可用波形的频率范围大致在：700HZ-23KHZ。占空比为百分之五十左右。

单路PWM捕获编程

编程思路：
将管脚设置为上升沿中断，也就是每次碰到方波的上升沿就产生中断。
产生中断就会进入到中断处理函数，从而进入到回调函数。
在回调函数中应该做什么呢？要获取CNT值。CNT其实就是一个时钟的走时。我们在上一个上升沿获取这个时间，然后将其清零，下一次上升沿再获取这个时间，就是两次上升沿相隔的时长。所以CNT值就是一个PWM波的周期，通过周期可以获得其频率。
为了方便我们计算周期，我们可以设置CNT为1微秒加一次。那么CNT的值就代表多少微秒，相应的就是多少HZ的频率。

步骤：

1. 【模板】作为STM32CUBEMX生成代码的工程;
2. 配置TIM2的PA15作为TIM2 CH1输入捕获;
3. 根据需求，配置TIM2_CH1的分频值，推荐配置成1us计数一次;
4. 将tim.c和tim.h移植到【编程工程】
   4.1 main.c包含#include" tim.h"
   4.2添加tim.c和stm32g4的HAL库函数到工程中;
   4.3 stm32g4xx hal_conf.h中启动TIM模块;
   4.4 stm32g4xx it.c中，移植TIM2_IRQHandler中断服务函数;
   4.5在主函数调用MX TIM2 lnit)定时器初始化函数和HAL_TIM_IC_Start_IT&htim2,TIM_CHANNEL 1)启动定时器2捕获功能;
   4.6在HAL_TIM_IC_CaptureCallback回调函数里，获取CNT值，计算PWM的频率!

按照以下方法配置引脚：

然后配置其预分频值：
如果想要配置预分频值使其频率等于1MHZ，首先要知道TIMER2的频率是多少。
在STM32G431的数据手册中我们可以找到：

由此可见TIMER2是挂载在APB1总线下的定时器。
那么在CUBE的时钟树里面我们可以看到：

对于APB1总线下的定时器，其频率都是80MHZ。
所以我们设置预分频值为79，即可将其分频为1MHZ，就是1微秒记一次时。

Counter Period:是定时周期，这个决定的事CNT一直递增到多少的时候溢出，然后自动归零。
所以我们尽量应该设置这个周期尽可能的大，让CNT不要自动溢出归零。由于是32位的，所以其最大值就是0xffffffff，所以配置为0xffffffff就可以了。

最后生成代码即可（由于TIMER2是挂载在总线上的，所以也不用初始化他的时钟了，因为之前已经初始化过了）

先在主函数开启pwm输入捕获中断：

 HAL_TIM_IC_Start_IT(&htim2,TIM_CHANNEL_1); //开启pwm输入捕获中断

在模板工程编写中断回调函数：

//PWM捕获中断的回调函数
u32 tim2_cnt1;
u32 f40=0;
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
    
    
  //获取CNT的值
	tim2_cnt1=__HAL_TIM_GetCounter(&htim2);
	__HAL_TIM_SetCounter(&htim2,0);//获取cnt值之后就把他清零
	f40=1000000/tim2_cnt1;//周期的倒数就是频率
	HAL_TIM_IC_Start_IT(&htim2,TIM_CHANNEL_1); //开启pwm输入捕获中断
}

把F40的值显示在LCD屏幕上即可观察到不断变化的方波频率了。

双路PWM捕获编程

再设置一路PWM捕获
就是把PB4设置好：

基本设置都是一样的，唯一需要注意的一点就是PB4的Counter Period是16位的，最大数是65535，也就是0xffff，这个不要和上面那个一样了，一样的话就设置错了，其他就没什么需要注意的了，直接生成代码即可。

然后进行代码移植，把模板工程的代码移植到编程工程去。
在主函数中添加timer3的初始化函数并且打开timer3channel1的pwm输入捕获中断之后
改写一下回调函数即可：

//PWM捕获中断的回调函数
u32 tim2_cnt1,tim3_cnt1;
u32 f40=0,f30;
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
    
    
  //获取CNT的值
	if(htim==&htim2)
	{
    
    
	tim2_cnt1=__HAL_TIM_GetCounter(&htim2);
	__HAL_TIM_SetCounter(&htim2,0);//获取cnt值之后就把他清零
	f40=1000000/tim2_cnt1;//周期的倒数就是频率
	HAL_TIM_IC_Start_IT(&htim2,TIM_CHANNEL_1); //开启pwm输入捕获中断
	}
	if(htim==&htim3)
	{
    
    
	tim3_cnt1=__HAL_TIM_GetCounter(&htim3);
	__HAL_TIM_SetCounter(&htim3,0);//获取cnt值之后就把他清零
	f30=1000000/tim3_cnt1;//周期的倒数就是频率
	HAL_TIM_IC_Start_IT(&htim2,TIM_CHANNEL_1); //开启pwm输入捕获中断
	}
}

测量单路PWM的频率和占空比

测量频率其实就是测量周期。
测量占空比就是测量高电平时长占整个周期的多长时间。

编程思路：

1. 第一次上升沿中断，开始计时（清零计数器），并改成下降沿中断。
2. 下降沿中断，获取计数器的CNT值T1，并改成上升沿中断。
3. 第二次上升沿中断，获取计数器的CNT值T2，通过T2可以获得PWM的频率。通过T1/T2可以获得PWM的占空比

所以一套操作下来我们其实就是获得了两个时间，一个是高电平的时间，一个是整个周期的时间。
这就足以让我们计算占空比了。

那么现在编程的难点就在于如何改变中断的极性：
可以看到如下的他的tim初始化函数里面：：

void MX_TIM3_Init(void)
{
    
    
  TIM_MasterConfigTypeDef sMasterConfig = {
    
    0};
  TIM_IC_InitTypeDef sConfigIC = {
    
    0};

  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 79;
  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_IC_Init(&htim3) != 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();
  }

}

定义了一个初始化tim的结构体：TIM_IC_InitTypeDef sConfigIC = {0};
点开这个结构体的定义可以看到:

typedef struct
{
    
    
  uint32_t  ICPolarity;  /*!< Specifies the active edge of the input signal.
                              This parameter can be a value of @ref TIM_Input_Capture_Polarity */

  uint32_t ICSelection;  /*!< Specifies the input.
                              This parameter can be a value of @ref TIM_Input_Capture_Selection */

  uint32_t ICPrescaler;  /*!< Specifies the Input Capture Prescaler.
                              This parameter can be a value of @ref TIM_Input_Capture_Prescaler */

  uint32_t ICFilter;     /*!< Specifies the input capture filter.
                              This parameter can be a number between Min_Data = 0x0 and Max_Data = 0xF */
} TIM_IC_InitTypeDef;

这个结构体里面第一个就是中断的极性，第二个是输入的通道，后面两个分别是分频和滤波。
初始化函数后面用了HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig)函数引用了这个结构体，然后对tim进行了配置。那么我们看下这个函数的定义：

HAL_StatusTypeDef HAL_TIM_IC_ConfigChannel(TIM_HandleTypeDef *htim, TIM_IC_InitTypeDef *sConfig, uint32_t Channel)
{
    
    
  /* Check the parameters */
  assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
  assert_param(IS_TIM_IC_POLARITY(sConfig->ICPolarity));
  assert_param(IS_TIM_IC_SELECTION(sConfig->ICSelection));
  assert_param(IS_TIM_IC_PRESCALER(sConfig->ICPrescaler));
  assert_param(IS_TIM_IC_FILTER(sConfig->ICFilter));

  /* Process Locked */
  __HAL_LOCK(htim);

  if (Channel == TIM_CHANNEL_1)
  {
    
    
    /* TI1 Configuration */
    TIM_TI1_SetConfig(htim->Instance,
                      sConfig->ICPolarity,
                      sConfig->ICSelection,
                      sConfig->ICFilter);

    /* Reset the IC1PSC Bits */
    htim->Instance->CCMR1 &= ~TIM_CCMR1_IC1PSC;

    /* Set the IC1PSC value */
    htim->Instance->CCMR1 |= sConfig->ICPrescaler;
  }
  else if (Channel == TIM_CHANNEL_2)
  {
    
    
    /* TI2 Configuration */
    assert_param(IS_TIM_CC2_INSTANCE(htim->Instance));

    TIM_TI2_SetConfig(htim->Instance,
                      sConfig->ICPolarity,
                      sConfig->ICSelection,
                      sConfig->ICFilter);

    /* Reset the IC2PSC Bits */
    htim->Instance->CCMR1 &= ~TIM_CCMR1_IC2PSC;

    /* Set the IC2PSC value */
    htim->Instance->CCMR1 |= (sConfig->ICPrescaler << 8U);
  }
  else if (Channel == TIM_CHANNEL_3)
  {
    
    
    /* TI3 Configuration */
    assert_param(IS_TIM_CC3_INSTANCE(htim->Instance));

    TIM_TI3_SetConfig(htim->Instance,
                      sConfig->ICPolarity,
                      sConfig->ICSelection,
                      sConfig->ICFilter);

    /* Reset the IC3PSC Bits */
    htim->Instance->CCMR2 &= ~TIM_CCMR2_IC3PSC;

    /* Set the IC3PSC value */
    htim->Instance->CCMR2 |= sConfig->ICPrescaler;
  }
  else
  {
    
    
    /* TI4 Configuration */
    assert_param(IS_TIM_CC4_INSTANCE(htim->Instance));

    TIM_TI4_SetConfig(htim->Instance,
                      sConfig->ICPolarity,
                      sConfig->ICSelection,
                      sConfig->ICFilter);

    /* Reset the IC4PSC Bits */
    htim->Instance->CCMR2 &= ~TIM_CCMR2_IC4PSC;

    /* Set the IC4PSC value */
    htim->Instance->CCMR2 |= (sConfig->ICPrescaler << 8U);
  }

  __HAL_UNLOCK(htim);

  return HAL_OK;
}

里面写了如果是通道1，执行：

if (Channel == TIM_CHANNEL_1)
  {
    
    
    /* TI1 Configuration */
    TIM_TI1_SetConfig(htim->Instance,
                      sConfig->ICPolarity,
                      sConfig->ICSelection,
                      sConfig->ICFilter);

    /* Reset the IC1PSC Bits */
    htim->Instance->CCMR1 &= ~TIM_CCMR1_IC1PSC;

    /* Set the IC1PSC value */
    htim->Instance->CCMR1 |= sConfig->ICPrescaler;
  }

如果是通道2或者3执行后面的程序。
我们只看通道1的即可：
这里面调用了TIM_TI1_SetConfig函数，把sConfigIC结构体的各个参数传了进去。
所以我们看下TIM_TI1_SetConfig函数内部是如何操作，然后把sConfigIC结构体的参数传入的：

void TIM_TI1_SetConfig(TIM_TypeDef *TIMx, uint32_t TIM_ICPolarity, uint32_t TIM_ICSelection,
                       uint32_t TIM_ICFilter)
{
    
    
  uint32_t tmpccmr1;
  uint32_t tmpccer;

  /* Disable the Channel 1: Reset the CC1E Bit */
  TIMx->CCER &= ~TIM_CCER_CC1E;
  tmpccmr1 = TIMx->CCMR1;
  tmpccer = TIMx->CCER;

  /* Select the Input */
  if (IS_TIM_CC2_INSTANCE(TIMx) != RESET)
  {
    
    
    tmpccmr1 &= ~TIM_CCMR1_CC1S;
    tmpccmr1 |= TIM_ICSelection;
  }
  else
  {
    
    
    tmpccmr1 |= TIM_CCMR1_CC1S_0;
  }

  /* Set the filter */
  tmpccmr1 &= ~TIM_CCMR1_IC1F;
  tmpccmr1 |= ((TIM_ICFilter << 4U) & TIM_CCMR1_IC1F);

  /* Select the Polarity and set the CC1E Bit */
  tmpccer &= ~(TIM_CCER_CC1P | TIM_CCER_CC1NP);
  tmpccer |= (TIM_ICPolarity & (TIM_CCER_CC1P | TIM_CCER_CC1NP));

  /* Write to TIMx CCMR1 and CCER registers */
  TIMx->CCMR1 = tmpccmr1;
  TIMx->CCER = tmpccer;
}

可以看到这个里面就是对各种寄存器进行操作了。在后面几行是对中断极性的寄存器的位进行配置的：

 tmpccer |= (TIM_ICPolarity & (TIM_CCER_CC1P | TIM_CCER_CC1NP));

TIMx->CCER = tmpccer;

TIM_ICPolarity 就是中断极性。这句话是对tmpccer 这个变量进行操作的，然后最后把tmpccer 赋值给了TIMx->CCER这个寄存器。
所以我们只要操作TIMx->CCER这个寄存器就可以操作中断极性了。

点击看一下TIMx->CCER的说明：

  __IO uint32_t CCER;        /*!< TIM capture/compare enable register,      Address offset: 0x20 */

可以看到官方给出的注释就是CCER就是输入捕获使能的寄存器。

我们查阅手册看到：

可以看到CCER是一个十六位的寄存器（虽然STM32是32位的，但有些时候为了节省内存有些寄存器也设置为16位的）。
我们需要配置的是哪一位呢？

手册上写明了bit1这一位，也就是倒数第二位是配置中断极性（Polarity）的。
这里说的是CC1NP是0的话是PWM输入模式，然后在输入模式下，CC1P如果是0，就是上升沿中断。CC1P为1的话就是下降沿中断。
所以我们只需要改变CC1P这一位就可以了（因为我们用的就是PWM输入模式，CC1NP已经在初始化的时候初始为0了）。

开始编程：
回调函数里面的TIM2可以这样写：

	if(htim==&htim2)
	{
    
    
		if(tim2_state==0)//第一个上升沿产生，开始计时
		{
    
    
			__HAL_TIM_SetCounter(&htim2,0);//把CNT清零
			TIM2->CCER|=0x02; //下降沿中断，就是要把CC1P置为1
			tim2_state=1;//等待下降沿产生
		}
		else if(tim2_state==1)//第一个下降沿产生，获取T1的值，就是高电平的时长
		{
    
    
			tim2_cnt1=__HAL_TIM_GetCounter(&htim2);//获取CNT的值
			TIM2->CCER &=~0x02;
			tim2_state=2;
		}
    else if(tim2_state==2)//第二个上升沿产生，获取T2的值，就是整个周期
		{
    
    
			tim2_cnt2=__HAL_TIM_GetCounter(&htim2);//获取CNT的值
	        f40=1000000/tim2_cnt2;//周期的倒数就是频率
			d40=tim2_cnt1*100.0f/tim2_cnt2;//计算占空比
			tim2_state=0;
		}
	  HAL_TIM_IC_Start_IT(&htim2,TIM_CHANNEL_1); //开启pwm输入捕获中断
	}

测量两路PWM的频率和占空比

就是把上面的代码应用到TIMER3上面重新写一遍就好了：

//PWM捕获中断的回调函数
u32 tim2_cnt1,tim3_cnt1,tim2_cnt2,tim3_cnt2;
u32 f40=0,f30=0;
float d40=0,d30=0;
u8 tim2_state=0,tim3_state=0;
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
    
    
  //获取CNT的值
	if(htim==&htim2)
	{
    
    
		if(tim2_state==0)//第一个上升沿产生，开始计时
		{
    
    
			__HAL_TIM_SetCounter(&htim2,0);//把CNT清零
			TIM2->CCER|=0x02; //下降沿中断，就是要把CC1P置为1
			tim2_state=1;//等待下降沿产生
		}
		else if(tim2_state==1)//第一个下降沿产生，获取T1的值，就是高电平的时长
		{
    
    
			tim2_cnt1=__HAL_TIM_GetCounter(&htim2);//获取CNT的值
			TIM2->CCER &=~0x02;
			tim2_state=2;
		}
    else if(tim2_state==2)//第二个上升沿产生，获取T2的值，就是整个周期
		{
    
    
			tim2_cnt2=__HAL_TIM_GetCounter(&htim2);//获取CNT的值
	    f40=1000000/tim2_cnt2;//周期的倒数就是频率
			d40=tim2_cnt1*100.0f/tim2_cnt2;
			tim2_state=0;
		}
	  HAL_TIM_IC_Start_IT(&htim2,TIM_CHANNEL_1); //开启pwm输入捕获中断
	}
	if(htim==&htim3)
	{
    
    
		if(tim3_state==0)//第一个上升沿产生，开始计时
		{
    
    
			__HAL_TIM_SetCounter(&htim3,0);//把CNT清零
			TIM3->CCER|=0x02; //下降沿中断，就是要把CC1P置为1
			tim3_state=1;//等待下降沿产生
		}
		else if(tim3_state==1)//第一个下降沿产生，获取T1的值，就是高电平的时长
		{
    
    
			tim3_cnt1=__HAL_TIM_GetCounter(&htim3);//获取CNT的值
			TIM3->CCER &=~0x02;
			tim3_state=2;
		}
    else if(tim3_state==2)//第二个上升沿产生，获取T2的值，就是整个周期
		{
    
    
			tim3_cnt2=__HAL_TIM_GetCounter(&htim3);//获取CNT的值
	    f30=1000000/tim3_cnt2;//周期的倒数就是频率
			d30=tim3_cnt1*100.0f/tim3_cnt2;
			tim3_state=0;
		}
	  HAL_TIM_IC_Start_IT(&htim3,TIM_CHANNEL_1); //开启pwm输入捕获中断
	}
	
}