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

PWM输入捕获编程

  • PWM捕获
  • 单路PWM捕获编程
  • 双路PWM捕获编程
  • 测量单路PWM的频率和占空比
  • 测量两路PWM的频率和占空比

PWM捕获

目的就是测量输入到特定管脚上的PWM波的频率和占空比。
下面是PWM部分的电路图:
PWM由XL555芯片产生,由滑动变阻器R40连接到PA15,滑动变阻器不同的阻值对应不同的PWM波的频率。下面一个也是一样的原理。
【蓝桥杯】【嵌入式组别】第十三节:PWM输入捕获编程_第1张图片
可以看到板子上的PA15引脚的功能分别有:TIM2_CH1和TIM8_CH1,我们在板子上就用TIM_CH1来捕获PWM。PB4引脚我们使用TIM3_CH1来捕获PWM。(都是使用基础定时器)
【蓝桥杯】【嵌入式组别】第十三节:PWM输入捕获编程_第2张图片

【蓝桥杯】【嵌入式组别】第十三节:PWM输入捕获编程_第3张图片
通过用示波器观察两个XL555产生的波形我们得到:其产生的可用波形的频率范围大致在:700HZ-23KHZ。占空比为百分之五十左右。

单路PWM捕获编程

编程思路:
将管脚设置为上升沿中断,也就是每次碰到方波的上升沿就产生中断。
产生中断就会进入到中断处理函数,从而进入到回调函数。
在回调函数中应该做什么呢?要获取CNT值。CNT其实就是一个时钟的走时。我们在上一个上升沿获取这个时间,然后将其清零,下一次上升沿再获取这个时间,就是两次上升沿相隔的时长。所以CNT值就是一个PWM波的周期,通过周期可以获得其频率。
为了方便我们计算周期,我们可以设置CNT为1微秒加一次。那么CNT的值就代表多少微秒,相应的就是多少HZ的频率。
【蓝桥杯】【嵌入式组别】第十三节:PWM输入捕获编程_第4张图片
步骤:

  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的频率!

按照以下方法配置引脚:

【蓝桥杯】【嵌入式组别】第十三节:PWM输入捕获编程_第5张图片
然后配置其预分频值:
如果想要配置预分频值使其频率等于1MHZ,首先要知道TIMER2的频率是多少。
在STM32G431的数据手册中我们可以找到:
【蓝桥杯】【嵌入式组别】第十三节:PWM输入捕获编程_第6张图片

由此可见TIMER2是挂载在APB1总线下的定时器。
那么在CUBE的时钟树里面我们可以看到:
【蓝桥杯】【嵌入式组别】第十三节:PWM输入捕获编程_第7张图片
对于APB1总线下的定时器,其频率都是80MHZ。
所以我们设置预分频值为79,即可将其分频为1MHZ,就是1微秒记一次时。
【蓝桥杯】【嵌入式组别】第十三节:PWM输入捕获编程_第8张图片
Counter Period:是定时周期,这个决定的事CNT一直递增到多少的时候溢出,然后自动归零。
所以我们尽量应该设置这个周期尽可能的大,让CNT不要自动溢出归零。由于是32位的,所以其最大值就是0xffffffff,所以配置为0xffffffff就可以了。
【蓝桥杯】【嵌入式组别】第十三节:PWM输入捕获编程_第9张图片
最后生成代码即可(由于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设置好:
【蓝桥杯】【嵌入式组别】第十三节:PWM输入捕获编程_第10张图片
基本设置都是一样的,唯一需要注意的一点就是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的占空比

【蓝桥杯】【嵌入式组别】第十三节:PWM输入捕获编程_第11张图片

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

那么现在编程的难点就在于如何改变中断的极性:
可以看到如下的他的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就是输入捕获使能的寄存器。

我们查阅手册看到:
【蓝桥杯】【嵌入式组别】第十三节:PWM输入捕获编程_第12张图片
可以看到CCER是一个十六位的寄存器(虽然STM32是32位的,但有些时候为了节省内存有些寄存器也设置为16位的)。
我们需要配置的是哪一位呢?
【蓝桥杯】【嵌入式组别】第十三节:PWM输入捕获编程_第13张图片
手册上写明了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输入捕获中断
	}
	
}

你可能感兴趣的:(蓝桥杯(嵌入式),单片机,蓝桥杯,stm32,嵌入式硬件,人工智能)