begriffs open source - cmsis-freertos/blob - Demo/CORTEX_STM32F103_Primer_GCC/ST_Code/stm32f10x_tim.c

   1 /******************** (C) COPYRIGHT 2007 STMicroelectronics ********************
   2 * File Name          : stm32f10x_tim.c
   3 * Author             : MCD Application Team
   4 * Date First Issued  : 09/29/2006
   5 * Description        : This file provides all the TIM firmware functions.
   6 ********************************************************************************
   7 * History:
   8 * 04/02/2007: V0.2
   9 * 02/05/2007: V0.1
  10 * 09/29/2006: V0.01
  11 ********************************************************************************
  12 * THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  13 * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
  14 * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
  15 * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
  16 * CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
  17 * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  18 *******************************************************************************/
  19
  20 /* Includes ------------------------------------------------------------------*/
  21 #include "stm32f10x_tim.h"
  22 #include "stm32f10x_rcc.h"
  23
  24 /* Private typedef -----------------------------------------------------------*/
  25 /* Private define ------------------------------------------------------------*/
  26 /* ---------------------- TIM registers bit mask ------------------------ */
  27 #define CR1_CEN_Set                 ((u16)0x0001)
  28 #define CR1_CEN_Reset               ((u16)0x03FE)
  29 #define CR1_UDIS_Set                ((u16)0x0002)
  30 #define CR1_UDIS_Reset              ((u16)0x03FD)
  31 #define CR1_URS_Set                 ((u16)0x0004)
  32 #define CR1_URS_Reset               ((u16)0x03FB)
  33 #define CR1_OPM_Mask                ((u16)0x03F7)
  34 #define CR1_CounterMode_Mask        ((u16)0x039F)
  35 #define CR1_ARPE_Set                ((u16)0x0080)
  36 #define CR1_ARPE_Reset              ((u16)0x037F)
  37 #define CR1_CKD_Mask                ((u16)0x00FF)
  38
  39 #define CR2_CCDS_Set                ((u16)0x0008)
  40 #define CR2_CCDS_Reset              ((u16)0x0007)
  41 #define CR2_MMS_Mask                ((u16)0x0080)
  42 #define CR2_TI1S_Set                ((u16)0x0080)
  43 #define CR2_TI1S_Reset              ((u16)0xFF70)
  44
  45 #define SMCR_SMS_Mask               ((u16)0xFFF0)
  46 #define SMCR_ETR_Mask               ((u16)0x00F7)
  47 #define SMCR_TS_Mask                ((u16)0xFF87)
  48 #define SMCR_MSM_Mask               ((u16)0xFF77)
  49 #define SMCR_ECE_Set                ((u16)0x4000)
  50
  51 #define CCMR_CC13S_Mask             ((u16)0x7F7C)
  52 #define CCMR_CC24S_Mask             ((u16)0x7C7F)
  53 #define CCMR_TI13Direct_Set         ((u16)0x0001)
  54 #define CCMR_TI24Direct_Set         ((u16)0x0100)
  55 #define CCMR_OC13FE_Mask            ((u16)0x7F7B)
  56 #define CCMR_OC24FE_Mask            ((u16)0x7B7F)
  57 #define CCMR_OC13PE_Mask            ((u16)0x7F77)
  58 #define CCMR_OC24PE_Mask            ((u16)0x777F)
  59 #define CCMR_OCM13_Mask             ((u16)0x7F0F)
  60 #define CCMR_OCM24_Mask             ((u16)0x0F7F)
  61 #define CCMR_IC13PSC_Mask           ((u16)0xFFF3)
  62 #define CCMR_IC24PSC_Mask           ((u16)0xF3FF)
  63 #define CCMR_IC13F_Mask             ((u16)0xFF0F)
  64 #define CCMR_IC24F_Mask             ((u16)0x0FFF)
  65 #define CCER_CC1P_Mask              ((u16)0xFFFD)
  66
  67 #define CCER_CC2P_Mask              ((u16)0xFFDF)
  68 #define CCER_CC3P_Mask              ((u16)0xFDFF)
  69 #define CCER_CC4P_Mask              ((u16)0xDFFF)
  70
  71 #define CCRE_CC1E_Set               ((u16)0x0001)
  72 #define CCRE_CC1E_Reset             ((u16)0xFFFE)
  73 #define CCRE_CC1E_Mask              ((u16)0xFFFE)
  74
  75 #define CCRE_CC2E_Set               ((u16)0x0010)
  76 #define CCRE_CC2E_Reset             ((u16)0xFFEF)
  77 #define CCRE_CC2E_Mask              ((u16)0xFFEF)
  78
  79 #define CCRE_CC3E_Set               ((u16)0x0100)
  80 #define CCRE_CC3E_Reset             ((u16)0xFEFF)
  81
  82 #define CCRE_CC4E_Set               ((u16)0x1000)
  83 #define CCRE_CC4E_Reset             ((u16)0xEFFF)
  84 #define CCRE_CC4E_Mask              ((u16)0xEFFF)
  85
  86 #define DCR_DMA_Mask                ((u16)0x0000)
  87
  88 /* TIM private Masks */
  89 #define TIM_Period_Reset_Mask       ((u16)0x0000)
  90 #define TIM_Prescaler_Reset_Mask    ((u16)0x0000)
  91 #define TIM_Pulse_Reset_Mask        ((u16)0x0000)
  92 #define TIM_ICFilter_Mask           ((u8)0x00)
  93
  94 /* Private macro -------------------------------------------------------------*/
  95 /* Private variables ---------------------------------------------------------*/
  96 static uc16 Tab_OCModeMask[4] = {0xFF00, 0x00FF, 0xFF00, 0x00FF};
  97 static uc16 Tab_PolarityMask[4] = {CCER_CC1P_Mask, CCER_CC2P_Mask, CCER_CC3P_Mask, CCER_CC4P_Mask};
  98
  99 /* Private function prototypes -----------------------------------------------*/
 100 static void PWMI_Config(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct);
 101 static void TI1_Config(TIM_TypeDef* TIMx, u16 TIM_ICPolarity, u16 TIM_ICSelection,
 102                        u8 TIM_ICFilter);
 103 static void TI2_Config(TIM_TypeDef* TIMx, u16 TIM_ICPolarity, u16 TIM_ICSelection,
 104                        u8 TIM_ICFilter);
 105 static void TI3_Config(TIM_TypeDef* TIMx, u16 TIM_ICPolarity, u16 TIM_ICSelection,
 106                        u8 TIM_ICFilter);
 107 static void TI4_Config(TIM_TypeDef* TIMx, u16 TIM_ICPolarity, u16 TIM_ICSelection,
 108                        u8 TIM_ICFilter);
 109 static void ETR_Config(TIM_TypeDef* TIMx, u16 TIM_ExtTRGPrescaler,
 110                        u16 TIM_ExtTRGPolarity, u8 ExtTRGFilter);
 111 /* Private functions ---------------------------------------------------------*/
 112
 113 /*******************************************************************************
 114 * Function Name  : TIM_DeInit
 115 * Description    : Deinitializes the TIMx peripheral registers to their default
 116 *                  reset values.
 117 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 118 * Output         : None
 119 * Return         : None
 120 *******************************************************************************/
 121 void TIM_DeInit(TIM_TypeDef* TIMx)
 122 {
 123   switch (*(u32*)&TIMx)
 124   {
 125     case TIM2_BASE:
 126       RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM2, ENABLE);
 127       RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM2, DISABLE);
 128       break;
 129
 130     case TIM3_BASE:
 131       RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM3, ENABLE);
 132       RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM3, DISABLE);
 133       break;
 134
 135     case TIM4_BASE:
 136       RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM4, ENABLE);
 137       RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM4, DISABLE);
 138       break;
 139
 140     default:
 141       break;
 142   }
 143 }
 144
 145 /*******************************************************************************
 146 * Function Name  : TIM_TimeBaseInit
 147 * Description    : Initializes the TIMx Time Base Unit peripheral according to
 148 *                  the specified parameters in the TIM_TimeBaseInitStruct.
 149 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 150 *                  - TIM_TimeBaseInitStruct: pointer to a TIM_TimeBaseInitTypeDef
 151 *                   structure that contains the configuration information for
 152 *                   the specified TIM peripheral.
 153 * Output         : None
 154 * Return         : None
 155 *******************************************************************************/
 156 void TIM_TimeBaseInit(TIM_TypeDef* TIMx, TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct)
 157 {
 158   /* Check the parameters */
 159   assert(IS_TIM_COUNTER_MODE(TIM_TimeBaseInitStruct->TIM_CounterMode));
 160   assert(IS_TIM_CKD_DIV(TIM_TimeBaseInitStruct->TIM_ClockDivision));
 161
 162   /* Set the Autoreload value */
 163   TIMx->ARR = TIM_TimeBaseInitStruct->TIM_Period ;
 164
 165   /* Set the Prescaler value */
 166   TIMx->PSC = TIM_TimeBaseInitStruct->TIM_Prescaler;
 167
 168   /* Select the Counter Mode and set the clock division */
 169   TIMx->CR1 &= CR1_CKD_Mask & CR1_CounterMode_Mask;
 170   TIMx->CR1 |= (u32)TIM_TimeBaseInitStruct->TIM_ClockDivision |
 171                TIM_TimeBaseInitStruct->TIM_CounterMode;
 172 }
 173 /*******************************************************************************
 174 * Function Name  : TIM_OCInit
 175 * Description    : Initializes the TIMx peripheral according to the specified
 176 *                  parameters in the TIM_OCInitStruct.
 177 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 178 *                  - TIM_OCInitStruct: pointer to a TIM_OCInitTypeDef structure
 179 *                    that contains the configuration information for the specified
 180 *                    TIM peripheral.
 181 * Output         : None
 182 * Return         : None
 183 *******************************************************************************/
 184 void TIM_OCInit(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct)
 185 {
 186   u32 tmpccmrx = 0, tmpccer = 0;
 187
 188   /* Check the parameters */
 189   assert(IS_TIM_OC_MODE(TIM_OCInitStruct->TIM_OCMode));
 190   assert(IS_TIM_CHANNEL(TIM_OCInitStruct->TIM_Channel));
 191   assert(IS_TIM_OC_POLARITY(TIM_OCInitStruct->TIM_OCPolarity));
 192
 193   tmpccer = TIMx->CCER;
 194
 195   if ((TIM_OCInitStruct->TIM_Channel == (u16)TIM_Channel_1) ||
 196       (TIM_OCInitStruct->TIM_Channel == (u16)TIM_Channel_2))
 197   {
 198     tmpccmrx = TIMx->CCMR1;
 199
 200     /* Reset the Output Compare Bits */
 201     tmpccmrx &= Tab_OCModeMask[TIM_OCInitStruct->TIM_Channel];
 202
 203     /* Set the Output Polarity level */
 204     tmpccer &= Tab_PolarityMask[TIM_OCInitStruct->TIM_Channel];
 205
 206     if (TIM_OCInitStruct->TIM_Channel == TIM_Channel_1)
 207     {
 208       /* Disable the Channel 1: Reset the CCE Bit */
 209       TIMx->CCER &= CCRE_CC1E_Reset;
 210
 211       /* Select the Output Compare Mode */
 212       tmpccmrx |= TIM_OCInitStruct->TIM_OCMode;
 213
 214       /* Set the Capture Compare Register value */
 215       TIMx->CCR1 = TIM_OCInitStruct->TIM_Pulse;
 216
 217       /* Set the Capture Compare Enable Bit */
 218       tmpccer |= CCRE_CC1E_Set;
 219
 220       /* Set the Capture Compare Polarity */
 221       tmpccer |= TIM_OCInitStruct->TIM_OCPolarity;
 222     }
 223     else /* TIM_Channel_2 */
 224     {
 225       /* Disable the Channel 2: Reset the CCE Bit */
 226       TIMx->CCER &= CCRE_CC2E_Reset;
 227
 228       /* Select the Output Compare Mode */
 229       tmpccmrx |= (u32)TIM_OCInitStruct->TIM_OCMode << 8;
 230
 231       /* Set the Capture Compare Register value */
 232       TIMx->CCR2 = TIM_OCInitStruct->TIM_Pulse;
 233
 234       /* Set the Capture Compare Enable Bit */
 235       tmpccer |= CCRE_CC2E_Set;
 236
 237       /* Set the Capture Compare Polarity */
 238       tmpccer |= (u32)TIM_OCInitStruct->TIM_OCPolarity << 4;
 239     }
 240
 241     TIMx->CCMR1 = (u16)tmpccmrx;
 242   }
 243   else
 244   {
 245     if ((TIM_OCInitStruct->TIM_Channel == TIM_Channel_3) ||
 246         (TIM_OCInitStruct->TIM_Channel == TIM_Channel_4))
 247     {
 248       tmpccmrx = TIMx->CCMR2;
 249
 250       /* Reset the Output Compare Bits */
 251       tmpccmrx &= Tab_OCModeMask[TIM_OCInitStruct->TIM_Channel];
 252
 253       /* Set the Output Polarity level */
 254       tmpccer &= Tab_PolarityMask[TIM_OCInitStruct->TIM_Channel];
 255
 256       if (TIM_OCInitStruct->TIM_Channel == TIM_Channel_3)
 257       {
 258         /* Disable the Channel 3: Reset the CCE Bit */
 259         TIMx->CCER &= CCRE_CC3E_Reset;
 260
 261         /* Select the Output Compare Mode */
 262         tmpccmrx |= TIM_OCInitStruct->TIM_OCMode;
 263
 264         /* Set the Capture Compare Register value */
 265         TIMx->CCR3 = TIM_OCInitStruct->TIM_Pulse;
 266
 267         /* Set the Capture Compare Enable Bit */
 268         tmpccer |= CCRE_CC3E_Set;
 269
 270         /* Set the Capture Compare Polarity */
 271         tmpccer |= (u32)TIM_OCInitStruct->TIM_OCPolarity << 8;
 272       }
 273       else  /* TIM_Channel_4 */
 274       {
 275         /* Disable the Channel 4: Reset the CCE Bit */
 276         TIMx->CCER &= CCRE_CC4E_Reset;
 277
 278        /* Select the Output Compare Mode */
 279         tmpccmrx |= (u32)TIM_OCInitStruct->TIM_OCMode << 8;
 280
 281         /* Set the Capture Compare Register value */
 282         TIMx->CCR4 = TIM_OCInitStruct->TIM_Pulse;
 283
 284         /* Set the Capture Compare Enable Bit */
 285         tmpccer |= CCRE_CC4E_Set;
 286
 287         /* Set the Capture Compare Polarity */
 288         tmpccer |= (u32)TIM_OCInitStruct->TIM_OCPolarity << 12;
 289       }
 290
 291       TIMx->CCMR2 = (u16)tmpccmrx;
 292     }
 293   }
 294
 295   TIMx->CCER = (u16)tmpccer;
 296 }
 297
 298 /*******************************************************************************
 299 * Function Name  : TIM_ICInit
 300 * Description    : Initializes the TIMx peripheral according to the specified
 301 *                  parameters in the TIM_ICInitStruct.
 302 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 303 *                  - TIM_ICInitStruct: pointer to a TIM_ICInitTypeDef structure
 304 *                    that contains the configuration information for the specified
 305 *                    TIM peripheral.
 306 * Output         : None
 307 * Return         : None
 308 *******************************************************************************/
 309 void TIM_ICInit(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct)
 310 {
 311   /* Check the parameters */
 312   assert(IS_TIM_IC_MODE(TIM_ICInitStruct->TIM_ICMode));
 313   assert(IS_TIM_CHANNEL(TIM_ICInitStruct->TIM_Channel));
 314   assert(IS_TIM_IC_POLARITY(TIM_ICInitStruct->TIM_ICPolarity));
 315   assert(IS_TIM_IC_SELECTION(TIM_ICInitStruct->TIM_ICSelection));
 316   assert(IS_TIM_IC_PRESCALER(TIM_ICInitStruct->TIM_ICPrescaler));
 317   assert(IS_TIM_IC_FILTER(TIM_ICInitStruct->TIM_ICFilter));
 318
 319   if (TIM_ICInitStruct->TIM_ICMode == TIM_ICMode_ICAP)
 320   {
 321     if (TIM_ICInitStruct->TIM_Channel == TIM_Channel_1)
 322     {
 323       /* TI1 Configuration */
 324       TI1_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity,
 325                  TIM_ICInitStruct->TIM_ICSelection,
 326                  TIM_ICInitStruct->TIM_ICFilter);
 327
 328       /* Set the Input Capture Prescaler value */
 329       TIM_SetIC1Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler);
 330     }
 331     else if (TIM_ICInitStruct->TIM_Channel == TIM_Channel_2)
 332     {
 333       /* TI2 Configuration */
 334       TI2_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity,
 335                  TIM_ICInitStruct->TIM_ICSelection,
 336                  TIM_ICInitStruct->TIM_ICFilter);
 337
 338       /* Set the Input Capture Prescaler value */
 339       TIM_SetIC2Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler);
 340     }
 341     else if (TIM_ICInitStruct->TIM_Channel == TIM_Channel_3)
 342     {
 343       /* TI3 Configuration */
 344       TI3_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity,
 345                  TIM_ICInitStruct->TIM_ICSelection,
 346                  TIM_ICInitStruct->TIM_ICFilter);
 347
 348       /* Set the Input Capture Prescaler value */
 349       TIM_SetIC3Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler);
 350     }
 351     else /* TIM_Channel_4 */
 352     {
 353       /* TI4 Configuration */
 354       TI4_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity,
 355                  TIM_ICInitStruct->TIM_ICSelection,
 356                  TIM_ICInitStruct->TIM_ICFilter);
 357
 358       /* Set the Input Capture Prescaler value */
 359       TIM_SetIC4Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler);
 360     }
 361   }
 362   else
 363   {
 364     PWMI_Config(TIMx, TIM_ICInitStruct);
 365   }
 366 }
 367
 368 /*******************************************************************************
 369 * Function Name  : TIM_TimeBaseStructInit
 370 * Description    : Fills each TIM_TimeBaseInitStruct member with its default value.
 371 * Input          : - TIM_TimeBaseInitStruct: pointer to a TIM_TimeBaseInitTypeDef
 372 *                    structure which will be initialized.
 373 * Output         : None
 374 * Return         : None
 375 *******************************************************************************/
 376 void TIM_TimeBaseStructInit(TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct)
 377 {
 378   /* Set the default configuration */
 379   TIM_TimeBaseInitStruct->TIM_Period = TIM_Period_Reset_Mask;
 380   TIM_TimeBaseInitStruct->TIM_Prescaler = TIM_Prescaler_Reset_Mask;
 381   TIM_TimeBaseInitStruct->TIM_ClockDivision = TIM_CKD_DIV1;
 382   TIM_TimeBaseInitStruct->TIM_CounterMode = TIM_CounterMode_Up;
 383 }
 384
 385 /*******************************************************************************
 386 * Function Name  : TIM_OCStructInit
 387 * Description    : Fills each TIM_OCInitStruct member with its default value.
 388 * Input          : - TIM_OCInitStruct: pointer to a TIM_OCInitTypeDef structure
 389 *                    which will be initialized.
 390 * Output         : None
 391 * Return         : None
 392 *******************************************************************************/
 393 void TIM_OCStructInit(TIM_OCInitTypeDef* TIM_OCInitStruct)
 394 {
 395   /* Set the default configuration */
 396   TIM_OCInitStruct->TIM_OCMode = TIM_OCMode_Timing;
 397   TIM_OCInitStruct->TIM_Channel = TIM_Channel_1;
 398   TIM_OCInitStruct->TIM_Pulse = TIM_Pulse_Reset_Mask;
 399   TIM_OCInitStruct->TIM_OCPolarity = TIM_OCPolarity_High;
 400 }
 401
 402 /*******************************************************************************
 403 * Function Name  : TIM_ICStructInit
 404 * Description    : Fills each TIM_InitStruct member with its default value.
 405 * Input          : - TIM_ICInitStruct: pointer to a TIM_ICInitTypeDef structure
 406 *                    which will be initialized.
 407 * Output         : None
 408 * Return         : None
 409 *******************************************************************************/
 410 void TIM_ICStructInit(TIM_ICInitTypeDef* TIM_ICInitStruct)
 411 {
 412   /* Set the default configuration */
 413   TIM_ICInitStruct->TIM_ICMode = TIM_ICMode_ICAP;
 414   TIM_ICInitStruct->TIM_Channel = TIM_Channel_1;
 415   TIM_ICInitStruct->TIM_ICPolarity = TIM_ICPolarity_Rising;
 416   TIM_ICInitStruct->TIM_ICSelection = TIM_ICSelection_DirectTI;
 417   TIM_ICInitStruct->TIM_ICPrescaler = TIM_ICPSC_DIV1;
 418   TIM_ICInitStruct->TIM_ICFilter = TIM_ICFilter_Mask;
 419 }
 420
 421 /*******************************************************************************
 422 * Function Name  : TIM_Cmd
 423 * Description    : Enables or disables the specified TIM peripheral.
 424 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIMx peripheral.
 425 *                  - Newstate: new state of the TIMx peripheral.
 426 *                    This parameter can be: ENABLE or DISABLE.
 427 * Output         : None
 428 * Return         : None
 429 *******************************************************************************/
 430 void TIM_Cmd(TIM_TypeDef* TIMx, FunctionalState NewState)
 431 {
 432   /* Check the parameters */
 433   assert(IS_FUNCTIONAL_STATE(NewState));
 434
 435   if (NewState != DISABLE)
 436   {
 437     /* Enable the TIM Counter */
 438     TIMx->CR1 |= CR1_CEN_Set;
 439   }
 440   else
 441   {
 442     /* Disable the TIM Counter */
 443     TIMx->CR1 &= CR1_CEN_Reset;
 444   }
 445 }
 446
 447 /*******************************************************************************
 448 * Function Name  : TIM_ITConfig
 449 * Description    : Enables or disables the TIMx interrupts.
 450 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 451 *                  - TIM_IT: specifies the TIM interrupts sources to be enabled
 452 *                    or disabled.
 453 *                    This parameter can be any combination of the following values:
 454 *                       - TIM_IT_Update: Timer update Interrupt
 455 *                       - TIM_IT_CC1: Capture Compare 1 Interrupt
 456 *                       - TIM_IT_CC2: Capture Compare 2 Interrupt
 457 *                       - TIM_IT_CC3: Capture Compare 3 Interrupt
 458 *                       - TIM_IT_CC4: Capture Compare 4 Interrupt
 459 *                       - TIM_IT_Trigger: Trigger Interrupt
 460 *                  - Newstate: new state of the specified TIMx interrupts.
 461 *                    This parameter can be: ENABLE or DISABLE.
 462 * Output         : None
 463 * Return         : None
 464 *******************************************************************************/
 465 void TIM_ITConfig(TIM_TypeDef* TIMx, u16 TIM_IT, FunctionalState NewState)
 466 {
 467   /* Check the parameters */
 468   assert(IS_TIM_IT(TIM_IT));
 469   assert(IS_FUNCTIONAL_STATE(NewState));
 470
 471   if (NewState != DISABLE)
 472   {
 473     /* Enable the Interrupt sources */
 474     TIMx->DIER |= TIM_IT;
 475   }
 476   else
 477   {
 478     /* Disable the Interrupt sources */
 479     TIMx->DIER &= (u16)(~TIM_IT);
 480   }
 481 }
 482
 483 /*******************************************************************************
 484 * Function Name  : TIM_DMAConfig
 485 * Description    : Configures the TIMx\92s DMA interface.
 486 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 487 *                  - TIM_DMABase: DMA Base address.
 488 *                    This parameter can be one of the following values:
 489 *                       - TIM_DMABase_CR1, TIM_DMABase_CR2, TIM_DMABase_SMCR,
 490 *                         TIM_DMABase_DIER, TIM_DMABase_SR, TIM_DMABase_EGR,
 491 *                         TIM_DMABase_CCMR1, TIM_DMABase_CCMR2, TIM_DMABase_CCER,
 492 *                         TIM_DMABase_CNT, TIM_DMABase_PSC, TIM_DMABase_ARR,
 493 *                         TIM_DMABase_CCR1, TIM_DMABase_CCR2, TIM_DMABase_CCR3,
 494 *                         TIM_DMABase_CCR4, TIM_DMABase_DCR.
 495 *                  - TIM_DMABurstLength: DMA Burst length.
 496 *                    This parameter can be one value between:
 497 *                    TIM_DMABurstLength_1Byte and TIM_DMABurstLength_18Bytes.
 498 * Output         : None
 499 * Return         : None
 500 *******************************************************************************/
 501 void TIM_DMAConfig(TIM_TypeDef* TIMx, u16 TIM_DMABase, u16 TIM_DMABurstLength)
 502 {
 503   u32 tmpdcr = 0;
 504
 505   /* Check the parameters */
 506   assert(IS_TIM_DMA_BASE(TIM_DMABase));
 507   assert(IS_TIM_DMA_LENGTH(TIM_DMABurstLength));
 508
 509   tmpdcr = TIMx->DCR;
 510
 511   /* Reset the DBA and the DBL Bits */
 512   tmpdcr &= DCR_DMA_Mask;
 513
 514   /* Set the DMA Base and the DMA Burst Length */
 515   tmpdcr |= TIM_DMABase | TIM_DMABurstLength;
 516
 517   TIMx->DCR = (u16)tmpdcr;
 518 }
 519
 520 /*******************************************************************************
 521 * Function Name  : TIM_DMACmd
 522 * Description    : Enables or disables the TIMx\92s DMA Requests.
 523 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 524 *                  - TIM_DMASources: specifies the DMA Request sources.
 525 *                    This parameter can be any combination of the following values:
 526 *                       - TIM_DMA_CC1: Capture Compare 1 DMA source
 527 *                       - TIM_DMA_CC2: Capture Compare 2 DMA source
 528 *                       - TIM_DMA_CC3: Capture Compare 3 DMA source
 529 *                       - TIM_DMA_CC4: Capture Compare 4 DMA source
 530 *                       - TIM_DMA_Trigger: Trigger DMA source
 531 *                  - Newstate: new state of the DMA Request sources.
 532 *                    This parameter can be: ENABLE or DISABLE.
 533 * Output         : None
 534 * Return         : None
 535 *******************************************************************************/
 536 void TIM_DMACmd(TIM_TypeDef* TIMx, u16 TIM_DMASource, FunctionalState Newstate)
 537 {
 538   u32 tmpdier = 0;
 539
 540   /* Check the parameters */
 541   assert(IS_TIM_DMA_SOURCE(TIM_DMASource));
 542   assert(IS_FUNCTIONAL_STATE(Newstate));
 543
 544   tmpdier = TIMx->DIER;
 545
 546   if (Newstate != DISABLE)
 547   {
 548     /* Enable the DMA sources */
 549     tmpdier |= TIM_DMASource;
 550   }
 551   else
 552   {
 553     /* Disable the DMA sources */
 554     tmpdier &= (u16)(~TIM_DMASource);
 555   }
 556   TIMx->DIER = (u16)tmpdier;
 557 }
 558
 559 /*******************************************************************************
 560 * Function Name  : TIM_InternalClockConfig
 561 * Description    : Configures the TIMx interrnal Clock
 562 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 563 * Output         : None
 564 * Return         : None
 565 *******************************************************************************/
 566 void TIM_InternalClockConfig(TIM_TypeDef* TIMx)
 567 {
 568   /* Disable slave mode to clock the prescaler directly with the internal clock */
 569   TIMx->SMCR &=  SMCR_SMS_Mask;
 570 }
 571 /*******************************************************************************
 572 * Function Name  : TIM_ITRxExternalClockConfig
 573 * Description    : Configures the TIMx Internal Trigger as External Clock
 574 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 575 *                  - TIM_ITRSource: Trigger source.
 576 *                    This parameter can be one of the following values:
 577 *                       - TIM_TS_ITR0: Internal Trigger 0
 578 *                       - TIM_TS_ITR1: Internal Trigger 1
 579 *                       - TIM_TS_ITR2: Internal Trigger 2
 580 *                       - TIM_TS_ITR3: Internal Trigger 3
 581 * Output         : None
 582 * Return         : None
 583 *******************************************************************************/
 584 void TIM_ITRxExternalClockConfig(TIM_TypeDef* TIMx, u16 TIM_InputTriggerSource)
 585 {
 586   /* Check the parameters */
 587   assert(IS_TIM_INTERNAL_TRIGGER_SELECTION(TIM_InputTriggerSource));
 588
 589   /* Select the Internal Trigger */
 590   TIM_SelectInputTrigger(TIMx, TIM_InputTriggerSource);
 591
 592   /* Select the External clock mode1 */
 593   TIMx->SMCR |= TIM_SlaveMode_External1;
 594 }
 595 /*******************************************************************************
 596 * Function Name  : TIM_TIxExternalClockConfig
 597 * Description    : Configures the TIMx Trigger as External Clock
 598 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 599 *                  - TIM_TIxExternalCLKSource: Trigger source.
 600 *                    This parameter can be one of the following values:
 601 *                       - TIM_TS_TI1F_ED: TI1 Edge Detector
 602 *                       - TIM_TS_TI1FP1: Filtered Timer Input 1
 603 *                       - TIM_TS_TI2FP2: Filtered Timer Input 2
 604 *                  - TIM_ICPolarity: specifies the TIx Polarity.
 605 *                    This parameter can be:
 606 *                       - TIM_ICPolarity_Rising
 607 *                       - TIM_ICPolarity_Falling
 608 *                   - ICFilter : specifies the filter value.
 609 *                     This parameter must be a value between 0x0 and 0xF.
 610 * Output         : None
 611 * Return         : None
 612 *******************************************************************************/
 613 void TIM_TIxExternalClockConfig(TIM_TypeDef* TIMx, u16 TIM_TIxExternalCLKSource,
 614                                 u16 TIM_ICPolarity, u8 ICFilter)
 615 {
 616   /* Check the parameters */
 617   assert(IS_TIM_TIX_TRIGGER_SELECTION(TIM_TIxExternalCLKSource));
 618   assert(IS_TIM_IC_POLARITY(TIM_ICPolarity));
 619   assert(IS_TIM_IC_FILTER(ICFilter));
 620
 621   /* Configure the Timer Input Clock Source */
 622   if (TIM_TIxExternalCLKSource == TIM_TIxExternalCLK1Source_TI2)
 623   {
 624     TI2_Config(TIMx, TIM_ICPolarity, TIM_ICSelection_DirectTI, ICFilter);
 625   }
 626   else
 627   {
 628     TI1_Config(TIMx, TIM_ICPolarity, TIM_ICSelection_DirectTI, ICFilter);
 629   }
 630
 631   /* Select the Trigger source */
 632   TIM_SelectInputTrigger(TIMx, TIM_TIxExternalCLKSource);
 633
 634   /* Select the External clock mode1 */
 635   TIMx->SMCR |= TIM_SlaveMode_External1;
 636 }
 637
 638 /*******************************************************************************
 639 * Function Name  : TIM_ETRClockMode1Config
 640 * Description    : Configures the External clock Mode1
 641 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 642 *                  - TIM_ExtTRGPrescaler: The external Trigger Prescaler.
 643 *                    It can be one of the following values:
 644 *                       - TIM_ExtTRGPSC_OFF
 645 *                       - TIM_ExtTRGPSC_DIV2
 646 *                       - TIM_ExtTRGPSC_DIV4
 647 *                       - TIM_ExtTRGPSC_DIV8.
 648 *                  - TIM_ExtTRGPolarity: The external Trigger Polarity.
 649 *                    It can be one of the following values:
 650 *                       - TIM_ExtTRGPolarity_Inverted
 651 *                       - TIM_ExtTRGPolarity_NonInverted
 652 *                  - ExtTRGFilter: External Trigger Filter.
 653 *                    This parameter must be a value between 0x00 and 0x0F
 654 * Output         : None
 655 * Return         : None
 656 *******************************************************************************/
 657 void TIM_ETRClockMode1Config(TIM_TypeDef* TIMx, u16 TIM_ExtTRGPrescaler, u16 TIM_ExtTRGPolarity,
 658                              u8 ExtTRGFilter)
 659 {
 660   /* Check the parameters */
 661   assert(IS_TIM_EXT_PRESCALER(TIM_ExtTRGPrescaler));
 662   assert(IS_TIM_EXT_POLARITY(TIM_ExtTRGPolarity));
 663
 664   /* Configure the ETR Clock source */
 665   ETR_Config(TIMx, TIM_ExtTRGPrescaler, TIM_ExtTRGPolarity, ExtTRGFilter);
 666
 667   /* Select the External clock mode1 */
 668   TIMx->SMCR &= SMCR_SMS_Mask;
 669   TIMx->SMCR |= TIM_SlaveMode_External1;
 670
 671   /* Select the Trigger selection : ETRF */
 672   TIMx->SMCR &= SMCR_TS_Mask;
 673   TIMx->SMCR |= TIM_TS_ETRF;
 674 }
 675
 676 /*******************************************************************************
 677 * Function Name  : TIM_ETRClockMode2Config
 678 * Description    : Configures the External clock Mode2
 679 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 680 *                  - TIM_ExtTRGPrescaler: The external Trigger Prescaler.
 681 *                    It can be one of the following values:
 682 *                       - TIM_ExtTRGPSC_OFF
 683 *                       - TIM_ExtTRGPSC_DIV2
 684 *                       - TIM_ExtTRGPSC_DIV4
 685 *                       - TIM_ExtTRGPSC_DIV8
 686 *                  - TIM_ExtTRGPolarity: The external Trigger Polarity.
 687 *                    It can be one of the following values:
 688 *                       - TIM_ExtTRGPolarity_Inverted
 689 *                       - TIM_ExtTRGPolarity_NonInverted
 690 *                  - ExtTRGFilter: External Trigger Filter.
 691 *                    This parameter must be a value between 0x00 and 0x0F
 692 * Output         : None
 693 * Return         : None
 694 *******************************************************************************/
 695 void TIM_ETRClockMode2Config(TIM_TypeDef* TIMx, u16 TIM_ExtTRGPrescaler,
 696                              u16 TIM_ExtTRGPolarity, u8 ExtTRGFilter)
 697 {
 698   /* Check the parameters */
 699   assert(IS_TIM_EXT_PRESCALER(TIM_ExtTRGPrescaler));
 700   assert(IS_TIM_EXT_POLARITY(TIM_ExtTRGPolarity));
 701
 702   /* Configure the ETR Clock source */
 703   ETR_Config(TIMx, TIM_ExtTRGPrescaler, TIM_ExtTRGPolarity, ExtTRGFilter);
 704
 705   /* Enable the External clock mode2 */
 706   TIMx->SMCR |= SMCR_ECE_Set;
 707 }
 708 /*******************************************************************************
 709 * Function Name  : TIM_SelectInputTrigger
 710 * Description    : Selects the Input Trigger source
 711 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 712 *                  - TIM_InputTriggerSource: The Input Trigger source.
 713 *                    This parameter can be one of the following values:
 714 *                       - TIM_TS_ITR0: Internal Trigger 0
 715 *                       - TIM_TS_ITR1: Internal Trigger 1
 716 *                       - TIM_TS_ITR2: Internal Trigger 2
 717 *                       - TIM_TS_ITR3: Internal Trigger 3
 718 *                       - TIM_TS_TI1F_ED: TI1 Edge Detector
 719 *                       - TIM_TS_TI1FP1: Filtered Timer Input 1
 720 *                       - TIM_TS_TI2FP2: Filtered Timer Input 2
 721 *                       - TIM_TS_ETRF: External Trigger input
 722 * Output         : None
 723 * Return         : None
 724 *******************************************************************************/
 725 void TIM_SelectInputTrigger(TIM_TypeDef* TIMx, u16 TIM_InputTriggerSource)
 726 {
 727   u32 tmpsmcr = 0;
 728
 729   /* Check the parameters */
 730   assert(IS_TIM_TRIGGER_SELECTION(TIM_InputTriggerSource));
 731
 732   tmpsmcr = TIMx->SMCR;
 733
 734   /* Select the Tgigger Source */
 735   tmpsmcr &= SMCR_TS_Mask;
 736   tmpsmcr |= TIM_InputTriggerSource;
 737
 738   TIMx->SMCR = (u16)tmpsmcr;
 739 }
 740
 741 /*******************************************************************************
 742 * Function Name  : TIM_PrescalerConfig
 743 * Description    : Configures the TIMx Prescaler.
 744 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 745 *                  - Prescaler: specifies the Prescaler Register value
 746 *                  - TIM_PSCReloadMode: specifies the TIM Prescaler Reload mode
 747 *                    This parameter can be one of the following values:
 748 *                       - TIM_PSCReloadMode_Update: The Prescaler is loaded at
 749 *                         the update event.
 750 *                       - TIM_PSCReloadMode_Immediate: The Prescaler is loaded
 751 *                         immediatly.
 752 * Output         : None
 753 * Return         : None
 754 *******************************************************************************/
 755 void TIM_PrescalerConfig(TIM_TypeDef* TIMx, u16 Prescaler, u16 TIM_PSCReloadMode)
 756 {
 757   /* Check the parameters */
 758   assert(IS_TIM_PRESCALER_RELOAD(TIM_PSCReloadMode));
 759
 760   /* Set the Prescaler value */
 761   TIMx->PSC = Prescaler;
 762
 763   /* Set or reset the UG Bit */
 764   if (TIM_PSCReloadMode == TIM_PSCReloadMode_Immediate)
 765   {
 766     TIMx->EGR |= TIM_EventSource_Update;
 767   }
 768   else
 769   {
 770     TIMx->EGR &= TIM_EventSource_Update;
 771   }
 772 }
 773
 774 /*******************************************************************************
 775 * Function Name  : TIM_CounterModeConfig
 776 * Description    : Specifies the TIMx Counter Mode to be used.
 777 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 778 *                  - TIM_CounterMode: specifies the Counter Mode to be used
 779 *                    This parameter can be one of the following values:
 780 *                       - TIM_CounterMode_Up: TIM Up Counting Mode
 781 *                       - TIM_CounterMode_Down: TIM Down Counting Mode
 782 *                       - TIM_CounterMode_CenterAligned1: TIM Center Aligned Mode1
 783 *                       - TIM_CounterMode_CenterAligned2: TIM Center Aligned Mode2
 784 *                       - TIM_CounterMode_CenterAligned3: TIM Center Aligned Mode3
 785 * Output         : None
 786 * Return         : None
 787 *******************************************************************************/
 788 void TIM_CounterModeConfig(TIM_TypeDef* TIMx, u16 TIM_CounterMode)
 789 {
 790   u32 tmpcr1 = 0;
 791
 792   /* Check the parameters */
 793   assert(IS_TIM_COUNTER_MODE(TIM_CounterMode));
 794
 795   tmpcr1 = TIMx->CR1;
 796
 797   /* Reset the CMS and DIR Bits */
 798   tmpcr1 &= CR1_CounterMode_Mask;
 799
 800   /* Set the Counter Mode */
 801   tmpcr1 |= TIM_CounterMode;
 802
 803   TIMx->CR1 = (u16)tmpcr1;
 804 }
 805
 806 /*******************************************************************************
 807 * Function Name  : TIM_ForcedOC1Config
 808 * Description    : Forces the TIMx output 1 waveform to active or inactive level.
 809 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 810 *                  - TIM_ForcedAction: specifies the forced Action to be set to
 811 *                    the output waveform.
 812 *                    This parameter can be one of the following values:
 813 *                       - TIM_ForcedAction_Active: Force active level on OC1REF
 814 *                       - TIM_ForcedAction_InActive: Force inactive level on
 815 *                         OC1REF.
 816 * Output         : None
 817 * Return         : None
 818 *******************************************************************************/
 819 void TIM_ForcedOC1Config(TIM_TypeDef* TIMx, u16 TIM_ForcedAction)
 820 {
 821   u32 tmpccmr1 = 0;
 822
 823   /* Check the parameters */
 824   assert(IS_TIM_FORCED_ACTION(TIM_ForcedAction));
 825
 826   tmpccmr1 = TIMx->CCMR1;
 827
 828   /* Reset the OCM Bits */
 829   tmpccmr1 &= CCMR_OCM13_Mask;
 830
 831   /* Configure The Forced output Mode */
 832   tmpccmr1 |= TIM_ForcedAction;
 833
 834   TIMx->CCMR1 = (u16)tmpccmr1;
 835 }
 836
 837 /*******************************************************************************
 838 * Function Name  : TIM_ForcedOC2Config
 839 * Description    : Forces the TIMx output 2 waveform to active or inactive level.
 840 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 841 *                  - TIM_ForcedAction: specifies the forced Action to be set to
 842 *                    the output waveform.
 843 *                    This parameter can be one of the following values:
 844 *                       - TIM_ForcedAction_Active: Force active level on OC2REF
 845 *                       - TIM_ForcedAction_InActive: Force inactive level on
 846 *                         OC2REF.
 847 * Output         : None
 848 * Return         : None
 849 *******************************************************************************/
 850 void TIM_ForcedOC2Config(TIM_TypeDef* TIMx, u16 TIM_ForcedAction)
 851 {
 852   u32 tmpccmr1 = 0;
 853
 854   /* Check the parameters */
 855   assert(IS_TIM_FORCED_ACTION(TIM_ForcedAction));
 856
 857   tmpccmr1 = TIMx->CCMR1;
 858
 859   /* Reset the OCM Bits */
 860   tmpccmr1 &= CCMR_OCM24_Mask;
 861
 862   /* Configure The Forced output Mode */
 863   tmpccmr1 |= (u16)(TIM_ForcedAction << 8);
 864
 865   TIMx->CCMR1 = (u16)tmpccmr1;
 866 }
 867
 868 /*******************************************************************************
 869 * Function Name  : TIM_ForcedOC3Config
 870 * Description    : Forces the TIMx output 3 waveform to active or inactive level.
 871 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 872 *                  - TIM_ForcedAction: specifies the forced Action to be set to
 873 *                    the output waveform.
 874 *                    This parameter can be one of the following values:
 875 *                       - TIM_ForcedAction_Active: Force active level on OC3REF
 876 *                       - TIM_ForcedAction_InActive: Force inactive level on
 877 *                         OC3REF.
 878 * Output         : None
 879 * Return         : None
 880 *******************************************************************************/
 881 void TIM_ForcedOC3Config(TIM_TypeDef* TIMx, u16 TIM_ForcedAction)
 882 {
 883   u32 tmpccmr2 = 0;
 884
 885   /* Check the parameters */
 886   assert(IS_TIM_FORCED_ACTION(TIM_ForcedAction));
 887
 888   tmpccmr2 = TIMx->CCMR2;
 889
 890   /* Reset the OCM Bits */
 891   tmpccmr2 &= CCMR_OCM13_Mask;
 892
 893   /* Configure The Forced output Mode */
 894   tmpccmr2 |= TIM_ForcedAction;
 895
 896   TIMx->CCMR2 = (u16)tmpccmr2;
 897 }
 898
 899 /*******************************************************************************
 900 * Function Name  : TIM_ForcedOC4Config
 901 * Description    : Forces the TIMx output 4 waveform to active or inactive level.
 902 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 903 *                  - TIM_ForcedAction: specifies the forced Action to be set to
 904 *                    the output waveform.
 905 *                    This parameter can be one of the following values:
 906 *                       - TIM_ForcedAction_Active: Force active level on OC4REF
 907 *                       - TIM_ForcedAction_InActive: Force inactive level on
 908 *                         OC4REF.
 909 * Output         : None
 910 * Return         : None
 911 *******************************************************************************/
 912 void TIM_ForcedOC4Config(TIM_TypeDef* TIMx, u16 TIM_ForcedAction)
 913 {
 914   u32 tmpccmr2 = 0;
 915
 916   /* Check the parameters */
 917   assert(IS_TIM_FORCED_ACTION(TIM_ForcedAction));
 918
 919   tmpccmr2 = TIMx->CCMR2;
 920
 921   /* Reset the OCM Bits */
 922   tmpccmr2 &= CCMR_OCM24_Mask;
 923
 924   /* Configure The Forced output Mode */
 925   tmpccmr2 |= (u16)(TIM_ForcedAction << 8);
 926
 927   TIMx->CCMR2 = (u16)tmpccmr2;
 928 }
 929
 930 /*******************************************************************************
 931 * Function Name  : TIM_ARRPreloadConfig
 932 * Description    : Enables or disables TIMx peripheral Preload register on ARR.
 933 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 934 *                  - Newstate: new state of the TIMx peripheral Preload register
 935 *                    This parameter can be: ENABLE or DISABLE.
 936 * Output         : None
 937 * Return         : None
 938 *******************************************************************************/
 939 void TIM_ARRPreloadConfig(TIM_TypeDef* TIMx, FunctionalState Newstate)
 940 {
 941   u32 tmpcr1 = 0;
 942
 943   /* Check the parameters */
 944   assert(IS_FUNCTIONAL_STATE(Newstate));
 945
 946   tmpcr1 = TIMx->CR1;
 947
 948   if (Newstate != DISABLE)
 949   {
 950     /* Set the ARR Preload Bit */
 951     tmpcr1 |= CR1_ARPE_Set;
 952   }
 953   else
 954   {
 955     /* Reset the ARR Preload Bit */
 956     tmpcr1 &= CR1_ARPE_Reset;
 957   }
 958
 959   TIMx->CR1 = (u16)tmpcr1;
 960 }
 961
 962 /*******************************************************************************
 963 * Function Name  : TIM_SelectCCDMA
 964 * Description    : Selects the TIMx peripheral Capture Compare DMA source.
 965 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 966 *                  - Newstate: new state of the Capture Compare DMA source
 967 *                    This parameter can be: ENABLE or DISABLE.
 968 * Output         : None
 969 * Return         : None
 970 *******************************************************************************/
 971 void TIM_SelectCCDMA(TIM_TypeDef* TIMx, FunctionalState Newstate)
 972 {
 973   u32 tmpcr2 = 0;
 974
 975   /* Check the parameters */
 976   assert(IS_FUNCTIONAL_STATE(Newstate));
 977
 978   tmpcr2 = TIMx->CR2;
 979
 980   if (Newstate != DISABLE)
 981   {
 982     /* Set the CCDS Bit */
 983     tmpcr2 |= CR2_CCDS_Set;
 984   }
 985   else
 986   {
 987     /* Reset the CCDS Bit */
 988     tmpcr2 &= CR2_CCDS_Reset;
 989   }
 990
 991   TIMx->CR2 = (u16)tmpcr2;
 992 }
 993
 994 /*******************************************************************************
 995 * Function Name  : TIM_OC1PreloadConfig
 996 * Description    : Enables or disables the TIMx peripheral Preload register on CCR1.
 997 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
 998 *                  - TIM_OCPreload: new state of the TIMx peripheral Preload
 999 *                    register
1000 *                    This parameter can be one of the following values:
1001 *                       - TIM_OCPreload_Enable
1002 *                       - TIM_OCPreload_Disable
1003 * Output         : None
1004 * Return         : None
1005 *******************************************************************************/
1006 void TIM_OC1PreloadConfig(TIM_TypeDef* TIMx, u16 TIM_OCPreload)
1007 {
1008   u32 tmpccmr1 = 0;
1009
1010   /* Check the parameters */
1011   assert(IS_TIM_OCPRELOAD_STATE(TIM_OCPreload));
1012
1013   tmpccmr1 = TIMx->CCMR1;
1014
1015   /* Reset the OCPE Bit */
1016   tmpccmr1 &= CCMR_OC13PE_Mask;
1017
1018   /* Enable or Disable the Output Compare Preload feature */
1019   tmpccmr1 |= TIM_OCPreload;
1020
1021   TIMx->CCMR1 = (u16)tmpccmr1;
1022 }
1023
1024 /*******************************************************************************
1025 * Function Name  : TIM_OC2PreloadConfig
1026 * Description    : Enables or disables the TIMx peripheral Preload register on CCR2.
1027 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1028 *                  - TIM_OCPreload: new state of the TIMx peripheral Preload
1029 *                    register
1030 *                    This parameter can be one of the following values:
1031 *                       - TIM_OCPreload_Enable
1032 *                       - TIM_OCPreload_Disable
1033 * Output         : None
1034 * Return         : None
1035 *******************************************************************************/
1036 void TIM_OC2PreloadConfig(TIM_TypeDef* TIMx, u16 TIM_OCPreload)
1037 {
1038   u32 tmpccmr1 = 0;
1039
1040   /* Check the parameters */
1041   assert(IS_TIM_OCPRELOAD_STATE(TIM_OCPreload));
1042
1043   tmpccmr1 = TIMx->CCMR1;
1044
1045   /* Reset the OCPE Bit */
1046   tmpccmr1 &= CCMR_OC24PE_Mask;
1047
1048   /* Enable or Disable the Output Compare Preload feature */
1049   tmpccmr1 |= (u16)(TIM_OCPreload << 8);
1050
1051   TIMx->CCMR1 = (u16)tmpccmr1;
1052 }
1053
1054 /*******************************************************************************
1055 * Function Name  : TIM_OC3PreloadConfig
1056 * Description    : Enables or disables the TIMx peripheral Preload register on CCR3.
1057 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1058 *                  - TIM_OCPreload: new state of the TIMx peripheral Preload
1059 *                    register
1060 *                    This parameter can be one of the following values:
1061 *                       - TIM_OCPreload_Enable
1062 *                       - TIM_OCPreload_Disable
1063 * Output         : None
1064 * Return         : None
1065 *******************************************************************************/
1066 void TIM_OC3PreloadConfig(TIM_TypeDef* TIMx, u16 TIM_OCPreload)
1067 {
1068   u32 tmpccmr2 = 0;
1069
1070   /* Check the parameters */
1071   assert(IS_TIM_OCPRELOAD_STATE(TIM_OCPreload));
1072
1073   tmpccmr2 = TIMx->CCMR2;
1074
1075   /* Reset the OCPE Bit */
1076   tmpccmr2 &= CCMR_OC13PE_Mask;
1077
1078   /* Enable or Disable the Output Compare Preload feature */
1079   tmpccmr2 |= TIM_OCPreload;
1080
1081   TIMx->CCMR2 = (u16)tmpccmr2;
1082 }
1083
1084 /*******************************************************************************
1085 * Function Name  : TIM_OC4PreloadConfig
1086 * Description    : Enables or disables the TIMx peripheral Preload register on CCR4.
1087 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1088 *                  - TIM_OCPreload: new state of the TIMx peripheral Preload
1089 *                    register
1090 *                    This parameter can be one of the following values:
1091 *                       - TIM_OCPreload_Enable
1092 *                       - TIM_OCPreload_Disable
1093 * Output         : None
1094 * Return         : None
1095 *******************************************************************************/
1096 void TIM_OC4PreloadConfig(TIM_TypeDef* TIMx, u16 TIM_OCPreload)
1097 {
1098   u32 tmpccmr2 = 0;
1099
1100   /* Check the parameters */
1101   assert(IS_TIM_OCPRELOAD_STATE(TIM_OCPreload));
1102
1103   tmpccmr2 = TIMx->CCMR2;
1104
1105   /* Reset the OCPE Bit */
1106   tmpccmr2 &= CCMR_OC24PE_Mask;
1107
1108   /* Enable or Disable the Output Compare Preload feature */
1109   tmpccmr2 |= (u16)(TIM_OCPreload << 8);
1110
1111   TIMx->CCMR2 = (u16)tmpccmr2;
1112 }
1113
1114 /*******************************************************************************
1115 * Function Name  : TIM_OC1FastConfig
1116 * Description    : Configures the TIMx Output Compare 1 Fast feature.
1117 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1118 *                  - TIM_OCFast: new state of the Output Compare Fast Enable Bit.
1119 *                    This parameter can be one of the following values:
1120 *                       - TIM_OCFast_Enable
1121 *                       - TIM_OCFast_Disable
1122 * Output         : None
1123 * Return         : None
1124 *******************************************************************************/
1125 void TIM_OC1FastConfig(TIM_TypeDef* TIMx, u16 TIM_OCFast)
1126 {
1127   u32 tmpccmr1 = 0;
1128
1129   /* Check the parameters */
1130   assert(IS_TIM_OCFAST_STATE(TIM_OCFast));
1131
1132   tmpccmr1 = TIMx->CCMR1;
1133
1134   /* Reset the OCFE Bit */
1135   tmpccmr1 &= CCMR_OC13FE_Mask;
1136
1137   /* Enable or Disable the Output Compare Fast Bit */
1138   tmpccmr1 |= TIM_OCFast;
1139
1140   TIMx->CCMR1 = (u16)tmpccmr1;
1141 }
1142
1143 /*******************************************************************************
1144 * Function Name  : TIM_OC2FastConfig
1145 * Description    : Configures the TIMx Output Compare 2 Fast feature.
1146 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1147 *                  - TIM_OCFast: new state of the Output Compare Fast Enable Bit.
1148 *                    This parameter can be one of the following values:
1149 *                       - TIM_OCFast_Enable
1150 *                       - TIM_OCFast_Disable
1151 * Output         : None
1152 * Return         : None
1153 *******************************************************************************/
1154 void TIM_OC2FastConfig(TIM_TypeDef* TIMx, u16 TIM_OCFast)
1155 {
1156   u32 tmpccmr1 = 0;
1157
1158   /* Check the parameters */
1159   assert(IS_TIM_OCFAST_STATE(TIM_OCFast));
1160
1161   tmpccmr1 = TIMx->CCMR1;
1162
1163   /* Reset the OCFE Bit */
1164   tmpccmr1 &= CCMR_OC24FE_Mask;
1165
1166   /* Enable or Disable the Output Compare Fast Bit */
1167   tmpccmr1 |= (u16)(TIM_OCFast << 8);
1168
1169   TIMx->CCMR1 = (u16)tmpccmr1;
1170 }
1171
1172 /*******************************************************************************
1173 * Function Name  : TIM_OC3FastConfig
1174 * Description    : Configures the TIMx Output Compare 3 Fast feature.
1175 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1176 *                  - TIM_OCFast: new state of the Output Compare Fast Enable Bit.
1177 *                    This parameter can be one of the following values:
1178 *                       - TIM_OCFast_Enable
1179 *                       - TIM_OCFast_Disable
1180 * Output         : None
1181 * Return         : None
1182 *******************************************************************************/
1183 void TIM_OC3FastConfig(TIM_TypeDef* TIMx, u16 TIM_OCFast)
1184 {
1185   u32 tmpccmr2 = 0;
1186
1187   /* Check the parameters */
1188   assert(IS_TIM_OCFAST_STATE(TIM_OCFast));
1189
1190   tmpccmr2 = TIMx->CCMR2;
1191
1192   /* Reset the OCFE Bit */
1193   tmpccmr2 &= CCMR_OC13FE_Mask;
1194
1195   /* Enable or Disable the Output Compare Fast Bit */
1196   tmpccmr2 |= TIM_OCFast;
1197
1198   TIMx->CCMR2 = (u16)tmpccmr2;
1199 }
1200
1201 /*******************************************************************************
1202 * Function Name  : TIM_OC4FastConfig
1203 * Description    : Configures the TIMx Output Compare 4 Fast feature.
1204 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1205 *                  - TIM_OCFast: new state of the Output Compare Fast Enable Bit.
1206 *                    This parameter can be one of the following values:
1207 *                       - TIM_OCFast_Enable
1208 *                       - TIM_OCFast_Disable
1209 * Output         : None
1210 * Return         : None
1211 *******************************************************************************/
1212 void TIM_OC4FastConfig(TIM_TypeDef* TIMx, u16 TIM_OCFast)
1213 {
1214   u32 tmpccmr2 = 0;
1215
1216   /* Check the parameters */
1217   assert(IS_TIM_OCFAST_STATE(TIM_OCFast));
1218
1219   tmpccmr2 = TIMx->CCMR2;
1220
1221   /* Reset the OCFE Bit */
1222   tmpccmr2 &= CCMR_OC24FE_Mask;
1223
1224   /* Enable or Disable the Output Compare Fast Bit */
1225   tmpccmr2 |= (u16)(TIM_OCFast << 8);
1226
1227   TIMx->CCMR2 = (u16)tmpccmr2;
1228 }
1229
1230 /*******************************************************************************
1231 * Function Name  : TIM_UpdateDisableConfig
1232 * Description    : Enables or Disables the TIMx Update event.
1233 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1234 *                  - Newstate: new state of the TIMx peripheral Preload register
1235 *                    This parameter can be: ENABLE or DISABLE.
1236 * Output         : None
1237 * Return         : None
1238 *******************************************************************************/
1239 void TIM_UpdateDisableConfig(TIM_TypeDef* TIMx, FunctionalState Newstate)
1240 {
1241   u32 tmpcr1 = 0;
1242
1243   /* Check the parameters */
1244   assert(IS_FUNCTIONAL_STATE(Newstate));
1245
1246   tmpcr1 = TIMx->CR1;
1247
1248   if (Newstate != DISABLE)
1249   {
1250     /* Set the Update Disable Bit */
1251     tmpcr1 |= CR1_UDIS_Set;
1252   }
1253   else
1254   {
1255     /* Reset the Update Disable Bit */
1256     tmpcr1 &= CR1_UDIS_Reset;
1257   }
1258
1259   TIMx->CR1 = (u16)tmpcr1;
1260 }
1261
1262 /*******************************************************************************
1263 * Function Name  : TIM_EncoderInterfaceConfig
1264 * Description    : Configures the TIMx Encoder Interface.
1265 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1266 *                  - TIM_EncoderMode: specifies the TIMx Encoder Mode.
1267 *                    This parameter can be one of the following values:
1268 *                       - TIM_EncoderMode_TI1: Counter counts on TI1FP1 edge
1269 *                         depending on TI2FP2 level.
1270 *                       - TIM_EncoderMode_TI2: Counter counts on TI2FP2 edge
1271 *                         depending on TI1FP1 level.
1272 *                       - TIM_EncoderMode_TI12: Counter counts on both TI1FP1 and
1273 *                         TI2FP2 edges depending on the level of the other input.
1274 *                  - TIM_IC1Polarity: specifies the IC1 Polarity
1275 *                    This parmeter can be one of the following values:
1276 *                        - TIM_ICPolarity_Falling
1277 *                        - TIM_ICPolarity_Rising
1278 *                  - TIM_IC2Polarity: specifies the IC2 Polarity
1279 *                    This parmeter can be one of the following values:
1280 *                       - TIM_ICPolarity_Falling
1281 *                       - TIM_ICPolarity_Rising
1282 * Output         : None
1283 * Return         : None
1284 *******************************************************************************/
1285 void TIM_EncoderInterfaceConfig(TIM_TypeDef* TIMx, u16 TIM_EncoderMode,
1286                                 u16 TIM_IC1Polarity, u16 TIM_IC2Polarity)
1287 {
1288   u32 tmpsmcr = 0;
1289   u32 tmpccmr1 = 0;
1290   u32 tmpccer = 0;
1291
1292   /* Check the parameters */
1293   assert(IS_TIM_ENCODER_MODE(TIM_EncoderMode));
1294   assert(IS_TIM_IC_POLARITY(TIM_IC1Polarity));
1295   assert(IS_TIM_IC_POLARITY(TIM_IC2Polarity));
1296
1297   tmpsmcr = TIMx->SMCR;
1298   tmpccmr1 = TIMx->CCMR1;
1299   tmpccer = TIMx->CCER;
1300
1301   /* Set the encoder Mode */
1302   tmpsmcr &= SMCR_SMS_Mask;
1303   tmpsmcr |= TIM_EncoderMode;
1304
1305   /* Select the Capture Compare 1 and the Capture Compare 2 as input */
1306   tmpccmr1 &= CCMR_CC13S_Mask & CCMR_CC24S_Mask;
1307   tmpccmr1 |= CCMR_TI13Direct_Set | CCMR_TI24Direct_Set;
1308
1309   /* Set the TI1 and the TI2 Polarities */
1310   tmpccer &= CCER_CC1P_Mask & CCER_CC2P_Mask;
1311   tmpccer |= (TIM_IC1Polarity | (u16)((u16)TIM_IC2Polarity << 4));
1312
1313   TIMx->SMCR = (u16)tmpsmcr;
1314
1315   TIMx->CCMR1 = (u16)tmpccmr1;
1316
1317   TIMx->CCER = (u16)tmpccer;
1318 }
1319
1320 /*******************************************************************************
1321 * Function Name  : TIM_GenerateEvent
1322 * Description    : Configures the TIMx event to be generate by software.
1323 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1324 *                  - TIM_EventSource: specifies the event source.
1325 *                    This parameter can be one or more of the following values:
1326 *                       - TIM_EventSource_Update: Timer update Event source
1327 *                       - TIM_EventSource_CC1: Timer Capture Compare 1 Event source
1328 *                       - TIM_EventSource_CC2: Timer Capture Compare 2 Event source
1329 *                       - TIM_EventSource_CC3: Timer Capture Compare 3 Event source
1330 *                       - TIM_EventSource_CC4: Timer Capture Compare 4 Event source
1331 *                       - TIM_EventSource_Trigger: Timer Trigger Event source
1332 * Output         : None
1333 * Return         : None
1334 *******************************************************************************/
1335 void TIM_GenerateEvent(TIM_TypeDef* TIMx, u16 TIM_EventSource)
1336 {
1337   /* Check the parameters */
1338   assert(IS_TIM_EVENT_SOURCE(TIM_EventSource));
1339
1340   /* Set the event sources */
1341   TIMx->EGR |= TIM_EventSource;
1342 }
1343
1344 /*******************************************************************************
1345 * Function Name  : TIM_OC1PolarityConfig
1346 * Description    : Configures the TIMx channel 1 polarity.
1347 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1348 *                  - TIM_OCPolarity: specifies the OC1 Polarity
1349 *                    This parmeter can be one of the following values:
1350 *                       - TIM_OCPolarity_High: Output Compare active high
1351 *                       - TIM_OCPolarity_Low: Output Compare active low
1352 * Output         : None
1353 * Return         : None
1354 *******************************************************************************/
1355 void TIM_OC1PolarityConfig(TIM_TypeDef* TIMx, u16 TIM_OCPolarity)
1356 {
1357   u32 tmpccer = 0;
1358
1359   /* Check the parameters */
1360   assert(IS_TIM_OC_POLARITY(TIM_OCPolarity));
1361
1362   tmpccer = TIMx->CCER;
1363
1364   /* Set or Reset the CC1P Bit */
1365   tmpccer &= CCER_CC1P_Mask;
1366   tmpccer |= TIM_OCPolarity;
1367
1368   TIMx->CCER = (u16)tmpccer;
1369 }
1370
1371 /*******************************************************************************
1372 * Function Name  : TIM_OC2PolarityConfig
1373 * Description    : Configures the TIMx channel 2 polarity.
1374 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1375 *                  - TIM_OCPolarity: specifies the OC2 Polarity
1376 *                    This parmeter can be one of the following values:
1377 *                       - TIM_OCPolarity_High: Output Compare active high
1378 *                       - TIM_OCPolarity_Low: Output Compare active low
1379 * Output         : None
1380 * Return         : None
1381 *******************************************************************************/
1382 void TIM_OC2PolarityConfig(TIM_TypeDef* TIMx, u16 TIM_OCPolarity)
1383 {
1384   u32 tmpccer = 0;
1385
1386   /* Check the parameters */
1387   assert(IS_TIM_OC_POLARITY(TIM_OCPolarity));
1388
1389   tmpccer = TIMx->CCER;
1390
1391   /* Set or Reset the CC2P Bit */
1392   tmpccer &= CCER_CC2P_Mask;
1393   tmpccer |= (u16)((u16)TIM_OCPolarity << 4);
1394
1395   TIMx->CCER = (u16)tmpccer;
1396 }
1397
1398 /*******************************************************************************
1399 * Function Name  : TIM_OC3PolarityConfig
1400 * Description    : Configures the TIMx channel 3 polarity.
1401 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1402 *                  - TIM_OCPolarity: specifies the OC3 Polarity
1403 *                    This parmeter can be one of the following values:
1404 *                       - TIM_OCPolarity_High: Output Compare active high
1405 *                       - TIM_OCPolarity_Low: Output Compare active low
1406 * Output         : None
1407 * Return         : None
1408 *******************************************************************************/
1409 void TIM_OC3PolarityConfig(TIM_TypeDef* TIMx, u16 TIM_OCPolarity)
1410 {
1411   u32 tmpccer = 0;
1412
1413   /* Check the parameters */
1414   assert(IS_TIM_OC_POLARITY(TIM_OCPolarity));
1415
1416   tmpccer = TIMx->CCER;
1417
1418   /* Set or Reset the CC3P Bit */
1419   tmpccer &= CCER_CC3P_Mask;
1420   tmpccer |= (u16)((u16)TIM_OCPolarity << 8);
1421
1422   TIMx->CCER = (u16)tmpccer;
1423 }
1424
1425 /*******************************************************************************
1426 * Function Name  : TIM_OC4PolarityConfig
1427 * Description    : Configures the TIMx channel 4 polarity.
1428 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1429 *                  - TIM_OCPolarity: specifies the OC4 Polarity
1430 *                    This parmeter can be one of the following values:
1431 *                       - TIM_OCPolarity_High: Output Compare active high
1432 *                       - TIM_OCPolarity_Low: Output Compare active low
1433 * Output         : None
1434 * Return         : None
1435 *******************************************************************************/
1436 void TIM_OC4PolarityConfig(TIM_TypeDef* TIMx, u16 TIM_OCPolarity)
1437 {
1438   u32 tmpccer = 0;
1439
1440   /* Check the parameters */
1441   assert(IS_TIM_OC_POLARITY(TIM_OCPolarity));
1442
1443   tmpccer = TIMx->CCER;
1444
1445   /* Set or Reset the CC4P Bit */
1446   tmpccer &= CCER_CC4P_Mask;
1447   tmpccer |= (u16)((u16)TIM_OCPolarity << 12);
1448
1449   TIMx->CCER = (u16)tmpccer;
1450 }
1451
1452 /*******************************************************************************
1453 * Function Name  : TIM_UpdateRequestConfig
1454 * Description    : Configures the TIMx Update Request Interrupt source.
1455 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1456 *                  - TIM_UpdateSource: specifies the Update source.
1457 *                    This parameter can be one of the following values:
1458 *                       - TIM_UpdateSource_Regular
1459 *                       - TIM_UpdateSource_Global
1460 * Output         : None
1461 * Return         : None
1462 *******************************************************************************/
1463 void TIM_UpdateRequestConfig(TIM_TypeDef* TIMx, u16 TIM_UpdateSource)
1464 {
1465   u32 tmpcr1 = 0;
1466
1467   /* Check the parameters */
1468   assert(IS_TIM_UPDATE_SOURCE(TIM_UpdateSource));
1469
1470   tmpcr1 = TIMx->CR1;
1471
1472   if (TIM_UpdateSource == TIM_UpdateSource_Regular)
1473   {
1474     /* Set the URS Bit */
1475     tmpcr1 |= CR1_URS_Set;
1476   }
1477   else
1478   {
1479     /* Reset the URS Bit */
1480     tmpcr1 &= CR1_URS_Reset;
1481   }
1482   TIMx->CR1 = (u16)tmpcr1;
1483 }
1484
1485 /*******************************************************************************
1486 * Function Name  : TIM_SelectHallSensor
1487 * Description    : Enables or disables the TIMx\92s Hall sensor interface.
1488 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1489 *                  - Newstate: new state of the TIMx Hall sensor interface.
1490 *                    This parameter can be: ENABLE or DISABLE.
1491 * Output         : None
1492 * Return         : None
1493 *******************************************************************************/
1494 void TIM_SelectHallSensor(TIM_TypeDef* TIMx, FunctionalState Newstate)
1495 {
1496   /* Check the parameters */
1497   assert(IS_FUNCTIONAL_STATE(Newstate));
1498
1499   if (Newstate != DISABLE)
1500   {
1501     /* Set the TI1S Bit */
1502     TIMx->CR2 |= CR2_TI1S_Set;
1503   }
1504   else
1505   {
1506     /* Reset the TI1S Bit */
1507     TIMx->CR2 &= CR2_TI1S_Reset;
1508   }
1509 }
1510
1511 /*******************************************************************************
1512 * Function Name  : TIM_SelectOnePulseMode
1513 * Description    : Selects the TIMx\92s One Pulse Mode.
1514 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1515 *                  - TIM_OPMode: specifies the OPM Mode to be used.
1516 *                    This parameter can be one of the following values:
1517 *                       - TIM_OPMode_Single
1518 *                       - TIM_OPMode_Repetitive
1519 * Output         : None
1520 * Return         : None
1521 *******************************************************************************/
1522 void TIM_SelectOnePulseMode(TIM_TypeDef* TIMx, u16 TIM_OPMode)
1523 {
1524   u32 tmpcr1 = 0;
1525
1526   /* Check the parameters */
1527   assert(IS_TIM_OPM_MODE(TIM_OPMode));
1528
1529   tmpcr1 = TIMx->CR1;
1530
1531   /* Reset the OPM Bit */
1532   tmpcr1 &= CR1_OPM_Mask;
1533
1534   /* Configure the OPM Mode */
1535   tmpcr1 |= TIM_OPMode;
1536
1537   TIMx->CR1 = (u16)tmpcr1;
1538 }
1539
1540 /*******************************************************************************
1541 * Function Name  : TIM_SelectOutputTrigger
1542 * Description    : Selects the TIMx Trigger Output Mode.
1543 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1544 *                  - TIM_TRGOSource: specifies the Trigger Output source.
1545 *                    This paramter can be one of the following values:
1546 *                       - TIM_TRGOSource_Reset
1547 *                       - TIM_TRGOSource_Enable
1548 *                       - TIM_TRGOSource_Update
1549 *                       - TIM_TRGOSource_OC1
1550 *                       - TIM_TRGOSource_OC1Ref
1551 *                       - TIM_TRGOSource_OC2Ref
1552 *                       - TIM_TRGOSource_OC3Ref
1553 *                       - TIM_TRGOSource_OC4Ref
1554 * Output         : None
1555 * Return         : None
1556 *******************************************************************************/
1557 void TIM_SelectOutputTrigger(TIM_TypeDef* TIMx, u16 TIM_TRGOSource)
1558 {
1559   u32 tmpcr2 = 0;
1560
1561   /* Check the parameters */
1562   assert(IS_TIM_TRGO_SOURCE(TIM_TRGOSource));
1563
1564   tmpcr2 = TIMx->CR2;
1565   /* Reset the MMS Bits */
1566   tmpcr2 &= CR2_MMS_Mask;
1567
1568   /* Select the TRGO source */
1569   tmpcr2 |=  TIM_TRGOSource;
1570
1571   TIMx->CR2 = (u16)tmpcr2;
1572 }
1573
1574 /*******************************************************************************
1575 * Function Name  : TIM_SelectSlaveMode
1576 * Description    : Selects the TIMx Slave Mode.
1577 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1578 *                  - TIM_SlaveMode: specifies the Timer Slave Mode.
1579 *                    This paramter can be one of the following values:
1580 *                       - TIM_SlaveMode_Reset
1581 *                       - TIM_SlaveMode_Gated
1582 *                       - TIM_SlaveMode_Trigger
1583 *                       - TIM_SlaveMode_External1
1584 * Output         : None
1585 * Return         : None
1586 *******************************************************************************/
1587 void TIM_SelectSlaveMode(TIM_TypeDef* TIMx, u16 TIM_SlaveMode)
1588 {
1589   u32 tmpsmcr = 0;
1590
1591   /* Check the parameters */
1592   assert(IS_TIM_SLAVE_MODE(TIM_SlaveMode));
1593
1594   tmpsmcr = TIMx->SMCR;
1595
1596   /* Reset the SMS Bits */
1597   tmpsmcr &= SMCR_SMS_Mask;
1598
1599   /* Select the Slave Mode */
1600   tmpsmcr |= TIM_SlaveMode;
1601
1602   TIMx->SMCR = (u16)tmpsmcr;
1603 }
1604
1605 /*******************************************************************************
1606 * Function Name  : TIM_SelectMasterSlaveMode
1607 * Description    : Sets or Resets the TIMx Master/Slave Mode.
1608 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1609 *                  - TIM_MasterSlaveMode: specifies the Timer Master Slave Mode.
1610 *                    This paramter can be one of the following values:
1611 *                       - TIM_MasterSlaveMode_Enable: synchronization between the
1612 *                         current timer and its slaves (through TRGO).
1613 *                       - TIM_MasterSlaveMode_Disable: No action
1614 * Output         : None
1615 * Return         : None
1616 *******************************************************************************/
1617 void TIM_SelectMasterSlaveMode(TIM_TypeDef* TIMx, u16 TIM_MasterSlaveMode)
1618 {
1619   u32 tmpsmcr = 0;
1620
1621   /* Check the parameters */
1622   assert(IS_TIM_MSM_STATE(TIM_MasterSlaveMode));
1623
1624   tmpsmcr = TIMx->SMCR;
1625
1626   /* Set or Reset the MSM Bit */
1627   tmpsmcr &= SMCR_MSM_Mask;
1628   tmpsmcr |= TIM_MasterSlaveMode;
1629
1630   TIMx->SMCR = (u16)tmpsmcr;
1631 }
1632
1633 /*******************************************************************************
1634 * Function Name  : TIM_SetAutoreload
1635 * Description    : Sets the TIMx Autoreload Register value
1636 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1637 *                  - Autoreload: specifies the Autoreload register new value.
1638 * Output         : None
1639 * Return         : None
1640 *******************************************************************************/
1641 void TIM_SetAutoreload(TIM_TypeDef* TIMx, u16 Autoreload)
1642 {
1643   /* Set the Autoreload Register value */
1644   TIMx->ARR = Autoreload;
1645 }
1646
1647 /*******************************************************************************
1648 * Function Name  : TIM_SetCompare1
1649 * Description    : Sets the TIMx Capture Compare1 Register value
1650 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1651 *                  - Compare1: specifies the Capture Compare1 register new value.
1652 * Output         : None
1653 * Return         : None
1654 *******************************************************************************/
1655 void TIM_SetCompare1(TIM_TypeDef* TIMx, u16 Compare1)
1656 {
1657   /* Set the Capture Compare1 Register value */
1658   TIMx->CCR1 = Compare1;
1659 }
1660
1661 /*******************************************************************************
1662 * Function Name  : TIM_SetCompare2
1663 * Description    : Sets the TIMx Capture Compare2 Register value
1664 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1665 *                  - Compare2: specifies the Capture Compare2 register new value.
1666 * Output         : None
1667 * Return         : None
1668 *******************************************************************************/
1669 void TIM_SetCompare2(TIM_TypeDef* TIMx, u16 Compare2)
1670 {
1671   /* Set the Capture Compare2 Register value */
1672   TIMx->CCR2 = Compare2;
1673 }
1674
1675 /*******************************************************************************
1676 * Function Name  : TIM_SetCompare3
1677 * Description    : Sets the TIMx Capture Compare3 Register value
1678 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1679 *                  - Compare3: specifies the Capture Compare3 register new value.
1680 * Output         : None
1681 * Return         : None
1682 *******************************************************************************/
1683 void TIM_SetCompare3(TIM_TypeDef* TIMx, u16 Compare3)
1684 {
1685   /* Set the Capture Compare3 Register value */
1686   TIMx->CCR3 = Compare3;
1687 }
1688
1689 /*******************************************************************************
1690 * Function Name  : TIM_SetCompare4
1691 * Description    : Sets the TIMx Capture Compare4 Register value
1692 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1693 *                  - Compare4: specifies the Capture Compare4 register new value.
1694 * Output         : None
1695 * Return         : None
1696 *******************************************************************************/
1697 void TIM_SetCompare4(TIM_TypeDef* TIMx, u16 Compare4)
1698 {
1699   /* Set the Capture Compare4 Register value */
1700   TIMx->CCR4 = Compare4;
1701 }
1702
1703 /*******************************************************************************
1704 * Function Name  : TIM_SetIC1Prescaler
1705 * Description    : Sets the TIMx Input Capture 1 prescaler.
1706 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1707 *                  - TIM_IC1Prescaler: specifies the Input Capture1 prescaler
1708 *                    new value.
1709 *                    This parameter can be one of the following values:
1710 *                       - TIM_ICPSC_DIV1: no prescaler
1711 *                       - TIM_ICPSC_DIV2: capture is done once every 2 events
1712 *                       - TIM_ICPSC_DIV4: capture is done once every 4 events
1713 *                       - TIM_ICPSC_DIV8: capture is done once every 8 events
1714 * Output         : None
1715 * Return         : None
1716 *******************************************************************************/
1717 void TIM_SetIC1Prescaler(TIM_TypeDef* TIMx, u16 TIM_IC1Prescaler)
1718 {
1719   u32 tmpccmr1 = 0;
1720
1721   /* Check the parameters */
1722   assert(IS_TIM_IC_PRESCALER(TIM_IC1Prescaler));
1723
1724   tmpccmr1 = TIMx->CCMR1;
1725
1726   /* Reset the IC1PSC Bits */
1727   tmpccmr1 &= CCMR_IC13PSC_Mask;
1728
1729   /* Set the IC1PSC value */
1730   tmpccmr1 |= TIM_IC1Prescaler;
1731
1732   TIMx->CCMR1 = (u16)tmpccmr1;
1733 }
1734
1735 /*******************************************************************************
1736 * Function Name  : TIM_SetIC2Prescaler
1737 * Description    : Sets the TIMx Input Capture 2 prescaler.
1738 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1739 *                  - TIM_IC2Prescaler: specifies the Input Capture2 prescaler
1740 *                    new value.
1741 *                    This parameter can be one of the following values:
1742 *                       - TIM_ICPSC_DIV1: no prescaler
1743 *                       - TIM_ICPSC_DIV2: capture is done once every 2 events
1744 *                       - TIM_ICPSC_DIV4: capture is done once every 4 events
1745 *                       - TIM_ICPSC_DIV8: capture is done once every 8 events
1746 * Output         : None
1747 * Return         : None
1748 *******************************************************************************/
1749 void TIM_SetIC2Prescaler(TIM_TypeDef* TIMx, u16 TIM_IC2Prescaler)
1750 {
1751   u32 tmpccmr1 = 0;
1752
1753   /* Check the parameters */
1754   assert(IS_TIM_IC_PRESCALER(TIM_IC2Prescaler));
1755
1756   tmpccmr1 = TIMx->CCMR1;
1757
1758   /* Reset the IC2PSC Bits */
1759   tmpccmr1 &= CCMR_IC24PSC_Mask;
1760
1761   /* Set the IC2PSC value */
1762   tmpccmr1 |= (u16)((u16)TIM_IC2Prescaler << 8);
1763
1764   TIMx->CCMR1 = (u16)tmpccmr1;
1765 }
1766
1767 /*******************************************************************************
1768 * Function Name  : TIM_SetIC3Prescaler
1769 * Description    : Sets the TIMx Input Capture 3 prescaler.
1770 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1771 *                  - TIM_IC3Prescaler: specifies the Input Capture3 prescaler
1772 *                    new value.
1773 *                    This parameter can be one of the following values:
1774 *                       - TIM_ICPSC_DIV1: no prescaler
1775 *                       - TIM_ICPSC_DIV2: capture is done once every 2 events
1776 *                       - TIM_ICPSC_DIV4: capture is done once every 4 events
1777 *                       - TIM_ICPSC_DIV8: capture is done once every 8 events
1778 * Output         : None
1779 * Return         : None
1780 *******************************************************************************/
1781 void TIM_SetIC3Prescaler(TIM_TypeDef* TIMx, u16 TIM_IC3Prescaler)
1782 {
1783   u32 tmpccmr2 = 0;
1784
1785   /* Check the parameters */
1786   assert(IS_TIM_IC_PRESCALER(TIM_IC3Prescaler));
1787
1788   tmpccmr2 = TIMx->CCMR2;
1789
1790   /* Reset the IC3PSC Bits */
1791   tmpccmr2 &= CCMR_IC13PSC_Mask;
1792
1793   /* Set the IC3PSC value */
1794   tmpccmr2 |= TIM_IC3Prescaler;
1795
1796   TIMx->CCMR2 = (u16)tmpccmr2;
1797 }
1798
1799 /*******************************************************************************
1800 * Function Name  : TIM_SetIC4Prescaler
1801 * Description    : Sets the TIMx Input Capture 4 prescaler.
1802 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1803 *                  - TIM_IC4Prescaler: specifies the Input Capture4 prescaler
1804 *                    new value.
1805 *                    This parameter can be one of the following values:
1806 *                      - TIM_ICPSC_DIV1: no prescaler
1807 *                      - TIM_ICPSC_DIV2: capture is done once every 2 events
1808 *                      - TIM_ICPSC_DIV4: capture is done once every 4 events
1809 *                      - TIM_ICPSC_DIV8: capture is done once every 8 events
1810 * Output         : None
1811 * Return         : None
1812 *******************************************************************************/
1813 void TIM_SetIC4Prescaler(TIM_TypeDef* TIMx, u16 TIM_IC4Prescaler)
1814 {
1815   u32 tmpccmr2 = 0;
1816
1817   /* Check the parameters */
1818   assert(IS_TIM_IC_PRESCALER(TIM_IC4Prescaler));
1819
1820   tmpccmr2 = TIMx->CCMR2;
1821
1822   /* Reset the IC4PSC Bits */
1823   tmpccmr2 &= CCMR_IC24PSC_Mask;
1824
1825   /* Set the IC4PSC value */
1826   tmpccmr2 |= (u16)((u16)TIM_IC4Prescaler << 8);
1827
1828   TIMx->CCMR2 = (u16)tmpccmr2;
1829 }
1830
1831 /*******************************************************************************
1832 * Function Name  : TIM_SetClockDivision
1833 * Description    : Sets the TIMx Clock Division value.
1834 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1835 *                  - TIM_CKD: specifies the clock division value.
1836 *                    This parameter can be one of the following value:
1837 *                       - TIM_CKD_DIV1: TDTS = Tck_tim
1838 *                       - TIM_CKD_DIV2: TDTS = 2*Tck_tim
1839 *                       - TIM_CKD_DIV4: TDTS = 4*Tck_tim
1840 * Output         : None
1841 * Return         : None
1842 *******************************************************************************/
1843 void TIM_SetClockDivision(TIM_TypeDef* TIMx, u16 TIM_CKD)
1844 {
1845   u32 tmpcr1 = 0;
1846
1847   /* Check the parameters */
1848   assert(IS_TIM_CKD_DIV(TIM_CKD));
1849
1850   tmpcr1 = TIMx->CR1;
1851
1852   /* Reset the CKD Bits */
1853   tmpcr1 &= CR1_CKD_Mask;
1854
1855   /* Set the CKD value */
1856   tmpcr1 |= TIM_CKD;
1857
1858   TIMx->CR1 = (u16)tmpcr1;
1859 }
1860
1861 /*******************************************************************************
1862 * Function Name  : TIM_GetCapture1
1863 * Description    : Gets the TIMx Input Capture 1 value.
1864 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1865 * Output         : None
1866 * Return         : Capture Compare 1 Register value.
1867 *******************************************************************************/
1868 u16 TIM_GetCapture1(TIM_TypeDef* TIMx)
1869 {
1870   /* Get the Capture 1 Register value */
1871   return TIMx->CCR1;
1872 }
1873
1874 /*******************************************************************************
1875 * Function Name  : TIM_GetCapture2
1876 * Description    : Gets the TIMx Input Capture 2 value.
1877 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1878 * Output         : None
1879 * Return         : Capture Compare 2 Register value.
1880 *******************************************************************************/
1881 u16 TIM_GetCapture2(TIM_TypeDef* TIMx)
1882 {
1883   /* Get the Capture 2 Register value */
1884   return TIMx->CCR2;
1885 }
1886
1887 /*******************************************************************************
1888 * Function Name  : TIM_GetCapture3
1889 * Description    : Gets the TIMx Input Capture 3 value.
1890 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1891 * Output         : None
1892 * Return         : Capture Compare 3 Register value.
1893 *******************************************************************************/
1894 u16 TIM_GetCapture3(TIM_TypeDef* TIMx)
1895 {
1896   /* Get the Capture 3 Register value */
1897   return TIMx->CCR3;
1898 }
1899
1900 /*******************************************************************************
1901 * Function Name  : TIM_GetCapture4
1902 * Description    : Gets the TIMx Input Capture 4 value.
1903 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1904 * Output         : None
1905 * Return         : Capture Compare 4 Register value.
1906 *******************************************************************************/
1907 u16 TIM_GetCapture4(TIM_TypeDef* TIMx)
1908 {
1909   /* Get the Capture 4 Register value */
1910   return TIMx->CCR4;
1911 }
1912
1913 /*******************************************************************************
1914 * Function Name  : TIM_GetCounter
1915 * Description    : Gets the TIMx Counter value.
1916 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1917 * Output         : None
1918 * Return         : Counter Register value.
1919 *******************************************************************************/
1920 u16 TIM_GetCounter(TIM_TypeDef* TIMx)
1921 {
1922   /* Get the Counter Register value */
1923   return TIMx->CNT;
1924 }
1925
1926 /*******************************************************************************
1927 * Function Name  : TIM_GetPrescaler
1928 * Description    : Gets the TIMx Prescaler value.
1929 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1930 * Output         : None
1931 * Return         : Prescaler Register value.
1932 *******************************************************************************/
1933 u16 TIM_GetPrescaler(TIM_TypeDef* TIMx)
1934 {
1935   /* Get the Prescaler Register value */
1936   return TIMx->PSC;
1937 }
1938
1939 /*******************************************************************************
1940 * Function Name  : TIM_GetFlagStatus
1941 * Description    : Checks whether the specified TIMx flag is set or not.
1942 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1943 *                  - TIM_FLAG: specifies the flag to check.
1944 *                    This parameter can be one of the following values:
1945 *                       - TIM_FLAG_Update: Timer update Flag
1946 *                       - TIM_FLAG_CC1: Timer Capture Compare 1 Flag
1947 *                       - TIM_FLAG_CC2: Timer Capture Compare 2 Flag
1948 *                       - TIM_FLAG_CC3: Timer Capture Compare 3 Flag
1949 *                       - TIM_FLAG_CC4: Timer Capture Compare 4 Flag
1950 *                       - TIM_FLAG_Trigger: Timer Trigger Flag
1951 *                       - TIM_FLAG_CC1OF: Timer Capture Compare 1 overcapture Flag
1952 *                       - TIM_FLAG_CC2OF: Timer Capture Compare 2 overcapture Flag
1953 *                       - TIM_FLAG_CC3OF: Timer Capture Compare 3 overcapture Flag
1954 *                       - TIM_FLAG_CC4OF: Timer Capture Compare 4 overcapture Flag
1955 * Output         : None
1956 * Return         : The new state of TIM_FLAG (SET or RESET).
1957 *******************************************************************************/
1958 FlagStatus TIM_GetFlagStatus(TIM_TypeDef* TIMx, u16 TIM_FLAG)
1959 {
1960   FlagStatus bitstatus = RESET;
1961
1962   /* Check the parameters */
1963   assert(IS_TIM_GET_FLAG(TIM_FLAG));
1964
1965   if ((TIMx->SR & TIM_FLAG) != (u16)RESET )
1966   {
1967     bitstatus = SET;
1968   }
1969   else
1970   {
1971     bitstatus = RESET;
1972   }
1973   return bitstatus;
1974 }
1975
1976 /*******************************************************************************
1977 * Function Name  : TIM_ClearFlag
1978 * Description    : Clears the TIMx's pending flags.
1979 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
1980 *                  - TIM_FLAG: specifies the flag bit to clear.
1981 *                    This parameter can be any combination of the following values:
1982 *                       - TIM_FLAG_Update: Timer update Flag
1983 *                       - TIM_FLAG_CC1: Timer Capture Compare 1 Flag
1984 *                       - TIM_FLAG_CC2: Timer Capture Compare 2 Flag
1985 *                       - TIM_FLAG_CC3: Timer Capture Compare 3 Flag
1986 *                       - TIM_FLAG_CC4: Timer Capture Compare 4 Flag
1987 *                       - TIM_FLAG_Trigger: Timer Trigger Flag
1988 *                       - TIM_FLAG_CC1OF: Timer Capture Compare 1 overcapture Flag
1989 *                       - TIM_FLAG_CC2OF: Timer Capture Compare 2 overcapture Flag
1990 *                       - TIM_FLAG_CC3OF: Timer Capture Compare 3 overcapture Flag
1991 *                       - TIM_FLAG_CC4OF: Timer Capture Compare 4 overcapture Flag
1992 * Output         : None
1993 * Return         : None
1994 *******************************************************************************/
1995 void TIM_ClearFlag(TIM_TypeDef* TIMx, u16 TIM_FLAG)
1996 {
1997   /* Check the parameters */
1998   assert(IS_TIM_CLEAR_FLAG(TIM_FLAG));
1999
2000   /* Clear the flags */
2001   TIMx->SR &= (u16)~TIM_FLAG;
2002 }
2003
2004 /*******************************************************************************
2005 * Function Name  : TIM_GetITStatus
2006 * Description    : Checks whether the TIMx interrupt has occurred or not.
2007 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
2008 *                  - TIM_IT: specifies the TIM interrupt source to check.
2009 *                    This parameter can be one of the following values:
2010 *                         - TIM_IT_Update: Timer update Interrupt source
2011 *                         - TIM_IT_CC1: Timer Capture Compare 1 Interrupt source
2012 *                         - TIM_IT_CC2: Timer Capture Compare 2 Interrupt source
2013 *                         - TIM_IT_CC3: Timer Capture Compare 3 Interrupt source
2014 *                         - TIM_IT_CC4: Timer Capture Compare 4 Interrupt source
2015 *                         - TIM_IT_Trigger: Timer Trigger Interrupt source
2016 * Output         : None
2017 * Return         : The new state of the TIM_IT(SET or RESET).
2018 *******************************************************************************/
2019 ITStatus TIM_GetITStatus(TIM_TypeDef* TIMx, u16 TIM_IT)
2020 {
2021   ITStatus bitstatus = RESET;
2022
2023   u16 itstatus = 0x0, itenable = 0x0;
2024
2025   /* Check the parameters */
2026   assert(IS_TIM_GET_IT(TIM_IT));
2027
2028   itstatus = TIMx->SR & TIM_IT;
2029
2030   itenable = TIMx->DIER & TIM_IT;
2031
2032   if ((itstatus != (u16)RESET)  && (itenable != (u16)RESET))
2033   {
2034     bitstatus = SET;
2035   }
2036   else
2037   {
2038     bitstatus = RESET;
2039   }
2040   return bitstatus;
2041 }
2042
2043 /*******************************************************************************
2044 * Function Name  : TIM_ClearITPendingBit
2045 * Description    : Clears the TIMx's interrupt pending bits.
2046 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
2047 *                  - TIM_IT: specifies the pending bit to clear.
2048 *                    This parameter can be any combination of the following values:
2049 *                       - TIM_IT_Update: Timer update Interrupt source
2050 *                       - TIM_IT_CC1: Timer Capture Compare 1 Interrupt source
2051 *                       - TIM_IT_CC2: Timer Capture Compare 2 Interrupt source
2052 *                       - TIM_IT_CC3: Timer Capture Compare 3 Interrupt source
2053 *                       - TIM_IT_CC4: Timer Capture Compare 4 Interrupt source
2054 *                       - TIM_IT_Trigger: Timer Trigger Interrupt source
2055 * Output         : None
2056 * Return         : None
2057 *******************************************************************************/
2058 void TIM_ClearITPendingBit(TIM_TypeDef* TIMx, u16 TIM_IT)
2059 {
2060   /* Check the parameters */
2061   assert(IS_TIM_IT(TIM_IT));
2062
2063   /* Clear the IT pending Bit */
2064   TIMx->SR &= (u16)~TIM_IT;
2065 }
2066
2067 /*******************************************************************************
2068 * Function Name  : PWMInput_Config
2069 * Description    : Configures the TIM peripheral according to the specified
2070 *                  parameters in the TIM_ICInitStruct to measure an external PWM
2071 *                  signal.
2072 * Input          : - TIM_ICInitStruct: pointer to a TIM_ICInitTypeDef structure
2073 *                    that contains the configuration information for the specified
2074 *                    TIM peripheral.
2075 * Output         : None
2076 * Return         : None
2077 *******************************************************************************/
2078 static void PWMI_Config(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct)
2079 {
2080   u8 ICPolarity = TIM_ICPolarity_Rising;
2081   u8 ICSelection = TIM_ICSelection_DirectTI;
2082
2083   /* Select the Opposite Input Polarity */
2084   if (TIM_ICInitStruct->TIM_ICPolarity == TIM_ICPolarity_Rising)
2085   {
2086     ICPolarity = TIM_ICPolarity_Falling;
2087   }
2088   else
2089   {
2090     ICPolarity = TIM_ICPolarity_Rising;
2091   }
2092
2093   /* Select the Opposite Input */
2094   if (TIM_ICInitStruct->TIM_ICSelection == TIM_ICSelection_DirectTI)
2095   {
2096     ICSelection = TIM_ICSelection_IndirectTI;
2097   }
2098   else
2099   {
2100     ICSelection = TIM_ICSelection_DirectTI;
2101   }
2102
2103   if (TIM_ICInitStruct->TIM_Channel == TIM_Channel_1)
2104   {
2105     /* TI1 Configuration */
2106     TI1_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity, TIM_ICInitStruct->TIM_ICSelection,
2107                TIM_ICInitStruct->TIM_ICFilter);
2108
2109     /* Set the Input Capture Prescaler value */
2110     TIM_SetIC1Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler);
2111
2112     /* TI2 Configuration */
2113     TI2_Config(TIMx, ICPolarity, ICSelection, TIM_ICInitStruct->TIM_ICFilter);
2114
2115     /* Set the Input Capture Prescaler value */
2116     TIM_SetIC2Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler);
2117   }
2118   else
2119   {
2120     /* TI1 Configuration */
2121     TI2_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity, TIM_ICInitStruct->TIM_ICSelection,
2122                TIM_ICInitStruct->TIM_ICFilter);
2123
2124     /* Set the Input Capture Prescaler value */
2125     TIM_SetIC2Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler);
2126
2127     /* TI2 Configuration */
2128     TI1_Config(TIMx, ICPolarity, ICSelection, TIM_ICInitStruct->TIM_ICFilter);
2129
2130     /* Set the Input Capture Prescaler value */
2131     TIM_SetIC1Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler);
2132   }
2133 }
2134
2135 /*******************************************************************************
2136 * Function Name  : TI1_Config
2137 * Description    : Configure the TI1 as Input.
2138 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
2139 *                  - TIM_ICPolarity : The Input Polarity.
2140 *                    This parameter can be one of the following values:
2141 *                       - TIM_ICPolarity_Rising
2142 *                       - TIM_ICPolarity_Falling
2143 *                  - TIM_ICSelection: specifies the input to be used.
2144 *                    This parameter can be one of the following values:
2145 *                       - TIM_ICSelection_DirectTI: TIM Input 1 is selected to
2146 *                         be connected to IC1.
2147 *                       - TIM_ICSelection_IndirectTI: TIM Input 1 is selected to
2148 *                         be connected to IC2.
2149 *                       - TIM_ICSelection_TRGI: TIM Input 1 is selected to be
2150 *                         connected to TRGI.
2151 *                  - TIM_ICFilter: Specifies the Input Capture Filter.
2152 *                    This parameter must be a value between 0x00 and 0x0F.
2153 * Output         : None
2154 * Return         : None
2155 *******************************************************************************/
2156 static void TI1_Config(TIM_TypeDef* TIMx, u16 TIM_ICPolarity, u16 TIM_ICSelection,
2157                        u8 TIM_ICFilter)
2158 {
2159   u32 tmpccmr1 = 0, tmpccer = 0;
2160
2161   tmpccmr1 = TIMx->CCMR1;
2162   tmpccer = TIMx->CCER;
2163
2164   /* Disable the Channel 1: Reset the CCE Bit */
2165   TIMx->CCER &= CCRE_CC1E_Reset;
2166
2167   /* Select the Input and set the filter */
2168   tmpccmr1 &= CCMR_CC13S_Mask & CCMR_IC13F_Mask;
2169   tmpccmr1 |= TIM_ICSelection | (u16)((u16)TIM_ICFilter << 4);
2170
2171   /* Select the Polarity  and set the CCE Bit */
2172   tmpccer &= CCER_CC1P_Mask & CCRE_CC1E_Mask;
2173   tmpccer |= TIM_ICPolarity | CCRE_CC1E_Set;
2174
2175   TIMx->CCMR1 = 0x0000;
2176   TIMx->CCMR1 = (u16)tmpccmr1;
2177   TIMx->CCER = (u16)tmpccer;
2178 }
2179
2180 /*******************************************************************************
2181 * Function Name  : TI2_Config
2182 * Description    : Configure the TI2 as Input.
2183 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
2184 *                  - TIM_ICPolarity : The Input Polarity.
2185 *                    This parameter can be one of the following values:
2186 *                       - TIM_ICPolarity_Rising
2187 *                       - TIM_ICPolarity_Falling
2188 *                  - TIM_ICSelection: specifies the input to be used.
2189 *                    This parameter can be one of the following values:
2190 *                       - TIM_ICSelection_DirectTI: TIM Input 2 is selected to
2191 *                         be connected to IC2.
2192 *                       - TIM_ICSelection_IndirectTI: TIM Input 2 is selected to
2193 *                         be connected to IC1.
2194 *                       - TIM_ICSelection_TRGI: TIM Input 2 is selected to be
2195 *                         connected to TRGI.
2196 *                  - TIM_ICFilter: Specifies the Input Capture Filter.
2197 *                    This parameter must be a value between 0x00 and 0x0F.
2198 * Output         : None
2199 * Return         : None
2200 *******************************************************************************/
2201 static void TI2_Config(TIM_TypeDef* TIMx, u16 TIM_ICPolarity, u16 TIM_ICSelection,
2202                        u8 TIM_ICFilter)
2203 {
2204   u32 tmpccmr1 = 0, tmpccer = 0, tmp = 0;
2205
2206   tmpccmr1 = TIMx->CCMR1;
2207   tmpccer = TIMx->CCER;
2208   tmp = (u16)((u16)TIM_ICPolarity << 4);
2209
2210   /* Disable the Channel 2: Reset the CCE Bit */
2211   TIMx->CCER &= CCRE_CC2E_Reset;
2212
2213   /* Select the Input and set the filter */
2214   tmpccmr1 &= CCMR_CC24S_Mask & CCMR_IC24F_Mask;
2215   tmpccmr1 |= (u16)((u16)TIM_ICFilter << 12);
2216   tmpccmr1 |= (u16)((u16)TIM_ICSelection << 8);
2217
2218   /* Select the Polarity  and set the CCE Bit */
2219   tmpccer &= CCER_CC2P_Mask & CCRE_CC2E_Mask;
2220   tmpccer |=  tmp | CCRE_CC2E_Set;
2221
2222   TIMx->CCMR1 = (u16)tmpccmr1 ;
2223   TIMx->CCER = (u16)tmpccer;
2224 }
2225
2226 /*******************************************************************************
2227 * Function Name  : TI3_Config
2228 * Description    : Configure the TI3 as Input.
2229 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
2230 *                  - TIM_ICPolarity : The Input Polarity.
2231 *                    This parameter can be one of the following values:
2232 *                       - TIM_ICPolarity_Rising
2233 *                       - TIM_ICPolarity_Falling
2234 *                  - TIM_ICSelection: specifies the input to be used.
2235 *                    This parameter can be one of the following values:
2236 *                       - TIM_ICSelection_DirectTI: TIM Input 3 is selected to
2237 *                         be connected to IC3.
2238 *                       - TIM_ICSelection_IndirectTI: TIM Input 3 is selected to
2239 *                         be connected to IC4.
2240 *                       - TIM_ICSelection_TRGI: TIM Input 3 is selected to be
2241 *                         connected to TRGI.
2242 *                  - TIM_ICFilter: Specifies the Input Capture Filter.
2243 *                    This parameter must be a value between 0x00 and 0x0F.
2244 * Output         : None
2245 * Return         : None
2246 *******************************************************************************/
2247 static void TI3_Config(TIM_TypeDef* TIMx, u16 TIM_ICPolarity, u16 TIM_ICSelection,
2248                        u8 TIM_ICFilter)
2249 {
2250   u32 tmpccmr2 = 0, tmpccer = 0, tmp = 0;
2251
2252   tmpccmr2 = TIMx->CCMR2;
2253   tmpccer = TIMx->CCER;
2254   tmp = (u16)((u16)TIM_ICPolarity << 8);
2255
2256   /* Disable the Channel 3: Reset the CCE Bit */
2257   TIMx->CCER &= CCRE_CC3E_Reset;
2258
2259   /* Select the Input and set the filter */
2260   tmpccmr2 &= CCMR_CC13S_Mask & CCMR_IC13F_Mask;
2261   tmpccmr2 |= TIM_ICSelection | (u16)((u16)TIM_ICFilter << 4);
2262
2263   /* Select the Polarity  and set the CCE Bit */
2264   tmpccer &= CCER_CC1P_Mask & CCRE_CC1E_Mask;
2265   tmpccer |= tmp | CCRE_CC3E_Set;
2266
2267   TIMx->CCMR2 = (u16)tmpccmr2;
2268   TIMx->CCER = (u16)tmpccer;
2269 }
2270
2271 /*******************************************************************************
2272 * Function Name  : TI4_Config
2273 * Description    : Configure the TI1 as Input.
2274 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
2275 *                  - TIM_ICPolarity : The Input Polarity.
2276 *                    This parameter can be one of the following values:
2277 *                       - TIM_ICPolarity_Rising
2278 *                       - TIM_ICPolarity_Falling
2279 *                  - TIM_ICSelection: specifies the input to be used.
2280 *                    This parameter can be one of the following values:
2281 *                       - TIM_ICSelection_DirectTI: TIM Input 4 is selected to
2282 *                         be connected to IC4.
2283 *                       - TIM_ICSelection_IndirectTI: TIM Input 4 is selected to
2284 *                         be connected to IC3.
2285 *                       - TIM_ICSelection_TRGI: TIM Input 4 is selected to be
2286 *                         connected to TRGI.
2287 *                  - TIM_ICFilter: Specifies the Input Capture Filter.
2288 *                    This parameter must be a value between 0x00 and 0x0F.
2289 * Output         : None
2290 * Return         : None
2291 *******************************************************************************/
2292 static void TI4_Config(TIM_TypeDef* TIMx, u16 TIM_ICPolarity, u16 TIM_ICSelection,
2293                        u8 TIM_ICFilter)
2294 {
2295   u32 tmpccmr2 = 0, tmpccer = 0, tmp = 0;
2296
2297   tmpccmr2 = TIMx->CCMR2;
2298   tmpccer = TIMx->CCER;
2299   tmp = (u16)((u16)TIM_ICPolarity << 12);
2300
2301   /* Disable the Channel 4: Reset the CCE Bit */
2302   TIMx->CCER &= CCRE_CC4E_Reset;
2303
2304   /* Select the Input and set the filter */
2305   tmpccmr2 &= CCMR_CC24S_Mask & CCMR_IC24F_Mask;
2306   tmpccmr2 |= (u16)((u16)TIM_ICSelection << 8) | (u16)((u16)TIM_ICFilter << 12);
2307
2308   /* Select the Polarity  and set the CCE Bit */
2309   tmpccer &= CCER_CC4P_Mask & CCRE_CC4E_Mask;
2310   tmpccer |= tmp | CCRE_CC4E_Set;
2311
2312   TIMx->CCMR2 = (u16)tmpccmr2;
2313   TIMx->CCER = (u16)tmpccer ;
2314 }
2315
2316 /*******************************************************************************
2317 * Function Name  : ETR_Config
2318 * Description    : Configure the External Trigger
2319 * Input          : - TIMx: where x can be 2, 3 or 4 to select the TIM peripheral.
2320 *                  - TIM_ExtTRGPrescaler: The external Trigger Prescaler.
2321 *                    This parameter can be one of the following values:
2322 *                       - TIM_ExtTRGPSC_OFF
2323 *                       - TIM_ExtTRGPSC_DIV2
2324 *                       - TIM_ExtTRGPSC_DIV4
2325 *                       - TIM_ExtTRGPSC_DIV8
2326 *                  - TIM_ExtTRGPolarity: The external Trigger Polarity.
2327 *                    This parameter can be one of the following values:
2328 *                       - TIM_ExtTRGPolarity_Inverted
2329 *                       - TIM_ExtTRGPolarity_NonInverted
2330 *                  - ExtTRGFilter: External Trigger Filter.
2331 *                    This parameter must be a value between 0x00 and 0x0F.
2332 * Output         : None
2333 * Return         : None
2334 *******************************************************************************/
2335 static void ETR_Config(TIM_TypeDef* TIMx, u16 TIM_ExtTRGPrescaler, u16 TIM_ExtTRGPolarity,
2336                        u8 ExtTRGFilter)
2337 {
2338   u32 tmpsmcr = 0;
2339
2340   tmpsmcr = TIMx->SMCR;
2341
2342   /* Set the Prescaler, the Filter value and the Polarity */
2343   tmpsmcr &= SMCR_ETR_Mask;
2344   tmpsmcr |= TIM_ExtTRGPrescaler | TIM_ExtTRGPolarity | (u16)((u16)ExtTRGFilter << 8);
2345
2346   TIMx->SMCR = (u16)tmpsmcr;
2347 }
2348 /******************* (C) COPYRIGHT 2007 STMicroelectronics *****END OF FILE****/