STM32F103RCT6 定时器相关常用函数

只看该作者 · 2024-3-31 15:02

TIM_ITRxExternalClockConfig
/**
  * @brief  Configures the TIMx Internal Trigger as External Clock
  * @param  TIMx: where x can be  1, 2, 3, 4, 5, 9, 12 or 15 to select the TIM peripheral.
  * @param  TIM_ITRSource: Trigger source.
  * This parameter can be one of the following values:
  * @param  TIM_TS_ITR0: Internal Trigger 0
  * @param  TIM_TS_ITR1: Internal Trigger 1
  * @param  TIM_TS_ITR2: Internal Trigger 2
  * @param  TIM_TS_ITR3: Internal Trigger 3
  * @retval None
  */
void TIM_ITRxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource)
{
  /* Check the parameters */
  assert_param(IS_TIM_LIST6_PERIPH(TIMx));
  assert_param(IS_TIM_INTERNAL_TRIGGER_SELECTION(TIM_InputTriggerSource));
  /* Select the Internal Trigger */
  TIM_SelectInputTrigger(TIMx, TIM_InputTriggerSource);
  /* Select the External clock mode1 */
  TIMx->SMCR |= TIM_SlaveMode_External1;
}

只看该作者 · 2024-3-31 15:02

TIM_EncoderInterfaceConfig
/**
  * @brief  Configures the TIMx Encoder Interface.
  * @param  TIMx: where x can be  1, 2, 3, 4, 5 or 8 to select the TIM peripheral.
  * @param  TIM_EncoderMode: specifies the TIMx Encoder Mode.
  * This parameter can be one of the following values:
  *    @arg TIM_EncoderMode_TI1: Counter counts on TI1FP1 edge depending on TI2FP2 level.
  *    @arg TIM_EncoderMode_TI2: Counter counts on TI2FP2 edge depending on TI1FP1 level.
  *    @arg TIM_EncoderMode_TI12: Counter counts on both TI1FP1 and TI2FP2 edges depending
  *                               on the level of the other input.
  * @param  TIM_IC1Polarity: specifies the IC1 Polarity
  * This parameter can be one of the following values:
  *    @arg TIM_ICPolarity_Falling: IC Falling edge.
  *    @arg TIM_ICPolarity_Rising: IC Rising edge.
  * @param  TIM_IC2Polarity: specifies the IC2 Polarity
  * This parameter can be one of the following values:
  *    @arg TIM_ICPolarity_Falling: IC Falling edge.
  *    @arg TIM_ICPolarity_Rising: IC Rising edge.
  * @retval None
  */
void TIM_EncoderInterfaceConfig(TIM_TypeDef* TIMx, uint16_t TIM_EncoderMode,
                              uint16_t TIM_IC1Polarity, uint16_t TIM_IC2Polarity)
{
  uint16_t tmpsmcr = 0;
  uint16_t tmpccmr1 = 0;
  uint16_t tmpccer = 0;

  /* Check the parameters */
  assert_param(IS_TIM_LIST5_PERIPH(TIMx));
  assert_param(IS_TIM_ENCODER_MODE(TIM_EncoderMode));
  assert_param(IS_TIM_IC_POLARITY(TIM_IC1Polarity));
  assert_param(IS_TIM_IC_POLARITY(TIM_IC2Polarity));

  /* Get the TIMx SMCR register value */
  tmpsmcr = TIMx->SMCR;

  /* Get the TIMx CCMR1 register value */
  tmpccmr1 = TIMx->CCMR1;

  /* Get the TIMx CCER register value */
  tmpccer = TIMx->CCER;

  /* Set the encoder Mode */
  tmpsmcr &= (uint16_t)(~((uint16_t)TIM_SMCR_SMS));
  tmpsmcr |= TIM_EncoderMode;

  /* Select the Capture Compare 1 and the Capture Compare 2 as input */
  tmpccmr1 &= (uint16_t)(((uint16_t)~((uint16_t)TIM_CCMR1_CC1S)) & (uint16_t)(~((uint16_t)TIM_CCMR1_CC2S)));
  tmpccmr1 |= TIM_CCMR1_CC1S_0 | TIM_CCMR1_CC2S_0;

  /* Set the TI1 and the TI2 Polarities */
  tmpccer &= (uint16_t)(((uint16_t)~((uint16_t)TIM_CCER_CC1P)) & ((uint16_t)~((uint16_t)TIM_CCER_CC2P)));
  tmpccer |= (uint16_t)(TIM_IC1Polarity | (uint16_t)(TIM_IC2Polarity << (uint16_t)4));

  /* Write to TIMx SMCR */
  TIMx->SMCR = tmpsmcr;
  /* Write to TIMx CCMR1 */
  TIMx->CCMR1 = tmpccmr1;
  /* Write to TIMx CCER */
  TIMx->CCER = tmpccer;
}

只看该作者 · 2024-3-31 15:03

TIM_ICInit
/**
  * @brief  Initializes the TIM peripheral according to the specified
  *       parameters in the TIM_ICInitStruct.
  * @param  TIMx: where x can be  1 to 17 except 6 and 7 to select the TIM peripheral.
  * @param  TIM_ICInitStruct: pointer to a TIM_ICInitTypeDef structure
  *       that contains the configuration information for the specified TIM peripheral.
  * @retval None
  */
void TIM_ICInit(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct)
{
  /* Check the parameters */
  assert_param(IS_TIM_CHANNEL(TIM_ICInitStruct->TIM_Channel));
  assert_param(IS_TIM_IC_SELECTION(TIM_ICInitStruct->TIM_ICSelection));
  assert_param(IS_TIM_IC_PRESCALER(TIM_ICInitStruct->TIM_ICPrescaler));
  assert_param(IS_TIM_IC_FILTER(TIM_ICInitStruct->TIM_ICFilter));

  if((TIMx == TIM1) || (TIMx == TIM8) || (TIMx == TIM2) || (TIMx == TIM3) ||
   (TIMx == TIM4) ||(TIMx == TIM5))
  {
assert_param(IS_TIM_IC_POLARITY(TIM_ICInitStruct->TIM_ICPolarity));
  }
  else
  {
assert_param(IS_TIM_IC_POLARITY_LITE(TIM_ICInitStruct->TIM_ICPolarity));
  }
  if (TIM_ICInitStruct->TIM_Channel == TIM_Channel_1)
  {
assert_param(IS_TIM_LIST8_PERIPH(TIMx));
/* TI1 Configuration */
TI1_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity,
            TIM_ICInitStruct->TIM_ICSelection,
            TIM_ICInitStruct->TIM_ICFilter);
/* Set the Input Capture Prescaler value */
TIM_SetIC1Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler);
  }
  else if (TIM_ICInitStruct->TIM_Channel == TIM_Channel_2)
  {
assert_param(IS_TIM_LIST6_PERIPH(TIMx));
/* TI2 Configuration */
TI2_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity,
            TIM_ICInitStruct->TIM_ICSelection,
            TIM_ICInitStruct->TIM_ICFilter);
/* Set the Input Capture Prescaler value */
TIM_SetIC2Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler);
  }
  else if (TIM_ICInitStruct->TIM_Channel == TIM_Channel_3)
  {
assert_param(IS_TIM_LIST3_PERIPH(TIMx));
/* TI3 Configuration */
TI3_Config(TIMx,  TIM_ICInitStruct->TIM_ICPolarity,
            TIM_ICInitStruct->TIM_ICSelection,
            TIM_ICInitStruct->TIM_ICFilter);
/* Set the Input Capture Prescaler value */
TIM_SetIC3Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler);
  }
  else
  {
assert_param(IS_TIM_LIST3_PERIPH(TIMx));
/* TI4 Configuration */
TI4_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity,
            TIM_ICInitStruct->TIM_ICSelection,
            TIM_ICInitStruct->TIM_ICFilter);
/* Set the Input Capture Prescaler value */
TIM_SetIC4Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler);
  }
}

只看该作者 · 2024-3-31 15:03

TIM_SetICxPrescaler
TIM_SetIC1Prescaler
/**
  * @brief  Sets the TIMx Input Capture 1 prescaler.
  * @param  TIMx: where x can be 1 to 17 except 6 and 7 to select the TIM peripheral.
  * @param  TIM_ICPSC: specifies the Input Capture1 prescaler new value.
  * This parameter can be one of the following values:
  *    @arg TIM_ICPSC_DIV1: no prescaler
  *    @arg TIM_ICPSC_DIV2: capture is done once every 2 events
  *    @arg TIM_ICPSC_DIV4: capture is done once every 4 events
  *    @arg TIM_ICPSC_DIV8: capture is done once every 8 events
  * @retval None
  */
void TIM_SetIC1Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC)
{
  /* Check the parameters */
  assert_param(IS_TIM_LIST8_PERIPH(TIMx));
  assert_param(IS_TIM_IC_PRESCALER(TIM_ICPSC));
  /* Reset the IC1PSC Bits */
  TIMx->CCMR1 &= (uint16_t)~((uint16_t)TIM_CCMR1_IC1PSC);
  /* Set the IC1PSC value */
  TIMx->CCMR1 |= TIM_ICPSC;
}

只看该作者 · 2024-3-31 15:03

TIM_SetIC2Prescaler
/**
  * @brief  Sets the TIMx Input Capture 2 prescaler.
  * @param  TIMx: where x can be 1, 2, 3, 4, 5, 8, 9, 12 or 15 to select the TIM peripheral.
  * @param  TIM_ICPSC: specifies the Input Capture2 prescaler new value.
  * This parameter can be one of the following values:
  *    @arg TIM_ICPSC_DIV1: no prescaler
  *    @arg TIM_ICPSC_DIV2: capture is done once every 2 events
  *    @arg TIM_ICPSC_DIV4: capture is done once every 4 events
  *    @arg TIM_ICPSC_DIV8: capture is done once every 8 events
  * @retval None
  */
void TIM_SetIC2Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC)
{
  /* Check the parameters */
  assert_param(IS_TIM_LIST6_PERIPH(TIMx));
  assert_param(IS_TIM_IC_PRESCALER(TIM_ICPSC));
  /* Reset the IC2PSC Bits */
  TIMx->CCMR1 &= (uint16_t)~((uint16_t)TIM_CCMR1_IC2PSC);
  /* Set the IC2PSC value */
  TIMx->CCMR1 |= (uint16_t)(TIM_ICPSC << 8);
}

只看该作者 · 2024-3-31 15:03

TIM_SetIC3Prescaler
/**
  * @brief  Sets the TIMx Input Capture 3 prescaler.
  * @param  TIMx: where x can be 1, 2, 3, 4, 5 or 8 to select the TIM peripheral.
  * @param  TIM_ICPSC: specifies the Input Capture3 prescaler new value.
  * This parameter can be one of the following values:
  *    @arg TIM_ICPSC_DIV1: no prescaler
  *    @arg TIM_ICPSC_DIV2: capture is done once every 2 events
  *    @arg TIM_ICPSC_DIV4: capture is done once every 4 events
  *    @arg TIM_ICPSC_DIV8: capture is done once every 8 events
  * @retval None
  */
void TIM_SetIC3Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC)
{
  /* Check the parameters */
  assert_param(IS_TIM_LIST3_PERIPH(TIMx));
  assert_param(IS_TIM_IC_PRESCALER(TIM_ICPSC));
  /* Reset the IC3PSC Bits */
  TIMx->CCMR2 &= (uint16_t)~((uint16_t)TIM_CCMR2_IC3PSC);
  /* Set the IC3PSC value */
  TIMx->CCMR2 |= TIM_ICPSC;
}

只看该作者 · 2024-3-31 15:03

TIM_SetIC4Prescaler
/**
  * @brief  Sets the TIMx Input Capture 4 prescaler.
  * @param  TIMx: where x can be 1, 2, 3, 4, 5 or 8 to select the TIM peripheral.
  * @param  TIM_ICPSC: specifies the Input Capture4 prescaler new value.
  * This parameter can be one of the following values:
  *    @arg TIM_ICPSC_DIV1: no prescaler
  *    @arg TIM_ICPSC_DIV2: capture is done once every 2 events
  *    @arg TIM_ICPSC_DIV4: capture is done once every 4 events
  *    @arg TIM_ICPSC_DIV8: capture is done once every 8 events
  * @retval None
  */
void TIM_SetIC4Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC)
{
  /* Check the parameters */
  assert_param(IS_TIM_LIST3_PERIPH(TIMx));
  assert_param(IS_TIM_IC_PRESCALER(TIM_ICPSC));
  /* Reset the IC4PSC Bits */
  TIMx->CCMR2 &= (uint16_t)~((uint16_t)TIM_CCMR2_IC4PSC);
  /* Set the IC4PSC value */
  TIMx->CCMR2 |= (uint16_t)(TIM_ICPSC << 8);
}

只看该作者 · 2024-3-31 15:04

TIM_SetICxFilter

TIM_SetIC1Filter
void TIM_SetIC1Filter(TIM_TypeDef* TIMx, uint16_t TIM_ICFilter)
{
  /* Check the parameters */
  assert_param(IS_TIM_LIST3_PERIPH(TIMx));

  /* Reset the IC1F Bits */
  TIMx->CCMR1 &= (uint16_t)~((uint16_t)TIM_CCMR1_IC1F);
  /* Set the IC1F value */
  TIMx->CCMR1 |= TIM_ICFilter;
}

只看该作者 · 2024-3-31 15:04

TIM_SetIC2Filter
void TIM_SetIC2Filter(TIM_TypeDef* TIMx, uint16_t TIM_ICFilter)
{
  /* Check the parameters */
  assert_param(IS_TIM_LIST3_PERIPH(TIMx));

  /* Reset the IC2F Bits */
  TIMx->CCMR1 &= (uint16_t)~((uint16_t)TIM_CCMR1_IC2F);
  /* Set the IC2F value */
  TIMx->CCMR1 |= (uint16_t)(TIM_ICFilter << 8);
}

只看该作者 · 2024-3-31 15:04

IM_SetIC3Filter
void TIM_SetIC3Filter(TIM_TypeDef* TIMx, uint16_t TIM_ICFilter)
{
  /* Check the parameters */
  assert_param(IS_TIM_LIST3_PERIPH(TIMx));

  /* Reset the IC3F Bits */
  TIMx->CCMR2 &= (uint16_t)~((uint16_t)TIM_CCMR2_IC3F);
  /* Set the IC3F value */
  TIMx->CCMR2 |= TIM_ICFilter;
}

只看该作者 · 2024-3-31 15:04

TIM_SetIC4Filter
void TIM_SetIC4Filter(TIM_TypeDef* TIMx, uint16_t TIM_ICFilter)
{
  /* Check the parameters */
  assert_param(IS_TIM_LIST3_PERIPH(TIMx));

  /* Reset the IC4F Bits */
  TIMx->CCMR2 &= (uint16_t)~((uint16_t)TIM_CCMR2_IC4F);
  /* Set the IC4F value */
  TIMx->CCMR2 |= (uint16_t)(TIM_ICFilter << 8);
}

只看该作者 · 2024-3-31 15:04

TIM_GetITStatus
/**
  * @brief  Checks whether the TIM interrupt has occurred or not.
  * @param  TIMx: where x can be 1 to 17 to select the TIM peripheral.
  * @param  TIM_IT: specifies the TIM interrupt source to check.
  * This parameter can be one of the following values:
  *    @arg TIM_IT_Update: TIM update Interrupt source
  *    @arg TIM_IT_CC1: TIM Capture Compare 1 Interrupt source
  *    @arg TIM_IT_CC2: TIM Capture Compare 2 Interrupt source
  *    @arg TIM_IT_CC3: TIM Capture Compare 3 Interrupt source
  *    @arg TIM_IT_CC4: TIM Capture Compare 4 Interrupt source
  *    @arg TIM_IT_COM: TIM Commutation Interrupt source
  *    @arg TIM_IT_Trigger: TIM Trigger Interrupt source
  *    @arg TIM_IT_Break: TIM Break Interrupt source
  * @note
  * - TIM6 and TIM7 can generate only an update interrupt.
  * - TIM9, TIM12 and TIM15 can have only TIM_IT_Update, TIM_IT_CC1,
  *    TIM_IT_CC2 or TIM_IT_Trigger.
  * - TIM10, TIM11, TIM13, TIM14, TIM16 and TIM17 can have TIM_IT_Update or TIM_IT_CC1.
  * - TIM_IT_Break is used only with TIM1, TIM8 and TIM15.
  * - TIM_IT_COM is used only with TIM1, TIM8, TIM15, TIM16 and TIM17.
  * @retval The new state of the TIM_IT(SET or RESET).
  */
ITStatus TIM_GetITStatus(TIM_TypeDef* TIMx, uint16_t TIM_IT)
{
  ITStatus bitstatus = RESET;
  uint16_t itstatus = 0x0, itenable = 0x0;
  /* Check the parameters */
  assert_param(IS_TIM_ALL_PERIPH(TIMx));
  assert_param(IS_TIM_GET_IT(TIM_IT));

  itstatus = TIMx->SR & TIM_IT;

  itenable = TIMx->DIER & TIM_IT;
  if ((itstatus != (uint16_t)RESET) && (itenable != (uint16_t)RESET))
  {
bitstatus = SET;
  }
  else
  {
bitstatus = RESET;
  }
  return bitstatus;
}

只看该作者 · 2024-3-31 15:05

其中，TIMx是指定的定时器，TIM_IT是需要查询的中断源，可以是以下常量之一：

TIM_IT_Update：定时器更新中断。
TIM_IT_CC1：定时器通道1中断。
TIM_IT_CC2：定时器通道2中断。
TIM_IT_CC3：定时器通道3中断。
TIM_IT_CC4：定时器通道4中断。
TIM_IT_COM：定时器比较输出中断。
TIM_IT_Trigger：定时器触发事件中断。
TIM_IT_Break：定时器故障中断。
如果对应的中断发生，则TIM_GetITStatus()函数将返回值为SET，否则返回值为RESET。

使用此函数之前应该首先调用TIM_ClearITPendingBit()函数清除中断标志位。

只看该作者 · 2024-3-31 22:50

这个是标准库函数，现在使用的还多嘛？

只看该作者 · 2024-4-1 13:54

定时器的功能特别强大，功能函数也很多