stm32f10x_tim.c

中文固件库.rar

  assert_param(IS_TIM_BREAK_POLARITY(TIM_BDTRInitStruct->TIM_BreakPolarity));
  assert_param(IS_TIM_AUTOMATIC_OUTPUT_STATE(TIM_BDTRInitStruct->TIM_AutomaticOutput));
  /* Set the Lock level, the Break enable Bit and the Ploarity, the OSSR State,
     the OSSI State, the dead time value and the Automatic Output Enable Bit */
  TIMx->BDTR = (uint32_t)TIM_BDTRInitStruct->TIM_OSSRState | TIM_BDTRInitStruct->TIM_OSSIState |
             TIM_BDTRInitStruct->TIM_LOCKLevel | TIM_BDTRInitStruct->TIM_DeadTime |
             TIM_BDTRInitStruct->TIM_Break | TIM_BDTRInitStruct->TIM_BreakPolarity |
             TIM_BDTRInitStruct->TIM_AutomaticOutput;
}

/**
  * @brief  Fills each TIM_TimeBaseInitStruct member with its default value.
  * @param TIM_TimeBaseInitStruct : pointer to a TIM_TimeBaseInitTypeDef
  *   structure which will be initialized.
  * @retval : None
  */
void TIM_TimeBaseStructInit(TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct)
{
  /* Set the default configuration */
  TIM_TimeBaseInitStruct->TIM_Period = 0xFFFF;
  TIM_TimeBaseInitStruct->TIM_Prescaler = 0x0000;
  TIM_TimeBaseInitStruct->TIM_ClockDivision = TIM_CKD_DIV1;
  TIM_TimeBaseInitStruct->TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInitStruct->TIM_RepetitionCounter = 0x0000;
}

/**
  * @brief  Fills each TIM_OCInitStruct member with its default value.
  * @param TIM_OCInitStruct : pointer to a TIM_OCInitTypeDef structure
  *   which will be initialized.
  * @retval : None
  */
void TIM_OCStructInit(TIM_OCInitTypeDef* TIM_OCInitStruct)
{
  /* Set the default configuration */
  TIM_OCInitStruct->TIM_OCMode = TIM_OCMode_Timing;
  TIM_OCInitStruct->TIM_OutputState = TIM_OutputState_Disable;
  TIM_OCInitStruct->TIM_OutputNState = TIM_OutputNState_Disable;
  TIM_OCInitStruct->TIM_Pulse = 0x0000;
  TIM_OCInitStruct->TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OCInitStruct->TIM_OCNPolarity = TIM_OCPolarity_High;
  TIM_OCInitStruct->TIM_OCIdleState = TIM_OCIdleState_Reset;
  TIM_OCInitStruct->TIM_OCNIdleState = TIM_OCNIdleState_Reset;
}

/**
  * @brief  Fills each TIM_ICInitStruct member with its default value.
  * @param TIM_ICInitStruct : pointer to a TIM_ICInitTypeDef structure
  *   which will be initialized.
  * @retval : None
  */
void TIM_ICStructInit(TIM_ICInitTypeDef* TIM_ICInitStruct)
{
  /* Set the default configuration */
  TIM_ICInitStruct->TIM_Channel = TIM_Channel_1;
  TIM_ICInitStruct->TIM_ICPolarity = TIM_ICPolarity_Rising;
  TIM_ICInitStruct->TIM_ICSelection = TIM_ICSelection_DirectTI;
  TIM_ICInitStruct->TIM_ICPrescaler = TIM_ICPSC_DIV1;
  TIM_ICInitStruct->TIM_ICFilter = 0x00;
}

/**
  * @brief  Fills each TIM_BDTRInitStruct member with its default value.
  * @param TIM_BDTRInitStruct : pointer to a TIM_BDTRInitTypeDef
  *   structure which will be initialized.
  * @retval : None
  */
void TIM_BDTRStructInit(TIM_BDTRInitTypeDef* TIM_BDTRInitStruct)
{
  /* Set the default configuration */
  TIM_BDTRInitStruct->TIM_OSSRState = TIM_OSSRState_Disable;
  TIM_BDTRInitStruct->TIM_OSSIState = TIM_OSSIState_Disable;
  TIM_BDTRInitStruct->TIM_LOCKLevel = TIM_LOCKLevel_OFF;
  TIM_BDTRInitStruct->TIM_DeadTime = 0x00;
  TIM_BDTRInitStruct->TIM_Break = TIM_Break_Disable;
  TIM_BDTRInitStruct->TIM_BreakPolarity = TIM_BreakPolarity_Low;
  TIM_BDTRInitStruct->TIM_AutomaticOutput = TIM_AutomaticOutput_Disable;
}

/**
  * @brief  Enables or disables the specified TIM peripheral.
  * @param TIMx: where x can be 1 to 8 to select the TIMx peripheral.
  * @param NewState: new state of the TIMx peripheral.
  *   This parameter can be: ENABLE or DISABLE.
  * @retval : None
  */
void TIM_Cmd(TIM_TypeDef* TIMx, FunctionalState NewState)
{
  /* Check the parameters */
  assert_param(IS_TIM_ALL_PERIPH(TIMx));
  assert_param(IS_FUNCTIONAL_STATE(NewState));
  
  if (NewState != DISABLE)
  {
    /* Enable the TIM Counter */
    TIMx->CR1 |= CR1_CEN_Set;
  }
  else
  {
    /* Disable the TIM Counter */
    TIMx->CR1 &= CR1_CEN_Reset;
  }
}

/**
  * @brief  Enables or disables the TIM peripheral Main Outputs.
  * @param TIMx: where x can be 1 or 8 to select the TIMx peripheral.
  * @param NewState: new state of the TIM peripheral Main Outputs.
  *   This parameter can be: ENABLE or DISABLE.
  * @retval : None
  */
void TIM_CtrlPWMOutputs(TIM_TypeDef* TIMx, FunctionalState NewState)
{
  /* Check the parameters */
  assert_param(IS_TIM_18_PERIPH(TIMx));
  assert_param(IS_FUNCTIONAL_STATE(NewState));
  if (NewState != DISABLE)
  {
    /* Enable the TIM Main Output */
    TIMx->BDTR |= BDTR_MOE_Set;
  }
  else
  {
    /* Disable the TIM Main Output */
    TIMx->BDTR &= BDTR_MOE_Reset;
  }  
}

/**
  * @brief  Enables or disables the specified TIM interrupts.
  * @param TIMx: where x can be 1 to 8 to select the TIMx peripheral.
  * @param TIM_IT: specifies the TIM interrupts sources to be enabled
  *   or disabled.
  *   This parameter can be any combination 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
  * @param NewState: new state of the TIM interrupts.
  *   This parameter can be: ENABLE or DISABLE.
  * @retval : None
  */
void TIM_ITConfig(TIM_TypeDef* TIMx, uint16_t TIM_IT, FunctionalState NewState)
{  
  /* Check the parameters */
  assert_param(IS_TIM_ALL_PERIPH(TIMx));
  assert_param(IS_TIM_IT(TIM_IT));
  assert_param(IS_TIM_PERIPH_IT((TIMx), (TIM_IT)));
  assert_param(IS_FUNCTIONAL_STATE(NewState));
  
  if (NewState != DISABLE)
  {
    /* Enable the Interrupt sources */
    TIMx->DIER |= TIM_IT;
  }
  else
  {
    /* Disable the Interrupt sources */
    TIMx->DIER &= (uint16_t)~TIM_IT;
  }
}

/**
  * @brief  Configures the TIMx event to be generate by software.
  * @param TIMx: where x can be 1 to 8 to select the TIM peripheral.
  * @param TIM_EventSource: specifies the event source.
  *   This parameter can be one or more of the following values:	   
  * @arg TIM_EventSource_Update: Timer update Event source
  * @arg TIM_EventSource_CC1: Timer Capture Compare 1 Event source
  * @arg TIM_EventSource_CC2: Timer Capture Compare 2 Event source
  * @arg TIM_EventSource_CC3: Timer Capture Compare 3 Event source
  * @arg TIM_EventSource_CC4: Timer Capture Compare 4 Event source
  * @arg TIM_EventSource_Trigger: Timer Trigger Event source
  * @retval : None
  */
void TIM_GenerateEvent(TIM_TypeDef* TIMx, uint16_t TIM_EventSource)
{ 
  /* Check the parameters */
  assert_param(IS_TIM_ALL_PERIPH(TIMx));
  assert_param(IS_TIM_EVENT_SOURCE(TIM_EventSource));
  assert_param(IS_TIM_PERIPH_EVENT((TIMx), (TIM_EventSource)));
  /* Set the event sources */
  TIMx->EGR = TIM_EventSource;
}

/**
  * @brief  Configures the TIMx抯 DMA interface.
  * @param TIMx: where x can be  1, 2, 3, 4, 5 or 8 to select the TIM 
  *   peripheral.
  * @param TIM_DMABase: DMA Base address.
  *   This parameter can be one of the following values:
  * @arg TIM_DMABase_CR, TIM_DMABase_CR2, TIM_DMABase_SMCR,
  *   TIM_DMABase_DIER, TIM1_DMABase_SR, TIM_DMABase_EGR,
  *   TIM_DMABase_CCMR1, TIM_DMABase_CCMR2, TIM_DMABase_CCER,
  *   TIM_DMABase_CNT, TIM_DMABase_PSC, TIM_DMABase_ARR,
  *   TIM_DMABase_RCR, TIM_DMABase_CCR1, TIM_DMABase_CCR2,
  *   TIM_DMABase_CCR3, TIM_DMABase_CCR4, TIM_DMABase_BDTR,
  *   TIM_DMABase_DCR.
  * @param TIM_DMABurstLength: DMA Burst length.
  *   This parameter can be one value between:
  *   TIM_DMABurstLength_1Byte and TIM_DMABurstLength_18Bytes.
  * @retval : None
  */
void TIM_DMAConfig(TIM_TypeDef* TIMx, uint16_t TIM_DMABase, uint16_t TIM_DMABurstLength)
{
  /* Check the parameters */
  assert_param(IS_TIM_123458_PERIPH(TIMx));
  assert_param(IS_TIM_DMA_BASE(TIM_DMABase));
  assert_param(IS_TIM_DMA_LENGTH(TIM_DMABurstLength));
  /* Set the DMA Base and the DMA Burst Length */
  TIMx->DCR = TIM_DMABase | TIM_DMABurstLength;
}

/**
  * @brief  Enables or disables the TIMx抯 DMA Requests.
  * @param TIMx: where x can be  1 to 8 to select the TIM peripheral. 
  * @param TIM_DMASource: specifies the DMA Request sources.
  *   This parameter can be any combination of the following values:
  * @arg TIM_DMA_Update: TIM update Interrupt source
  * @arg TIM_DMA_CC1: TIM Capture Compare 1 DMA source
  * @arg TIM_DMA_CC2: TIM Capture Compare 2 DMA source
  * @arg TIM_DMA_CC3: TIM Capture Compare 3 DMA source
  * @arg TIM_DMA_CC4: TIM Capture Compare 4 DMA source
  * @arg TIM_DMA_COM: TIM Commutation DMA source
  * @arg TIM_DMA_Trigger: TIM Trigger DMA source
  * @param NewState: new state of the DMA Request sources.
  *   This parameter can be: ENABLE or DISABLE.
  * @retval : None
  */
void TIM_DMACmd(TIM_TypeDef* TIMx, uint16_t TIM_DMASource, FunctionalState NewState)
{ 
  /* Check the parameters */
  assert_param(IS_TIM_ALL_PERIPH(TIMx));
  assert_param(IS_TIM_DMA_SOURCE(TIM_DMASource));
  assert_param(IS_TIM_PERIPH_DMA(TIMx, TIM_DMASource));
  assert_param(IS_FUNCTIONAL_STATE(NewState));
  
  if (NewState != DISABLE)
  {
    /* Enable the DMA sources */
    TIMx->DIER |= TIM_DMASource; 
  }
  else
  {
    /* Disable the DMA sources */
    TIMx->DIER &= (uint16_t)~TIM_DMASource;
  }
}

/**
  * @brief  Configures the TIMx interrnal Clock
  * @param TIMx: where x can be  1, 2, 3, 4, 5 or 8 to select the TIM 
  *   peripheral.
  * @retval : None
  */
void TIM_InternalClockConfig(TIM_TypeDef* TIMx)
{
  /* Check the parameters */
  assert_param(IS_TIM_123458_PERIPH(TIMx));
  /* Disable slave mode to clock the prescaler directly with the internal clock */
  TIMx->SMCR &=  SMCR_SMS_Mask;
}

/**
  * @brief  Configures the TIMx Internal Trigger as External Clock
  * @param TIMx: where x can be  1, 2, 3, 4, 5 or 8 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_123458_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;
}

/**
  * @brief  Configures the TIMx Trigger as External Clock
  * @param TIMx: where x can be  1, 2, 3, 4, 5 or 8 to select the TIM 
  *   peripheral.
  * @param TIM_TIxExternalCLKSource: Trigger source.
  *   This parameter can be one of the following values:
  * @arg TIM_TIxExternalCLK1Source_TI1ED: TI1 Edge Detector
  * @arg TIM_TIxExternalCLK1Source_TI1: Filtered Timer Input 1
  * @arg TIM_TIxExternalCLK1Source_TI2: Filtered Timer Input 2
  * @param TIM_ICPolarity: specifies the TIx Polarity.
  *   This parameter can be:
  * @arg TIM_ICPolarity_Rising
  * @arg TIM_ICPolarity_Falling
  * @param ICFilter : specifies the filter value.
  *   This parameter must be a value between 0x0 and 0xF.
  * @retval : None
  */
void TIM_TIxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_TIxExternalCLKSource,
                                uint16_t TIM_ICPolarity, uint16_t ICFilter)
{
  /* Check the parameters */
  assert_param(IS_TIM_123458_PERIPH(TIMx));
  assert_param(IS_TIM_TIXCLK_SOURCE(TIM_TIxExternalCLKSource));
  assert_param(IS_TIM_IC_POLARITY(TIM_ICPolarity));
  assert_param(IS_TIM_IC_FILTER(ICFilter));
  /* Configure the Timer Input Clock Source */
  if (TIM_TIxExternalCLKSource == TIM_TIxExternalCLK1Source_TI2)
  {
    TI2_Config(TIMx, TIM_ICPolarity, TIM_ICSelection_DirectTI, ICFilter);
  }
  else
  {
    TI1_Config(TIMx, TIM_ICPolarity, TIM_ICSelection_DirectTI, ICFilter);
  }
  /* Select the Trigger source */
  TIM_SelectInputTrigger(TIMx, TIM_TIxExternalCLKSource);
  /* Select the External clock mode1 */
  TIMx->SMCR |= TIM_SlaveMode_External1;
}

/**
  * @brief  Configures the External clock Mode1
  * @param TIMx: where x can be  1, 2, 3, 4, 5 or 8 to select the TIM 
  *   peripheral.
  * @param TIM_ExtTRGPrescaler: The external Trigger Prescaler.
  *   It can be one of the following values:
  * @arg TIM_ExtTRGPSC_OFF
  * @arg TIM_ExtTRGPSC_DIV2
  * @arg TIM_ExtTRGPSC_DIV4
  * @arg TIM_ExtTRGPSC_DIV8.
  * @param TIM_ExtTRGPolarity: The external Trigger Polarity.
  *   It can be one of the following values:
  * @arg TIM_ExtTRGPolarity_Inverted
  * @arg TIM_ExtTRGPolarity_NonInverted
  * @param ExtTRGFilter: External Trigger Filter.
  *   This parameter must be a value between 0x00 and 0x0F
  * @retval : None
  */
void TIM_ETRClockMode1Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity,
                             uint16_t ExtTRGFilter)
{
  uint16_t tmpsmcr = 0;
  /* Check the parameters */
  assert_param(IS_TIM_123458_PERIPH(TIMx));
  assert_param(IS_TIM_EXT_PRESCALER(TIM_ExtTRGPrescaler));
  assert_param(IS_TIM_EXT_POLARITY(TIM_ExtTRGPolarity));
  assert_param(IS_TIM_EXT_FILTER(ExtTRGFilter));
  /* Configure the ETR Clock source */
  TIM_ETRConfig(TIMx, TIM_ExtTRGPrescaler, TIM_ExtTRGPolarity, ExtTRGFilter);