• PY32F003F18之定时器中断

    PY32F003F18定时器有TIM1，TIM3，TIM14，TIM16和TIM17。其中TIM1为高级定时器，其它为通用定时器。见下表：

    一、PY32F003F18定时器的工作模式：

    1、边沿对齐模式

    计数器工作在"边沿对齐模式"
    设置"TIMx控制寄存器1(TIMx_CR1)"的DIR和"TIMx控制寄存器1(TIMx_CR1)"的CMS[1:0]；
    CMS[1:0]=00，配置TIMx为边沿对齐模式，当DIR=0时，计数器向上计数；当DIR=1时,计数器向下计数；

    计数器使用"内部时钟源"：
    如果从模式控制器被禁止，则CEN、DIR（TIMx_CR1 寄存器）和UG 位（TIMx_EGR 寄存器）是事实上的控制位，并且只能被软件修改。只要CEN 位被写成1，预分频器的时钟就由内部时钟CK_INT 提供。

    2、中央对齐模式1

    3、中央对齐模式2

    4、中央对齐模式3
    在中央对齐模式中，计数器从0开始计数到自动加载的值(TIMx_ARR 寄存器)，会产生一个计数器溢出事件；然后向下计数，
    当计数器计数到1时，也会产生一个计数器下溢事件；然后再从0开始重新计数，这样循环往复开始计数。所以计数器中断时间不变。
    计数器工作在"中央对齐模式"
    设置"TIMx控制寄存器1(TIMx_CR1)"的CMS[1:0]；
    1）、CMS[1:0]=01，配置TIMx为中央对齐模式1，计数器交替地向上和向下计数；若配置为输出通道的，则在计数器向下计数时,"OCx的输出比较中断标志位"被置1；
    2）、CMS[1:0]=10，配置TIMx为中央对齐模式2，计数器交替地向上和向下计数；若配置为输出通道的，则在计数器向上计数时,"OCx的输出比较中断标志位"被置1；
    3）、CMS[1:0]=11，配置TIMx为中央对齐模式3，计数器交替地向上和向下计数；若配置为输出通道的，则在计数器向上/向下计数时,"OCx的输出比较中断标志位"被置1；

    计数器使用"内部时钟源"
    如果从模式控制器被禁止，则CEN、DIR（TIMx_CR1 寄存器）和UG 位（TIMx_EGR 寄存器）是事实上
    的控制位，并且只能被软件修改。只要CEN 位被写成1，预分频器的时钟就由内部时钟CK_INT 提供。

    二、计数器使用内部时钟源的时序图

     三、测试程序

    1. #include "TIM1_COUNTERMODE_UP.h"
    2. #include "LED.h"
    3. #include "MyTimer.h"
    4.  
    5. /*
    6. 计数器工作在"边沿对齐模式"
    7. //将"TIMx控制寄存器1(TIMx_CR1)"的DIR=0
    8. //将"TIMx控制寄存器1(TIMx_CR1)"的CMS[1:0]=00B
    9. //CMS[1:0]=00，配置TIMx为边沿对齐模式，当DIR=0时，计数器向上计数；当DIR=1时,计数器向下计数；
    10.  
    11. 计数器使用"内部时钟源"
    12. 如果从模式控制器被禁止，则CEN、DIR（TIMx_CR1 寄存器）和UG 位（TIMx_EGR 寄存器）是事实上
    13. 的控制位，并且只能被软件修改。只要CEN 位被写成1，预分频器的时钟就由内部时钟CK_INT 提供。
    14. */
    15.  
    16. void TIM1_COUNTERMODE_UP_Init(uint16_t arr,uint16_t psc);
    17.  
    18. //函数功能:TIM1中基本计数功能,并使能了更新中断,每次重装ARR值时会产生一次更新中断
    19. //arr：自动重装值。
    20. //psc：时钟预分频数
    21. //TIM1_COUNTERMODE_UP_Init(20000,240);//若使用HSE，当arr=20000,psc=240时,则为200ms,误差为10us;
    22. //TIM1_COUNTERMODE_UP_Init(20000,80);//若使用HSI，当arr=20000,psc=80时,则为200ms,误差为10us;
    23. void TIM1_COUNTERMODE_UP_Init(uint16_t arr,uint16_t psc)
    24. {
    25. 	TIM_Base_InitTypeDef TIM_Base_InitStructure;
    26. //	TIM_HandleTypeDef  TIM1_HandleStructure;
    27.  
    28. 	__HAL_RCC_TIM1_CLK_ENABLE(); //使能TIM1时钟
    29.   HAL_NVIC_SetPriority(TIM1_BRK_UP_TRG_COM_IRQn, 0, 0); //设置中断优先级
    30.   HAL_NVIC_EnableIRQ(TIM1_BRK_UP_TRG_COM_IRQn);         //使能TIM1中断
    31.  
    32.   TIM_Base_InitStructure.Period            = arr-1;
    33. 	//设置在下一个更新事件产生时，装入"自动重载入寄存器TIMx_ARR"的值
    34. 	//将(1600 - 1)写入"自动重载入寄存器TIMx_ARR",设置自动重装载值
    35.   TIM_Base_InitStructure.Prescaler         = psc-1;
    36. 	//设置用来作为TIMx时钟频率除数的预分频值
    37. 	//将(1000-1)写入"预装载寄存器TIMx_PSC",的PSC[15:0],设置预分频值
    38. 	//计数器的时钟频率CK_CNT=fCK_PSC/(PSC[15:0]+1)
    39.   TIM_Base_InitStructure.ClockDivision = TIM_CLOCKDIVISION_DIV1; //时钟不分频,则tDTS=tCK_INT
    40. 	//若使用HSE，计算公式:arr*psc/24000000/1,当arr=20000,psc=240时,则为200ms,误差为10us;
    41. 	//若使用HSI，计算公式:arr*psc/8000000/1,当arr=20000,psc=80时,则为200ms,误差为100us;
    42.   TIM_Base_InitStructure.CounterMode   = TIM_COUNTERMODE_UP;     //计数器向上计数
    43.   TIM_Base_InitStructure.RepetitionCounter = 1 - 1;
    44. 	//不重复计数
    45. 	//将(1-1)写入"重复计数寄存器TIMx_RCR"中的REP[7:0],设置"重复计数器值"
    46.   TIM_Base_InitStructure.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    47. 	//"自动重装载寄存器"没有缓冲
    48. 	//不允许将"TIMx自动重新加载寄存器TIMx_ARR"的值被装入缓冲区;
    49.  
    50. 	TIM_Base_SetConfig(TIM1,&TIM_Base_InitStructure);
    51. 	//选择计数器模式:向上计数
    52. 	//设置时钟分频因子:时钟不分频,则tDTS=tCK_INT
    53. 	//设置自动重装载:"自动重装载寄存器"没有缓冲
    54. 	//设置自动重装载值:TIM_Base_InitStructure.Period
    55. 	//设置预分频值:TIM_Base_InitStructure.Prescaler
    56. 	//设置"重复计数器值":TIM_Base_InitStructure.RepetitionCounter
    57.   //启动更新事件:将TIMx_EGR中的UG位置1,由软件产生更新事件
    58.  
    59.   _HAL_TIM_ENABLE_IT(TIM1, TIM_IT_UPDATE);
    60. 	//将"TIMx DMA/中断使能寄存器TIM3_DIER"的UIE=1,允许计数器更新产生中断
    61. 	_HAL_TIM_ENABLE(TIM1);//计数器使能,开始计数
    62.  
    63. //  TIM1_HandleStructure.Instance = TIM1; 
    64. //	HAL_TIM_Base_Start_IT(&TIM1_HandleStructure);
    65. 	//TIM1使能启动,开始计数,并使能中断
    66. }
    67.  
    68. //函数功能:定时器中断服务程序
    69. //200ms中断一次
    70. void TIM1_BRK_UP_TRG_COM_IRQHandler(void)
    71. {
    72.   if (_HAL_TIM_GET_FLAG(TIM1,TIM_FLAG_UPDATE) != RESET)
    73.   {//计数器更新事件
    74.     if (_HAL_TIM_GET_IT_SOURCE(TIM1, TIM_IT_UPDATE) != RESET)
    75.     {
    76.       _HAL_TIM_CLEAR_IT(TIM1, TIM_IT_UPDATE);
    77.       MCU_LED_Toggle();
    78.     }
    79.   }
    80. }
    1. #ifndef __MyTimer_H
    2. #define __MyTimer_H
    3.  
    4. #include "py32f0xx_hal.h"
    5.  
    6. #define _HAL_TIM_ENABLE(__INSTANCE__)                 ((__INSTANCE__)->CR1|=(TIM_CR1_CEN))
    7. //计数器使能,开始计数
    8.  
    9. #define _HAL_TIM_DISABLE(__INSTANCE__) \
    10.   do { \
    11.     if (((__INSTANCE__)->CCER & TIM_CCER_CCxE_MASK) == 0UL) \
    12.     { \
    13.       if(((__INSTANCE__)->CCER & TIM_CCER_CCxNE_MASK) == 0UL) \
    14.       { \
    15.         (__INSTANCE__)->CR1 &= ~(TIM_CR1_CEN); \
    16.       } \
    17.     } \
    18.   } while(0)
    19. //计数器不使能,停止计数
    20.  
    21. #define _HAL_TIM_MOE_ENABLE(__INSTANCE__)             ((__INSTANCE__)->BDTR|=(TIM_BDTR_MOE))
    22. //将"TIMx刹车和死区寄存器(TIMx_BDTR)"中的MOE=1,开启OCx和OCxN输出,即使能"TIMx_CH1和TIMx_CH1N"输出
    23.  
    24. #define _HAL_TIM_MOE_DISABLE_UNCONDITIONALLY(__INSTANCE__)  (__INSTANCE__)->BDTR &= ~(TIM_BDTR_MOE)
    25. //将"TIMx刹车和死区寄存器(TIMx_BDTR)"中的MOE=0,关闭OCx和OCxN输出,即不使能"TIMx_CH1和TIMx_CH1N"输出
    26.  
    27. #define _HAL_TIM_MOE_DISABLE(__INSTANCE__) \
    28.   do { \
    29.     if (((__INSTANCE__)->CCER & TIM_CCER_CCxE_MASK) == 0UL) \
    30.     { \
    31.       if(((__INSTANCE__)->CCER & TIM_CCER_CCxNE_MASK) == 0UL) \
    32.       { \
    33.         (__INSTANCE__)->BDTR &= ~(TIM_BDTR_MOE); \
    34.       } \
    35.     } \
    36.   } while(0)
    37. //在"TIMx捕获/比较使能寄存器TIMx_CCER"中,如果"OCx禁止输出或捕获禁止",且"OCxNE禁止输出"
    38. //则将"TIMx刹车和死区寄存器(TIMx_BDTR)"中的MOE=0,关闭OCx和OCxN输出,即不使能"TIMx_CH1和TIMx_CH1N"输出
    39.  
    40. #define _HAL_TIM_ENABLE_IT(__INSTANCE__, __INTERRUPT__)    ((__INSTANCE__)->DIER |= (__INTERRUPT__))
    41. //根据__INTERRUPT__，将TIMx DMA/中断使能寄存器(TIM3_DIER)的对应位置1，使能相应的中断
    42. //TIM_IT_UPDATE,允许定时器更新中断,UIE=1
    43. //TIM_IT_CC1,允许捕获/比较1中断,CC1IE=1
    44. //TIM_IT_CC2,允许捕获/比较2中断,CC2IE=1
    45. //TIM_IT_CC3,允许捕获/比较3中断,CC3IE=1
    46. //TIM_IT_CC4,允许捕获/比较4中断,CC4IE=1
    47. //TIM_IT_COM,允许COM事件中断,COMIE=1
    48. //TIM_IT_TRIGGER,允许触发中断,TIE=1
    49. //TIM_IT_BREAK,允许刹车中断,BIE=1
    50.  
    51. #define _HAL_TIM_DISABLE_IT(__INSTANCE__, __INTERRUPT__)   ((__INSTANCE__)->DIER &= ~(__INTERRUPT__))
    52. //根据__INTERRUPT__，将TIMx DMA/中断使能寄存器(TIM3_DIER)的对应位清除，不使能相应的中断
    53. //TIM_IT_UPDATE,禁止定时器更新中断,UIE=0
    54. //TIM_IT_CC1,禁止捕获/比较1中断,CC1IE=0
    55. //TIM_IT_CC2,禁止捕获/比较2中断,CC2IE=0
    56. //TIM_IT_CC3,禁止捕获/比较3中断,CC3IE=0
    57. //TIM_IT_CC4,禁止捕获/比较4中断,CC4IE=0
    58. //TIM_IT_COM,禁止COM事件中断,COMIE=0
    59. //TIM_IT_TRIGGER,禁止触发中断,TIE=0
    60. //TIM_IT_BREAK,禁止刹车中断,BIE=0
    61.  
    62. #define _HAL_TIM_ENABLE_DMA(__INSTANCE__, __DMA__)         ((__INSTANCE__)->DIER |= (__DMA__))
    63. //根据__INTERRUPT__，将TIMx DMA/中断使能寄存器(TIMx_DIER)的对应位置1，使能相应的DMA请求
    64. //TIM_DMA_UPDATE,允许更新的DMA请求,UDE=1
    65. //TIM_DMA_CC1,允许捕获/比较1的DMA请求,CC1DE=1
    66. //TIM_DMA_CC2,允许捕获/比较2的DMA请求,CC2DE=1
    67. //TIM_DMA_CC3,允许捕获/比较3的DMA请求,CC3DE=1
    68. //TIM_DMA_CC4,允许捕获/比较4的DMA请求,CC4DE=1
    69. //TIM_DMA_COM,允许COM的DMA请求,COMDE=1
    70. //TIM_DMA_TRIGGER,允许触发DMA请求,TDE=1
    71.  
    72. #define _HAL_TIM_DISABLE_DMA(__INSTANCE__, __DMA__)        ((__INSTANCE__)->DIER &= ~(__DMA__))
    73. //根据__INTERRUPT__，将TIMx DMA/中断使能寄存器(TIMx_DIER)的对应位置1，不使能相应的DMA请求
    74. //TIM_DMA_UPDATE,禁止更新的DMA请求,UDE=0
    75. //TIM_DMA_CC1,禁止捕获/比较1的DMA请求,CC1DE=0
    76. //TIM_DMA_CC2,禁止捕获/比较2的DMA请求,CC2DE=0
    77. //TIM_DMA_CC3,禁止捕获/比较3的DMA请求,CC3DE=0
    78. //TIM_DMA_CC4,禁止捕获/比较4的DMA请求,CC4DE=0
    79. //TIM_DMA_COM,禁止COM的DMA请求,COMDE=0
    80. //TIM_DMA_TRIGGER,禁止触发DMA请求,TDE=0
    81.  
    82. #define _HAL_TIM_GET_FLAG(__INSTANCE__, __FLAG__)          (((__INSTANCE__)->SR &(__FLAG__)) == (__FLAG__))
    83. //根据__FLAG__,若"TIMx状态寄存器(TIMx_SR)"中相应的位置1,则返回1
    84. //TIM_FLAG_UPDATE,若UIF=1,建立"更新事件"
    85. //TIM_FLAG_CC1,若CC1IF=1,如果通道CC1配置为输出模式，则建立"CC1输出事件"；
    86. //TIM_FLAG_CC1,若CC1IF=1,如果通道CC1配置为输入模式，则建立"CC1捕获事件"
    87. //TIM_FLAG_CC2,若CC2IF=1,如果通道CC2配置为输出模式，则建立"CC2输出事件"；
    88. //TIM_FLAG_CC2,若CC2IF=1,如果通道CC2配置为输入模式，则建立"CC2捕获事件"
    89. //TIM_FLAG_CC3,若CC3IF=1,如果通道CC3配置为输出模式，则建立"CC3输出事件"；
    90. //TIM_FLAG_CC3,若CC3IF=1,如果通道CC3配置为输入模式，则建立"CC3捕获事件"
    91. //TIM_FLAG_CC4,若CC4IF=1,如果通道CC4配置为输出模式，则建立"CC4输出事件"；
    92. //TIM_FLAG_CC4,若CC4IF=1,如果通道CC4配置为输入模式，则建立"CC4捕获事件"；
    93. //TIM_FLAG_COM，若COMIF=1，则建立"COM事件"
    94. //TIM_FLAG_TRIGGER，若TIF=1，则建立"触发事件"
    95. //TIM_FLAG_BREAK,若BIF=1,则建立"刹车事件"
    96. //TIM_FLAG_CC1OF,若CC1OF=1,则表示"计数器x的值被捕获到TIMx_CCR1寄存器"
    97. //TIM_FLAG_CC2OF,若CC2OF=1,则表示"计数器x的值被捕获到TIMx_CCR2寄存器"
    98. //TIM_FLAG_CC3OF,若CC3OF=1,则表示"计数器x的值被捕获到TIMx_CCR3寄存器"
    99. //TIM_FLAG_CC4OF,若CC4OF=1,则表示"计数器x的值被捕获到TIMx_CCR4寄存器"
    100.  
    101. #define _HAL_TIM_CLEAR_FLAG(__INSTANCE__, __FLAG__)        ((__INSTANCE__)->SR = ~(__FLAG__))
    102. //这么写的原因,因为定时器只能做某一种功能,不能同时实现多种功能
    103. //根据__FLAG__,若"TIMx状态寄存器(TIMx_SR)"中相应的位置0,则返回1
    104. //TIM_FLAG_UPDATE,若UIF=1,建立"更新事件"
    105. //TIM_FLAG_CC1,令CC1IF=0,如果通道CC1配置为输出模式，则清除"CC1输出事件"；
    106. //TIM_FLAG_CC1,令CC1IF=0,如果通道CC1配置为输入模式，则清除"CC1捕获事件"
    107. //TIM_FLAG_CC2,令CC2IF=0,如果通道CC2配置为输出模式，则清除"CC2输出事件"；
    108. //TIM_FLAG_CC2,令CC2IF=0,如果通道CC2配置为输入模式，则清除"CC2捕获事件"
    109. //TIM_FLAG_CC3,令CC3IF=0,如果通道CC3配置为输出模式，则清除"CC3输出事件"；
    110. //TIM_FLAG_CC3,令CC3IF=0,如果通道CC3配置为输入模式，则清除"CC3捕获事件"
    111. //TIM_FLAG_CC4,令CC4IF=0,如果通道CC4配置为输出模式，则清除"CC4输出事件"；
    112. //TIM_FLAG_CC4,令CC4IF=0,如果通道CC4配置为输入模式，则清除"CC4捕获事件"；
    113. //TIM_FLAG_COM，令COMIF=0，则清除"COM事件"
    114. //TIM_FLAG_TRIGGER，令TIF=0，则清除"触发事件"
    115. //TIM_FLAG_BREAK,令BIF=0,则清除"刹车事件"
    116. //TIM_FLAG_CC1OF,令CC1OF=0,则清除建立的事件(计数器x的值被捕获到TIMx_CCR1寄存器)
    117. //TIM_FLAG_CC2OF,令CC2OF=0,则清除建立的事件(计数器x的值被捕获到TIMx_CCR2寄存器)
    118. //TIM_FLAG_CC3OF,令CC3OF=0,则清除建立的事件(计数器x的值被捕获到TIMx_CCR3寄存器)
    119. //TIM_FLAG_CC4OF,令CC4OF=0,则清除建立的事件(计数器x的值被捕获到TIMx_CCR4寄存器)
    120.  
    121. #define _HAL_TIM_GET_IT_SOURCE(__INSTANCE__, __INTERRUPT__) ((((__INSTANCE__)->DIER & (__INTERRUPT__)) \
    122.                                                              == (__INTERRUPT__)) ? SET : RESET)
    123. //根据__INTERRUPT__,若"TIMx DMA/中断使能寄存器(TIM3_DIER)的对应位置1,则返回1
    124. //TIM_IT_UPDATE,若UIE=1，返回1,当前允许定时器更新中断
    125. //TIM_IT_CC1,若CC1IE=1，返回1,当前允许捕获/比较1中断
    126. //TIM_IT_CC2,若CC2IE=1，返回1,当前允许捕获/比较2中断
    127. //TIM_IT_CC3,若CC3IE=1，返回1,当前允许捕获/比较3中断
    128. //TIM_IT_CC4,若CC4IE=1，返回1,当前允许捕获/比较4中断
    129. //TIM_IT_COM,若COMIE=1，返回1,当前允许COM事件中断
    130. //TIM_IT_TRIGGER,若TIE=1，返回1,当前允许触发中断
    131. //TIM_IT_BREAK,若BIE=1,返回1,当前允许刹车中断
    133. #define _HAL_TIM_CLEAR_IT(__INSTANCE__, __INTERRUPT__)      ((__INSTANCE__)->SR = ~(__INTERRUPT__))
    134. //根据__INTERRUPT__,将"TIMx状态寄存器(TIMx_SR)"中相应的位置0,取消中断标志位
    135. //TIM_IT_UPDATE,令UIE=0，不允许定时器更新中断
    136. //TIM_IT_CC1,令CC1IE=0，不允许捕获/比较1中断
    137. //TIM_IT_CC2,令CC2IE=0，不允许捕获/比较2中断
    138. //TIM_IT_CC3,令CC3IE=0，不允许捕获/比较3中断
    139. //TIM_IT_CC4,令CC4IE=0，不允许捕获/比较4中断
    140. //TIM_IT_COM,令COMIE=0，不允许COM事件中断
    141. //TIM_IT_TRIGGER,令TIE=0，不允许触发中断
    142. //TIM_IT_BREAK,令BIE=0,不允许刹车中断
    144. #define _HAL_TIM_IS_TIM_COUNTING_DOWN(__INSTANCE__)    (((__INSTANCE__)->CR1 &(TIM_CR1_DIR)) == (TIM_CR1_DIR))
    145. //读"TIMx控制寄存器1(TIMx_CR1)"的DIR位,若返回值为1,则表示该计数器为向下计数；否则为向上计数
    147. #define _HAL_TIM_SET_PRESCALER(__INSTANCE__, __PRESC__)       ((__INSTANCE__)->PSC = (__PRESC__))
    148. //将(__PRESC__)写入"预装载寄存器TIMx_PSC",的PSC[15:0],设置预分频值
    149. //计数器的时钟频率CK_CNT=fCK_PSC/(PSC[15:0]+1)
    151. #define _HAL_TIM_SET_COUNTER(__INSTANCE__, __COUNTER__)  ((__INSTANCE__)->CNT = (__COUNTER__))
    152. //将(__COUNTER__)的值写入"TIMx计数器(TIMx_CNT)"
    154. #define _HAL_TIM_GET_COUNTER(__INSTANCE__)  ((__INSTANCE__)->CNT)
    155. //读"TIMx计数器(TIMx_CNT)"的值
    157. #define _HAL_TIM_SET_AUTORELOAD(__INSTANCE__, __AUTORELOAD__) \
    158.   do{                                                    \
    159.     (__INSTANCE__)->ARR = (__AUTORELOAD__);  \
    160.   } while(0)
    161. //将(__AUTORELOAD__)写入"自动重载入寄存器TIMx_ARR",设置自动重装载值
    163. #define _HAL_TIM_GET_AUTORELOAD(__INSTANCE__)  ((__INSTANCE__)->ARR)
    164. //从"自动重载入寄存器TIMx_ARR"中,读取"自动重装载值"
    166. #define _HAL_TIM_SET_CLOCKDIVISION(__INSTANCE__, __CKD__) \
    167.   do{                                                   \
    168.     (__INSTANCE__)->CR1 &= (~TIM_CR1_CKD);  \
    169.     (__INSTANCE__)->CR1 |= (__CKD__);       \
    170.   } while(0)
    171. //设置"时钟分频因子"
    172. //将TIM1控制寄存器1(TIM1_CR1)的CKD[1:0]置00B
    173. //TIM_CLOCKDIVISION_DIV1,则(__CKD__)=00B：时钟分频因子tDTS=tCK_INT
    174. //TIM_CLOCKDIVISION_DIV2,则((__CKD__)=01B：时钟分频因子tDTS=2*tCK_INT
    175. //TIM_CLOCKDIVISION_DIV4,则((__CKD__)=10B：时钟分频因子tDTS=4*tCK_INT
    177. #define _HAL_TIM_GET_CLOCKDIVISION(__INSTANCE__)  ((__INSTANCE__)->CR1 & TIM_CR1_CKD)
    178. //从"TIMx控制寄存器1(TIM1_CR1)"中,读取CKD[1:0]位值,就是"时钟分频因子"
    179. //将TIM1控制寄存器1(TIM1_CR1)的CKD[1:0]置00B
    180. //返回值为TIM_CLOCKDIVISION_DIV1,表示时钟分频因子tDTS=tCK_INT
    181. //返回值为TIM_CLOCKDIVISION_DIV2,表示时钟分频因子tDTS=2*tCK_INT
    182. //返回值为TIM_CLOCKDIVISION_DIV4,表示时钟分频因子tDTS=4*tCK_INT
    184. #define TIMx_RESET_ICPRESCALERVALUE(__INSTANCE__, __CHANNEL__) \
    185.   ( ( (__CHANNEL__) == TIM_CHANNEL_1) ? ( (__INSTANCE__)->CCMR1 &= ~TIM_CCMR1_IC1PSC ) :\
    186.     ( (__CHANNEL__) == TIM_CHANNEL_2) ? ( (__INSTANCE__)->CCMR1 &= ~TIM_CCMR1_IC2PSC ) :\
    187.     ( (__CHANNEL__) == TIM_CHANNEL_3) ? ( (__INSTANCE__)->CCMR2 &= ~TIM_CCMR2_IC3PSC ) :\
    188.     ( (__INSTANCE__)->CCMR2 &= ~TIM_CCMR2_IC4PSC ) )
    189. //设置"输入捕获模式，Input Capture mode"
    190. //如果(__CHANNEL__)为TIM_CHANNEL_1，则清除"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获1预分频器C1PSC[1:0]
    191. //如果(__CHANNEL__)为TIM_CHANNEL_2，则清除"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获2预分频器C2PSC[1:0]
    192. //如果(__CHANNEL__)为TIM_CHANNEL_3，则清除"TIMx捕获/比较模式寄存器1(TIMx_CCMR2)"中的输入/捕获3预分频器C3PSC[1:0]
    194. #define TIMx_SET_ICPRESCALERVALUE(__INSTANCE__, __CHANNEL__, __ICPSC__) \
    195.   (((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCMR1 |= (__ICPSC__)) :\
    196.    ((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCMR1 |= ((__ICPSC__) << 8U)) :\
    197.    ((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCMR2 |= (__ICPSC__)) :\
    198.    ((__INSTANCE__)->CCMR2 |= ((__ICPSC__) << 8U)))
    199. //设置"输入捕获模式，Input Capture mode"
    200. //若(__CHANNEL__)=TIM_CHANNEL_1，则用(__ICPSC__)设置"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获1预分频器C1PSC[1:0]
    201. //若(__CHANNEL__)=TIM_CHANNEL_2，则(__ICPSC__)设置"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获2预分频器C2PSC[1:0]
    202. //若(__CHANNEL__)=TIM_CHANNEL_3，则(__ICPSC__)设置"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的输入/捕获3预分频器C3PSC[1:0]
    204. #define _HAL_TIM_GET_ICPRESCALER(__INSTANCE__, __CHANNEL__)  \
    205.   (((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCMR1 & TIM_CCMR1_IC1PSC) :\
    206.    ((__CHANNEL__) == TIM_CHANNEL_2) ? (((__INSTANCE__)->CCMR1 & TIM_CCMR1_IC2PSC) >> 8U) :\
    207.    ((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCMR2 & TIM_CCMR2_IC3PSC) :\
    208.    (((__INSTANCE__)->CCMR2 & TIM_CCMR2_IC4PSC)) >> 8U)
    209. //在"输入捕获模式"中,
    210. //若(__CHANNEL__)=TIM_CHANNEL_1，则读取"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获1预分频器C1PSC[1:0]
    211. //若(__CHANNEL__)=TIM_CHANNEL_2，则读取"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获2预分频器C2PSC[1:0]
    212. //若(__CHANNEL__)=TIM_CHANNEL_3，则读取"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的输入/捕获3预分频器C3PSC[1:0]
    214. #define _HAL_TIM_SET_COMPARE(__INSTANCE__, __CHANNEL__, __COMPARE__) \
    215.   (((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCR1 = (__COMPARE__)) :\
    216.    ((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCR2 = (__COMPARE__)) :\
    217.    ((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCR3 = (__COMPARE__)) :\
    218.    ((__INSTANCE__)->CCR4 = (__COMPARE__)))
    219. //设置"CCx的预装载值"：
    220. //若(__CHANNEL__)=TIM_CHANNEL_1，则将(__COMPARE__)写入TIMx捕获/比较寄存器1(TIMx_CCR1)中的CCR1[15:0],表示预装载值
    221. //若(__CHANNEL__)=TIM_CHANNEL_2，则将(__COMPARE__)写入TIMx捕获/比较寄存器2(TIMx_CCR2)中的CCR2[15:0],表示预装载值
    222. //若(__CHANNEL__)=TIM_CHANNEL_3，则将(__COMPARE__)写入TIMx捕获/比较寄存器3(TIMx_CCR3)中的CCR3[15:0],表示预装载值
    223. //若(__CHANNEL__)=TIM_CHANNEL_4，则将(__COMPARE__)写入TIMx捕获/比较寄存器4(TIMx_CCR4)中的CCR3[15:0],表示预装载值
    225. #define _HAL_TIM_GET_COMPARE(__INSTANCE__, __CHANNEL__) \
    226.   (((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCR1) :\
    227.    ((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCR2) :\
    228.    ((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCR3) :\
    229.    ((__INSTANCE__)->CCR4))
    230. //读取"CCx的预装载值"：
    231. //若(__CHANNEL__)=TIM_CHANNEL_1，则从TIMx捕获/比较寄存器1(TIMx_CCR1)中的CCR1[15:0]读取预装载值
    232. //若(__CHANNEL__)=TIM_CHANNEL_2，则从TIMx捕获/比较寄存器2(TIMx_CCR2)中的CCR2[15:0]读取预装载值
    233. //若(__CHANNEL__)=TIM_CHANNEL_3，则从TIMx捕获/比较寄存器3(TIMx_CCR3)中的CCR3[15:0]读取预装载值
    234. //若(__CHANNEL__)=TIM_CHANNEL_4，则从TIMx捕获/比较寄存器3(TIMx_CCR4)中的CCR3[15:0]读取预装载值
    236. #define _HAL_TIM_ENABLE_OCxPRELOAD(__INSTANCE__, __CHANNEL__)    \
    237.   (((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCMR1 |= TIM_CCMR1_OC1PE) :\
    238.    ((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCMR1 |= TIM_CCMR1_OC2PE) :\
    239.    ((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCMR2 |= TIM_CCMR2_OC3PE) :\
    240.    ((__INSTANCE__)->CCMR2 |= TIM_CCMR2_OC4PE))
    241. //开启TIMx_CCRy寄存器的预装载功能
    242. //若(__CHANNEL__)=TIM_CHANNEL_1，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC1PE位置1，开启TIMx_CCR1寄存器的预装载功能
    243. //若(__CHANNEL__)=TIM_CHANNEL_2，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC2PE位置1，开启TIMx_CCR2寄存器的预装载功能
    244. //若(__CHANNEL__)=TIM_CHANNEL_3，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC3PE位置1，开启TIMx_CCR3寄存器的预装载功能
    245. //若(__CHANNEL__)=TIM_CHANNEL_4，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC4PE位置1，开启TIMx_CCR4寄存器的预装载功能
    247. #define _HAL_TIM_DISABLE_OCxPRELOAD(__INSTANCE__, __CHANNEL__)    \
    248.   (((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCMR1 &= ~TIM_CCMR1_OC1PE) :\
    249.    ((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCMR1 &= ~TIM_CCMR1_OC2PE) :\
    250.    ((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCMR2 &= ~TIM_CCMR2_OC3PE) :\
    251.    ((__INSTANCE__)->CCMR2 &= ~TIM_CCMR2_OC4PE))
    252. //禁止TIMx_CCRy寄存器的预装载功能
    253. //若(__CHANNEL__)=TIM_CHANNEL_1，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC1PE位置0，禁止TIMx_CCR1寄存器的预装载功能
    254. //若(__CHANNEL__)=TIM_CHANNEL_2，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC2PE位置0，禁止TIMx_CCR2寄存器的预装载功能
    255. //若(__CHANNEL__)=TIM_CHANNEL_3，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC3PE位置0，禁止TIMx_CCR3寄存器的预装载功能
    256. //若(__CHANNEL__)=TIM_CHANNEL_4，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC4PE位置0，禁止TIMx_CCR4寄存器的预装载功能
    258. #define _HAL_TIM_ENABLE_OCxFAST(__INSTANCE__, __CHANNEL__)    \
    259.   (((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCMR1 |= TIM_CCMR1_OC1FE) :\
    260.    ((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCMR1 |= TIM_CCMR1_OC2FE) :\
    261.    ((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCMR2 |= TIM_CCMR2_OC3FE) :\
    262.    ((__INSTANCE__)->CCMR2 |= TIM_CCMR2_OC4FE))
    263. //开启"比较x快速输出"功能，加快CCx输出对触发器x输入事件的响应
    264. //若(__CHANNEL__)=TIM_CHANNEL_1，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC1FE位置1，开启"比较1快速输出"功能
    265. //若(__CHANNEL__)=TIM_CHANNEL_2，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC2FE位置1，开启"比较2快速输出"功能
    266. //若(__CHANNEL__)=TIM_CHANNEL_3，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC3FE位置1，开启"比较3快速输出"功能
    267. //若(__CHANNEL__)=TIM_CHANNEL_4，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC4FE位置1，开启"比较4快速输出"功能
    269. #define _HAL_TIM_DISABLE_OCxFAST(__INSTANCE__, __CHANNEL__)    \
    270.   (((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCMR1 &= ~TIM_CCMR1_OC1FE) :\
    271.    ((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCMR1 &= ~TIM_CCMR1_OC2FE) :\
    272.    ((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCMR2 &= ~TIM_CCMR2_OC3FE) :\
    273.    ((__INSTANCE__)->CCMR2 &= ~TIM_CCMR2_OC4FE))
    274. //禁止"比较x快速输出"功能，不用加快CC输出对触发器输入事件的响应
    275. //若(__CHANNEL__)=TIM_CHANNEL_1，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC1FE位置0，禁止"比较1快速输出"功能
    276. //若(__CHANNEL__)=TIM_CHANNEL_2，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC2FE位置0，禁止"比较2快速输出"功能
    277. //若(__CHANNEL__)=TIM_CHANNEL_3，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC3FE位置0，禁止"比较3快速输出"功能
    278. //若(__CHANNEL__)=TIM_CHANNEL_4，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC4FE位置0，禁止"比较4快速输出"功能
    280. #define _HAL_TIM_URS_ENABLE(__INSTANCE__)  ((__INSTANCE__)->CR1|= TIM_CR1_URS)
    281. //将"TIMx控制寄存器1(TIM1_CR1)"中的URS位置1
    282. //允许在"计数器溢出/下溢"时,产生一个更新中断或DMA请求;
    284. #define _HAL_TIM_URS_DISABLE(__INSTANCE__)  ((__INSTANCE__)->CR1&=~TIM_CR1_URS)
    285. //将"TIMx控制寄存器1(TIM1_CR1)"中的URS位置0
    286. //允许在"计数器溢出/下溢"时,产生一个更新中断或DMA请求;
    287. //允许在"TIMx_EGR中的UG位置1"时,产生一个更新中断或DMA请求;
    288. //允许在"从模式控制器产生更新"时,产生一个更新中断或DMA请求;
    292. #define _HAL_TIM_SET_ICPRESCALER(__INSTANCE__, __CHANNEL__, __ICPSC__) \
    293.   do{                                                    \
    294.     TIMx_RESET_ICPRESCALERVALUE((__INSTANCE__), (__CHANNEL__));  \
    295.     TIMx_SET_ICPRESCALERVALUE((__INSTANCE__), (__CHANNEL__), (__ICPSC__)); \
    296.   } while(0)
    297. //使用(__ICPSC__)设置通道为(__CHANNEL__)的"输入捕获预分频器"的值
    298. //设置"输入捕获模式，Input Capture mode"
    299. //如果(__CHANNEL__)为TIM_CHANNEL_1，则清除"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获1预分频器C1PSC[1:0]
    300. //如果(__CHANNEL__)为TIM_CHANNEL_2，则清除"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获2预分频器C2PSC[1:0]
    301. //如果(__CHANNEL__)为TIM_CHANNEL_3，则清除"TIMx捕获/比较模式寄存器1(TIMx_CCMR2)"中的输入/捕获3预分频器C3PSC[1:0]
    302. //设置"输入捕获模式，Input Capture mode"
    303. //若(__CHANNEL__)=TIM_CHANNEL_1，则用(__ICPSC__)设置"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获1预分频器C1PSC[1:0]
    304. //若(__CHANNEL__)=TIM_CHANNEL_2，则(__ICPSC__)设置"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获2预分频器C2PSC[1:0]
    305. //若(__CHANNEL__)=TIM_CHANNEL_3，则(__ICPSC__)设置"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的输入/捕获3预分频器C3PSC[1:0]
    307. #define TIMx_RESET_CAPTUREPOLARITY(__INSTANCE__, __CHANNEL__) \
    308.   (((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCER &= ~(TIM_CCER_CC1P | TIM_CCER_CC1NP)) :\
    309.    ((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCER &= ~(TIM_CCER_CC2P | TIM_CCER_CC2NP)) :\
    310.    ((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCER &= ~(TIM_CCER_CC3P | TIM_CCER_CC3NP)) :\
    311.    ((__INSTANCE__)->CCER &= ~(TIM_CCER_CC4P | TIM_CCER_CC4NP)))
    312. //设置"输入/捕获x的输出极性"
    313. //TIMx捕获/比较使能寄存器(TIMx_CCER)
    314. //当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1P时,令CC1P=0；CC1P=0表示"输入/捕获1输出极性"为高电平有效，否则为低电平有效
    315. //当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1NP时,令CC1NP=0；CC1NP=0表示"输入/捕获1互补输出极性"为高电平有效，否则为低电平有效
    316. //当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2P时,令CC2P=0；CC2P=0表示"输入/捕获2输出极性"为高电平有效，否则为低电平有效
    317. //当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2NP时,令CC2NP=0；CC2NP=0表示"输入/捕获2互补输出极性"为高电平有效，否则为低电平有效
    318. //当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3P时,令CC3P=0；CC3P=0表示"输入/捕获3输出极性"为高电平有效，否则为低电平有效
    319. //当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3NP时,令CC3NP=0；CC3NP=0表示"输入/捕获3互补输出极性"为高电平有效，否则为低电平有效
    320. //当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4P时,令CC4P=0；CC4P=0表示"输入/捕获4输出极性"为高电平有效，否则为低电平有效
    321. //当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4NP时,令CC4NP=0；CC4NP=0表示"输入/捕获4互补输出极性"为高电平有效，否则为低电平有效
    323. #define TIMx_SET_CAPTUREPOLARITY(__INSTANCE__, __CHANNEL__, __POLARITY__) \
    324.   (((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCER |= (__POLARITY__)) :\
    325.    ((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCER |= ((__POLARITY__) << 4U)) :\
    326.    ((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCER |= ((__POLARITY__) << 8U)) :\
    327.    ((__INSTANCE__)->CCER |= (((__POLARITY__) << 12U))))
    328. //设置"输入/捕获x的输出极性"
    329. //TIMx捕获/比较使能寄存器(TIMx_CCER)
    330. //当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1P时,令CC1P=1；CC1P=0表示"输入/捕获1输出极性"为高电平有效，否则为低电平有效
    331. //当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1NP时,令CC1NP=1；CC1NP=0表示"输入/捕获1互补输出极性"为高电平有效，否则为低电平有效
    332. //当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2P时,令CC2P=1；CC2P=0表示"输入/捕获2输出极性"为高电平有效，否则为低电平有效
    333. //当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2NP时,令CC2NP=1；CC2NP=0表示"输入/捕获2互补输出极性"为高电平有效，否则为低电平有效
    334. //当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3P时,令CC3P=1；CC3P=0表示"输入/捕获3输出极性"为高电平有效，否则为低电平有效
    335. //当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3NP时,令CC3NP=1；CC3NP=0表示"输入/捕获3互补输出极性"为高电平有效，否则为低电平有效
    336. //当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4P时,令CC4P=1；CC4P=0表示"输入/捕获4输出极性"为高电平有效，否则为低电平有效
    337. //当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4NP时,令CC4NP=1；CC4NP=0表示"输入/捕获4互补输出极性"为高电平有效，否则为低电平有效
    339. #define _HAL_TIM_SET_CAPTUREPOLARITY(__INSTANCE__, __CHANNEL__, __POLARITY__)    \
    340.   do{                                                                     \
    341.     TIMx_RESET_CAPTUREPOLARITY((__INSTANCE__), (__CHANNEL__));               \
    342.     TIMx_SET_CAPTUREPOLARITY((__INSTANCE__), (__CHANNEL__), (__POLARITY__)); \
    343.   }while(0)
    344. //设置"输入/捕获x的输出极性"
    345. //TIMx捕获/比较使能寄存器(TIMx_CCER)
    346. //当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1P时,令CC1P=0；CC1P=0表示"输入/捕获1输出极性"为高电平有效，否则为低电平有效
    347. //当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1NP时,令CC1NP=0；CC1NP=0表示"输入/捕获1互补输出极性"为高电平有效，否则为低电平有效
    348. //当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2P时,令CC2P=0；CC2P=0表示"输入/捕获2输出极性"为高电平有效，否则为低电平有效
    349. //当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2NP时,令CC2NP=0；CC2NP=0表示"输入/捕获2互补输出极性"为高电平有效，否则为低电平有效
    350. //当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3P时,令CC3P=0；CC3P=0表示"输入/捕获3输出极性"为高电平有效，否则为低电平有效
    351. //当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3NP时,令CC3NP=0；CC3NP=0表示"输入/捕获3互补输出极性"为高电平有效，否则为低电平有效
    352. //当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4P时,令CC4P=0；CC4P=0表示"输入/捕获4输出极性"为高电平有效，否则为低电平有效
    353. //当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4NP时,令CC4NP=0；CC4NP=0表示"输入/捕获4互补输出极性"为高电平有效，否则为低电平有效
    354. //设置"输入/捕获x的输出极性"
    355. //TIMx捕获/比较使能寄存器(TIMx_CCER)
    356. //当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1P时,令CC1P=1；CC1P=0表示"输入/捕获1输出极性"为高电平有效，否则为低电平有效
    357. //当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1NP时,令CC1NP=1；CC1NP=0表示"输入/捕获1互补输出极性"为高电平有效，否则为低电平有效
    358. //当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2P时,令CC2P=1；CC2P=0表示"输入/捕获2输出极性"为高电平有效，否则为低电平有效
    359. //当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2NP时,令CC2NP=1；CC2NP=0表示"输入/捕获2互补输出极性"为高电平有效，否则为低电平有效
    360. //当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3P时,令CC3P=1；CC3P=0表示"输入/捕获3输出极性"为高电平有效，否则为低电平有效
    361. //当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3NP时,令CC3NP=1；CC3NP=0表示"输入/捕获3互补输出极性"为高电平有效，否则为低电平有效
    362. //当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4P时,令CC4P=1；CC4P=0表示"输入/捕获4输出极性"为高电平有效，否则为低电平有效
    363. //当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4NP时,令CC4NP=1；CC4NP=0表示"输入/捕获4互补输出极性"为高电平有效，否则为低电平有效	
    364. #endif /* __MyTimer_H */
    1. #include "py32f0xx_hal.h"
    2. #include "SystemClock.h"
    3. #include "USART2.h"
    4. #include "stdio.h"  //getchar(),putchar(),scanf(),printf(),puts(),gets(),sprintf()
    5. #include "string.h" //使能strcpy(),strlen(),memset()
    6. #include "delay.h"
    7. #include "LED.h"
    8. #include "TIM1_COUNTERMODE_UP.h"
    9. #include "SystemClock.h"
    10.  
    11. const char CPU_Reset_REG[]="\r\nCPU reset!\r\n";
    12. int main(void)
    13. {
    14. 	HSE_Config();
    15. 	HAL_Init();//systick初始化
    16.   delay_init();
    17. 	HAL_Delay(1000);
    18.  
    19. 	MCU_LED_Init();
    20. 	USART2_Init(115200);
    21. 	printf("%s",CPU_Reset_REG);
    22. 	TIM1_COUNTERMODE_UP_Init(20000,240);//若使用HSE，当arr=20000,psc=240时,则为200ms,误差为10us;
    23. //	TIM1_COUNTERMODE_UP_Init(20000,80);//若使用HSI，当arr=20000,psc=80时,则为200ms,误差为10us;
    24.  
    25.   while (1)
    26.   {
    27. 		delay_ms(100);
    28.   }
    29. }
    1. #include "SystemClock.h"
    2. #include "py32f0xx_hal.h"
    3.  
    4. void HSE_Config(void);
    5. void HSI_Config(void);
    6.  
    7. //函数功能:初始化"HSI,HSE,LSI振荡器",HSE用作系统时钟(SYSCLK),同时配置"AHB时钟(HCLK)和APB时钟(PCLK)"
    8. void HSE_Config(void)
    9. {
    10. 	HAL_StatusTypeDef retData;
    11.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    12.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
    13.  
    14.   //配置HSE,HSI和LSI振荡器
    15.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE | RCC_OSCILLATORTYPE_HSI | RCC_OSCILLATORTYPE_LSI;
    16.  
    17.   RCC_OscInitStruct.HSIState = RCC_HSI_ON; //开启HSI
    18.   RCC_OscInitStruct.HSIDiv = RCC_HSI_DIV1; //HSI不分频
    19. //  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_4MHz;    //配置HSI输出时钟为4MHz
    20.   RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_8MHz;      //配置HSI输出时钟为8MHz
    21. //  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_16MHz;   //配置HSI输出时钟为16MHz
    22. //  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_22p12MHz;//配置HSI输出时钟为22.12MHz
    23. //  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_24MHz;   //配置HSI输出时钟为24MHz
    24.  
    25.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;      //开启HSE
    26.   RCC_OscInitStruct.HSEFreq = RCC_HSE_16_32MHz; //HSE工作频率范围16M~32M
    27.  
    28.   RCC_OscInitStruct.LSIState = RCC_LSI_ON;      //开启LSI
    29.  
    30. 	retData=HAL_RCC_OscConfig(&RCC_OscInitStruct);//初始化HSI,HSE,LSI振荡器
    31.   if ( retData!= HAL_OK)//初始化振荡器失败
    32.   {
    33.   }
    34.  
    35.   //初始化"系统时钟(SYSCLK),AHB时钟(HCLK)和APB时钟(PCLK)"
    36.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1;
    37.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSE;//SYSCLK的源选择为HSE
    38.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;//AHB时钟(HCLK)不分频,输出为APB时钟
    39.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2; //APB时钟(PCLK)分频器为2分频,输出为PCLK时钟
    40. 	retData=HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);
    41. 	//初始化RCC系统时钟(小于24MHz,则使用FLASH_LATENCY_0;大于24MHz且小于48MHz,则使用FLASH_LATENCY_1)
    42.   if ( retData!= HAL_OK)//初始化RCC系统时钟失败
    43.   {
    44.   }
    45. }
    46.  
    47. //函数功能:初始化"HSI振荡器",用作系统时钟(SYSCLK),同时配置"AHB时钟(HCLK)和APB时钟(PCLK)"
    48. void HSI_Config(void)
    49. {
    50. 	HAL_StatusTypeDef retData;
    51.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    52.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
    53.  
    54.   //配置HSI振荡器
    55.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;//选择振荡器类型为HSI
    56.   RCC_OscInitStruct.HSIState = RCC_HSI_ON;//开启HSI
    57.   RCC_OscInitStruct.HSIDiv = RCC_HSI_DIV1;//不分频
    58. //  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_4MHz;//配置HSI输出时钟为4MHz
    59. //  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_8MHz;//配置HSI输出时钟为8MHz
    60. //  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_16MHz;//配置HSI输出时钟为16MHz
    61. //  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_22p12MHz;//配置HSI输出时钟为22.12MHz
    62.   RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_24MHz; //配置HSI输出时钟为24MHz
    63. 	retData=HAL_RCC_OscConfig(&RCC_OscInitStruct);
    64.  
    65.   if(retData != HAL_OK)//初始化振荡器失败
    66.   {
    67.   }
    68.  
    69.   //初始化"系统时钟(SYSCLK),AHB时钟(HCLK)和APB时钟(PCLK)"
    70.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1;  //RCC系统时钟类型
    71.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;//SYSCLK的源选择为HSI
    72.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;    //AHB时钟(HCLK)不分频,输出为APB时钟
    73.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;     //APB时钟(PCLK)分频器为1分频,输出为PCLK时钟
    74. 	retData=HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);
    75. 	初始化RCC系统时钟(小于24MHz,则使用FLASH_LATENCY_0;大于24MHz且小于48MHz,则使用FLASH_LATENCY_1)
    76.  
    77.   if( retData!=HAL_OK)初始化RCC系统时钟失败
    78.   {
    79.   }
    80. }

    四、测试结果 

  • 相关阅读:
    [SpringBoot] SpringBoot-03-配置文件格式
    初识云计算
    NFTFi赛道版图概览
    FinalShell软件连接成功后，root文件夹显示一直加载中....
    Rust学习日记（二）变量的使用--结合--温度换算/斐波那契数列--实例
    解决用IPV6+DDNS访问UNRAID webui周期性失效的问题，smb不能访问的问题
    每日三题 8.19
    性能优化：TCP连接优化之四次挥手
    企业运维实践-还不会部署高可用的kubernetes集群?使用kubeadm方式安装高可用k8s集群v1.23.7
    基于Java毕业设计游泳馆管理平台源码+系统+mysql+lw文档+部署软件
  • 原文地址：https://blog.csdn.net/weixin_42550185/article/details/132853814