32.1 初学者重要提示
  学习定时器外设推荐从硬件框图开始了解基本的功能特性，然后逐步深入了解各种特性，这种方式方便记忆和以后查阅。
, H: N' q+ I9 _$ ]; n6 K4 |  STM32H7的定时器输出100MHz方波是完全没问题。
  STM32H7定时器进出中断的速度能跑到12.5MHz，所有程序在TCM和Flash运行没差别。
  STM32H7的定时器输入捕获可以实现12MHz方波的双边沿捕获，单边沿可以做到24MHz。
  特别注意STM32H7的TIM1,8,15,16,17才有RCR重复计数器，其它都没用的。
  STM32H7的单个定时器中不同通道可以配置不同频率PWM。
  STM32H7的TIM1-TIM17中断入口函数名使用时要注意，别搞错了：

1. TIM1_BRK_IRQHandler            
   
2. TIM1_UP_IRQHandler              
   2 o" D0 j' y' m- X
3. TIM1_TRG_COM_IRQHandler        
   
4. TIM1_CC_IRQHandler                                                   
   # L& g5 m: J8 c7 {
5. TIM2_IRQHandler                                          
   
6. TIM3_IRQHandler                                                
     q6 w6 L  a) `4 u8 q
7. TIM4_IRQHandler                 
     N$ P2 m9 L% I" }8 ^/ V- Z
8. TIM5_IRQHandler            
   
9. TIM6_DAC_IRQHandler           <------------------要注意            
   4 s% |, g! f  P8 f+ Z0 w
10. TIM7_IRQHandler
    ( `( ]) u* c& P) d9 `
11. TIM8_BRK_TIM12_IRQHandler      <------------------要注意，定时器12也是用的这个
    * j$ n7 O7 H+ q2 O5 @
12. TIM8_UP_TIM13_IRQHandler       <------------------要注意，定时器13也是用的这个
    
13. TIM8_TRG_COM_TIM14_IRQHandler  <------------------要注意，定时器14也是用的这个
    ; Y: W" b: J6 W; ^" i5 j9 v6 s
14. TIM8_CC_IRQHandler         
    ) |  D8 a) a4 L* Q" u
15. TIM15_IRQHandler
    , i( ?' J) B% N+ R- T. ~- J
16. TIM16_IRQHandler
      f+ i: i* I% T1 N, O
17. TIM17_IRQHandler

复制代码

8 F* |& `  ?7 R5 t- j8 l32.2 定时器基础知识
1 _2 @- d# |- Y9 n3 m" F注，不同定时支持的功能略有区别，基础定时器功能较少，TIM1和TIM8高级定时器功能多些。
! O# ]9 ?# l: ~
, u" @+ d$ i  A  TIM2和TIM5是32位定时器，其它定时器都是16位定时器。16位和32位的区别是CNT计数器范围不同，32位的范围是0 到2^32 – 1，而16位的是0到65535；它们支持的分频是范围是一样的，都是1到65535。
; S  l1 d: I4 ]( ]  计数器支持递增、递减和递增/递减二合一。
  多个独立通道，可用于：
– 输入捕获。
4 K5 m$ n3 [) P6 F% m1 h; m. Q
/ l" r: r$ O& X4 ^5 e# d+ k– 输出比较。

3 u4 Z) b: V8 G7 x– PWM 生成（边沿和中心对齐模式）。
' k; m4 z6 ~  {" |! h0 i# O
  O' L" F* O6 b% M– 单脉冲模式输出。
+ g! _* e0 E% G2 |; Z) g0 p1 ?
  带死区插入，断路功能和PWM互补输出
  发生如下事件时生成中断/DMA 请求：
9 ?5 t6 T* X. x0 x- ~" h– 更新：计数器上溢/下溢、计数器初始化（通过软件或内部/外部触发）
/ t& N9 P# W$ N
2 }) P1 o8 _* s– 触发事件（计数器启动、停止、初始化或通过内部/外部触发计数）
: \5 s' Q7 U9 v1 k) L
2 N+ n- I+ E3 z( l* }" H$ C– 输入捕获

: {, A: X1 D4 Z0 u– 输出比较
. P# v9 L. _, v: L5 T
  支持增量式编码器和霍尔传感器。
32.2.1 定时器TIM1-TIM17的区别
; K7 D/ |3 t0 F9 _* f$ k+ iSTM32H7支持的定时器有点多，要简单的区分下。STM32H7支持TIM1-TIM8，TIM12-TIM17共14个定时器，而中间的TIM9，TIM10，TIM11是不存在的，这点要注意。
1 ~8 Q" T0 f9 l* u& G: ^) e
5 m2 f- c  z5 v1 M粗略的比较如下：

* ~1 u7 P5 t1 k; h& q; ^5 d$ O
' c) @2 m3 }, w) g1 M) n  f1 y6 h
. h! u( k$ ^% E% n8 B6 I通过上面的表格，至少要了解到以下两点：

* \* Y0 x# S( ?  c  STM32H7的定时器主要分为高级定时器，通用定时器，基础定时器和低功耗定时器。
9 z, M+ F1 k, K" k& r- |) d  TIM2和TIM5是32位定时器，其它都是16位定时器。
5 e8 B* h7 K4 ^: k! \1 w9 T32.2.2 定时器的硬件框图
# B- n( M1 x- U, {* j! e认识一个外设，最好的方式就是看他的框图，方便我们快速的了解定时器的基本功能，然后再看手册了解细节。
  K: R; d+ a& J/ z/ i, S
下面我们直接看最复杂的高级定时器TIM1&TIM8框图：

. x6 B+ Z8 q8 ~' K
& `' D" k4 H( x/ Q) M通过这个框图，我们可以得到如下信息：

  TIMx_ETR接口
! w9 g) l5 N% }" v) q/ E外部触发输入接口。ETR支持多种输入源：输入引脚（默认配置）、比较器输出和模拟看门狗。

  截图左侧的TIMx_CH1，TIMx_CH2，TIMx_CH3和TIMx_CH4接口
这四个通道主要用于输入捕获，可以计算波形频率和脉宽。                                                                                                                             

  TIMx_BKIN和TIMx_BKIN2接口
" M8 G7 W, x  I$ A2 M" n0 b* O断路功能，主要用于保护由 TIM1 和 TIM8 定时器产生的 PWM 信号所驱动的功率开关

  TRGO内部输出通道
主要用于定时器级联，ADC和DAC的定时器触发。

6 P( n* @, W8 R2 L  k. L  6组输出比较单元OC1到OC6
- ?. J* _3 A; G# r% @, y/ q5 sOC1到OC4有对应的输出引脚，而OC5和OC6没有对应的输出引脚，主要用于内部控制。

1 |6 m$ v9 `2 c" I' c  截图右侧的输出比较通道TIMx_CH1，TIMx_CH1N，TIMx_CH2，TIMx_CH2N，TIMx_CH3，TIMx_CH3N和TIMx_CH4
主要用于PWM输出，注意CH1到CH3有互补输出，而CH4没有互补输出。
/ ^% G" _( \1 g5 e- \6 ^$ C7 X
# ~& g/ j$ j* y. [0 J) k  其它框图里面未展示出来功能
' _( y. ~2 w7 {3 t定时器TIM1&TIM8还支持的其它功能在用到的时候再做说明。
4 U1 U1 b! f8 e/ w) S+ _# N6 V
32.2.3 定时器的时基单元
0 ~4 d# O0 H7 N定时器要工作就需要一个基本时基单元，而基本的时基单元是由下面几个寄存器组成的：

  预分频器寄存器 (TIMx_PSC)
用于设置定时器的分频，比如定时器的主频是200MHz，通过此寄存器可以将其设置为100MHz，50MHz，25MHz等分频值。
$ Z- V6 Q: m2 ]& S" i# c( h; [9 a# G
0 w# t# [) S3 R6 c0 ^) b* C注：预分频器有个缓冲功能，可以让用户实时更改，新的预分频值将在下一个更新事件发生时被采用（以递增计数模式为例，就是CNT计数值达到ARR自动重装寄存器的数值时会产生更新事件）。

! z$ L  Q9 W1 f; D  计数器寄存器 (TIMx_CNT)
计数器是最基本的计数单元，计数值是建立在分频的基础上面，比如通过TIMx_PSC设置分频后的频率为100MHz，那么计数寄存器计一次数就是10ns。

  自动重载寄存器 (TIMx_ARR)
自动重装寄存器是CNT计数寄存器能达到的最大计数值，以递增计数模式为例，就是CNT计数器达到ARR寄存器数值时，重新从0开始计数。

6 P# U& M. y# o注，自动重载寄存器是预装载的。对自动重载寄存器执行写入或读取操作时会访问预装载寄存器。预装载寄存器的内容既可以立即传送到影子寄存器（让设置立即起到效果的寄存器），也可以在每次发生更新事件时传送到影子寄存器。简单的说就是让ARR寄存器的数值立即更新还是更新事件发送的时候更新。

  重复计数器寄存器 (TIMx_RCR)
, a+ W0 m. P' R2 @& u' i1 Q以递增计数模式为例，当CNT计数器数值达到ARR自动重载数值时，重复计数器的数值加1，重复次数达到TIMx_RCR+ 1后就，将生成更新事件。

注，只有TIM1，TIM8，TIM15，TIM16，TIM17有此寄存器。

比如我们要配置定时器实现周期性的中断，主要使用这几个寄存器即可。

32.2.4 定时器输出比较（PWM）
: Y) w3 O+ b4 [使用定时器时基单元的那几个寄存器仅仅能设置周期，还不能设置占空比。针对这个问题，还需要比较捕获寄存CCR的参与，这样就可以设置占空比了。
9 ^3 \) l) k. w% H- z
为了方便大家理解，以PWM 边沿对齐模式，递增计数配置为例：
, L9 ]) d1 {: a# `
  当计数器TIMx_CNT < 比较捕获寄存器TIMx_CCRx期间，PWM参考信号OCxREF输出高电平。
2 P# Z$ R% n/ \  当计数器TIMx_CNT >= 比较捕获寄存器TIMx_CCRx期间， PWM参考信号OCxREF输出低电平。
  当比较捕获寄存器TIMx_CCRx > 自动重载寄存器TIMx_ARR，OCxREF保持为1。
% @- P: z7 e4 M( d: i; U% `0 Q  X  当比较捕获寄存器TIMx_CCRx = 0，则OCxRef保持为0。
2 e/ Q* b8 r0 Q7 q; j5 W下面是TIMx_ARR=8的波形效果：

7 k  A0 }1 u+ c7 y# ^
32.2.5 定时器输入捕获
" Q6 s" [" H* g与PWM一样，使用定时器实现输入捕获，仅靠时基单元的那几个寄存器是不行的，我们需要一个寄存器来记录发生捕获时的具体时间，这个寄存器依然由比较捕获寄存器TIMx_CCRx来实现。
! D% O* I$ O5 @% B
比如我们要测量一路方波的周期：

  配置定时器为输入捕获模式，上升沿触发，设置分频，自动重装等寄存器，比如设置的CNT计数器计数1次是1微秒。
  当有上升沿触发的时候，TIMx_CCRx寄存器就会自动记录当前的CNT数值，然后用户就可以通过CC中断，在中断复位程序里面保存当前的TIMx_CCRx寄存器数值。等下次再检测到上升沿触发，两次时间求差就可以得到方波的周期。
不过这里要特别注意一点，如果CNT发生溢出（比如16位定时器，计数到65535就溢出了）就需要特别处理下，将CNT计数溢出考虑进来。

32.3 定时器的HAL库用法
定时器的HAL库用法其实就是几个结构体变量成员的配置和使用，然后配置GPIO、时钟，并根据需要配置NVIC、中断和DMA。下面我们逐一展开为大家做个说明。

32.3.1 定时器寄存器结构体TIM_TypeDef
% @& M6 U' X- G8 C" t* k1 g, R定时器相关的寄存器是通过HAL库中的结构体TIM_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：

1. typedef struct
   & S0 O. ?0 F6 O$ C4 z
2. {
   & ?: h3 y6 b0 R6 t4 s
3.   __IO uint16_t CR1;         /*!< TIM control register 1,                   Address offset: 0x00 */
   
4.   uint16_t      RESERVED0;   /*!< Reserved, 0x02                                                 */
   
5.   __IO uint32_t CR2;         /*!< TIM control register 2,                   Address offset: 0x04 */
   
6.   __IO uint32_t SMCR;        /*!< TIM slave mode control register,          Address offset: 0x08 */
   
7.   __IO uint32_t DIER;        /*!< TIM DMA/interrupt enable register,        Address offset: 0x0C */
   
8.   __IO uint32_t SR;          /*!< TIM status register,                      Address offset: 0x10 */
   , _5 i6 X% v( _
9.   __IO uint32_t EGR;         /*!< TIM event generation register,            Address offset: 0x14 */
     L. |) L8 X. ]) r* R2 ]
10.   __IO uint32_t CCMR1;       /*!< TIM capture/compare mode register 1,      Address offset: 0x18 */
    . L% n+ e+ h8 o; ]* a
11.   __IO uint32_t CCMR2;       /*!< TIM capture/compare mode register 2,      Address offset: 0x1C */
    
12.   __IO uint32_t CCER;        /*!< TIM capture/compare enable register,      Address offset: 0x20 */
    * M/ J5 Z5 H- l/ g# N
13.   __IO uint32_t CNT;         /*!< TIM counter register,                     Address offset: 0x24 */
    
14.   __IO uint16_t PSC;         /*!< TIM prescaler,                            Address offset: 0x28 */
    
15.   uint16_t      RESERVED9;   /*!< Reserved, 0x2A                                                 */
    
16.   __IO uint32_t ARR;         /*!< TIM auto-reload register,                 Address offset: 0x2C */
    
17.   __IO uint16_t RCR;         /*!< TIM repetition counter register,          Address offset: 0x30 */
    7 R$ g- U5 }" G3 h. G5 n9 Q% ^
18.   uint16_t      RESERVED10;  /*!< Reserved, 0x32                                                 */
    
19.   __IO uint32_t CCR1;        /*!< TIM capture/compare register 1,           Address offset: 0x34 */
    
20.   __IO uint32_t CCR2;        /*!< TIM capture/compare register 2,           Address offset: 0x38 */
    ) M& F3 Q1 P* N$ @: i' R
21.   __IO uint32_t CCR3;        /*!< TIM capture/compare register 3,           Address offset: 0x3C */
    
22.   __IO uint32_t CCR4;        /*!< TIM capture/compare register 4,           Address offset: 0x40 */
    
23.   __IO uint32_t BDTR;        /*!< TIM break and dead-time register,         Address offset: 0x44 */
    0 Q. l# @# N" w# `4 P1 v
24.   __IO uint16_t DCR;         /*!< TIM DMA control register,                 Address offset: 0x48 */
    
25.   uint16_t      RESERVED12;  /*!< Reserved, 0x4A                                                 */
    ' Y! ~- r: f; p0 n  C( J9 J
26.   __IO uint16_t DMAR;        /*!< TIM DMA address for full transfer,        Address offset: 0x4C */
    0 Z9 \  T% H* n6 I3 |1 `2 `
27.   uint16_t      RESERVED13;  /*!< Reserved, 0x4E                                                 */
    8 e3 W: n) J& W2 n" }
28.   uint16_t      RESERVED14;  /*!< Reserved, 0x50                                                 */
    $ Q- L/ r2 Q. Y; P
29.   __IO uint32_t CCMR3;       /*!< TIM capture/compare mode register 3,      Address offset: 0x54 */
    
30.   __IO uint32_t CCR5;        /*!< TIM capture/compare register5,            Address offset: 0x58 */
    + Q; [7 l: ]! E* m, l6 Q8 _8 V- P
31.   __IO uint32_t CCR6;        /*!< TIM capture/compare register6,            Address offset: 0x5C */
    
32.   __IO uint32_t AF1;         /*!< TIM alternate function option register 1, Address offset: 0x60 */
    
33.   __IO uint32_t AF2;         /*!< TIM alternate function option register 2, Address offset: 0x64 */
    
34.   __IO uint32_t TISEL;       /*!< TIM Input Selection register,             Address offset: 0x68 */
    
35. } TIM_TypeDef;

复制代码

这个结构体的成员名称和排列次序和CPU的定时器寄存器是一 一对应的。

! f) n) j+ E5 b  n% e__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

. a% t0 r, k$ ?- `1 D- k/ y下面我们看下定时器的定义，在stm32h743xx.h文件。

3 W9 ]) U) z) d6 G) P: c6 v6 P

1. #define PERIPH_BASE         ((uint32_t)0x40000000)
   
2. #define D2_APB1PERIPH_BASE   PERIPH_BASE
   9 ~5 Q  [/ H' Z) S, `( C- r  `
3. #define D2_APB2PERIPH_BASE   (PERIPH_BASE + 0x00010000)
   % B* V8 ?2 T, ^7 H/ F9 X1 l0 M, ~
4. 
   
5. /*!< D2_APB1PERIPH 外设 */
   2 i0 W$ ~* T5 a& {( Y& s2 z# \
6. #define TIM2_BASE             (D2_APB1PERIPH_BASE + 0x0000) <----- 展开这个宏，(TIM_TypeDef *) 0x40000000
   
7. #define TIM3_BASE             (D2_APB1PERIPH_BASE + 0x0400)
   / D( Z3 }2 v: o: h* A) D
8. #define TIM4_BASE             (D2_APB1PERIPH_BASE + 0x0800)
   & j  i2 W2 \! I2 B+ e
9. #define TIM5_BASE             (D2_APB1PERIPH_BASE + 0x0C00)
   
10. #define TIM6_BASE             (D2_APB1PERIPH_BASE + 0x1000)
    
11. #define TIM7_BASE             (D2_APB1PERIPH_BASE + 0x1400)
    6 M  _$ i) p: v7 M0 s9 B4 @" y
12. #define TIM12_BASE            (D2_APB1PERIPH_BASE + 0x1800)
    6 ^; N  ]$ J! ]: z% k% d1 g3 z
13. #define TIM13_BASE            (D2_APB1PERIPH_BASE + 0x1C00)
    
14. #define TIM14_BASE            (D2_APB1PERIPH_BASE + 0x2000)
    # U# U/ X$ T; Z1 L% x
15. 
    
16. /*!< D2_APB1PERIPH 外设 */
    
17. #define TIM1_BASE             (D2_APB2PERIPH_BASE + 0x0000)
    " X- B6 A4 J: ]" m" _- J; s: m
18. #define TIM8_BASE             (D2_APB2PERIPH_BASE + 0x0400)
    
19. #define TIM15_BASE            (D2_APB2PERIPH_BASE + 0x4000)
    
20. #define TIM16_BASE            (D2_APB2PERIPH_BASE + 0x4400)
    
21. #define TIM17_BASE            (D2_APB2PERIPH_BASE + 0x4800)
    , L- Z& R; |( ~
22. 
    
23. #define TIM1                ((TIM_TypeDef *) TIM1_BASE)
    5 v- ~$ d4 K8 `
24. #define TIM2                ((TIM_TypeDef *) TIM2_BASE)
    
25. #define TIM3                ((TIM_TypeDef *) TIM3_BASE)
    
26. #define TIM4                ((TIM_TypeDef *) TIM4_BASE)
    
27. #define TIM5                ((TIM_TypeDef *) TIM5_BASE)
    
28. #define TIM6                ((TIM_TypeDef *) TIM6_BASE)
    
29. #define TIM7                ((TIM_TypeDef *) TIM7_BASE)
    
30. #define TIM8                ((TIM_TypeDef *) TIM8_BASE)
    4 e- i9 k1 L6 Z
31. #define TIM12               ((TIM_TypeDef *) TIM12_BASE)
    9 J& _8 A4 k# g  J  I! h
32. #define TIM13               ((TIM_TypeDef *) TIM13_BASE)
    
33. #define TIM14               ((TIM_TypeDef *) TIM14_BASE)
    
34. #define TIM15               ((TIM_TypeDef *) TIM15_BASE)
    - r6 A+ S/ B5 M- o9 ~1 w
35. #define TIM16               ((TIM_TypeDef *) TIM16_BASE)
    / @( a5 F1 ^3 q/ P* [- z! T
36. #define TIM17               ((TIM_TypeDef *) TIM17_BASE)

复制代码

/ J( }. r* [0 q0 ]; t* e我们访问TIM2的CR1寄存器可以采用这种形式：TIM2->CR1 = 0；
) p1 `7 `1 T0 D/ D2 r3 @
32.3.2 定时器句柄结构体TIM_HandleTypeDef
HAL库在TIM_TypeDef的基础上封装了一个结构体TIM_HandleTypeDef，定义如下：

5 H- R/ Y; B* O+ G

1. typedef struct
   
2. {
   
3.   TIM_TypeDef              *Instance;     /*!< Register base address             */
   0 _- C" t5 R" F5 v) x1 r
4.   TIM_Base_InitTypeDef     Init;          /*!< TIM Time Base required parameters */
   
5.   HAL_TIM_ActiveChannel    Channel;       /*!< Active channel                    */
   
6. 
   
7. /*!< DMA Handlers array This array is accessed by a @ref DMA_Handle_index */
   ! f7 l. N  a% U% x" B: f
8.   DMA_HandleTypeDef        *hdma[7];      
   ! J* u5 _9 |# k& R
9.   HAL_LockTypeDef          Lock;          /*!< Locking object                    */
   
10.   __IO HAL_TIM_StateTypeDef   State;      /*!< TIM operation state               */  
      S. J9 D% I' P. t2 l$ L+ W
11. }TIM_HandleTypeDef;

复制代码

这里重点介绍前四个参数，其它参数主要是HAL库内部使用的。

  TIM_TypeDef  *Instance
( z# k0 H1 R' w: e! g$ {
$ g0 D- W; ?3 {% h# S5 P1 i这个参数是寄存器的例化，方便操作寄存器，比如使能定时器的计数器。
& A+ s( Y( |  U% I. }
% \8 o) r3 x( g0 C1 l0 dSET_BIT(huart->Instance->CR1,  TIM_CR1_CEN)。

9 g9 W0 H$ x' `2 q' Y" m  TIM_Base_InitTypeDef  Init

这个参数是用户接触最多的，用于配置定时器的基本参数。
: a& K; `- ^8 u9 n- f/ c! T* z* _; P
TIM_Base_InitTypeDef结构体的定义如下：
  ]1 R7 z* R! Y& ?
  U9 g3 @# A0 ]4 c( L

1. typedef struct
   
2. {
   
3.   uint32_t Prescaler;      
   9 @2 D! z3 p0 w" L& p" m
4.   uint32_t CounterMode;   
   : c2 U2 ^) t  v6 W4 U8 S
5.   uint32_t Period;         
   ( Q0 o% k% B- N& k
6.   uint32_t ClockDivision;   
   
7.   uint32_t RepetitionCounter;
   
8.   uint32_t AutoReloadPreload;  
   
9. } TIM_Base_InitTypeDef;

复制代码

  成员Prescaler
' A! A; e" U6 _5 s用于设置定时器分频，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。
5 A" E6 [2 |( N, {" E* A4 Q0 b% Q! @. A
/ y/ \% K1 \. m4 n  q" x  成员CounterMode
' w) J( f: F  m/ m- d, j' z用于设置计数模式，向上计数模式、向下计数模式和中心对齐模式。

1. 
   
2. #define TIM_COUNTERMODE_UP                ((uint32_t)0x0000U)   /*!< Up counting mode */
   
3. #define TIM_COUNTERMODE_DOWN               TIM_CR1_DIR          /*!< Down counting mode */
   
4. #define TIM_COUNTERMODE_CENTERALIGNED1     TIM_CR1_CMS_0        /*!< Center-aligned counting mode 1 */
   - h! `% v2 R2 l
5. #define TIM_COUNTERMODE_CENTERALIGNED2     TIM_CR1_CMS_1        /*!< Center-aligned counting mode 2 */
   
6. #define TIM_COUNTERMODE_CENTERALIGNED3     TIM_CR1_CMS          /*!< Center-aligned counting mode 3 */

复制代码

  成员Period
用于设置定时器周期，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。

( V4 Q% v8 r. {6 }. i6 ]- d0 w  成员ClockDivision
用于指示定时器时钟 (CK_INT) 频率与死区发生器以及数字滤波器（ETR、TIx）所使用的死区及采样时钟 (tDTS) 之间的分频比。

1. 
   # d+ G: n, @. y* M/ V- l7 B
2. #define TIM_CLOCKDIVISION_DIV1       ((uint32_t)0x0000U)        /*!< Clock Division DIV1 */
   , S) F! a* h5 u
3. #define TIM_CLOCKDIVISION_DIV2       (TIM_CR1_CKD_0)            /*!< Clock Division DIV2 */
   
4. #define TIM_CLOCKDIVISION_DIV4       (TIM_CR1_CKD_1)             /*!< Clock Division DIV4 */

复制代码

  成员RepetitionCounter
2 \2 ^$ d/ W4 R1 y: Z5 ^0 f5 {用于设置重复计数器，仅TIM1和TIM8有，其它定时器没有。作用是每当计数器上溢/下溢时，重复计数器减1，当减到零时，才会生成更新事件，这个在生成PWM时比较有用。
" B$ r: t/ g* c0 ]& h' r  Y  _
. z/ Z7 x) `7 v  成员AutoReloadPreload
& f; A3 Z1 L8 f) f$ h用于设置定时器的ARR自动重装寄存器是更新事件产生时写入有效还是立即写入有效。如果使能了表示更新事件产生时写入有效，否则反之。

1. #define TIM_AUTORELOAD_PRELOAD_DISABLE   ((uint32_t)0x0000U)   /*!< TIMx_ARR register is not buffered */
   
2. #define TIM_AUTORELOAD_PRELOAD_ENABLE    (TIM_CR1_ARPE)        /*!< TIMx_ARR register is buffered */

复制代码

  HAL_TIM_ActiveChannel    Channel;

5 T+ ~. F/ a8 V: b+ N& c. n! @, v9 I用于设置定时器通道，比如TIM1和TIM8都是6个通道。
6 S+ ^3 A/ A- w; ^- }4 k% n1 B
; B! n' A( O1 X" A

1. typedef enum
   
2. {
   
3.   HAL_TIM_ACTIVE_CHANNEL_1        = 0x01U,    /*!< The active channel is 1     */
   $ C; I. F- I, _0 ~" N; q
4.   HAL_TIM_ACTIVE_CHANNEL_2        = 0x02U,    /*!< The active channel is 2     */
   9 i! ^# N6 R3 {7 S' e: }. V
5.   HAL_TIM_ACTIVE_CHANNEL_3        = 0x04U,    /*!< The active channel is 3     */   
   
6.   HAL_TIM_ACTIVE_CHANNEL_4        = 0x08U,    /*!< The active channel is 4     */
   ( k2 x# ?2 c9 I" y0 n* ~
7.   HAL_TIM_ACTIVE_CHANNEL_5        = 0x10U,    /*!< The active channel is 5     */
     `; x9 |; p) @+ J1 o
8.   HAL_TIM_ACTIVE_CHANNEL_6        = 0x20U,    /*!< The active channel is 6     */
   
9.   HAL_TIM_ACTIVE_CHANNEL_CLEARED  = 0x00U     /*!< All active channels cleared */   
   
10. }HAL_TIM_ActiveChannel;

复制代码

  u) C( R/ B2 {' G  DMA_HandleTypeDef        *hdma[7];
, V( l" Y2 M: q. ~' V$ f
用于关联DMA。

配置定时器参数，其实就是配置结构体TIM_HandleTypeDef的成员。

1. TIM_HandleTypeDef   TimHandle = {0};
   
2. 
   # L( A/ C- }- ^" p6 {3 m* y
3. /*
   4 U, k& }! i  b% i: N
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   2 X7 J& d' b* h& y5 [
6. TimHandle.Instance = TIMx;
   
7. TimHandle.Init.Prescaler         = usPrescaler;
   
8. TimHandle.Init.Period            = usPeriod;        
   3 T8 I3 N: T* F6 d' G
9. TimHandle.Init.ClockDivision     = 0;
   
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    1 N% N8 |9 t8 @2 g
11. TimHandle.Init.RepetitionCounter = 0;
    & k/ J$ i  x# `) _( N$ v
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    
14. {
    
15.         Error_Handler(__FILE__, __LINE__);
    8 C% _8 {% Q" p/ c+ o# Q1 c
16. }

复制代码

32.3.3 定时器输出比较结构体TIM_OC_InitTypeDef
此结构体主要用于定时器的输出比较，定义如下：
4 L. @% h6 a9 s' O

1. typedef struct
   
2. {                                 
   8 V6 e: |5 T5 h  O- r  @
3.   uint32_t OCMode;      
   
4.   uint32_t Pulse;      
   
5.   uint32_t OCPolarity;   
   9 H' u( P8 U7 p6 ?" [# H* _% _
6.   uint32_t OCNPolarity;   
   5 w( G$ y# F( h* k( q5 F6 z
7.   uint32_t OCFastMode;  
   
8.   uint32_t OCIdleState;   
   
9.   uint32_t OCNIdleState;  
   
10. } TIM_OC_InitTypeDef;  

复制代码

) c  i1 l3 s+ U+ _& J2 i下面将这几个参数一 一做个说明。
4 u" p; S8 B. J
  N) F: _/ e# t& k  OCMode
用于配置输出比较模式，支持的模式较多：

1. /*!< TIM Output timing mode */
   
2. #define TIM_OCMODE_TIMING                ((uint32_t)0x0000U)      
   4 J- @) k- C- t; {* Y
3. 
   # m3 P3 x1 x; h' _" d8 k
4. /*!< TIM Output Active mode */                          
   ( P" {+ F/ G6 ?7 q! \
5. #define TIM_OCMODE_ACTIVE                ((uint32_t)TIM_CCMR1_OC1M_0)
   
6. 
   , @3 Z+ _8 z( v
7. /*!< TIM Output Inactive mode */                       
   8 E4 m$ p0 y* z
8. #define TIM_OCMODE_INACTIVE              ((uint32_t)TIM_CCMR1_OC1M_1)           
   ' {+ v2 O3 e. J! C
9. 
   % j( h! ?; z: v9 e* w5 T; d
10. /*!< TIM Output Toggle mode */               
    
11. #define TIM_OCMODE_TOGGLE                 ((uint32_t)TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)         
      s9 x6 F. h1 h! ?8 ^' ^/ o: Y
12. 
    ( U- c8 c) |, f0 R+ ~6 p4 s% P* p
13. /*!< TIM PWM mode 1 */
    1 j8 Q' d2 ^. V
14. #define TIM_OCMODE_PWM1                   ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1)
    
15. 
    ! D! x) M2 _. U8 w$ V
16. /*!< TIM PWM mode 2 */                    
    
17. #define TIM_OCMODE_PWM2                    ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)   
    
18. 
    * M7 l% o* a* n( v; k: T* {. [
19. /*!< TIM Forced Active mode */   
    
20. #define TIM_OCMODE_FORCED_ACTIVE           ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0)         
    
21. 
    & \) D- w) Z3 X# p5 A2 e
22. /*!< TIM Forced Inactive mode */            
    5 N: F3 q1 t# F+ c6 E; I7 f
23. #define TIM_OCMODE_FORCED_INACTIVE         ((uint32_t)TIM_CCMR1_OC1M_2)                                       
    
24. 
    
25. /*!< TIM Rettrigerrable OPM mode 1 */  
    
26. #define TIM_OCMODE_RETRIGERRABLE_OPM1      ((uint32_t)TIM_CCMR1_OC1M_3)   
    9 G9 z5 T5 h$ Z! h' e1 R
27. 
    , m0 B4 M& b) _9 d' a
28. /*!< TIM Rettrigerrable OPM mode 2 */                                       
    
29. #define TIM_OCMODE_RETRIGERRABLE_OPM2      ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0)   
    
30. 
    
31. /*!< TIM Combined PWM mode 1 */                     
    
32. #define TIM_OCMODE_COMBINED_PWM1           ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_2)     
    ( p9 y! }2 }/ r& p- D; q
33. 
    1 |8 k8 R1 T( ^5 ~3 J  `
34. /*!< TIM Combined PWM mode 2 */                  
    
35. #define TIM_OCMODE_COMBINED_PWM2           ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0 | TIM_CCMR1_OC1M_2)   
    
36. 
    
37. /*!< TIM Asymetruc PWM mode 1 */  
    8 _8 D: P  f" C, S, l( ?
38. #define TIM_OCMODE_ASSYMETRIC_PWM1         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2)  
    6 V0 o0 ]# C: a% e9 @9 l6 O3 k
39. 
    5 E0 k9 Q; `7 K! B. Z
40. /*!< TIM Asymetruc PWM mode 2 */   
    
41. #define TIM_OCMODE_ASSYMETRIC_PWM2         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M)   

复制代码

1 l, n, M' {4 n! C$ ]- F; m  Pulse
  H2 Q0 [4 X% g, `* V可用于设置占空比，对应定时器的CCR寄存器，32位的TIM2和TIM5范围是0到0xFFFFFFFF。

  OCPolarity
( \9 f0 u$ |; I3 E7 o* k设置输出极性，可选高电平或低电平有效。

1. 
   
2. #define TIM_OCPOLARITY_HIGH                ((uint32_t)0x0000U)
   
3. #define TIM_OCPOLARITY_LOW                 (TIM_CCER_CC1P)

复制代码

  OCNPolarity
* k. T' F7 c" P互补输出极性设置，可选高电平或者低电平有效。

  I% i( y1 q2 g* f1 z& ^

1. #define TIM_OCNPOLARITY_HIGH               ((uint32_t)0x0000U)
   8 o* p" u* a$ g# H; f' y1 }
2. #define TIM_OCNPOLARITY_LOW                (TIM_CCER_CC1NP)

复制代码

8 h" p) Z+ n; ?: m1 |6 n; U) s  OCFastMode
快速输出模式使能，仅OCMode配置为PWM1或者PWM2模式时才有意义。

1. 
   
2. #define TIM_OCFAST_DISABLE                ((uint32_t)0x0000U)
   $ [' K& p+ t' f' W0 Z8 h
3. #define TIM_OCFAST_ENABLE                 (TIM_CCMR1_OC1FE)

复制代码

  OCIdleState
. |$ z3 z) f5 x" t& Y空闲状态时，设置输出比较引脚的电平状态。
% [; h1 J$ j1 a

1. #define TIM_OCIDLESTATE_SET                (TIM_CR2_OIS1)
     F2 C* Q. N/ k+ g$ W# s
2. #define TIM_OCIDLESTATE_RESET              ((uint32_t)0x0000U)

复制代码

  OCNIdleState
空闲状态时，设置互补输出引脚的电平状态。
: y9 [; o. _  A0 z$ C

1. #define TIM_OCNIDLESTATE_SET               (TIM_CR2_OIS1N)
   ; i7 |3 p0 V. a% }( i, N
2. #define TIM_OCNIDLESTATE_RESET             ((uint32_t)0x0000U)

复制代码

5 F# q* B( M* f. E3 _+ Y32.3.4 定时器输入捕获结构体TIM_IC_InitTypeDef
此结构体主要用于定时器的输入捕获，定义如下：
2 r6 r5 G( U0 p) V: q- H

1. 
   
2. typedef struct
   
3. {                                 
   4 j$ I6 s7 U1 x, |& S# w# B5 L
4.   uint32_t ICPolarity;   
   
5.   uint32_t ICSelection;
   9 J8 P& O7 x2 n( x; i
6.   uint32_t ICPrescaler;
   8 I' x. E4 O! U1 H& T8 ?
7.   uint32_t ICFilter;   
   
8. } TIM_IC_InitTypeDef;

复制代码

下面将这几个参数一 一做个说明。

) `) p! w! @& J' h) A( K  ICPolarity
输入触发极性，可以选择上升沿，下降沿或者双沿触发。

" R: A- w. I3 f% I  N+ n( ]

1. #define  TIM_ICPOLARITY_RISING             TIM_INPUTCHANNELPOLARITY_RISING
   
2. #define  TIM_ICPOLARITY_FALLING            TIM_INPUTCHANNELPOLARITY_FALLING
   
3. #define  TIM_ICPOLARITY_BOTHEDGE           TIM_INPUTCHANNELPOLARITY_BOTHEDGE

复制代码

5 n7 l8 c9 s; e' ?  ICSelection
输入捕获通道选择，可以选择直接输入（即CC1选择TI1，CC2选择TI2等），间接输入（CC1选择TI2，CC3选择TI4等）或者TRC。
  Q; O$ s$ T0 E6 L" {+ E

1. 
   
2. #define TIM_ICSELECTION_DIRECTTI       (TIM_CCMR1_CC1S_0)   
     u& j  R) G& @) v1 P+ I  N
3. #define TIM_ICSELECTION_INDIRECTTI     (TIM_CCMR1_CC1S_1)  
   
4. #define TIM_ICSELECTION_TRC            (TIM_CCMR1_CC1S)   

复制代码

  ICPrescaler
: S- t7 Y% S" t0 K输入捕获分频，表示每捕获1，2，4或8个事件后表示一次捕获。

1. #define TIM_ICPSC_DIV1       ((uint32_t)0x0000U)                 
   3 q( F5 H2 D/ q" s
2. #define TIM_ICPSC_DIV2       (TIM_CCMR1_IC1PSC_0)   
   
3. #define TIM_ICPSC_DIV4       (TIM_CCMR1_IC1PSC_1)   
   2 u/ |# V  v, o9 m% ?1 C  g
4. #define TIM_ICPSC_DIV8       (TIM_CCMR1_IC1PSC)

复制代码

3 _2 c2 f$ Q" M% M1 K. ]9 t9 T7 z5 n2 b  ICFilter
输入捕获滤波器，可以定义采样频率和多少个连续事件才视为有效的触发，参数范围0到15。具体定义如下，其中fCK_INT表示定时器时钟，fDTS表示死区时间采样率，N表示这么多个事件代表一次有效边沿。

3 P- x/ u  T# P' ?9 y% h, m

1. 0000：无滤波器，按 fDTS 频率进行采样
   1 K2 R( v- c. T# V1 ~
2. 0001： fSAMPLING=fCK_INT， N=2
   
3. 0010： fSAMPLING=fCK_INT， N=4
   
4. 0011： fSAMPLING=fCK_INT， N=8
   
5. 0100： fSAMPLING=fDTS/2， N=6
   / G' x7 @8 I- q8 Z4 p4 E' d5 S, t0 F
6. 0101： fSAMPLING=fDTS/2， N=8
   
7. 0110： fSAMPLING=fDTS/4， N=6
   * x: N6 g% Q1 W  ~% ~
8. 0111： fSAMPLING=fDTS/4， N=8
   
9. 1000： fSAMPLING=fDTS/8， N=6
   1 o7 o1 d1 ~. x, b6 I9 e" H' v
10. 1001： fSAMPLING=fDTS/8， N=8
    , a/ B( h4 L/ G# B6 j
11. 1010： fSAMPLING=fDTS/16， N=5
    2 L1 U- m8 X* F$ p' k/ e6 _- u
12. 1011： fSAMPLING=fDTS/16， N=6
    2 k7 L- A" ^4 ]+ n: q7 C
13. 1100： fSAMPLING=fDTS/16， N=8
    3 v7 K/ L# L; _3 \+ z* x
14. 1101： fSAMPLING=fDTS/32， N=5
    ! `& f2 y0 ]: b+ W( L( a5 v2 a2 L
15. 1110： fSAMPLING=fDTS/32， N=6

复制代码

- \) b# u0 @; V$ {  b+ ^32.3.5 定时器的底层配置（GPIO，时钟，中断等）
) s7 C+ F' k& C* S0 LHAL库有个自己的底层初始化回调函数，比如调用函数HAL_TIM_Base_Init就会调用HAL_TIM_Base_MspInit，此函数是弱定义的。

& v1 C. c# n: d$ l1 S

1. __weak void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
   & K! N6 B5 s& a7 l2 p* R% @1 j
2. {
   
3.   /* Prevent unused argument(s) compilation warning */
   
4.   UNUSED(htim);
   7 E& I5 O( x. D) @7 [$ X
5.   /* NOTE : This function Should not be modified, when the callback is needed,
   
6.             the HAL_TIM_Base_MspDeInit could be implemented in the user file
   
7.    */
   6 r0 T+ [6 F8 [' J& T8 g! I9 E
8. }

复制代码

  g% `  J  Z2 |' b1 ~& q/ }0 U用户可以在其它的C文件重定向，并将相对的底层初始化在里面实现。对应的底层复位函数HAL_TIM_Base_DeInit是在函数HAL_TIM_Base_MspDeInit里面被调用的，也是弱定义的。
  ?( C, P9 g) z0 |4 Q/ M5 a& C% @
8 [& Z7 f3 F$ M, q0 C  e当然，用户也可以自己初始化，不限制必须在两个函数里面实现。

7 g8 W  d+ J) L" O8 M6 Q5 H定时器外设的基本参数配置完毕后还不能使用，还需要配置GPIO、时钟、中断等参数，比如下面配置TIM1使用PA8做PWM输出。
8 j9 O7 P$ l% W' g" n

1. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
   
2. {
   
3.   GPIO_InitTypeDef   GPIO_InitStruct;
   
4. 
   3 ~8 n. T5 C- y8 {7 c; w5 C
5.   /* 使能TIM1时钟 */
   
6.   __HAL_RCC_TIM1_CLK_ENABLE ();
   
7. 
   & j% h7 }; V. U( ]5 L) `
8.   /* 使能GPIOA时钟 */
   
9.   __HAL_RCC_GPIOA_CLK_ENABLE ();
   
10. 
    
11.   /* 设置TIM1使用PA8做PWM输出引脚，将其配置为输出，推挽，复用模式 */
    
12.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    ( F! @3 T* n# v# T9 o5 G
13.   GPIO_InitStruct.Pull = GPIO_PULLUP;
    
14.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    4 i, W1 v; ^- i& o
15. 
    4 C- ]7 x# Y" g, S, H! d* I: a
16.   GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
    
17.   GPIO_InitStruct.Pin = GPIO_PIN_8;
    5 u8 F! e- ^/ w# f
18.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
19. 
    7 N7 ~+ [' Z1 t6 |" S, Z4 T
20. }

复制代码

总结下来就是以下几点：
: h8 k2 C+ L- y% ]8 I* q5 ]
  配置TIM时钟。
  配置TIM所用到引脚和对应的GPIO时钟。
  如果用到定时器中断，还需要通过NVIC配置中断。
: Q, {- {. b' S) W% N7 R9 t  如果用到DMA，还要配置DMA。
! P9 V  d8 V7 n" E. G! D关于这个底层配置有以下几点要着重说明下：

  定时器所使用引脚的复用模式选择已经被HAL库定义好，放在了stm32h7xx_hal_gpio_ex.h文件里面。比如TIM1有一个复用，
5 g! M/ f0 Y- @6 U#define GPIO_AF1_TIM1      ((uint8_t)0x01)  /* TIM1 Alternate Function mapping */
1 e+ d$ s" G1 E" j4 w( D但是却有4个输出通道，每个通道都有几个支持的输出引脚：

1. 
   3 h" q6 L! C+ A- B- E1 [2 J
2. TIM1_CH1,  PA8   PE9    PK1
   + x: m5 w, F! |& ?. k( {& F
3. TIM1_CH2,  PA9   PE11
   7 S) U! P/ N8 N
4. TIM1_CH3,  PA10  PE13   PJ9
   
5. TIM1_CH4,  PA11  PE14   PJ11

复制代码

8 X- a" N, N7 J$ J7 L+ c: M具体使用哪个，配置对应引脚的复用即可：
2 Z; r+ Z; N9 O9 g

8 u9 b& s' o# A4 Z1 K2 A9 e  r32.3.6 定时器的状态标志清除问题
下面我们介绍__HAL_TIM_GET_FLAG函数。这个函数用来检查定时器标志位是否被设置。
- Q7 |+ W6 h. U6 v: @/ ?
( V) O! D  D  E3 `9 S2 H  F+ K

1. /** @brief  Check whether the specified TIM interrupt flag is set or not.
   4 B$ P- e! F& @. A! ?( t" r
2.   * @param  __HANDLE__: specifies the TIM Handle.
   9 Y" J, Z" w) w; t/ k
3.   * @param  __FLAG__: specifies the TIM interrupt flag to check.
   ! K% d, }8 `8 ~0 n/ O; j
4.   *        This parameter can be one of the following values:
   
5.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag
   
6.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
   ; F9 ?  b5 b" V' a+ V3 t, ~" Y
7.   *            @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
   
8.   *            @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
   2 B- A  f* [" B7 D4 S
9.   *            @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
   
10.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag
    % E1 ?3 x: u3 D; j8 t( m# P
11.   *            @arg TIM_FLAG_CC6: Compare 6 interrupt flag
    
12.   *            @arg TIM_FLAG_COM:  Commutation interrupt flag
    - S' g) v$ p  _" ?6 P# s0 Q
13.   *            @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
    
14.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   
    0 }# i& G# _3 I! c% `! A
15.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    : C( F: P2 i  ^
16.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
    
17.   *            @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
    
18.   *            @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
    
19.   *            @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
    ' d7 b$ f% G5 I! O, z
20.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    9 L+ ^, U0 ~/ `
21.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    
22.   */
    ) w5 \; W  P) i, U2 x' w8 G2 n
23. #define __HAL_TIM_GET_FLAG(__HANDLE__, __FLAG__)   (((__HANDLE__)->Instance->SR &(__FLAG__)) == (__FLAG__))

复制代码

前5个是比较常用的中断标志。

  TIM_FLAG_UPDATE
0 p; m/ S, K: q: I; y* N+ A定时器更新标准，配置一个周期性的定时器中断要用到。
! W; H8 U0 l; _% ?  e6 g. p% U
     TIM_FLAG_CC1
: A- G8 N/ c: u1 w' m- L' @TIM_FLAG_CC2

% t# t# T* i1 K) ZTIM_FLAG_CC3
& s( m3 g5 k' L( U
TIM_FLAG_CC4

捕获/比较标志，配置了捕获/比较中断要用到。
* e( P  L8 s( @  b! k# b
* D* h* x0 E& X与标志获取函数__HAL_TIM_GET_FLAG对应的清除函数是__HAL_TIM_CLEAR_FLAG：

1. /** @brief  Clear the specified TIM interrupt flag.
   
2.   * @param  __HANDLE__: specifies the TIM Handle.
   ( d- }! t+ @; j' N. n7 h  N
3.   * @param  __FLAG__: specifies the TIM interrupt flag to clear.
   # a" Y8 v! I# P6 l# x( w3 O& U; c
4.   *        This parameter can be one of the following values:
   . K5 O: A& ]- D4 m6 m9 h
5.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag
   / s# i# n$ B3 n/ a2 Z3 b% u& H
6.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
   $ y2 G: z, j4 t% z
7.   *            @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
   0 ~7 ~4 B7 O" N, ?9 t
8.   *            @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
   
9.   *            @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
   5 f1 T7 X4 u- O: P; ~0 v
10.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag
    
11.   *            @arg TIM_FLAG_CC6: Compare 6 interrupt flag
    1 v& [( C/ I( }! T7 t! r1 P- _9 I
12.   *            @arg TIM_FLAG_COM:  Commutation interrupt flag
    
13.   *            @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
    # h$ n  |% G$ ~
14.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   
    
15.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    
16.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
    
17.   *            @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
    / y! {( \5 q! G4 C4 h7 ^; \. W
18.   *            @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
    
19.   *            @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
    
20.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    
21.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    ; o+ ~6 U$ P, K% h
22.   */
    ' E2 x+ [) `$ z! S8 e. ]' L
23. #define __HAL_TIM_CLEAR_FLAG(__HANDLE__, __FLAG__)       ((__HANDLE__)->Instance->SR = ~(__FLAG__))

复制代码

清除标志函数所支持的参数跟获取函数是一 一对应的。除了这两个函数，还是定时器的中断开启和中断关闭函数用的也比较多。
% h4 i1 \, u( Y' O. U
1 K; g  q& j( W

1. /** @brief  Enable the specified TIM interrupt.
   / B, f# Z/ z6 Z6 l
2. * @param  __HANDLE__: specifies the TIM Handle.
   
3. * @param  __INTERRUPT__: specifies the TIM interrupt source to enable.
   
4. *          This parameter can be one of the following values:
   
5. *            @arg TIM_IT_UPDATE: Update interrupt
   
6. *            @arg TIM_IT_CC1:   Capture/Compare 1 interrupt
   & r- l5 X. k. X0 \4 r( H* r( \
7. *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt
   ' p+ y6 ]+ ?+ k. H# k# E7 b0 Z3 I. e
8. *            @arg TIM_IT_CC3:  Capture/Compare 3 interrupt
   / j+ O5 z" Z% r( A" ~
9. *            @arg TIM_IT_CC4:  Capture/Compare 4 interrupt
   7 l! |* G5 k* y2 ]: l
10. *            @arg TIM_IT_COM:   Commutation interrupt
    
11. *            @arg TIM_IT_TRIGGER: Trigger interrupt
    2 G- ]3 J* s  [+ T' r2 A5 @6 T" S
12. *            @arg TIM_IT_BREAK: Break interrupt
    ( K" h! T' j& q* Y
13. * @retval None
    
14. */
    
15. #define __HAL_TIM_ENABLE_IT(__HANDLE__, __INTERRUPT__)  ((__HANDLE__)->Instance->DIER |= (__INTERRUPT__))
    
16. 
    - |* j( O. D6 ~9 P: R
17.   /** @brief  Disable the specified TIM interrupt.
    
18.   * @param  __HANDLE__: specifies the TIM Handle.
    
19.   * @param  __INTERRUPT__: specifies the TIM interrupt source to disable.
    " j: H: ]6 p8 u. J" c- k% T
20.   *          This parameter can be one of the following values:
    8 c# M% n& W* B$ {
21.   *            @arg TIM_IT_UPDATE: Update interrupt
    6 @$ @$ ~# o' a$ N0 f! v
22.   *            @arg TIM_IT_CC1:   Capture/Compare 1 interrupt
    & m0 A' V1 o* Y( J, {2 P# B
23.   *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt
    - V3 Y4 `9 k- l4 z# n
24.   *            @arg TIM_IT_CC3:  Capture/Compare 3 interrupt
    0 N0 m* O( P4 \2 V9 N
25.   *            @arg TIM_IT_CC4:  Capture/Compare 4 interrupt
    " v2 T. l; d  b& {0 Z" h5 q& O. I
26.   *            @arg TIM_IT_COM:   Commutation interrupt
    6 m( q8 q/ D5 }9 X
27.   *            @arg TIM_IT_TRIGGER: Trigger interrupt
    
28.   *            @arg TIM_IT_BREAK: Break interrupt
    5 t* \& W  t4 g' r% c
29.   * @retval None
    / k' [0 U+ M/ F! q
30.   */
    
31. #define __HAL_TIM_DISABLE_IT(__HANDLE__, __INTERRUPT__)   ((__HANDLE__)->Instance->DIER &= ~(__INTERRUPT__))

复制代码

1 d+ ^( X7 a/ C1 z( ]- c常用的也是前五个参数，1个定时器更新中断以及4个CC中断 。

注意：操作定时器的寄存器不限制必须要用HAL库提供的API，比如要操作寄存器CR1，直接调用TIM1->CR1操作即可。

/ O2 m  J8 z9 Z5 i! n32.3.7 定时器初始化流程总结
" l. j1 }5 m! v. S2 o使用方法由HAL库提供：

% I, T0 l$ ^- ~. g( V  第1步：通过下面几个函数配置定时器工作在相应的模式

; _- Y7 u4 A6 R& _( J  HAL_TIM_Base_Init
简单的定时器时基础功能

8 w9 ^2 W* k; k& B0 {$ m  HAL_TIM_OC_Init 和 HAL_TIM_OC_ConfigChannel
配置定时器产生输出比较信号
+ k9 b1 V3 S- P& ^
' V2 S5 @3 b0 c% c; d' \  HAL_TIM_PWM_Init 和 HAL_TIM_PWM_ConfigChannel
! n5 {: N+ N. N配置定时器产生PWM信号
- P# c# B! z8 j  A- L+ U
  HAL_TIM_IC_Init 和 HAL_TIM_IC_ConfigChannel
* x6 e  D& P6 W9 r' J$ C配置定时器测量外部信号
# C  M% i0 w0 D
  HAL_TIM_OnePulse_Init 和 HAL_TIM_OnePulse_ConfigChannel
配置定时器工作在单脉冲模式

" \/ t9 Y1 j8 m7 X# d( M( C  HAL_TIM_Encoder_Init
8 P2 V! V; @$ ~& ^$ V) N5 g6 X( A配置定时器使用编码器接口
. X3 A; ^# p4 X" O4 N0 w) i0 c: M
: h6 `+ Z; y" {5 _9 p$ r( I  第2步：定时器几个常用功能的底层初始化API，这个里面需要用户自己填

第1步里面的几个函数会调用下面的API。

  定时器基本功能 : HAL_TIM_Base_MspInit()
  输入捕获 : HAL_TIM_IC_MspInit()
  输出比较 : HAL_TIM_OC_MspInit()
6 H* |9 L/ r3 R6 Q& O: Y  PWM输出 : HAL_TIM_PWM_MspInit()
  单脉冲输出模式: HAL_TIM_OnePulse_MspInit()
# c" ^8 N  c( e% f7 m  @9 ~7 B  编码器模式 : HAL_TIM_Encoder_MspInit()
  第3步：底层初始化具体实现
3 G8 v" S+ |( |
, n) N3 Y# s3 n, K  M4 o第2步中函数的具体实现。
) M9 x3 @0 j3 v8 v; _6 y
  使用函数__HAL_RCC_TIMx_CLK_ENABLE()使能定时器时钟。
  使用函数__HAL_RCC_GPIOx_CLK_ENABLE()使能定时器使用到的引脚时钟。
  使用函数HAL_GPIO_Init()配置GPIO的复用功能。
  如果使能了定时器中断，调用函数HAL_NVIC_SetPriority和HAL_NVIC_EnableIRQ配置。
; h/ x2 {: d9 b  如果使能了DMA，还需要做DMA的配置。
  定时器默认使用APB时钟，如果使用外部时钟，调用函数HAL_TIM_ConfigClockSource可以配置。
  第4步：启动定时器外设

  定时器基础功能:
4 k" L" ]9 L% x$ `% jHAL_TIM_Base_Start()

HAL_TIM_Base_Start_DMA()
3 w* g; R5 r2 e( u  C0 n
0 r2 a: y/ o! C5 I3 n: bHAL_TIM_Base_Start_IT()
! u# _+ M) e7 \/ O
6 g3 {& Y  p& L- J  输入捕获 :
HAL_TIM_IC_Start()

HAL_TIM_IC_Start_DMA()
6 e3 T( z0 B, P( j# Q1 T" I" `% w
HAL_TIM_IC_Start_IT()

  输出比较 :
3 g  z, F: j7 c- qHAL_TIM_OC_Start()

: C$ N) S* o* S) u8 j: |HAL_TIM_OC_Start_DMA()

HAL_TIM_OC_Start_IT()
, \: W# ]2 o9 z7 k4 T
  PWM输出：
% f& N" Q2 i7 {4 r( q" _" \HAL_TIM_PWM_Start()
9 ]' J4 s  M2 C; D
HAL_TIM_PWM_Start_DMA()

+ Y/ H5 i+ w: BHAL_TIM_PWM_Start_IT()
. {/ ]" n/ D2 k, p4 J7 T0 T* m: z
8 g) ^: K3 h" Z" z2 [9 l% Q* S  单脉冲模式：
HAL_TIM_OnePulse_Start()
' Z: g# T6 H6 T
HAL_TIM_OnePulse_Start_IT().

1 X; A# P: e+ j7 n6 f# j: y' l  编码器模式：
( l) E; U7 d5 A" wHAL_TIM_Encoder_Start()

HAL_TIM_Encoder_Start_DMA()
$ [- g. P* O6 y4 {4 V
HAL_TIM_Encoder_Start_IT().
" a' n+ k8 j$ w: K! z
) W0 b2 n: B; b; g  第5步：定时器的DMA突发使用下面两个函数

  HAL_TIM_DMABurst_WriteStart()
  HAL_TIM_DMABurst_ReadStart()
定时器常用的功能，通过上面这几步即可实现。

32.4 源文件stm32h7xx_hal_tim.c
此文件涉及到的函数非常多，这里把几个常用的函数做个说明：

  HAL_TIM_Base_Init
9 C$ e. m/ i& k5 P; ~2 m3 j% V  HAL_TIM_Base_Start
; q4 A4 k. H: [% V  HAL_TIM_PWM_Init
- \- g' k1 ~* a7 `+ J  HAL_TIM_PWM_ConfigChannel
: C, ^) n2 c& j  HAL_TIM_PWM_Start
  HAL_TIM_IC_Init
  HAL_TIM_IC_ConfigChannel
7 D+ }/ @% J) J$ i% O  HAL_TIM_IC_Start_IT
. H8 ?" d2 q* o1 m( J) u+ o  HAL_TIM_OC_Init
  HAL_TIM_OC_ConfigChannel
  HAL_TIM_OC_Start
! u2 j; G1 |2 u9 [% P- w- S32.4.1 函数HAL_TIM_Base_Init
函数原型：

1. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   7 a" o: |& C: d! O, N$ X: z* O
2. {
   
3.   /* 检测是否是有效句柄 */
   : e# `- P" s8 r1 g' U8 [
4.   if(htim == NULL)
   
5.   {
   
6.     return HAL_ERROR;
   
7.   }
   ( ~2 ?: Q7 W6 ^- f/ A# ~
8. 
   0 s* d  A9 d2 A) ~
9.   /* 检测参数 */
   5 |1 i. Q" P: b* q( j- F! |
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    + x6 _+ l0 A" B
13. 
    
14.   if(htim->State == HAL_TIM_STATE_RESET)
    
15.   {
    
16.     /* 默认取消锁 */
    
17.     htim->Lock = HAL_UNLOCKED;
    3 S- d0 D) {- h: D9 R' [
18.     /* 初始化底层硬件 : GPIO, CLOCK, NVIC */
    
19.     HAL_TIM_Base_MspInit(htim);
    
20.   }
    
21. 
    
22.   /* 设置TIM状态 */
      \) Q0 c" t: I, ?1 v% A
23.   htim->State= HAL_TIM_STATE_BUSY;
    
24. 
    ( e( g; f  F7 n
25.   /* 基本参数配置 */
    
26.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
27. 
    
28.   /* 设置TIM就绪 */
    2 k; P6 C. O5 J7 r
29.   htim->State= HAL_TIM_STATE_READY;
    : b& d- x; x; h3 l
30. 
    
31.   return HAL_OK;
    
32. }

复制代码

函数描述：

& i. T( d: s  S此函数用于初始化定时器用于PWM。
$ j) a+ [* v! q% V. |8 ]! g6 K2 d
函数参数：
3 S; @' s9 u# @
8 W4 _2 d% Y  l6 e1 H  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
8 ?" B( |  D/ ~" I& f0 \! _3 ^注意事项：

( b4 R9 n( g* o0 I' n1 ~函数HAL_TIM_Base_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
5 V$ }, n$ T9 K; A3 A如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
/ p6 V- F0 {# T' ^5 m6 B对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_TIM_STATE_RESET  = 0x00U。
3 C: K" i# T' t
9 N* S% e2 ~7 N3 `3 E3 z解决办法有三：
) \6 Q+ a4 u$ a0 q$ Z- \3 v
: m2 w: Q7 L3 ?7 c# K9 F方法1：用户自己初始定时器和涉及到的GPIO等。
  Y: ^' M9 }9 b6 @) j, h
方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
! z# |: A) `  I8 \: r
方法3：下面的方法
" u1 g+ ]1 f* ^/ [+ v) \; \+ ?; ~# _, N
2 `: b! ^3 v' _$ w/ k* m

1. if(HAL_TIM_Base_DeInit(&TimHandle) != HAL_OK)
   2 s, ^' o! e, D6 x% P- Y2 c' j
2. {
   
3.     Error_Handler();
   
4. }  
   5 R' I/ Q+ q. Y+ R( }
5. if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
   
6. {
   1 O% v! f; \6 f3 U
7.     Error_Handler();
   
8. }

复制代码

* @; s( Q4 i  ^+ p6 }使用举例：
$ V# J$ y* R8 U
- N: @1 m( o  h

1. TIM_HandleTypeDef   TimHandle = {0};
   : g. ^, O- z1 b( _% M5 _
2. 
   + @4 |. J/ W/ Y; Q+ w9 B9 T
3. /*
   
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   $ _$ M% V$ t2 I* @) s4 ?0 y2 _# i
5. */
   : R7 t4 D; k0 `% C+ T
6. TimHandle.Instance = TIMx;
   % C, a" T0 [! D/ [
7. TimHandle.Init.Prescaler         = usPrescaler;
   
8. TimHandle.Init.Period            = usPeriod;        
   
9. TimHandle.Init.ClockDivision     = 0;
   $ R+ _# Q  }5 H; _8 ?- W5 ]! T
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    ! f# G4 }: z' w2 B
11. TimHandle.Init.RepetitionCounter = 0;
    ) I& l0 K# D* D
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    " F. _/ B( Y$ A1 F7 h/ l: y
14. {
    . L. `9 q, g5 N' e7 W3 u+ O$ O
15.         Error_Handler(__FILE__, __LINE__);
    
16. }

复制代码

32.4.2 函数HAL_TIM_Base_Start
2 t* J4 p* J" O函数原型：

; f- R2 G- w& R( w* S4 o

1. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   
2. {
   
3.   /* 检测参数状态 */
   
4.   assert_param(IS_TIM_INSTANCE(htim->Instance));
   
5. 
   
6.   /* 设置定时器状态 */
   . A; Z7 P( D7 Q8 K2 l. Y! d
7.   htim->State= HAL_TIM_STATE_BUSY;
   6 u& n' y9 j5 O* P7 G
8. 
   % U# L1 K/ o, x3 s6 \
9.   /* 使能定时器 */
   * O4 S- O/ ~( l6 B( Z' b
10.   __HAL_TIM_ENABLE(htim);
    , F. }: A' ?; o3 I# w; W
11. 
    8 n  y1 w& j# |5 d4 G' t
12.   /* 设置定时器状态 */
    
13.   htim->State= HAL_TIM_STATE_READY;
    
14. 
    
15.   /* 返回HAL_OK */
    7 ~3 U% u1 h( Z$ w
16.   return HAL_OK;
    
17. }

复制代码

函数描述：

3 P8 R- C8 n& Z此函数比较简单，调用函数HAL_TIM_Base_Init配置了基础功能后，启动定时器。

函数参数：

" j  {/ a1 E) Q  第1个参数是TIM_HandleTypeDef类型结构体指针变量。
2 I5 z; J% H4 v: e  返回值，固定返回HAL_OK，表示初始化成功。
使用举例：

4 H& J0 T$ J; b

1. TIM_HandleTypeDef   TimHandle = {0};
   
2. 
   
3. /*
   , Z( l. b9 u) I% C" J! o
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   
6. TimHandle.Instance = TIMx;
   9 v5 k4 j) |! d
7. TimHandle.Init.Prescaler         = usPrescaler;
   
8. TimHandle.Init.Period            = usPeriod;        
   
9. TimHandle.Init.ClockDivision     = 0;
   
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    
11. TimHandle.Init.RepetitionCounter = 0;
    
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    
14. {
    ' z5 x/ L! V0 d! K
15.         Error_Handler(__FILE__, __LINE__);
    
16. }
    
17. 
    - W" u! c* T, ~, f6 }! g- j% R, ^
18. /* 启动定时器 */
    , s/ q+ m. n! i9 P0 D
19. if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
    ' Q1 y4 R; N1 |# t
20. {
    
21. Error_Handler(__FILE__, __LINE__);
    2 A* I$ P0 k8 I5 m# ]: z$ q0 b( `
22. }

复制代码

- Z+ T, ]  H8 |- k32.4.3 函数HAL_TIM_PWM_Init
  P! W  Q7 S) o9 D0 ^& Y函数原型：
) y' a" {) F  G. r4 n% p. U; u
) _8 C: _4 w* b& y

1. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
   
2. {
   
3.   /* 检查句柄是否有效 */
   % T0 @4 ?. T+ y" i" H% k
4.   if(htim == NULL)
   
5.   {
   
6.     return HAL_ERROR;
   6 e3 I$ Z( V' Z, h5 G3 y2 B0 B
7.   }
   : n: x" d! r7 R1 P
8. 
   8 C% Q% U1 B: ^+ P8 I; K
9.   /* 检测参数 */
   4 z# C3 p/ E" f/ T
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    4 D0 l" D+ R$ K6 g% T
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
13. 
    
14.   if(htim->State == HAL_TIM_STATE_RESET)
    , ^& u2 z4 s7 I+ x7 P
15.   {
    
16.     /* 默认取消锁 */
    8 v3 q' M5 Z, ?) K: N4 _( k
17.     htim->Lock = HAL_UNLOCKED;
    
18. 
    * s6 T- d+ F: I! J
19.     /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    & ?. H6 h: E! Y/ Z7 h  z; A  q  _
20.     HAL_TIM_PWM_MspInit(htim);
    
21.   }
    
22. 
    9 D" K- |" G5 v# m# A; n' E) u
23.   /* 设置定时状态 */
    
24.   htim->State= HAL_TIM_STATE_BUSY;
    
25. 
    
26.   /* 配置定时器用于PWM */  
    
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    ' y3 B: j8 Z- i- R4 Q" L$ A* ?# P
28. 
    
29.   /* 设置定时器状态 */
    
30.   htim->State= HAL_TIM_STATE_READY;
    ' v$ W0 r9 j- ^$ W" @% Y% k
31. 
    
32.   return HAL_OK;
    
33. }

复制代码

函数描述：
3 v, ]+ k3 y, h% H* ^
此函数用于初始化定时为PWM方式。
, E3 g/ ]) n; t. ^: r3 u
函数参数：
9 b4 H' p' i$ C4 m4 _; W% f, V
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
+ t+ j* e& s. }% M2 a. {. G  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：
$ C: D( n  S! F2 \& [/ V
5 V7 ^! Z' w# w9 \) |- v9 i  X% z函数HAL_TIM_PWM_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
5 I# w5 d. ?+ X/ T如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_TIM_STATE_RESET  = 0x00U。

/ A& }3 Z1 W2 N+ k7 P0 u解决办法有三：

, S8 K. v2 |9 c' N: c4 T2 I; b  S方法1：用户自己初始定时器和涉及到的GPIO等。
1 s; w$ o4 y% e: C/ [/ O+ t
% x; T6 K. U8 q: l* z方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
( l: U9 K+ i- B  u' W  H8 b
方法3：下面的方法
" c( s* b) c0 R6 ?4 ]2 ]

1. if(HAL_TIM_PWM_DeInit(&TimHandle) != HAL_OK)
   3 H+ N6 c" i7 f: p7 x
2. {
   
3.     Error_Handler();
   
4. }  
   
5. if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
   
6. {
   
7.     Error_Handler();
   
8. }

复制代码

使用举例：
: m0 U& p& D( t$ B

1. TIM_HandleTypeDef  TimHandle = {0};
   9 L4 X5 ~% ?/ @1 z6 l# i0 B
2. 
   / h! g5 C- f0 [8 ^3 Y6 H
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   2 Y6 s! }' A6 P/ K' }5 Z/ A# R
4. TimHandle.Instance = TIM1;
     W8 f( ]$ O; {# W( M
5. TimHandle.Init.Prescaler         = usPrescaler;
   ) X; c. a% p" x2 q3 r2 H
6. TimHandle.Init.Period            = usPeriod;
   
7. TimHandle.Init.ClockDivision     = 0;
   
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   : r) m0 L- U* Z8 ^1 N& n7 L6 ~0 z
9. TimHandle.Init.RepetitionCounter = 0;
   
10. TimHandle.Init.AutoReloadPreload = 0;
    
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    2 i& o& p$ b6 y" V& d0 u
12. {
    
13.     Error_Handler(__FILE__, __LINE__);
    
14. }

复制代码

0 r8 U4 d5 b- A( Z0 {- d2 n; ]5 ^9 l32.4.4 函数HAL_TIM_PWM_ConfigChannel
( I: {( {' p* ?: a% l, B! {函数原型：

' O  L* S# h+ A) q% {+ a( z7 X

1. HAL_StatusTypeDef HAL_TIM_PWM_ConfigChannel(TIM_HandleTypeDef *htim,
   3 Q* Y3 B$ J' |$ x6 y
2.                                             TIM_OC_InitTypeDef* sConfig,
   ' i& W# d# k0 C: I; f5 P
3.                                             uint32_t Channel)
   
4. {
   
5.    /* 省略 */
   
6. 
   ' V/ B; c, ^2 f( Z4 s; W7 {3 L
7.   /* 开锁 */
   
8.   __HAL_LOCK(htim);
   ( y& D: S" h" `' U5 n+ W3 s( O+ X
9. 
   
10.   htim->State = HAL_TIM_STATE_BUSY;
    4 V1 ~% i& V1 {. D7 x+ u
11. 
    ! j  K( W9 |; j) Y
12.   switch (Channel)
    8 o& j3 g8 X2 W7 o# x* V
13.   {
    
14.     case TIM_CHANNEL_1:
    
15.     {
    
16.       /* 检查参数 */
    
17.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    0 ?6 m( M& I2 D' G$ H) o
18. 
    . F# X' \3 Z( ~$ i
19.       /* 配置通道1的PWM模式 */
    8 X7 B( Y( @. c% i+ q" [( S" F: B
20.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    4 r# P! Z/ G# |6 o. ]3 }
21. 
    
22.       /*预装载使能，更新事件产生时写入有效 */
    
23.       htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;
    
24. 
    
25.       /* 配置是快速输出模式 */
    
26.       htim->Instance->CCMR1 &= ~TIM_CCMR1_OC1FE;
    
27.       htim->Instance->CCMR1 |= sConfig->OCFastMode;
    3 S/ P5 |# B0 o/ z+ J0 d/ Z
28.     }
    
29.     break;
    
30. 
    . Y$ y' L9 j" B/ N+ `. i/ l
31.     case TIM_CHANNEL_2:
    
32.     {
    , p8 ^6 K* _2 h
33.        /* 省略 */
    & I. p5 w+ {, @
34.     }
    
35.     break;
    9 b, U% K& q+ k* S0 O' `$ }
36. 
    
37.     case TIM_CHANNEL_3:
    3 h$ e! d8 L/ `$ L
38.     {
    
39.        /* 省略 */
    ) h& N4 K3 d% f) S$ C
40.     }
    
41.     break;
    6 K2 b% n: I8 z3 Q2 y
42. 
    ! x8 b6 z* o% |0 t% y
43.     case TIM_CHANNEL_4:
    % ~3 O- `! F+ Z
44.     {
    ) c9 l  |, U  {$ ~1 G
45.       /* 省略 */
    . R1 G* V3 N  m0 }" K
46.     }
    
47.     break;
    
48. 
    $ e0 @0 x9 V+ `5 v( K
49.     case TIM_CHANNEL_5:
    
50.     {
    : R9 F- E# \( x! q
51.        /* 省略 */
    ! Z% d8 N3 F; F5 U5 ?
52.     }
      P5 [/ B3 F/ G( v
53.     break;
    # ~/ H$ {4 P* }# v  I5 h, F' \
54. 
    
55.     case TIM_CHANNEL_6:
    / j% s  x, n# M' m7 C
56.     {
    
57.         /* 省略 */
    
58.     }
    
59.     break;
    6 c0 X9 N/ G$ N+ H, f3 E
60. 
    # l: P; A0 m9 P
61.     default:
    % p' i/ e: W7 p  a) {$ a
62.     break;
    
63.   }
    
64. 
    
65.   htim->State = HAL_TIM_STATE_READY;
    
66. 
    
67.   /* 关锁 */
    8 y) ]8 n6 K9 H8 i5 y4 y
68.   __HAL_UNLOCK(htim);
    $ s# T' A  d$ E8 ]- v% B
69. 
    
70.   return HAL_OK;
    6 ?5 q2 L5 \  f; W
71. }

复制代码

函数描述：
/ v; a& {2 z# d. k! m
此函数用于配置定时器的PWM通道。
, g: G) X* G9 T# o
函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
" [/ `! C4 R0 r4 S* W  第3个参数是通道设置，支持以下参数：
& N1 {6 `2 U% qTIM_CHANNEL_1
. @- h5 n& N1 l5 F' N1 ~( M
TIM_CHANNEL_2

+ ]8 j' {/ _. D7 K1 ~8 y1 KTIM_CHANNEL_3

TIM_CHANNEL_4
5 J% L$ A" X7 L( U% f' \$ \
1 {! S1 _) D0 NTIM_CHANNEL_5
9 {( H( [  x( ?* q) O  P
3 T  G8 y6 y- A$ jTIM_CHANNEL_6
* G0 r# _: g* B" @
: I, X7 s) R: R' v+ \/ ~* U$ ]6 u  R  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
! m7 n  `6 T8 ~6 ]; m6 J2 B  x4 y使用举例：
' Q7 m8 v8 ]# R7 S1 H1 s) U9 P, g3 g: h
# t8 V. g2 ^! x

1. TIM_HandleTypeDef  TimHandle = {0};
   
2. 
   
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   & k0 C$ ^, x4 t0 h6 ^) o2 q
4. TimHandle.Instance = TIM1;
   
5. TimHandle.Init.Prescaler         = usPrescaler;
   6 `$ }% X3 a( f, g
6. TimHandle.Init.Period            = usPeriod;
   7 k" p0 q! {) A5 C
7. TimHandle.Init.ClockDivision     = 0;
   
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   
9. TimHandle.Init.RepetitionCounter = 0;
   0 H  w' \% ^4 T
10. TimHandle.Init.AutoReloadPreload = 0;
    8 }. Y$ Z( `: B
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    4 r2 e- W1 h( M7 b0 S8 t& D
12. {
    
13.     Error_Handler(__FILE__, __LINE__);
    $ |3 `! d; N* H- v% }  {
14. }
    , O" Y9 R* d4 R9 M! |; ]
15. 
    : b9 Q4 G' C' A& F' H0 H: B  q: g
16. /* 配置定时器PWM输出通道 */
    " G9 N2 {) v! |- `" q. S5 p
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    4 ^/ K" s5 \! l' ^* N
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    : P' |% ~* h9 S% |
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    ( w. o6 {' ]* _0 Y/ }0 J: T
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
    / y" N2 _! ]5 d- q  w& d4 }) ]" A+ O
23. 
    
24. /* 占空比 */
      A2 G/ j  ^8 w8 |/ F4 M7 ^
25. sConfig.Pulse = pulse;
    
26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    
27. {
    # J( k7 R0 x3 P. Y% o; {
28.     Error_Handler(__FILE__, __LINE__);
    . }, M  f6 i: z) M5 x% c: k
29. }

复制代码

5 U! _$ [' i/ e32.4.5 函数HAL_TIM_PWM_Start
函数原型：

1. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
   
2. {
   
3.   /* 检测参数 */
   
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   
5. 
   
6.   /* 使能捕获比较通道 */
   4 J. B" Z) ~4 H2 P* `+ Q
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   - j  O$ Z2 r! C/ M  X1 U
8. 
   ( i% G: @1 u* ]' W( y$ i7 k( o. v
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
   
10.   {
    
11.     /* 使能主输出 */
    
12.     __HAL_TIM_MOE_ENABLE(htim);
    % x: r  K" B- L% a; e
13.   }
    ) M& P  J" j$ h3 B5 Q
14. 
    
15.   /* 使能定时器 */
    3 w1 T6 A# A2 h: J1 N2 c  P  |
16.   __HAL_TIM_ENABLE(htim);
    : M( _/ Z4 ?# i8 P6 s
17. 
    
18.   /* 返回状态*/
    4 o* N* R+ h0 ^6 O  J4 u
19.   return HAL_OK;
    
20. }

复制代码

函数描述：
( x: ]+ Y5 B/ w
此函数用于启动PWM。
$ r5 ?; S: }1 z5 @% f$ b
- V6 `7 r$ f9 q, V- l函数参数：
5 W( I8 |4 ]+ m! h8 K* O
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  第2个参数是通道设置，支持以下参数：
4 l: X# b* m% a  c* [6 kTIM_CHANNEL_1
4 I* I4 l# N! W1 O$ M. h
5 O& V! s# ~! A7 e# U) \; wTIM_CHANNEL_2

TIM_CHANNEL_3
5 H9 l; K2 U9 s+ d& f
# W, p& i4 }7 jTIM_CHANNEL_4

  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
使用举例：
- T" H0 ?7 m* Y4 M1 s( s

1. TIM_HandleTypeDef  TimHandle = {0};
   
2. 
   9 f! L. B- p# F0 ^% b3 ]) q4 F$ p
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   
4. TimHandle.Instance = TIM1;
   3 C. Q$ j' \( o; i
5. TimHandle.Init.Prescaler         = usPrescaler;
   ; S! B1 ~. H9 e# ^  a
6. TimHandle.Init.Period            = usPeriod;
   
7. TimHandle.Init.ClockDivision     = 0;
   
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   # _+ v3 [3 k4 _- T6 i
9. TimHandle.Init.RepetitionCounter = 0;
   6 [+ Q1 O# \- t5 c( }4 S& |! o
10. TimHandle.Init.AutoReloadPreload = 0;
    
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    
12. {
    ; D3 F8 T, x! |7 N8 ^" ]
13.     Error_Handler(__FILE__, __LINE__);
    
14. }
    
15. 
    
16. /* 配置定时器PWM输出通道 */
    & d  X+ N1 {0 ?1 @' E6 Q. {4 t
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    # y' [$ M) }" b8 C
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    ) L8 B, \9 k6 `# K& t
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
      Q( l/ Y& ?2 g& |
23. 
    9 p. _8 W: w' [, [4 K* t9 P
24. /* 占空比 */
    
25. sConfig.Pulse = pulse;
    
26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    
27. {
    & X- j3 N8 a/ {$ Y
28.     Error_Handler(__FILE__, __LINE__);
    & u8 B' S! |7 {7 K8 \
29. }
    $ z7 B- W3 y" s1 b9 p
30. 
    
31. /* 启动PWM输出 */
    ( F" \7 D6 h" t0 j8 F9 y, o
32. if (HAL_TIM_PWM_Start(&TimHandle, TimChannel[_ucChannel]) != HAL_OK)
    1 B4 d. E; U$ `: v! U+ _
33. {
    
34.         Error_Handler(__FILE__, __LINE__);
    , r6 J: _, k% w  V8 i
35. }

复制代码

5 `, I0 D' s5 Z1 O' l- e32.4.6 函数HAL_TIM_IC_Init
函数原型：

! {' l! e8 @9 a* E" U( \4 ?

1. HAL_StatusTypeDef HAL_TIM_IC_Init(TIM_HandleTypeDef *htim)
   5 y# Z4 I- i9 \! y% c
2. {
   
3.   /* 检测形参是否有效 */
   7 c; N5 c! d) F2 _9 C- m& a% S
4.   if(htim == NULL)
   
5.   {
   
6.     return HAL_ERROR;
   
7.   }
   
8. 
   
9.   /* 检测参数 */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    # |7 n" ^- j2 y; Q4 I! q! }6 H! x
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    6 v$ p# ~8 x) p
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    / W" v4 n! F( R( O. G
13. 
    , V7 z5 v% ~# o8 a$ O$ {
14.   if(htim->State == HAL_TIM_STATE_RESET)
    + Z' a; L1 P: |6 r0 V0 l
15.   {
    + w& g5 S% P- B
16. /* 默认取消锁 */
    8 C6 @- x2 k9 F' l, D7 ~( @: y& }
17.     htim->Lock = HAL_UNLOCKED;
    
18. 
    
19.      /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_IC_MspInit(htim);
    / g- e/ ~% r0 O& G; r
21.   }
    
22. 
    
23.   /* 设置定时器状态 */
      o& S+ Q; I3 |4 v) ~" P
24.   htim->State= HAL_TIM_STATE_BUSY;
    
25. 
    2 s! S5 ^) ~6 H/ f$ |  O- q& r
26.   /* 配置定时器为输入捕获模式 */  
    6 `4 `; q1 @, C* K7 @: Z! G
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
28. 
    
29.   /* 设置定时器状态 */
    
30.   htim->State= HAL_TIM_STATE_READY;
    
31. 
    
32.   return HAL_OK;
      w# }/ {$ d" ^8 b" B) n, j+ ^
33. }

复制代码

函数描述：
, ]5 l8 t% c- ~  P' T) T4 [+ n
此函数用于定时器输入捕获初始化。
" V: L. x: g  n! J) P! @
% X$ z3 T! {1 E2 S6 w函数参数：
  h4 f! i! A; Q. v1 X
$ Q, i% i& k6 x  r  w; i  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  [5 y4 i0 I0 ^; L" q4 m  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：

) ^0 z1 M9 x. v8 x函数HAL_TIM_IC_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
: g. {/ c+ s  [$ f9 v: \如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个HAL_TIM_STATE_RESET  = 0x00U。

解决办法有三：

方法1：用户自己初始定时器和涉及到的GPIO等。
! z$ I$ Y( c! l/ T. K3 l( E% U, @
. H9 r5 j4 b& F) ]/ y方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

! e) X! c9 C' S+ K; ^  O方法3；下面的方法
" m+ S) c8 L, I) f/ c+ g# S8 h& M
, a' d4 e  K- ?/ n! tif(HAL_TIM_IC_DeInit(&UartHandle) != HAL_OK)
{
; u# P4 q3 I) \' ?# q  B    Error_Handler();
9 D- G- D" W! T. H3 o, O3 Q! Z}  
if(HAL_TIM_IC_Init(&UartHandle) != HAL_OK)
1 F$ v6 V! ]' t{
+ g' @5 G" g2 @& E! d    Error_Handler();
9 _5 U" v' A) b$ i( N. c4 [# Z}
3 e; H9 c) z: X32.4.7 函数HAL_TIM_IC_ConfigChannel
函数原型：
- W2 T* D: y; X+ A
. ~0 N# D% a( g1 E

1. HAL_StatusTypeDef HAL_TIM_IC_ConfigChannel(TIM_HandleTypeDef *htim, TIM_IC_InitTypeDef* sConfig, uint32_t Channel)
   ; ^, ~  Q. Z6 Q) l
2. {
   
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
   4 b9 q, I7 i8 j, J( N6 F
5.   assert_param(IS_TIM_IC_POLARITY(sConfig->ICPolarity));
   
6.   assert_param(IS_TIM_IC_SELECTION(sConfig->ICSelection));
   
7.   assert_param(IS_TIM_IC_PRESCALER(sConfig->ICPrescaler));
   , ]$ _& V$ H. {  H+ w
8.   assert_param(IS_TIM_IC_FILTER(sConfig->ICFilter));
   
9. 
   
10.   /* 开锁 */  
    
11.   __HAL_LOCK(htim);
    
12. 
    ) c) k& M, F% r- J
13.   htim->State = HAL_TIM_STATE_BUSY;
    
14. 
    1 j- s) _2 z* P1 v0 z
15.   if (Channel == TIM_CHANNEL_1)
    
16.   {
    
17.     /* 配置输入通道1 */
    
18.     TIM_TI1_SetConfig(htim->Instance,
    9 p) J4 k+ |( R. y
19.                sConfig->ICPolarity,
    1 L& W4 T% |" H: l2 @3 W
20.                sConfig->ICSelection,
    
21.                sConfig->ICFilter);
    : s- N4 Q0 o6 ?' @
22. 
    ; T/ |& a* R' T6 T; L9 E
23.     /* 清零IC1PSC位 */
    / P0 g! b% ^6 h% }
24.     htim->Instance->CCMR1 &= ~TIM_CCMR1_IC1PSC;
    + B" L" j# }- J5 M* M
25. 
    
26.     /* 根据用户配置，设置分频 */
    
27.     htim->Instance->CCMR1 |= sConfig->ICPrescaler;
    ' X4 v/ U4 l; U7 n4 @+ J' c' R4 m9 d
28.   }
    
29.   else if (Channel == TIM_CHANNEL_2)
    + e; y( w+ ~- }
30.   {
    " `( K6 X7 p/ {5 R
31. /* 省略 */
    
32.   }
    + a# V2 I" @3 [/ W
33.   else if (Channel == TIM_CHANNEL_3)
    
34.   {
    7 j* G  b: x; S- y1 F7 s/ P
35.      /* 省略 */
    2 V& a  v  H1 u; g1 I1 ~: x
36.   }
    3 D# ]) h6 X; M' C
37.   else
    
38.   {
    1 C* I% k& v  Z1 i
39.      /* 省略 */
    
40.   }
    3 y' F( Y& H  I2 Q8 i. ?5 H
41. 
    6 d, ^+ g5 ]( f5 }4 ?
42.   htim->State = HAL_TIM_STATE_READY;
    " i% K: h+ T- i* Q9 R, {: U
43. 
    3 X: V' v  ]8 }# [3 c' U6 I/ m
44.   __HAL_UNLOCK(htim);
    
45. 
    0 @5 G' ^+ |- P4 h% l5 l
46.   return HAL_OK;
    
47. }

复制代码

函数描述：

此函数用于配置定时器的输入捕获通道。
* G7 b# I0 X: V+ N& [, A; B4 v5 |
! n  }+ O# ~, V) I函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置
$ c/ P& z" @1 Q  N$ }6 ~% w+ R  第2个参数是TIM_IC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
1 |: a& ^7 R* o) j: ]3 t+ \  第3个参数是通道设置，支持以下参数：
! a+ F1 j) I7 _$ h# f% {! \7 e" QTIM_CHANNEL_1
' C9 s( S9 o5 a$ d  J$ e
TIM_CHANNEL_2
" ~/ |% O+ D1 R' _
TIM_CHANNEL_3

TIM_CHANNEL_4
3 i3 }5 D2 M0 i1 ?' g, R
; U  y. }  l8 L9 h, S' _  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
32.4.8 函数HAL_TIM_IC_Start_IT
' W; H8 r2 {: y  I: ^函数原型：
7 w& J5 D4 @! Y% k9 t/ [3 K, x
" t9 G" k% M8 f; R# Q# z, S6 x

1. HAL_StatusTypeDef HAL_TIM_IC_Start_IT (TIM_HandleTypeDef *htim, uint32_t Channel)
   . l9 B( Z: z. L4 D' q( ]
2. {
   3 V5 s/ R! h$ W9 W0 }0 H: {
3.   /* 检查参数 */
   ; A: V" w( {* Q6 r: ?
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   
5. 
   & H1 X( y" T1 y" `' X8 F' F& F
6.   switch (Channel)
   
7.   {
   ! a; N6 ~. m* {4 F- R! E
8.     case TIM_CHANNEL_1:
   " }  l6 g- v# Z; n" |, c
9.     {      
   
10.       /* 使能CC1（Capture/Compare 1）中断 */
    1 M- U+ ]1 K# v/ x) J# O
11.       __HAL_TIM_ENABLE_IT(htim, TIM_IT_CC1);
    
12.     }
    , f  w' X/ G1 E
13.     break;
    
14. 
    
15.     case TIM_CHANNEL_2:
    ' w; H1 v+ ^' Q5 x6 c2 w4 I. Y
16.     {
    2 q+ Z3 q# K/ S6 e: h, ]5 V2 c
17.    /* 省略 */
    6 r' T! N, I, Y. z7 _
18.     }
    / p! j' U1 w5 R* y( L
19.     break;
    
20. 
    
21.     case TIM_CHANNEL_3:
    
22.     {
    
23.   /* 省略 */
    
24.     }
    
25.     break;
    
26. 
    
27.     case TIM_CHANNEL_4:
    ; k+ u$ O, y5 k; U7 D
28.     {
    . n$ B8 c+ N: X  c9 e% n8 M' i. K( |
29.   /* 省略 */
    + q1 X% G9 G% m6 s9 Q
30.     }
    : m1 B' l& w( R; P6 T
31.     break;
    
32. 
    ( T8 f. t% @8 [
33.     default:
      I1 v, |" @5 ]* V
34.     break;
    
35.   }  
    
36.   /* 使能输入捕获通道 */
    5 @1 Q5 F: Y0 a9 y  X, A2 {0 ~
37.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    # I2 C1 d6 _9 ^2 n% I
38. 
    9 j7 t. f- j+ x5 ]7 Y$ Z
39.   /* 使能定时器 */
    
40.   __HAL_TIM_ENABLE(htim);  
    " B7 I( ]& T! m" f% b2 l6 v
41. 
    
42.   /* 返回状态 */
    
43.   return HAL_OK;  
    4 P1 W% R3 i: C( {
44. }

复制代码

5 l: H0 K4 h7 ~. ^( K  F函数描述：

: P3 l7 T$ X& T* x( p# F此函数用于启动定时器输入捕获模式，采用定时器方式。
7 g5 v2 M( _9 e; e- p
函数参数：

6 M7 E  ~% J8 l/ f4 y% a  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  第2个参数是通道设置，支持以下参数：
  a+ H! `2 O8 \4 G5 K- S* G" h3 iTIM_CHANNEL_1
$ N: i3 W% b. o4 U
1 \! X! S' x7 hTIM_CHANNEL_2

TIM_CHANNEL_3

TIM_CHANNEL_4

  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
' S3 p( E3 `; c) _9 f: p32.4.9 函数HAL_TIM_OC_Init
3 S4 s+ u2 ?# }函数原型：

9 L# b4 p. x3 C) a) K- R

1. HAL_StatusTypeDef HAL_TIM_OC_Init(TIM_HandleTypeDef* htim)
   
2. {
   " f4 I; Z' F/ A4 n
3.   /* 检测形参是否有效 Check */
   # [2 E1 n( ]# Y  C) h& O
4.   if(htim == NULL)
   
5.   {
   
6.     return HAL_ERROR;
   6 j, C2 Z8 w* x
7.   }
   
8. 
   
9.   /* 检查参数 */
   : b% u: z! U, C$ p  y
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    ) H2 F2 u, o" s" i! W
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    : z; _0 U2 ~0 m0 x8 M2 a7 v8 b/ l
13. 
    ; U! p" B; u3 B! M
14.   if(htim->State == HAL_TIM_STATE_RESET)
    ) f$ Y& {4 W7 K+ G: F- Y. E
15.   {
    7 Y/ L; E( q- V
16. /* 默认取消锁 */
    2 m+ R3 ~( J# e& U% z: U
17.     htim->Lock = HAL_UNLOCKED;
    + M# x* `1 \( F0 P
18. 
    1 t; J9 Y: Y( u, t3 b4 U' ^
19. /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_OC_MspInit(htim);
    
21.   }
    5 a$ W6 s4 l8 ^* M) B  }# `! U9 U
22. 
    $ K% ?& x( D5 M; |
23.   /* 设置定时器状态Set the TIM state */
    9 ]+ g( d" H4 e. v+ ^2 t: O' f
24.   htim->State= HAL_TIM_STATE_BUSY;
    
25. 
    # W( x' G. b1 ~& c$ j# d
26.   /* 配置定时器为输出比较模式Init the base time for the Output Compare */  
    7 h7 f( N0 ^( ~3 D4 y/ S, u" D6 v
27.   TIM_Base_SetConfig(htim->Instance,  &htim->Init);
    
28. 
    : K, e" K; F- z6 W$ p! u$ ?
29.   /* 设置定时器状态 */
    
30.   htim->State= HAL_TIM_STATE_READY;
    * |9 W. w3 x& ~# d
31. 
    
32.   return HAL_OK;
    
33. }

复制代码

函数描述：

  [1 o2 g. e$ _" N此函数用于定时器输出比较初始化。
7 s* {0 K5 x+ ~+ J7 p) Q+ p
函数参数：
! @1 `/ {7 r; t
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
, m0 O$ j0 L1 z- ^8 I! b) ^注意事项：
8 S8 {: e, W( r
函数HAL_TIM_OC_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
) y" s; L8 H: y: G如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
& x8 s& w3 `6 n1 t8 ^& l, P对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个HAL_TIM_STATE_RESET  = 0x00U。

, P" \& |: e7 I9 U解决办法有三：
. V- u/ o- E  N$ w+ f; R" U' S
; R' W: B- N# y- x' r( ^- g$ m方法1：用户自己初始定时器和涉及到的GPIO等。
# P* O+ I2 I: c* J. L0 Y
方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

- N3 L; ^/ r* {* M" U5 D7 V- P方法3；下面的方法
8 q2 E5 H. U/ E; Y8 l* _

1. if(HAL_TIM_OC_DeInit(&UartHandle) != HAL_OK)
   
2. {
   . i" f3 V7 q( r' N
3.     Error_Handler();
   
4. }  
   
5. if(HAL_TIM_OC_Init(&UartHandle) != HAL_OK)
   
6. {
   
7.     Error_Handler();
   ! P6 P4 H) v+ W( |! o
8. }
   2 Y' B( j1 h: E, z, o" S+ q- z  K  H
9. 32.4.10   函数HAL_TIM_OC_ConfigChannel
   % ~1 A* D6 h* u3 U1 B
10. 函数原型：
    
11. 
    : N$ ~) E' {8 u/ `# D3 C0 o
12. HAL_StatusTypeDef HAL_TIM_OC_ConfigChannel(TIM_HandleTypeDef *htim,
    
13.                                            TIM_OC_InitTypeDef* sConfig,
    
14.                                            uint32_t Channel)
    , p% p3 |+ @# e, m* P
15. {  
    
16.   /* Check the parameters */
    
17.   assert_param(IS_TIM_CHANNELS(Channel));
    8 J; n3 ?( ?  C
18.   assert_param(IS_TIM_OC_MODE(sConfig->OCMode));
    
19.   assert_param(IS_TIM_OC_POLARITY(sConfig->OCPolarity));
    
20. 
    1 z" p/ R$ F% d4 ?2 L% i
21.   /* Process Locked */
    
22.   __HAL_LOCK(htim);
    7 N( ~5 m  K( _# u" _
23. 
    9 v4 l! J) T6 s- R* l! ?: H8 {
24.   htim->State = HAL_TIM_STATE_BUSY;
    
25. 
    , K' P) m- Q9 C# L( `
26.   switch (Channel)
    / t8 n7 z, \, k/ {5 y% N& K
27.   {
    & X- v; P& Q3 R6 g) m
28.     case TIM_CHANNEL_1:
    
29.     {
    
30.       /* 检测参数Check the parameters */
    
31.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    & h: R1 @4 ?3 [9 S7 I% n: a& t
32. 
    
33.      /* 配置定时器输出比较通道1 */
    * U! z3 i4 G" Q& r1 H
34.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    
35.     }
    
36.     break;
    
37. 
    
38.     case TIM_CHANNEL_2:
    ) r9 m( I2 d. K0 e. z& c! s
39.     {
    
40.       /* 省略 */
    ! O& f4 k" r( b4 [$ A: E- E" G: ]% `
41.     }
    ' c* s6 j7 Z6 L% [6 S9 q
42.     break;
    
43. 
    0 \6 L0 T5 \8 n) _
44.     case TIM_CHANNEL_3:
    
45.     {
      j! o' g3 g, ?' v
46.       /* 省略 */
    
47.     }
    
48.     break;
    
49. 
    / d5 m6 H- ]# j2 S- \
50.     case TIM_CHANNEL_4:
    6 l/ L& a# F! [4 u
51.     {
    
52.       /* 省略 */
    
53.     }
    , Z0 {( D* j/ `" d$ W5 Q/ Q, K' k
54.     break;
    
55. 
    + r4 U5 I3 A4 y# E6 `6 W; P' B
56.     case TIM_CHANNEL_5:
    ' v' ?2 k+ {' f# Q7 ~) ]& u5 C
57.     {
    
58.       /* 省略 */
    ( C) O' Y, S6 ^% O
59.     }
    
60.     break;
    
61. 
    2 ~+ g: X/ y3 T
62.     case TIM_CHANNEL_6:
    # G* {) r# F. R
63.     {
    
64.       /* 省略 */
    
65.     }
    # u4 o' [8 d4 c3 X. [
66.     break;
    * U& ]# Q0 m5 @
67. 
    
68.     default:
    
69.     break;   
    . A2 }' h6 c& G; M0 c4 s' l2 n
70.   }
    
71. 
    , j% f5 l9 d+ h  K6 Z; y9 Y" W
72.   htim->State = HAL_TIM_STATE_READY;
    
73. 
    8 K* V- g* k& g+ p1 O7 Q$ t
74.   __HAL_UNLOCK(htim);
    
75. 
    & G5 V' t) [1 f7 Q) ~" X% G
76.   return HAL_OK;
    2 p& [4 i! Z+ \" G
77. }

复制代码

* C% J# y2 q1 Q, X* @函数描述：

) ~. R+ ^' ~8 h# C# m0 d此函数用于初始化串口的基础特性和高级特性。
6 m- y; i  d5 c% s1 g
8 \% ?& X7 R6 O/ o& }& u1 e函数参数：

, b2 z5 \8 E/ ~/ S0 b" ?" D7 q  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
) b* |( y3 k. j/ |' W  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
TIM_CHANNEL_1

! H" ]1 U( V% gTIM_CHANNEL_2
% o$ C6 @* F; C2 a$ I
TIM_CHANNEL_3
4 q5 B5 z7 E& _  [
/ D/ v1 B) p$ h1 nTIM_CHANNEL_4

TIM_CHANNEL_5
3 h5 c/ W! k& O0 }- d7 A% x
TIM_CHANNEL_6

  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
32.4.11   函数HAL_TIM_OC_Start
函数原型：

1. HAL_StatusTypeDef HAL_TIM_OC_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
   
2. {
   8 ~& @1 u; d2 p: e- V
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   
5. 
   4 g+ U5 s+ d3 F1 ^* \+ \; h3 n. R
6.   /* 使能输出比较通道 */
   
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
8. 
   
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
   ! B+ ^; A% F+ @3 w: t) q5 p3 r
10.   {
    
11.     /* 使能主输出 */
    1 \* _! i, l& `
12.     __HAL_TIM_MOE_ENABLE(htim);
    ! i/ C5 G4 H0 p' h( X! V
13.   }
    
14. 
    6 g1 E' g, M+ C5 E
15.   /* 使能定时器 */
    ! H/ U5 Z# k; Z% [
16.   __HAL_TIM_ENABLE(htim);
    
17. 
    - A; N% b  q1 d8 E
18.   /* 返回状态 */
    
19.   return HAL_OK;
    # N& I  R" `. P* v; ?8 L
20. }

复制代码

函数描述：
( X) Q* Q; s7 F" ~, I/ y
6 Y1 m, N2 s/ W/ |: {" I2 g  n此函数用于启动定时器输出比较模式。

函数参数：
+ x* }, f8 Y6 X2 p, s1 ]
: \3 @! g) k. W( {& Y2 V2 i# Z1 o, V4 X  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  第2个参数是通道设置，支持以下参数：
1 F0 z& \% B& ]2 KTIM_CHANNEL_1

/ R/ j7 K8 h' WTIM_CHANNEL_2

TIM_CHANNEL_3
6 O7 c- M  `0 J1 ?
9 |; H% P) }: _3 g* VTIM_CHANNEL_4

8 y0 i0 s& b1 F- ?; H  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
+ B+ ]; _5 \+ D2 [- r1 `) J* j0 J32.5 总结
本章节就为大家讲解这么多，建议大家将GPIO的驱动源码结合参考手册中的寄存器通读一遍，对于我们后面章节的学习大有裨益。
8 ^* [0 F; [/ a  R$ i+ a6 }/ l; s/ H

( V# a  i* b* {
+ N, \; K' q, E9 d! }