32.1 初学者重要提示
  学习定时器外设推荐从硬件框图开始了解基本的功能特性，然后逐步深入了解各种特性，这种方式方便记忆和以后查阅。
( v' k, [, O9 A1 E  STM32H7的定时器输出100MHz方波是完全没问题。
+ H# |+ k( S& t0 v6 b7 P  STM32H7定时器进出中断的速度能跑到12.5MHz，所有程序在TCM和Flash运行没差别。
% |8 ~& s9 o1 l" g: ?  STM32H7的定时器输入捕获可以实现12MHz方波的双边沿捕获，单边沿可以做到24MHz。
  特别注意STM32H7的TIM1,8,15,16,17才有RCR重复计数器，其它都没用的。
  STM32H7的单个定时器中不同通道可以配置不同频率PWM。
8 ^% C0 Q- U4 B9 \  STM32H7的TIM1-TIM17中断入口函数名使用时要注意，别搞错了：
. ^& m2 H1 P, r/ E7 u7 W. P1 x4 L

1. TIM1_BRK_IRQHandler            
   
2. TIM1_UP_IRQHandler              
   7 H1 l0 |  g% o. i% s" i3 [- A0 U
3. TIM1_TRG_COM_IRQHandler        
   
4. TIM1_CC_IRQHandler                                                   
   
5. TIM2_IRQHandler                                          
   
6. TIM3_IRQHandler                                                
   
7. TIM4_IRQHandler                 
   ' p1 _0 h0 A; {" a0 p
8. TIM5_IRQHandler            
   % A% ?' R* S5 I
9. TIM6_DAC_IRQHandler           <------------------要注意            
   4 J/ E, @7 T' k/ g: P
10. TIM7_IRQHandler
    # W$ [+ \6 T  \7 W8 k' ~5 N
11. TIM8_BRK_TIM12_IRQHandler      <------------------要注意，定时器12也是用的这个
    
12. TIM8_UP_TIM13_IRQHandler       <------------------要注意，定时器13也是用的这个
    
13. TIM8_TRG_COM_TIM14_IRQHandler  <------------------要注意，定时器14也是用的这个
    ' H" h9 s$ B8 F
14. TIM8_CC_IRQHandler         
    % c$ J0 v& B: f) y
15. TIM15_IRQHandler
    $ A( K2 j: V7 }8 i9 }& s
16. TIM16_IRQHandler
    " M9 e5 G1 Q2 B
17. TIM17_IRQHandler

复制代码

32.2 定时器基础知识
) p/ V1 g; ?8 z3 M# ]% F6 p+ N注，不同定时支持的功能略有区别，基础定时器功能较少，TIM1和TIM8高级定时器功能多些。

1 h/ E$ F1 I# H5 {  TIM2和TIM5是32位定时器，其它定时器都是16位定时器。16位和32位的区别是CNT计数器范围不同，32位的范围是0 到2^32 – 1，而16位的是0到65535；它们支持的分频是范围是一样的，都是1到65535。
  计数器支持递增、递减和递增/递减二合一。
9 e8 N1 J3 u( }$ R* @3 y3 v  多个独立通道，可用于：
" S$ a6 R/ z. |. D2 Q3 p– 输入捕获。

– 输出比较。
4 s4 d' Y3 r7 z( t: A
5 s2 J$ ?! L+ t3 H+ i  E+ I  s– PWM 生成（边沿和中心对齐模式）。

– 单脉冲模式输出。

  带死区插入，断路功能和PWM互补输出
  x, j6 V' D& Z, d7 w0 Z5 y7 E6 P  发生如下事件时生成中断/DMA 请求：
( ?1 U' n2 f: v% ^" C. Q# G– 更新：计数器上溢/下溢、计数器初始化（通过软件或内部/外部触发）
) g! W. V3 N9 d) a. l0 e, [
– 触发事件（计数器启动、停止、初始化或通过内部/外部触发计数）
; ]9 v2 T1 P9 A! K0 H# p
0 y8 t( e7 J$ A# v4 O' b9 @, @– 输入捕获
( T  O: X1 N) y
– 输出比较
$ K& u7 l! ^6 C. E
  支持增量式编码器和霍尔传感器。
1 d3 C' L) e" H+ d0 v8 [( G32.2.1 定时器TIM1-TIM17的区别
STM32H7支持的定时器有点多，要简单的区分下。STM32H7支持TIM1-TIM8，TIM12-TIM17共14个定时器，而中间的TIM9，TIM10，TIM11是不存在的，这点要注意。
) R* b/ C" ~$ S  V
粗略的比较如下：
5 C# m: g9 p$ H$ v6 K6 H& V5 T# k
0 x4 t/ T4 P3 r* E

通过上面的表格，至少要了解到以下两点：
4 d0 @, E% f, T
  STM32H7的定时器主要分为高级定时器，通用定时器，基础定时器和低功耗定时器。
  TIM2和TIM5是32位定时器，其它都是16位定时器。
& y( B3 S* C& P' B
* {; o0 ?" t9 `32.2.2 定时器的硬件框图
. l) X/ }) r$ z认识一个外设，最好的方式就是看他的框图，方便我们快速的了解定时器的基本功能，然后再看手册了解细节。

下面我们直接看最复杂的高级定时器TIM1&TIM8框图：
, b2 O. ^! ~+ _( N* _
" Q" \/ P: b5 K, Q3 o7 u# }

( o4 @, \5 Z0 \  R; I
  k1 h/ _, ]7 o( D/ j# {通过这个框图，我们可以得到如下信息：
" \- Q+ {7 W! z# ^. h% n" M9 [
  TIMx_ETR接口
% q+ w* k2 n( i3 C! s/ x外部触发输入接口。ETR支持多种输入源：输入引脚（默认配置）、比较器输出和模拟看门狗。
) S  @+ a' N8 O4 b

6 l/ h) e- g3 `1 ]7 T
  截图左侧的TIMx_CH1，TIMx_CH2，TIMx_CH3和TIMx_CH4接口
这四个通道主要用于输入捕获，可以计算波形频率和脉宽。                                                                                                                             

  TIMx_BKIN和TIMx_BKIN2接口
$ w! a3 `0 {; L  p9 Y7 d9 C2 ?9 a断路功能，主要用于保护由 TIM1 和 TIM8 定时器产生的 PWM 信号所驱动的功率开关

+ W  Z, I) C( `, D4 @  TRGO内部输出通道
; Q- N$ Z% \# d8 P$ K5 ]' U  r$ M主要用于定时器级联，ADC和DAC的定时器触发。

  6组输出比较单元OC1到OC6
OC1到OC4有对应的输出引脚，而OC5和OC6没有对应的输出引脚，主要用于内部控制。
4 [' a% g$ Y) v# Q" q; a
) R8 S9 |. ~$ f  截图右侧的输出比较通道TIMx_CH1，TIMx_CH1N，TIMx_CH2，TIMx_CH2N，TIMx_CH3，TIMx_CH3N和TIMx_CH4
, W" |& `9 U  u: F! x6 ~# u% X0 j主要用于PWM输出，注意CH1到CH3有互补输出，而CH4没有互补输出。
2 h$ ~8 p" i) d+ m0 w
1 \9 L* r) J! J  其它框图里面未展示出来功能
定时器TIM1&TIM8还支持的其它功能在用到的时候再做说明。

32.2.3 定时器的时基单元
定时器要工作就需要一个基本时基单元，而基本的时基单元是由下面几个寄存器组成的：

  预分频器寄存器 (TIMx_PSC)
, G2 X9 w6 e' t9 K; X用于设置定时器的分频，比如定时器的主频是200MHz，通过此寄存器可以将其设置为100MHz，50MHz，25MHz等分频值。
& i# b8 h6 O" N0 l" q
注：预分频器有个缓冲功能，可以让用户实时更改，新的预分频值将在下一个更新事件发生时被采用（以递增计数模式为例，就是CNT计数值达到ARR自动重装寄存器的数值时会产生更新事件）。
1 X7 g7 ~  L! t% G2 h+ o
  计数器寄存器 (TIMx_CNT)
计数器是最基本的计数单元，计数值是建立在分频的基础上面，比如通过TIMx_PSC设置分频后的频率为100MHz，那么计数寄存器计一次数就是10ns。
% a9 x+ x! E0 v' W. m
  自动重载寄存器 (TIMx_ARR)
自动重装寄存器是CNT计数寄存器能达到的最大计数值，以递增计数模式为例，就是CNT计数器达到ARR寄存器数值时，重新从0开始计数。

  n) C" M& J( K注，自动重载寄存器是预装载的。对自动重载寄存器执行写入或读取操作时会访问预装载寄存器。预装载寄存器的内容既可以立即传送到影子寄存器（让设置立即起到效果的寄存器），也可以在每次发生更新事件时传送到影子寄存器。简单的说就是让ARR寄存器的数值立即更新还是更新事件发送的时候更新。
- X2 ]" ?0 B* B" t
3 S5 s, M3 R  H3 [0 h$ `9 c* d4 e  重复计数器寄存器 (TIMx_RCR)
以递增计数模式为例，当CNT计数器数值达到ARR自动重载数值时，重复计数器的数值加1，重复次数达到TIMx_RCR+ 1后就，将生成更新事件。
& x0 d) a. _1 {
) i" X3 Q! C' e. O注，只有TIM1，TIM8，TIM15，TIM16，TIM17有此寄存器。

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

32.2.4 定时器输出比较（PWM）
) H/ P) w' V7 I5 t使用定时器时基单元的那几个寄存器仅仅能设置周期，还不能设置占空比。针对这个问题，还需要比较捕获寄存CCR的参与，这样就可以设置占空比了。

0 t8 ?4 n" ~3 M7 t# s为了方便大家理解，以PWM 边沿对齐模式，递增计数配置为例：
. H7 h& \+ A4 J: n% c7 E" `
# W' w' O7 ^/ [  当计数器TIMx_CNT < 比较捕获寄存器TIMx_CCRx期间，PWM参考信号OCxREF输出高电平。
  c& h& m! J: F. Z% Y  当计数器TIMx_CNT >= 比较捕获寄存器TIMx_CCRx期间， PWM参考信号OCxREF输出低电平。
  当比较捕获寄存器TIMx_CCRx > 自动重载寄存器TIMx_ARR，OCxREF保持为1。
  当比较捕获寄存器TIMx_CCRx = 0，则OCxRef保持为0。
4 X8 n; C( Z/ y& I, r/ z. S  {下面是TIMx_ARR=8的波形效果：
6 p4 X; ^7 H& [; _

) |) h, h1 A3 g: i2 s; o& X
32.2.5 定时器输入捕获
0 i+ h0 Z) @9 M- K# U& `/ k与PWM一样，使用定时器实现输入捕获，仅靠时基单元的那几个寄存器是不行的，我们需要一个寄存器来记录发生捕获时的具体时间，这个寄存器依然由比较捕获寄存器TIMx_CCRx来实现。
, G! j  y+ v/ `6 e. {% `5 }% k
8 U4 d/ w3 V8 J4 X* p" U1 i比如我们要测量一路方波的周期：
( N& Y! e# ^9 d4 N; _/ g
8 `+ ]( l* S, S7 Y$ [  配置定时器为输入捕获模式，上升沿触发，设置分频，自动重装等寄存器，比如设置的CNT计数器计数1次是1微秒。
  当有上升沿触发的时候，TIMx_CCRx寄存器就会自动记录当前的CNT数值，然后用户就可以通过CC中断，在中断复位程序里面保存当前的TIMx_CCRx寄存器数值。等下次再检测到上升沿触发，两次时间求差就可以得到方波的周期。
9 B- I' T- u2 M不过这里要特别注意一点，如果CNT发生溢出（比如16位定时器，计数到65535就溢出了）就需要特别处理下，将CNT计数溢出考虑进来。

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

32.3.1 定时器寄存器结构体TIM_TypeDef
定时器相关的寄存器是通过HAL库中的结构体TIM_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：
4 O1 }4 I9 c' s( a! v

1. typedef struct
   
2. {
   
3.   __IO uint16_t CR1;         /*!< TIM control register 1,                   Address offset: 0x00 */
   # V, `+ y4 {! |
4.   uint16_t      RESERVED0;   /*!< Reserved, 0x02                                                 */
   2 d/ k& M2 P! Y
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 */
   
9.   __IO uint32_t EGR;         /*!< TIM event generation register,            Address offset: 0x14 */
   ( F4 e! C# j+ t1 |: G
10.   __IO uint32_t CCMR1;       /*!< TIM capture/compare mode register 1,      Address offset: 0x18 */
    4 Z6 M: |( A5 y  u
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 */
    2 F0 U% P0 `* m2 T- P
13.   __IO uint32_t CNT;         /*!< TIM counter register,                     Address offset: 0x24 */
    
14.   __IO uint16_t PSC;         /*!< TIM prescaler,                            Address offset: 0x28 */
    - G" ]0 ^2 N; @3 t  O4 ^
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 */
    
18.   uint16_t      RESERVED10;  /*!< Reserved, 0x32                                                 */
    0 u: O2 i2 \" q+ n0 f$ O
19.   __IO uint32_t CCR1;        /*!< TIM capture/compare register 1,           Address offset: 0x34 */
    3 ]/ S# ^! |, }$ Y& L) S5 B
20.   __IO uint32_t CCR2;        /*!< TIM capture/compare register 2,           Address offset: 0x38 */
    
21.   __IO uint32_t CCR3;        /*!< TIM capture/compare register 3,           Address offset: 0x3C */
    + q$ n  E1 p5 K  s! S' N* v
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 */
    
24.   __IO uint16_t DCR;         /*!< TIM DMA control register,                 Address offset: 0x48 */
    
25.   uint16_t      RESERVED12;  /*!< Reserved, 0x4A                                                 */
    
26.   __IO uint16_t DMAR;        /*!< TIM DMA address for full transfer,        Address offset: 0x4C */
    9 q# d: N' B. d' A& ?
27.   uint16_t      RESERVED13;  /*!< Reserved, 0x4E                                                 */
    
28.   uint16_t      RESERVED14;  /*!< Reserved, 0x50                                                 */
    
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 */
    
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 */
    1 L0 V4 h& ~$ w  Q& \
34.   __IO uint32_t TISEL;       /*!< TIM Input Selection register,             Address offset: 0x68 */
    ! N" v1 b5 ]$ j3 B; d5 x; b3 {
35. } TIM_TypeDef;

复制代码

# p* a( k- T* x4 `! L# h: o这个结构体的成员名称和排列次序和CPU的定时器寄存器是一 一对应的。

__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
6 X2 O6 y6 V% k4 {, k9 G3 u' Q
8 N% S# G1 q" g% d# {4 c# s

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

复制代码

' v: }# l; c6 j# {9 V$ j+ ]下面我们看下定时器的定义，在stm32h743xx.h文件。
% k& o+ `8 g! `. Y3 a2 f$ S
" X3 h7 s1 Y4 t0 |+ _

1. #define PERIPH_BASE         ((uint32_t)0x40000000)
   ) s  {# [3 h3 I* M3 P3 @& E
2. #define D2_APB1PERIPH_BASE   PERIPH_BASE
   ' P# A  O" M% w+ ^9 L# @
3. #define D2_APB2PERIPH_BASE   (PERIPH_BASE + 0x00010000)
   
4. 
   9 P. n5 [8 N: s( R  x
5. /*!< D2_APB1PERIPH 外设 */
   
6. #define TIM2_BASE             (D2_APB1PERIPH_BASE + 0x0000) <----- 展开这个宏，(TIM_TypeDef *) 0x40000000
   
7. #define TIM3_BASE             (D2_APB1PERIPH_BASE + 0x0400)
   
8. #define TIM4_BASE             (D2_APB1PERIPH_BASE + 0x0800)
   , B) J; X9 n' b3 \# I- V/ Z
9. #define TIM5_BASE             (D2_APB1PERIPH_BASE + 0x0C00)
   $ T( ~' W: g2 g) I: j
10. #define TIM6_BASE             (D2_APB1PERIPH_BASE + 0x1000)
    
11. #define TIM7_BASE             (D2_APB1PERIPH_BASE + 0x1400)
    
12. #define TIM12_BASE            (D2_APB1PERIPH_BASE + 0x1800)
    ; g* j! U, W: F5 }4 x; f
13. #define TIM13_BASE            (D2_APB1PERIPH_BASE + 0x1C00)
    8 s; ]9 k3 y% t+ N; U
14. #define TIM14_BASE            (D2_APB1PERIPH_BASE + 0x2000)
    
15. 
    
16. /*!< D2_APB1PERIPH 外设 */
    ( y6 j/ f; b7 R
17. #define TIM1_BASE             (D2_APB2PERIPH_BASE + 0x0000)
    
18. #define TIM8_BASE             (D2_APB2PERIPH_BASE + 0x0400)
    ' D1 m- }5 s5 a3 y1 D
19. #define TIM15_BASE            (D2_APB2PERIPH_BASE + 0x4000)
    " K3 ^; r/ j7 Z; `9 T
20. #define TIM16_BASE            (D2_APB2PERIPH_BASE + 0x4400)
    
21. #define TIM17_BASE            (D2_APB2PERIPH_BASE + 0x4800)
    7 e! s1 W  R' s
22. 
    1 r( F8 a$ T5 V3 Z3 ]
23. #define TIM1                ((TIM_TypeDef *) TIM1_BASE)
    5 X3 F- e: x2 B2 u- t
24. #define TIM2                ((TIM_TypeDef *) TIM2_BASE)
    4 `, B' D2 X: R" F- l" K
25. #define TIM3                ((TIM_TypeDef *) TIM3_BASE)
    9 c% h) J9 Q. T% A/ @9 ^
26. #define TIM4                ((TIM_TypeDef *) TIM4_BASE)
    " {" k0 n' o; d- v4 {  j' P
27. #define TIM5                ((TIM_TypeDef *) TIM5_BASE)
    % `" V: P7 v6 n3 e
28. #define TIM6                ((TIM_TypeDef *) TIM6_BASE)
    
29. #define TIM7                ((TIM_TypeDef *) TIM7_BASE)
    
30. #define TIM8                ((TIM_TypeDef *) TIM8_BASE)
    ( ~7 f( [( _0 i/ {
31. #define TIM12               ((TIM_TypeDef *) TIM12_BASE)
    " p  T2 t; \. O/ _; ^$ g1 ^5 n
32. #define TIM13               ((TIM_TypeDef *) TIM13_BASE)
    0 L4 S% f0 i6 G. W9 d
33. #define TIM14               ((TIM_TypeDef *) TIM14_BASE)
    # W9 s1 |1 }* L0 z1 l+ @6 _9 a
34. #define TIM15               ((TIM_TypeDef *) TIM15_BASE)
    
35. #define TIM16               ((TIM_TypeDef *) TIM16_BASE)
    6 W$ T+ E0 `, F% k" Z1 O) h- n& V
36. #define TIM17               ((TIM_TypeDef *) TIM17_BASE)

复制代码

& o- M: J- j& H' ~我们访问TIM2的CR1寄存器可以采用这种形式：TIM2->CR1 = 0；
1 m" ?- M' E7 X5 x# s
5 X' ^% X3 V/ E  A9 G% ?32.3.2 定时器句柄结构体TIM_HandleTypeDef
HAL库在TIM_TypeDef的基础上封装了一个结构体TIM_HandleTypeDef，定义如下：
  G$ {; j2 \- E: S" a

1. typedef struct
   ) Y; b+ C9 O0 j. D2 \, p
2. {
   1 l! R$ ]. p+ @# \$ j4 o
3.   TIM_TypeDef              *Instance;     /*!< Register base address             */
   # F" Y* `' m5 y' k+ M1 e
4.   TIM_Base_InitTypeDef     Init;          /*!< TIM Time Base required parameters */
   5 i! M  C& c" w0 c
5.   HAL_TIM_ActiveChannel    Channel;       /*!< Active channel                    */
   " Z5 O1 X  O: l  F4 m
6. 
   
7. /*!< DMA Handlers array This array is accessed by a @ref DMA_Handle_index */
   
8.   DMA_HandleTypeDef        *hdma[7];      
   1 I$ w* u/ f& {1 Y
9.   HAL_LockTypeDef          Lock;          /*!< Locking object                    */
   ( s& `# B; O8 p6 _7 i
10.   __IO HAL_TIM_StateTypeDef   State;      /*!< TIM operation state               */  
    
11. }TIM_HandleTypeDef;

复制代码

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

  TIM_TypeDef  *Instance

这个参数是寄存器的例化，方便操作寄存器，比如使能定时器的计数器。
0 R! Y- a) y$ O& ?" l
SET_BIT(huart->Instance->CR1,  TIM_CR1_CEN)。
: G5 R- ~2 r' V* k' z$ n
  TIM_Base_InitTypeDef  Init
5 S% e- N1 n; ^8 }$ z
这个参数是用户接触最多的，用于配置定时器的基本参数。

7 q7 [2 }3 p* m3 t% V; tTIM_Base_InitTypeDef结构体的定义如下：

* Q& v* {3 d  A: m/ \+ P

1. typedef struct
   
2. {
   
3.   uint32_t Prescaler;      
   + g' G- O  ?! O% p) U
4.   uint32_t CounterMode;   
   ( A' D! g; o. M8 E/ p- e5 W
5.   uint32_t Period;         
   6 o( @- P. a# B# e- I$ L0 g' ~9 J
6.   uint32_t ClockDivision;   
   
7.   uint32_t RepetitionCounter;
   1 x( o( {. d% ^7 ~
8.   uint32_t AutoReloadPreload;  
   4 S/ a8 ?" f: S, v4 e. z1 ^7 a
9. } TIM_Base_InitTypeDef;

复制代码

  成员Prescaler
用于设置定时器分频，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。
% u  \$ ~& D; c$ c
, e% i9 r# x$ ?. M: Y  成员CounterMode
用于设置计数模式，向上计数模式、向下计数模式和中心对齐模式。
* h" u) U8 X0 }+ j
* c2 M( ^. l6 F0 ?4 |; ?0 U8 w' X

1. #define TIM_COUNTERMODE_UP                ((uint32_t)0x0000U)   /*!< Up counting mode */
   $ N" g+ o" m  Z) j
2. #define TIM_COUNTERMODE_DOWN               TIM_CR1_DIR          /*!< Down counting mode */
   ) B: \" e, n& v7 ~& P
3. #define TIM_COUNTERMODE_CENTERALIGNED1     TIM_CR1_CMS_0        /*!< Center-aligned counting mode 1 */
   : E; ^0 u4 ^# f0 U# Z6 n6 P
4. #define TIM_COUNTERMODE_CENTERALIGNED2     TIM_CR1_CMS_1        /*!< Center-aligned counting mode 2 */
   
5. #define TIM_COUNTERMODE_CENTERALIGNED3     TIM_CR1_CMS          /*!< Center-aligned counting mode 3 */

复制代码

9 K- p& f4 x0 F1 v) b  成员Period
4 z1 E' V. c2 R6 J用于设置定时器周期，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。
: P% n" h) J1 ]0 N! P  V$ B
  成员ClockDivision
用于指示定时器时钟 (CK_INT) 频率与死区发生器以及数字滤波器（ETR、TIx）所使用的死区及采样时钟 (tDTS) 之间的分频比。

6 e' i- K  |; I2 r# D: ?

1. #define TIM_CLOCKDIVISION_DIV1       ((uint32_t)0x0000U)        /*!< Clock Division DIV1 */
   
2. #define TIM_CLOCKDIVISION_DIV2       (TIM_CR1_CKD_0)            /*!< Clock Division DIV2 */
   5 i! }" s; _) U: |
3. #define TIM_CLOCKDIVISION_DIV4       (TIM_CR1_CKD_1)             /*!< Clock Division DIV4 */

复制代码

. m( }& T  {  h5 w  成员RepetitionCounter
用于设置重复计数器，仅TIM1和TIM8有，其它定时器没有。作用是每当计数器上溢/下溢时，重复计数器减1，当减到零时，才会生成更新事件，这个在生成PWM时比较有用。

  成员AutoReloadPreload
  ~+ L$ g/ p4 S$ [# L用于设置定时器的ARR自动重装寄存器是更新事件产生时写入有效还是立即写入有效。如果使能了表示更新事件产生时写入有效，否则反之。
; b8 F3 Y0 N! K- K- ?4 Z8 Y1 e% N
! q8 j* ?9 |$ D% y0 I# |6 {5 }) t/ @

1. #define TIM_AUTORELOAD_PRELOAD_DISABLE   ((uint32_t)0x0000U)   /*!< TIMx_ARR register is not buffered */
   9 w# a* k0 D% _6 f6 [& w
2. #define TIM_AUTORELOAD_PRELOAD_ENABLE    (TIM_CR1_ARPE)        /*!< TIMx_ARR register is buffered */

复制代码

  HAL_TIM_ActiveChannel    Channel;
4 h0 m* a/ M4 x# Q7 J
+ t1 X3 j! @6 L/ }用于设置定时器通道，比如TIM1和TIM8都是6个通道。
! G, P/ E. V. ^' T! v( Q
4 I- n* Q  n7 n8 a) w9 b

1. typedef enum
   
2. {
   + d; d8 Q) C7 Y3 F& H
3.   HAL_TIM_ACTIVE_CHANNEL_1        = 0x01U,    /*!< The active channel is 1     */
   
4.   HAL_TIM_ACTIVE_CHANNEL_2        = 0x02U,    /*!< The active channel is 2     */
   ( V$ B' k/ G0 u, i
5.   HAL_TIM_ACTIVE_CHANNEL_3        = 0x04U,    /*!< The active channel is 3     */   
   : O- @* }+ o. Y# @" `. \+ q
6.   HAL_TIM_ACTIVE_CHANNEL_4        = 0x08U,    /*!< The active channel is 4     */
   
7.   HAL_TIM_ACTIVE_CHANNEL_5        = 0x10U,    /*!< The active channel is 5     */
   3 ~, u( `0 T6 {6 d( @/ W. u, r
8.   HAL_TIM_ACTIVE_CHANNEL_6        = 0x20U,    /*!< The active channel is 6     */
   
9.   HAL_TIM_ACTIVE_CHANNEL_CLEARED  = 0x00U     /*!< All active channels cleared */   
   9 C+ g5 A9 g0 X0 F' z
10. }HAL_TIM_ActiveChannel;
    
11.   DMA_HandleTypeDef        *hdma[7];

复制代码

用于关联DMA。

9 K; E. \/ I$ V& c配置定时器参数，其实就是配置结构体TIM_HandleTypeDef的成员。

1. TIM_HandleTypeDef   TimHandle = {0};
   6 J; Y7 v. }2 T) V1 t
2. 
   
3. /*
   
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   7 N/ w( H( t5 u, w# h
6. TimHandle.Instance = TIMx;
   6 \1 U6 ~" w8 _# R( d
7. TimHandle.Init.Prescaler         = usPrescaler;
   + }2 J9 [2 s: j+ u6 M
8. TimHandle.Init.Period            = usPeriod;        
   
9. TimHandle.Init.ClockDivision     = 0;
   # p) b1 h* F( [( E8 A
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)
    % P" X, @+ Y/ m
14. {
    ) i, K9 ?7 F  w7 p
15.         Error_Handler(__FILE__, __LINE__);
    
16. }

复制代码

32.3.3 定时器输出比较结构体TIM_OC_InitTypeDef
( e8 J4 s* B% s此结构体主要用于定时器的输出比较，定义如下：

& ?4 E0 U; r4 b' n" I

1. typedef struct
   
2. {                                 
   % J9 T3 ~6 b# I3 f# V5 i4 X
3.   uint32_t OCMode;      
   ( k6 p/ P, w* q1 b
4.   uint32_t Pulse;      
   
5.   uint32_t OCPolarity;   
   
6.   uint32_t OCNPolarity;   
   
7.   uint32_t OCFastMode;  
   
8.   uint32_t OCIdleState;   
   
9.   uint32_t OCNIdleState;  
   ) `# P! a# |% g3 W# i/ B
10. } TIM_OC_InitTypeDef;  

复制代码

. \4 c1 E, z1 V下面将这几个参数一 一做个说明。
2 q2 Y0 K: W, d7 m: b
: ^& K; Z. Z' U: x+ d( X  OCMode
5 W6 f: w' V5 J8 c5 F; F用于配置输出比较模式，支持的模式较多：
4 ^0 i- s& ]" ?! q0 {2 p; `

1. /*!< TIM Output timing mode */
   6 J4 u! d/ b" D! m; q7 `
2. #define TIM_OCMODE_TIMING                ((uint32_t)0x0000U)      
   2 m( ?$ o) X3 B/ e; q' G
3. 
   " L7 A( l9 C% \+ N3 e
4. /*!< TIM Output Active mode */                          
   
5. #define TIM_OCMODE_ACTIVE                ((uint32_t)TIM_CCMR1_OC1M_0)
   
6. 
   
7. /*!< TIM Output Inactive mode */                       
   4 E7 \" q4 S1 ]4 D' z1 w
8. #define TIM_OCMODE_INACTIVE              ((uint32_t)TIM_CCMR1_OC1M_1)           
   - x& {( ^! O/ V/ l7 A
9. 
   
10. /*!< TIM Output Toggle mode */               
    
11. #define TIM_OCMODE_TOGGLE                 ((uint32_t)TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)         
    
12. 
    
13. /*!< TIM PWM mode 1 */
    
14. #define TIM_OCMODE_PWM1                   ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1)
    
15. 
    
16. /*!< TIM PWM mode 2 */                    
    & \/ i+ I# |& P, U
17. #define TIM_OCMODE_PWM2                    ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)   
    
18. 
    0 z- z  Z6 O7 {0 X: `6 n
19. /*!< TIM Forced Active mode */   
    ( X# ?. ?! }# @  a( X  Q, c
20. #define TIM_OCMODE_FORCED_ACTIVE           ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0)         
    * {/ b1 R% z. Z* f
21. 
    
22. /*!< TIM Forced Inactive mode */            
    . {* v! b2 I/ v! _4 ]. {( a9 R4 w
23. #define TIM_OCMODE_FORCED_INACTIVE         ((uint32_t)TIM_CCMR1_OC1M_2)                                       
    3 s( G  r3 i8 ?9 g2 ]$ v/ U
24. 
    
25. /*!< TIM Rettrigerrable OPM mode 1 */  
    
26. #define TIM_OCMODE_RETRIGERRABLE_OPM1      ((uint32_t)TIM_CCMR1_OC1M_3)   
    
27. 
    
28. /*!< TIM Rettrigerrable OPM mode 2 */                                       
    ! u( q  K% ~9 c+ Z+ H% w
29. #define TIM_OCMODE_RETRIGERRABLE_OPM2      ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0)   
    
30. 
      E' q: R1 O- L. {$ T/ E
31. /*!< TIM Combined PWM mode 1 */                     
    , A$ V5 x5 d& S4 x
32. #define TIM_OCMODE_COMBINED_PWM1           ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_2)     
    
33. 
    6 r! }  a( _  [& l/ G! F! G- K+ x
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 */  
    / G5 N  l( V! P
38. #define TIM_OCMODE_ASSYMETRIC_PWM1         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2)  
    
39. 
    ! U* ?8 I" z5 |" Z: r* J- L) j
40. /*!< TIM Asymetruc PWM mode 2 */   
    
41. #define TIM_OCMODE_ASSYMETRIC_PWM2         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M)  

复制代码

  
- B+ s1 Z- t. ~5 M5 m0 B  Pulse
7 r) l( m9 ^# w) ^1 }+ v4 W: o可用于设置占空比，对应定时器的CCR寄存器，32位的TIM2和TIM5范围是0到0xFFFFFFFF。
0 y* t4 E3 p: R* I
  OCPolarity
设置输出极性，可选高电平或低电平有效。

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

复制代码

7 B5 X3 Z0 s3 g: |  OCNPolarity
: ~# Q9 F8 I6 @9 t3 E  R互补输出极性设置，可选高电平或者低电平有效。
7 a7 j* u2 b0 H- |* R. m8 _& K
4 d0 z4 B0 o6 f  S+ A. m

1. #define TIM_OCNPOLARITY_HIGH               ((uint32_t)0x0000U)
   
2. #define TIM_OCNPOLARITY_LOW                (TIM_CCER_CC1NP)

复制代码

  OCFastMode
; u5 W& i5 z/ p5 p8 s+ ^( J4 H8 B% a快速输出模式使能，仅OCMode配置为PWM1或者PWM2模式时才有意义。
! q6 c7 o/ Z1 J/ n4 f: ?. f3 b

1. #define TIM_OCFAST_DISABLE                ((uint32_t)0x0000U)
   
2. #define TIM_OCFAST_ENABLE                 (TIM_CCMR1_OC1FE)

复制代码

; c! D8 @6 ^( r; Z' s2 C  ?. z  OCIdleState
空闲状态时，设置输出比较引脚的电平状态。

* B# w- P2 D7 f& A3 X8 S5 J1 h

1. #define TIM_OCIDLESTATE_SET                (TIM_CR2_OIS1)
   5 H8 h3 N0 ]( }5 O
2. #define TIM_OCIDLESTATE_RESET              ((uint32_t)0x0000U)

复制代码

! h# N& l# _3 n8 y  OCNIdleState
空闲状态时，设置互补输出引脚的电平状态。
# U, G  Y! c9 X% ]" T
, f, x2 {$ K2 Y4 l* M

1. #define TIM_OCNIDLESTATE_SET               (TIM_CR2_OIS1N)
   ) h- q6 l. o( d' j
2. #define TIM_OCNIDLESTATE_RESET             ((uint32_t)0x0000U)

复制代码

: _, P! X) U0 S7 r9 L3 m/ t/ b1 `32.3.4 定时器输入捕获结构体TIM_IC_InitTypeDef
此结构体主要用于定时器的输入捕获，定义如下：
; }- z$ L. H  @

1. typedef struct
   
2. {                                 
   ( `4 I" y$ i- w5 i
3.   uint32_t ICPolarity;   
   . E. D  ^  H/ l, `1 N2 d
4.   uint32_t ICSelection;
   2 y5 f: R7 [5 P5 A
5.   uint32_t ICPrescaler;
   / v; j3 K( y4 a' q+ c9 |( Z1 f
6.   uint32_t ICFilter;   
   
7. } TIM_IC_InitTypeDef;

复制代码

2 Z; R5 ^3 ^6 F! F下面将这几个参数一 一做个说明。

  ICPolarity
3 a9 B- F4 i) v输入触发极性，可以选择上升沿，下降沿或者双沿触发。
1 y+ ]$ o% J+ w

1. #define  TIM_ICPOLARITY_RISING             TIM_INPUTCHANNELPOLARITY_RISING
   8 F, V# T& P  F2 F- L
2. #define  TIM_ICPOLARITY_FALLING            TIM_INPUTCHANNELPOLARITY_FALLING
   
3. #define  TIM_ICPOLARITY_BOTHEDGE           TIM_INPUTCHANNELPOLARITY_BOTHEDGE

复制代码

  ICSelection
8 C# `/ Q' X) G; m; T1 f1 |输入捕获通道选择，可以选择直接输入（即CC1选择TI1，CC2选择TI2等），间接输入（CC1选择TI2，CC3选择TI4等）或者TRC。
) u5 F8 \& L0 |5 g1 }* w' S7 f7 W
$ k+ X& E% d2 |. T4 W) |1 f

1. #define TIM_ICSELECTION_DIRECTTI       (TIM_CCMR1_CC1S_0)   
   
2. #define TIM_ICSELECTION_INDIRECTTI     (TIM_CCMR1_CC1S_1)  
   : S5 \: P& F- s8 z* D9 V; G
3. #define TIM_ICSELECTION_TRC            (TIM_CCMR1_CC1S)   

复制代码

  ICPrescaler
  g8 b0 M% y2 w) l, M2 c' c  O3 s输入捕获分频，表示每捕获1，2，4或8个事件后表示一次捕获。

1. #define TIM_ICPSC_DIV1       ((uint32_t)0x0000U)                 
   
2. #define TIM_ICPSC_DIV2       (TIM_CCMR1_IC1PSC_0)   
     B& R  B5 s4 D. Q/ }7 p
3. #define TIM_ICPSC_DIV4       (TIM_CCMR1_IC1PSC_1)   
     x# n4 M$ q5 j* A* k: F/ n7 s+ K
4. #define TIM_ICPSC_DIV8       (TIM_CCMR1_IC1PSC)

复制代码

. Y  @' f6 _) i; N5 b& J+ R  ICFilter
输入捕获滤波器，可以定义采样频率和多少个连续事件才视为有效的触发，参数范围0到15。具体定义如下，其中fCK_INT表示定时器时钟，fDTS表示死区时间采样率，N表示这么多个事件代表一次有效边沿。

1. 0000：无滤波器，按 fDTS 频率进行采样
   : ]5 C8 y$ K' n% d0 I  u& D0 |' M
2. 0001： fSAMPLING=fCK_INT， N=2
   * R7 f8 [/ o/ e$ F4 T
3. 0010： fSAMPLING=fCK_INT， N=4
   ; k  R- _0 w+ Y9 @) Z4 U% F/ w
4. 0011： fSAMPLING=fCK_INT， N=8
   
5. 0100： fSAMPLING=fDTS/2， N=6
   0 Q4 s4 s3 R9 D! a  ~; _- C+ y3 f
6. 0101： fSAMPLING=fDTS/2， N=8
   
7. 0110： fSAMPLING=fDTS/4， N=6
   
8. 0111： fSAMPLING=fDTS/4， N=8
   7 G# y, n6 V; D: k
9. 1000： fSAMPLING=fDTS/8， N=6
   
10. 1001： fSAMPLING=fDTS/8， N=8
    
11. 1010： fSAMPLING=fDTS/16， N=5
    
12. 1011： fSAMPLING=fDTS/16， N=6
    
13. 1100： fSAMPLING=fDTS/16， N=8
    
14. 1101： fSAMPLING=fDTS/32， N=5
    : O2 L) [( u6 ~/ L3 w* g
15. 1110： fSAMPLING=fDTS/32， N=6

复制代码

32.3.5 定时器的底层配置（GPIO，时钟，中断等）
HAL库有个自己的底层初始化回调函数，比如调用函数HAL_TIM_Base_Init就会调用HAL_TIM_Base_MspInit，此函数是弱定义的。
7 O# @9 s- J5 W& q8 K

1. __weak void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
   
2. {
   5 F: Q& m; ~2 \# T/ x, y& ]' ]
3.   /* Prevent unused argument(s) compilation warning */
   
4.   UNUSED(htim);
   3 L) h: Z) X* A1 N% ^4 Q( w
5.   /* NOTE : This function Should not be modified, when the callback is needed,
   3 Y7 z- c& g7 w' d$ Y
6.             the HAL_TIM_Base_MspDeInit could be implemented in the user file
   / j) d$ C4 S( G6 o( a
7.    */
   
8. }

复制代码

3 @# m( W7 s) H2 G3 ?8 H用户可以在其它的C文件重定向，并将相对的底层初始化在里面实现。对应的底层复位函数HAL_TIM_Base_DeInit是在函数HAL_TIM_Base_MspDeInit里面被调用的，也是弱定义的。

1 X4 c$ a+ ~: S9 H5 t当然，用户也可以自己初始化，不限制必须在两个函数里面实现。
6 `4 M9 u0 h' @$ o2 H' q3 Q
定时器外设的基本参数配置完毕后还不能使用，还需要配置GPIO、时钟、中断等参数，比如下面配置TIM1使用PA8做PWM输出。
: ]# h! H( w- q1 Z9 P

1. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
   
2. {
   
3.   GPIO_InitTypeDef   GPIO_InitStruct;
   ( k" g& H5 P+ ]( j7 Z
4. 
   
5.   /* 使能TIM1时钟 */
   
6.   __HAL_RCC_TIM1_CLK_ENABLE ();
   2 e/ l( _1 J. s3 m4 d
7. 
   
8.   /* 使能GPIOA时钟 */
   
9.   __HAL_RCC_GPIOA_CLK_ENABLE ();
   
10. 
    2 d% ?. B- K% y8 X  z; h; w
11.   /* 设置TIM1使用PA8做PWM输出引脚，将其配置为输出，推挽，复用模式 */
    . |4 F4 j8 I) l
12.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    6 a  g  |. U, d; D% e5 ]
13.   GPIO_InitStruct.Pull = GPIO_PULLUP;
    9 V( `0 X, d) a! E7 W
14.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    2 p( E0 ^9 J! W+ K. C
15. 
    6 v/ W+ e% ~1 z( g" G7 ^, i
16.   GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
    
17.   GPIO_InitStruct.Pin = GPIO_PIN_8;
    3 N9 x& i4 N8 H2 R' v! F9 `
18.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    - N4 I' l) G. o1 _& F" u2 g
19. 
    7 c( _) @9 g% X( G9 [+ {& F
20. }

复制代码

总结下来就是以下几点：
6 {; T$ h7 Y/ ^3 d) Z& K- Z' s
  配置TIM时钟。
  配置TIM所用到引脚和对应的GPIO时钟。
  如果用到定时器中断，还需要通过NVIC配置中断。
  如果用到DMA，还要配置DMA。
关于这个底层配置有以下几点要着重说明下：
! |& p8 B8 c0 ]8 H& k) H/ R7 L
& S% w, z0 P( g: [6 j& U0 }7 c. ~( f  定时器所使用引脚的复用模式选择已经被HAL库定义好，放在了stm32h7xx_hal_gpio_ex.h文件里面。比如TIM1有一个复用，
; h& D: @$ f; ~  D# p8 l& p0 I- y0 a

1. #define GPIO_AF1_TIM1      ((uint8_t)0x01)  /* TIM1 Alternate Function mapping */

复制代码

$ Y1 `& C$ A* Z2 G但是却有4个输出通道，每个通道都有几个支持的输出引脚：
- E7 C; A4 C4 w' X; A
' O3 X3 c) D! m8 M, k

1. TIM1_CH1,  PA8   PE9    PK1
   ! _/ u0 C2 W! q' n6 p* A% u
2. TIM1_CH2,  PA9   PE11
   
3. TIM1_CH3,  PA10  PE13   PJ9
   ; n1 {0 \3 u/ \1 S' Z
4. TIM1_CH4,  PA11  PE14   PJ11

复制代码

0 _. A. E, j3 s( I4 N& M: a具体使用哪个，配置对应引脚的复用即可：

  K- \# l* P/ H1 ~2 \1 n( Q0 d
32.3.6 定时器的状态标志清除问题
下面我们介绍__HAL_TIM_GET_FLAG函数。这个函数用来检查定时器标志位是否被设置。
( A( R$ D3 ]3 b+ V  o. r) }

1. 
   
2. /** @brief  Check whether the specified TIM interrupt flag is set or not.
   + z6 ~" y& e( [2 x& f
3.   * @param  __HANDLE__: specifies the TIM Handle.
   
4.   * @param  __FLAG__: specifies the TIM interrupt flag to check.
   3 ^1 W* o$ q3 c1 v
5.   *        This parameter can be one of the following values:
   2 k! K5 x! q# |( _6 R9 r
6.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag
   ) N( q) t* v8 y
7.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
   
8.   *            @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
   & \- z/ f& I+ c
9.   *            @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
   - I- W" \0 f: S) e
10.   *            @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
    5 N4 @) Q' ]5 D" n
11.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag
    
12.   *            @arg TIM_FLAG_CC6: Compare 6 interrupt flag
    
13.   *            @arg TIM_FLAG_COM:  Commutation interrupt flag
    
14.   *            @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
    
15.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   
    ( Z* A* P8 _7 w0 {* G8 w
16.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    5 o) g; {% T8 U) n
17.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
    $ T6 c1 e" m0 e+ C0 H
18.   *            @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
    
19.   *            @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
    
20.   *            @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
    2 R" m( H. V1 z) t1 N, t5 x
21.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    
22.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    
23.   */
    ' I3 B6 ^& [7 L9 U% e- X+ O
24. #define __HAL_TIM_GET_FLAG(__HANDLE__, __FLAG__)   (((__HANDLE__)->Instance->SR &(__FLAG__)) == (__FLAG__))

复制代码

0 \, R8 A5 I8 E: j1 }" E前5个是比较常用的中断标志。
9 S3 q6 j  `- C$ o' s* W4 ?; k
9 ^+ G: r7 y' l/ D$ _/ Q  TIM_FLAG_UPDATE
! }# I: x3 \1 c, i定时器更新标准，配置一个周期性的定时器中断要用到。

     TIM_FLAG_CC1
TIM_FLAG_CC2
* r7 R! A1 [( @+ j1 u
, A, I! a* c; YTIM_FLAG_CC3
; L' R# W. k' S
  {# s  q7 M/ @3 tTIM_FLAG_CC4
; R" I: v- D) r* U. @
3 P. [9 I% k1 T; a" s捕获/比较标志，配置了捕获/比较中断要用到。

与标志获取函数__HAL_TIM_GET_FLAG对应的清除函数是__HAL_TIM_CLEAR_FLAG：
, z2 f7 k/ C1 p3 h
- C6 U" |! d1 m/ W' G  t$ B

1. /** @brief  Clear the specified TIM interrupt flag.
   
2.   * @param  __HANDLE__: specifies the TIM Handle.
   + D1 G  i- o6 |( [, ~4 X# V+ Q
3.   * @param  __FLAG__: specifies the TIM interrupt flag to clear.
   ' f  I* u8 _  Q4 I# p
4.   *        This parameter can be one of the following values:
   % A" M6 n) R* P
5.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag
   
6.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
   4 ^  _7 [& |8 ?9 E+ o8 z0 t
7.   *            @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
   
8.   *            @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
   
9.   *            @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
   
10.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag
    ) U8 x3 M& K1 I) j3 R3 W
11.   *            @arg TIM_FLAG_CC6: Compare 6 interrupt flag
    . ~, y# w8 n0 p) B- J9 e1 A0 J! u( A/ r9 }! Z
12.   *            @arg TIM_FLAG_COM:  Commutation interrupt flag
    ) f; H) q. f- h$ N! i4 n) r
13.   *            @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
    " c3 i$ j4 Q; Q
14.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   
    
15.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    9 e+ d; p) \$ y/ ~( n/ n
16.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
    1 k, k0 E; K$ w$ S$ O
17.   *            @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
    ' K  r% K# H# P
18.   *            @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
    6 G; m, X- f$ ]1 P& z
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).
    
22.   */
    
23. #define __HAL_TIM_CLEAR_FLAG(__HANDLE__, __FLAG__)       ((__HANDLE__)->Instance->SR = ~(__FLAG__))

复制代码

清除标志函数所支持的参数跟获取函数是一 一对应的。除了这两个函数，还是定时器的中断开启和中断关闭函数用的也比较多。

1. /** @brief  Enable the specified TIM interrupt.
   
2. * @param  __HANDLE__: specifies the TIM Handle.
   
3. * @param  __INTERRUPT__: specifies the TIM interrupt source to enable.
   ) W* q! G# E; |0 O! ~
4. *          This parameter can be one of the following values:
   6 k( D5 |$ J* t& D: P
5. *            @arg TIM_IT_UPDATE: Update interrupt
   
6. *            @arg TIM_IT_CC1:   Capture/Compare 1 interrupt
   8 Q" a& G& l. a. P
7. *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt
   1 H9 o1 \6 i1 o% a+ Q3 S# L
8. *            @arg TIM_IT_CC3:  Capture/Compare 3 interrupt
   , y8 c3 v) o6 L
9. *            @arg TIM_IT_CC4:  Capture/Compare 4 interrupt
   ! m+ Z! R# _; ?6 q" r* s
10. *            @arg TIM_IT_COM:   Commutation interrupt
    6 q% S$ G  b% C  b
11. *            @arg TIM_IT_TRIGGER: Trigger interrupt
    * K: f5 I8 w- ?- T' X6 G  d. O! q
12. *            @arg TIM_IT_BREAK: Break interrupt
    6 s* z$ Z8 ?5 A$ t. }# Q; V  N
13. * @retval None
    $ L4 m: c7 ~! d8 o3 _% [0 Y7 f* O
14. */
      u3 y- Y  q( B6 u0 r
15. #define __HAL_TIM_ENABLE_IT(__HANDLE__, __INTERRUPT__)  ((__HANDLE__)->Instance->DIER |= (__INTERRUPT__))
    
16. 
    
17.   /** @brief  Disable the specified TIM interrupt.
    " t* f( [9 j0 g% s$ q- I
18.   * @param  __HANDLE__: specifies the TIM Handle.
    
19.   * @param  __INTERRUPT__: specifies the TIM interrupt source to disable.
    $ k6 v% P+ l# }1 d4 [. o7 B! q
20.   *          This parameter can be one of the following values:
    
21.   *            @arg TIM_IT_UPDATE: Update interrupt
    # m8 _- x4 F4 c8 C: B, r) A
22.   *            @arg TIM_IT_CC1:   Capture/Compare 1 interrupt
    
23.   *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt
    
24.   *            @arg TIM_IT_CC3:  Capture/Compare 3 interrupt
    6 b+ o' C% k+ }+ j7 r* T
25.   *            @arg TIM_IT_CC4:  Capture/Compare 4 interrupt
    ( I, K( L2 M* e2 T3 C5 O3 s' c9 h
26.   *            @arg TIM_IT_COM:   Commutation interrupt
    
27.   *            @arg TIM_IT_TRIGGER: Trigger interrupt
    & K, Q7 A; Y; ^) b( f1 n! k
28.   *            @arg TIM_IT_BREAK: Break interrupt
    3 H0 x6 I3 l! W* ?- k8 |4 K+ H* x
29.   * @retval None
    + E1 l! _+ W0 A' ]9 r! y
30.   */
    
31. #define __HAL_TIM_DISABLE_IT(__HANDLE__, __INTERRUPT__)   ((__HANDLE__)->Instance->DIER &= ~(__INTERRUPT__))

复制代码

/ {6 G8 @( _7 r: Q常用的也是前五个参数，1个定时器更新中断以及4个CC中断 。
* e! J& W$ D1 v$ t; a' A( u
注意：操作定时器的寄存器不限制必须要用HAL库提供的API，比如要操作寄存器CR1，直接调用TIM1->CR1操作即可。

32.3.7 定时器初始化流程总结
7 z3 \2 _+ f+ k+ d/ p) x使用方法由HAL库提供：
/ m$ e, }( U+ ~9 V, G* r/ v2 [
/ u6 g$ C: B& P* P  第1步：通过下面几个函数配置定时器工作在相应的模式

  HAL_TIM_Base_Init
: a- h% n7 c2 V3 h$ ~8 f简单的定时器时基础功能

  HAL_TIM_OC_Init 和 HAL_TIM_OC_ConfigChannel
6 O7 m- b6 b# Y: M; C% z+ X( L; [# [配置定时器产生输出比较信号

7 Q4 A7 a- ]7 ~4 g, ~$ D" f$ D  HAL_TIM_PWM_Init 和 HAL_TIM_PWM_ConfigChannel
3 ^- r3 {6 W  ~  P- E' [( h1 p7 ^1 V配置定时器产生PWM信号
% t2 a4 E8 z/ K. q. S, `+ N" w5 x
+ b7 S" j/ O) K% M  D9 ^, Z  HAL_TIM_IC_Init 和 HAL_TIM_IC_ConfigChannel
配置定时器测量外部信号
9 h1 s" @! L+ P7 W' S4 i
% k4 L' M3 k/ u8 T1 t& ^1 Z+ e  HAL_TIM_OnePulse_Init 和 HAL_TIM_OnePulse_ConfigChannel
) K/ ?, D" K% C$ G4 b. ]配置定时器工作在单脉冲模式

  HAL_TIM_Encoder_Init
9 l0 i: F: @* R5 F3 _7 d) j+ K4 Y, l配置定时器使用编码器接口

  第2步：定时器几个常用功能的底层初始化API，这个里面需要用户自己填
- P6 M$ e) S: d, D
' E' o4 {8 D3 w+ _5 n6 k9 @$ k1 [第1步里面的几个函数会调用下面的API。
( l( @8 i, S- ?' }/ k
  定时器基本功能 : HAL_TIM_Base_MspInit()
  输入捕获 : HAL_TIM_IC_MspInit()
  输出比较 : HAL_TIM_OC_MspInit()
1 G8 l4 ^; W3 P. l2 j" g  PWM输出 : HAL_TIM_PWM_MspInit()
# T$ A: e& y4 U3 m8 p$ P2 g  ^  单脉冲输出模式: HAL_TIM_OnePulse_MspInit()
  编码器模式 : HAL_TIM_Encoder_MspInit()
; W% F$ f. `# @( K4 s  第3步：底层初始化具体实现

: a' s! I2 N( Y, ?第2步中函数的具体实现。

" q% x4 ]* X. F; J8 W$ F  使用函数__HAL_RCC_TIMx_CLK_ENABLE()使能定时器时钟。
% Q" t( x  y! d( w* L0 d" e  使用函数__HAL_RCC_GPIOx_CLK_ENABLE()使能定时器使用到的引脚时钟。
  使用函数HAL_GPIO_Init()配置GPIO的复用功能。
- @( C! |* Q3 y9 T) X  如果使能了定时器中断，调用函数HAL_NVIC_SetPriority和HAL_NVIC_EnableIRQ配置。
0 o2 F- L! y" S  ]: r1 v  如果使能了DMA，还需要做DMA的配置。
  定时器默认使用APB时钟，如果使用外部时钟，调用函数HAL_TIM_ConfigClockSource可以配置。
; U2 ^0 F+ Z" _  e  第4步：启动定时器外设

* \* h" n6 Z- p5 N* _7 d3 Z, j8 y  定时器基础功能:
HAL_TIM_Base_Start()
$ ]6 I: C, V9 p$ \1 Q
' C. I  ~2 O: Y' o% @! c$ MHAL_TIM_Base_Start_DMA()
5 R" x7 c1 z( ^: `: T
, U  @; |# Q% T& i; u  \" B9 D/ f; SHAL_TIM_Base_Start_IT()

  输入捕获 :
HAL_TIM_IC_Start()

7 Z2 d5 J" N  uHAL_TIM_IC_Start_DMA()
, U' S$ C5 f/ T
HAL_TIM_IC_Start_IT()
# X3 y: z9 }6 I* C/ E! s  y/ E
5 |- b: w/ A6 s1 p: U6 w1 E) M  输出比较 :
HAL_TIM_OC_Start()
* Y! u# H9 m! H; b' d: ^
HAL_TIM_OC_Start_DMA()

+ a  d. I$ [9 f# a; ?( }9 t$ tHAL_TIM_OC_Start_IT()

7 n2 e) h1 D- u2 P" \  PWM输出：
HAL_TIM_PWM_Start()
2 B3 z9 _, N2 Q) I# Y
3 U  _. q: \) v1 N9 q- CHAL_TIM_PWM_Start_DMA()
; F" n' [$ g: n  c
; b$ _' r4 I& J. A& }5 b9 rHAL_TIM_PWM_Start_IT()

  单脉冲模式：
HAL_TIM_OnePulse_Start()

6 L, ]* u7 _% {. U- l9 VHAL_TIM_OnePulse_Start_IT().

  编码器模式：
HAL_TIM_Encoder_Start()
: J* ~/ O! {) a) Z
HAL_TIM_Encoder_Start_DMA()

" q: F* {$ S8 M- b. ?9 i% EHAL_TIM_Encoder_Start_IT().

+ ^7 `, D* F2 j: i  d/ }- L  第5步：定时器的DMA突发使用下面两个函数

& O8 V5 s$ g, W6 i  HAL_TIM_DMABurst_WriteStart()
  HAL_TIM_DMABurst_ReadStart()
7 |2 N7 v! m4 p. B; W+ z% U定时器常用的功能，通过上面这几步即可实现。

32.4 源文件stm32h7xx_hal_tim.c
此文件涉及到的函数非常多，这里把几个常用的函数做个说明：
2 Z' s, M: Z: ~% _9 B
! {2 ]" x' k" z$ b( O: P  HAL_TIM_Base_Init
  HAL_TIM_Base_Start
) K# Z* l( t+ c, y. F! h" v+ i0 o9 a  HAL_TIM_PWM_Init
  HAL_TIM_PWM_ConfigChannel
& D6 T, ]' E! c* F$ o: q. u% w, D  HAL_TIM_PWM_Start
  HAL_TIM_IC_Init
  HAL_TIM_IC_ConfigChannel
. y& N2 n- |7 L# ?0 N9 R  HAL_TIM_IC_Start_IT
  HAL_TIM_OC_Init
3 h3 T" |3 y( m( F. x  s  _  HAL_TIM_OC_ConfigChannel
4 E1 O% b/ C9 h3 V, G0 t  HAL_TIM_OC_Start
1 s! ~! q% v  m8 o32.4.1 函数HAL_TIM_Base_Init
函数原型：
9 w+ P( J. s! f2 h4 ^- Q
- |, u( A* a1 v, b

1. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   0 N7 X3 w* i4 ?9 n# O' h
2. {
   % u8 ~0 j9 T# S+ T
3.   /* 检测是否是有效句柄 */
   
4.   if(htim == NULL)
   2 t" B8 s) k# o/ j0 f2 \& a( t
5.   {
   
6.     return HAL_ERROR;
   7 k. P# i, ?% q
7.   }
   
8. 
   ! P! P3 `8 X; G1 g1 U5 O
9.   /* 检测参数 */
   
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));
    
13. 
    
14.   if(htim->State == HAL_TIM_STATE_RESET)
    ) |$ _% [, I5 \* ^! l) r8 H( p
15.   {
    / x+ A1 Y. _0 t$ r  i
16.     /* 默认取消锁 */
    
17.     htim->Lock = HAL_UNLOCKED;
    , Z$ f  [* R1 o% c3 y5 O/ ?: I, N3 z
18.     /* 初始化底层硬件 : GPIO, CLOCK, NVIC */
    + A, ?' A1 L# Y' ^
19.     HAL_TIM_Base_MspInit(htim);
    
20.   }
    ' b8 Q: o8 U5 N! W+ b
21. 
    * l% ?6 l0 `& w, o5 i' y* l
22.   /* 设置TIM状态 */
    : y; M4 Z: n+ e" ]! a" q
23.   htim->State= HAL_TIM_STATE_BUSY;
    1 Q3 r; }# \6 e8 b/ x
24. 
    
25.   /* 基本参数配置 */
    
26.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
27. 
    
28.   /* 设置TIM就绪 */
    8 ^* `4 ~  }  d: X" {
29.   htim->State= HAL_TIM_STATE_READY;
    ' l/ g$ ?' s  @$ s0 X6 W5 N: x/ Q- D
30. 
    
31.   return HAL_OK;
    
32. }

复制代码

函数描述：
; B# ^4 y8 y- R" {4 e7 n
此函数用于初始化定时器用于PWM。

! I8 _) c  `, ]: X0 l函数参数：

5 C, k0 \7 w2 R  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：
1 ~# P/ I; C7 Y% E% W( H
8 `: K% _- a* T, u函数HAL_TIM_Base_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
( C/ ]2 A+ {" ~8 c如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
# A) U7 ~" @: @- |  C对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_TIM_STATE_RESET  = 0x00U。

解决办法有三：
$ f6 t0 x4 h# @- j
, K2 h+ D. p2 j方法1：用户自己初始定时器和涉及到的GPIO等。
2 \, O3 o) Q( h9 a/ ~3 W
1 b5 x4 ]4 l0 b方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

, w' K" ~) n3 L6 x( Q8 w% ?方法3：下面的方法

4 f4 V  A3 ?7 e6 T( _# r

1. if(HAL_TIM_Base_DeInit(&TimHandle) != HAL_OK)
   
2. {
   4 D- x! s. T$ `- E( ?( G. B1 r4 D
3.     Error_Handler();
   
4. }  
   
5. if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
   " {0 R1 |, T2 A7 Y/ Y
6. {
   
7.     Error_Handler();
   
8. }

复制代码

$ w; x- v& E! `  k. `, n9 [% B! f" P使用举例：
  J' d" q7 t' G! z3 V) B6 M9 L9 C
4 Z& a; F! j8 l% K  J" J

1. TIM_HandleTypeDef   TimHandle = {0};
   / I  f' V0 A" i$ t5 u
2. 
   
3. /*
   
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   # W7 V" w( C6 ]" z% {: j1 G4 z. F
6. TimHandle.Instance = TIMx;
   
7. TimHandle.Init.Prescaler         = usPrescaler;
   * j7 X. q8 L+ v0 u  L
8. TimHandle.Init.Period            = usPeriod;        
   - q" l+ U; }" K* B! j6 K+ k
9. TimHandle.Init.ClockDivision     = 0;
   
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    1 h  C! y: K+ B& p& b# p
11. TimHandle.Init.RepetitionCounter = 0;
    6 |! I. {8 o3 _
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    ) f- V! `# s7 J2 f5 \
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    4 e: j- S4 i. T5 k8 n" v
14. {
    
15.         Error_Handler(__FILE__, __LINE__);
    / ^$ a) B/ @$ d2 S7 {) S
16. }

复制代码

$ W+ C, B8 ~4 D3 j) q6 t& F32.4.2 函数HAL_TIM_Base_Start
- U5 Y! L# {2 w( s函数原型：

1. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   
2. {
   # q' V6 D" ?9 ~
3.   /* 检测参数状态 */
   
4.   assert_param(IS_TIM_INSTANCE(htim->Instance));
   " @$ ^" ~: [- ^' s
5. 
   
6.   /* 设置定时器状态 */
   - t, T- N) W# p# D
7.   htim->State= HAL_TIM_STATE_BUSY;
   
8. 
   , a% _( a( M: `% l. s3 ~% j, U' U
9.   /* 使能定时器 */
   ! q) Q3 Z, T* e. v: k+ Y
10.   __HAL_TIM_ENABLE(htim);
    2 U: ?% |3 V( }+ p
11. 
    
12.   /* 设置定时器状态 */
    
13.   htim->State= HAL_TIM_STATE_READY;
    
14. 
    ' r& B$ A9 H9 w- P6 Z" f
15.   /* 返回HAL_OK */
    + E  R& s' I1 u1 T
16.   return HAL_OK;
    . a7 n3 u, o& B1 ?
17. }

复制代码

3 U5 v2 f" z0 u0 }3 [& r2 y函数描述：
/ B% ^* L8 V: @* ^- T
2 p6 d/ o; \8 Y! m; b( L9 ~+ F此函数比较简单，调用函数HAL_TIM_Base_Init配置了基础功能后，启动定时器。
2 B# u2 `; g8 ^. N
函数参数：

, I* I8 `/ U$ N5 {2 A  第1个参数是TIM_HandleTypeDef类型结构体指针变量。
  返回值，固定返回HAL_OK，表示初始化成功。
使用举例：

& D2 X' O  X9 |) C6 m- T

1. TIM_HandleTypeDef   TimHandle = {0};
   
2. 
   0 W, h# k  y  Q, k5 [0 y
3. /*
     B7 E2 \3 B! V. v2 o/ F
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   + g: K( E& F8 q9 C# N# u% p; l
5. */
   : N  Q, \7 P+ }1 T7 m% v
6. TimHandle.Instance = TIMx;
   
7. TimHandle.Init.Prescaler         = usPrescaler;
   & }$ t9 J0 e4 o6 p- p/ |
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. {
    
15.         Error_Handler(__FILE__, __LINE__);
    
16. }
    ! c! o; S7 w0 b& w7 ?, [) E
17. 
    
18. /* 启动定时器 */
    
19. if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
    
20. {
    ; N$ y# F. v; s3 W# n1 u; D
21. Error_Handler(__FILE__, __LINE__);
    1 ]4 `0 g7 d1 S' r, W3 n  M
22. }

复制代码

32.4.3 函数HAL_TIM_PWM_Init
% k4 z4 V0 m/ j, B; }函数原型：

7 u- s; n( l% I4 M

1. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
   * @& ]6 z7 g' Y1 S7 G) a
2. {
   
3.   /* 检查句柄是否有效 */
   
4.   if(htim == NULL)
   
5.   {
   - f- s9 H5 A9 z
6.     return HAL_ERROR;
   
7.   }
   
8. 
   ! x& w4 b2 C0 d# ?1 y3 k
9.   /* 检测参数 */
   " o5 b8 x" e1 q% k. B2 [! p5 x$ \
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    ( l! K# v$ M6 n: s
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    5 ?, ^4 Z% o, n  U4 s8 C3 \
13. 
    ' _5 k3 r2 A! {% S
14.   if(htim->State == HAL_TIM_STATE_RESET)
    
15.   {
    ( t5 U. l4 o3 m8 q
16.     /* 默认取消锁 */
    3 d6 m6 u% r' l# R- ]2 N
17.     htim->Lock = HAL_UNLOCKED;
    
18. 
    : X4 g- L. A2 L9 D% J3 q4 Z$ b6 a/ t
19.     /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_PWM_MspInit(htim);
    , N% u1 e) P; b% q& V. k9 p
21.   }
    
22. 
    $ d- N3 |! d; k+ t3 v( T, z9 F
23.   /* 设置定时状态 */
    % b, r& ]  F# q0 V* M$ F* l8 V
24.   htim->State= HAL_TIM_STATE_BUSY;
    * y: d" Q& H6 y2 a7 Z5 b$ a! x
25. 
    * ~! @; P8 \. Q' P' ~7 K
26.   /* 配置定时器用于PWM */  
    % T8 f1 Z7 g2 K: q. {3 U
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    + H1 |3 N( {# |* C! C
28. 
    2 ~* K( Q8 N5 {% ?
29.   /* 设置定时器状态 */
    
30.   htim->State= HAL_TIM_STATE_READY;
    
31. 
    
32.   return HAL_OK;
    9 W  B( Q- v1 K( {9 }" ~5 e6 {
33. }

复制代码

0 r, M4 [/ U! p. q: g) K- `函数描述：

- g. H9 j5 ]" W$ b此函数用于初始化定时为PWM方式。

函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
& _2 w& r) F% S注意事项：
  k$ m/ l+ O- _- }
函数HAL_TIM_PWM_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
5 ?$ k9 S; D6 v( b4 q" y如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
) m1 U% J1 p0 [/ {+ W对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_TIM_STATE_RESET  = 0x00U。

* o) O! ~7 h" T* m$ w解决办法有三：

方法1：用户自己初始定时器和涉及到的GPIO等。

方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
! Z% i% S9 H* V+ ?7 X1 T# ]
方法3：下面的方法
/ }3 o# m- i4 I# ?' H
  e& z' a$ H3 o# @" A! i6 a8 c$ {! ~

1. if(HAL_TIM_PWM_DeInit(&TimHandle) != HAL_OK)
   ) E* X3 ~% B, d: D0 H' q0 ]& S
2. {
   % P; a4 |4 u6 i: A" H
3.     Error_Handler();
   * ^4 p; z! A3 n% r! Y
4. }  
   
5. if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
   ) k6 Y4 [- ^4 F
6. {
   
7.     Error_Handler();
   
8. }

复制代码

- P- K( \4 N0 l5 b9 X8 Y; w使用举例：
  [3 N1 \+ B: a

1. TIM_HandleTypeDef  TimHandle = {0};
   
2. 
   # D- f/ s8 ^0 g1 J0 S
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   2 k8 b3 L5 d, @- N
4. TimHandle.Instance = TIM1;
   
5. TimHandle.Init.Prescaler         = usPrescaler;
   % B5 W* J) t! J+ a% f( r/ s
6. TimHandle.Init.Period            = usPeriod;
   8 C6 {5 j$ P; m  T4 b: l' S
7. TimHandle.Init.ClockDivision     = 0;
   % I1 Q/ Q; G8 Y' ~; |% r% H
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   - A# S& M' O; s3 K$ Y6 N
9. TimHandle.Init.RepetitionCounter = 0;
   
10. TimHandle.Init.AutoReloadPreload = 0;
    % h! g" ~0 S. I/ o
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    / C1 v: I7 v9 J2 l" F  M9 y
12. {
    
13.     Error_Handler(__FILE__, __LINE__);
    - |4 a1 W* n7 P
14. }

复制代码

32.4.4 函数HAL_TIM_PWM_ConfigChannel
函数原型：

1. HAL_StatusTypeDef HAL_TIM_PWM_ConfigChannel(TIM_HandleTypeDef *htim,
   
2.                                             TIM_OC_InitTypeDef* sConfig,
   
3.                                             uint32_t Channel)
   . J! y& P  d: v& K# ?  e  E6 U
4. {
   - a' M! `- z: U+ u
5.    /* 省略 */
   
6. 
   , Y  S( S8 E0 E9 c9 `3 j- x& v
7.   /* 开锁 */
   
8.   __HAL_LOCK(htim);
   ; H7 h' J1 k) c3 N' N
9. 
   1 T9 {. ^9 I% ^8 P6 L0 j* E
10.   htim->State = HAL_TIM_STATE_BUSY;
    # X. N2 {3 e: d
11. 
    
12.   switch (Channel)
    
13.   {
    0 G) _; u" A' R3 H
14.     case TIM_CHANNEL_1:
    # N" A$ O+ E' [% C  h3 W. K5 Y
15.     {
    4 z7 }0 Y; I$ s4 S
16.       /* 检查参数 */
    6 y" W) y" A4 R7 ~' h( f
17.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    
18. 
    # w# T& H) y' B+ l& u. h9 F
19.       /* 配置通道1的PWM模式 */
    
20.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    8 A' r! W  G! j* A7 n( g' x
21. 
    
22.       /*预装载使能，更新事件产生时写入有效 */
    
23.       htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;
    ; y1 g0 a6 \  o3 s% ?
24. 
    
25.       /* 配置是快速输出模式 */
    - n8 N1 k% y5 ^
26.       htim->Instance->CCMR1 &= ~TIM_CCMR1_OC1FE;
    
27.       htim->Instance->CCMR1 |= sConfig->OCFastMode;
    
28.     }
    9 R) S( }# V# C
29.     break;
    ! b2 Z* U) Q: t8 _4 i: c2 b
30. 
    
31.     case TIM_CHANNEL_2:
    
32.     {
    9 z# e' L3 s8 J7 G% c  Z' m
33.        /* 省略 */
    
34.     }
    
35.     break;
    ' E; W4 [  @' w6 ]& r5 o
36. 
    
37.     case TIM_CHANNEL_3:
    " A' [  E2 J# q) {1 w
38.     {
    ! w: @* g+ `: D
39.        /* 省略 */
    
40.     }
    * u+ x  e8 y& Q- K9 J
41.     break;
    ; \  w% F1 k- J3 X: h8 i! Q
42. 
    
43.     case TIM_CHANNEL_4:
    . Q% o1 B1 M  t" U
44.     {
    
45.       /* 省略 */
    4 N% I# l7 t% v) T& P+ q" t0 \; R
46.     }
    ' D$ ?& i+ S$ ], R( A! f7 {8 M) `
47.     break;
    6 ^# I# H' b' u$ O% i6 R
48. 
    
49.     case TIM_CHANNEL_5:
    8 t6 w! s( n8 j5 E+ V1 p+ k
50.     {
    ; E! z3 Y2 g7 a5 V6 {% b
51.        /* 省略 */
    : R/ v2 q+ Q- u/ o$ ^/ v( I' [
52.     }
    
53.     break;
    
54. 
    8 l  |: }% p  d/ c$ O
55.     case TIM_CHANNEL_6:
    
56.     {
    * b7 y, J# {6 y; a: j
57.         /* 省略 */
    
58.     }
    
59.     break;
    
60. 
    - V( {/ Q$ @) x
61.     default:
    
62.     break;
    
63.   }
    
64. 
    5 D- U& W  y5 l6 C0 U/ @
65.   htim->State = HAL_TIM_STATE_READY;
    5 k0 Z9 ]8 u2 d3 W0 H" R
66. 
    
67.   /* 关锁 */
    
68.   __HAL_UNLOCK(htim);
    . s% o9 a# R7 a
69. 
    4 j. c" W( t* e5 m
70.   return HAL_OK;
    
71. }

复制代码

函数描述：

1 Z3 {: D: e) a) h, {2 h- b$ u此函数用于配置定时器的PWM通道。
, P/ h. T5 v. H  w* Z$ G8 }6 D+ k
函数参数：

  O/ e# U# w. b% S/ k+ S' b1 H  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
; }, V2 y( d$ o7 Y7 V  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
( S2 Q3 [; c! |, \# a# |. u/ j7 W6 `TIM_CHANNEL_1
: ]' C/ Q; i2 a; j. y# D! L
TIM_CHANNEL_2
1 z: e& E9 V6 p! g* P' a, @
: x7 ?2 f8 I7 A- eTIM_CHANNEL_3

6 R2 l. g2 l; S) ?9 C0 Q, zTIM_CHANNEL_4

4 `9 p# S/ ?8 d' t4 ^8 lTIM_CHANNEL_5
$ E: h$ Z- h% l: a
TIM_CHANNEL_6

7 B5 E4 F  m- ]- G6 t  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
使用举例：
) i& P& p0 r$ l" j' K/ X

1. TIM_HandleTypeDef  TimHandle = {0};
   
2. 
   1 s- e2 `, J+ m7 ?+ j
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   
4. TimHandle.Instance = TIM1;
   / Q) u& R3 i3 E" N7 S8 K# b
5. TimHandle.Init.Prescaler         = usPrescaler;
   1 l  O/ Z( u/ R& m
6. TimHandle.Init.Period            = usPeriod;
   ! o" k7 t' F# N5 ~# w$ e
7. TimHandle.Init.ClockDivision     = 0;
   
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   4 C7 Z! z3 ?1 \, D# D
9. TimHandle.Init.RepetitionCounter = 0;
   * b( W" _3 R! H, {. S
10. TimHandle.Init.AutoReloadPreload = 0;
    
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    
12. {
    
13.     Error_Handler(__FILE__, __LINE__);
    5 H  r1 b! C# s7 ^9 p$ R7 z# K
14. }
    2 q8 |& C2 v/ R/ O2 c: t" L
15. 
    
16. /* 配置定时器PWM输出通道 */
    
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    5 Q3 N( q2 R. G, i# i) C) c
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    " I  n4 r. O) ?
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    5 s' x4 g) u* M. P& ~& X
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
      m: V6 P& R( k; d7 v- u
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    3 n7 {' K5 R$ d; V
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
    
23. 
    
24. /* 占空比 */
    
25. sConfig.Pulse = pulse;
    
26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    - A; W  P, C+ v
27. {
    
28.     Error_Handler(__FILE__, __LINE__);
    8 x* j$ ?$ W& w3 ?; g
29. }

复制代码

; A! O) S7 b# {& E32.4.5 函数HAL_TIM_PWM_Start
, N4 R- Y+ p, l  X- \7 a2 I函数原型：

' X$ `) O& ]: z3 i

1. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
   # P5 R& }2 g8 v1 i0 S) X
2. {
   0 u2 N. R( K$ [5 E/ @1 \
3.   /* 检测参数 */
   & M7 Z$ H7 E1 c
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   
5. 
   
6.   /* 使能捕获比较通道 */
   
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
8. 
   
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
   
10.   {
    # A2 q7 J( ^! v1 C2 P3 O
11.     /* 使能主输出 */
    
12.     __HAL_TIM_MOE_ENABLE(htim);
    
13.   }
    2 C2 G2 P) J+ v2 W( y8 Q
14. 
    
15.   /* 使能定时器 */
    ( a/ n- C' G6 g5 g& L
16.   __HAL_TIM_ENABLE(htim);
    
17. 
    
18.   /* 返回状态*/
    5 Y, K6 s6 V, @3 O+ S* a
19.   return HAL_OK;
    + i1 y% Z. T  ^1 v1 e
20. }

复制代码

$ n- s* r" T/ d' p# s) d1 p函数描述：

此函数用于启动PWM。
7 X4 L7 j  p7 w4 K7 v
函数参数：

# O. `" k* b  n6 d. i- M6 _  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  第2个参数是通道设置，支持以下参数：
TIM_CHANNEL_1
! y! `# i. D/ j( }+ ?7 {$ v+ A$ c" E
) {  `4 ?0 t  \5 c- o: pTIM_CHANNEL_2
7 ~+ d( C# ?4 {5 c* M+ L5 s$ l
TIM_CHANNEL_3
: ?: j. d* u8 m! z
4 f4 ^& t) |, x5 B1 zTIM_CHANNEL_4

6 D' n2 e3 F$ ?! l2 n6 m% K  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
, Z1 e; S3 X' a* p! R使用举例：
; `" f1 {: z5 Z8 ?2 V
! ]" a5 p) J& A# F/ \6 c* Y

1. TIM_HandleTypeDef  TimHandle = {0};
   
2. 
   5 R; A4 m, q) [0 J' R) |/ i! Z
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   : o9 s1 |! J1 `; y
4. TimHandle.Instance = TIM1;
   + o, g% r" k+ H
5. TimHandle.Init.Prescaler         = usPrescaler;
   . G# j7 I) y( d5 \2 ?6 z# {
6. TimHandle.Init.Period            = usPeriod;
   
7. TimHandle.Init.ClockDivision     = 0;
   : ^9 g' l. u7 L0 n* J& `
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   $ e( @# M0 M. ?# K& V; {
9. TimHandle.Init.RepetitionCounter = 0;
   
10. TimHandle.Init.AutoReloadPreload = 0;
    
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    1 b; p- R! \, T. e
12. {
      R5 r. q3 h, h- G6 @" c+ `# @
13.     Error_Handler(__FILE__, __LINE__);
    + d/ U) K. D; Z7 U# J+ f
14. }
    : d2 T& a/ R4 H* d4 [/ Y' b
15. 
      x- D* |7 a  N
16. /* 配置定时器PWM输出通道 */
    
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    + K% z' h, B+ M& l7 H+ h
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    5 i% c. U4 `' u3 N. }$ H' h- h
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
    
23. 
    3 I. N% t) V& K8 M
24. /* 占空比 */
    ( O, i6 P+ [3 ^& {4 x6 z& b2 V! m" ^/ W
25. sConfig.Pulse = pulse;
    
26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    ' C3 q$ |  I  Z
27. {
    ! J# s# g$ I" G, H) D. t
28.     Error_Handler(__FILE__, __LINE__);
    3 T. B+ C! z" k4 B  A5 M
29. }
    
30. 
    9 N& f  N! M% v- C6 X1 p7 u
31. /* 启动PWM输出 */
    
32. if (HAL_TIM_PWM_Start(&TimHandle, TimChannel[_ucChannel]) != HAL_OK)
    , z  S! ?  ]+ S8 `' b1 p
33. {
    
34.         Error_Handler(__FILE__, __LINE__);
    3 t! p0 J1 S0 o  d# f: f
35. }

复制代码

32.4.6 函数HAL_TIM_IC_Init
函数原型：

1. HAL_StatusTypeDef HAL_TIM_IC_Init(TIM_HandleTypeDef *htim)
   $ W0 @4 r$ e0 ^7 Y; f. h7 _
2. {
   
3.   /* 检测形参是否有效 */
   , A, B" t9 n  @/ D- ^
4.   if(htim == NULL)
   
5.   {
   ) ^& r0 l" T, q; I( n" D8 I
6.     return HAL_ERROR;
   
7.   }
   7 i* C% t( i4 @1 b7 S/ P
8. 
   
9.   /* 检测参数 */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    2 `; g- n6 f3 R" }9 z$ ~
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    ; w' F2 ^% g; c+ Z
13. 
    , q8 ]5 O( @: `9 L/ M+ ^
14.   if(htim->State == HAL_TIM_STATE_RESET)
    
15.   {
    + Q* O' i* Y) R3 _% v
16. /* 默认取消锁 */
    
17.     htim->Lock = HAL_UNLOCKED;
    4 N# {$ [6 F  B5 i" L6 Y: \/ U- m
18. 
    
19.      /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_IC_MspInit(htim);
    # B0 j  }/ C/ e
21.   }
    
22. 
    
23.   /* 设置定时器状态 */
    # e; f: S# D9 K8 Z0 l
24.   htim->State= HAL_TIM_STATE_BUSY;
    ' z$ w  Q9 k; ^% S1 m8 E4 f8 M
25. 
    
26.   /* 配置定时器为输入捕获模式 */  
    $ ~) W( Q7 M9 q: S/ r
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
28. 
    
29.   /* 设置定时器状态 */
    $ S1 q' p1 i2 b0 j" J
30.   htim->State= HAL_TIM_STATE_READY;
    . i6 c( l9 r: `& {$ F! n
31. 
    
32.   return HAL_OK;
    
33. }

复制代码

  v7 m: q! }$ ]8 {) s) M4 Q函数描述：
9 B! p# `) q( O- Y; W3 f
此函数用于定时器输入捕获初始化。

7 U, `: q; l5 s- J! Z8 e函数参数：
) ?* i. H% U7 G; M4 c6 a: W
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
% B" d! q4 q# n  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
& a8 i4 l+ a2 G4 n注意事项：

, c* M: n  F# E4 d% o% g函数HAL_TIM_IC_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个HAL_TIM_STATE_RESET  = 0x00U。
4 d' `7 k1 y; z2 ^+ e
$ t1 ?4 C6 d" O7 \解决办法有三：

4 k! l% R& x: d1 r' p. R方法1：用户自己初始定时器和涉及到的GPIO等。
! T5 X8 W& i7 K( y7 [. G3 E% A
方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
3 a, j; t8 f# k+ `2 P8 O# x8 n6 H& B
4 C6 J% f4 h- ^" Y+ r/ {方法3；下面的方法

1. if(HAL_TIM_IC_DeInit(&UartHandle) != HAL_OK)
   
2. {
   " V" C5 B. [7 _) P* @& _8 |
3.     Error_Handler();
   
4. }  
   * U" m- C; y7 c# ]7 O+ r$ ?
5. if(HAL_TIM_IC_Init(&UartHandle) != HAL_OK)
   : j9 @- A' [! V% S& b* V4 z# e' [
6. {
   
7.     Error_Handler();
   " w  ]/ E' S; w/ y
8. }

复制代码

32.4.7 函数HAL_TIM_IC_ConfigChannel
5 O7 C6 q& [6 ^" }7 Y' Z9 G函数原型：

7 i( W3 Z/ E2 t* r# l

1. HAL_StatusTypeDef HAL_TIM_IC_ConfigChannel(TIM_HandleTypeDef *htim, TIM_IC_InitTypeDef* sConfig, uint32_t Channel)
   
2. {
   
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
   ! ?, l& ?9 E6 h% _9 X
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));
   
8.   assert_param(IS_TIM_IC_FILTER(sConfig->ICFilter));
   
9. 
   
10.   /* 开锁 */  
    
11.   __HAL_LOCK(htim);
    " o9 N# }3 N) g( L' F" p' _
12. 
    
13.   htim->State = HAL_TIM_STATE_BUSY;
    . G( R$ X9 N# h$ B2 J6 `! K
14. 
    
15.   if (Channel == TIM_CHANNEL_1)
    # `6 r. Y4 R. O7 t" d8 _- p. y
16.   {
    + P, ]# ]! W1 }$ H4 i. A- h5 H
17.     /* 配置输入通道1 */
    
18.     TIM_TI1_SetConfig(htim->Instance,
    
19.                sConfig->ICPolarity,
    
20.                sConfig->ICSelection,
    ' b4 v$ d/ t# Z5 J" T! G6 R
21.                sConfig->ICFilter);
    
22. 
    . w/ S  V/ E; S5 N" d( D9 h5 m; S
23.     /* 清零IC1PSC位 */
    
24.     htim->Instance->CCMR1 &= ~TIM_CCMR1_IC1PSC;
      H" l: l- x9 O) z  K) L
25. 
    ) k$ q  ?4 W2 z, A' L" k
26.     /* 根据用户配置，设置分频 */
    & @1 w4 n" Q' `  t7 V
27.     htim->Instance->CCMR1 |= sConfig->ICPrescaler;
    $ I4 w* ]& y! ?
28.   }
    2 c( Z* A4 l8 |% F. @
29.   else if (Channel == TIM_CHANNEL_2)
    
30.   {
      s' w7 V0 t" s3 Q7 N, K) L& M
31. /* 省略 */
    7 T& s% r) R* R
32.   }
    : C. ]4 d! ^8 R' y. T. K
33.   else if (Channel == TIM_CHANNEL_3)
    
34.   {
    + D2 h5 A% l. z6 v; @. h
35.      /* 省略 */
    
36.   }
    
37.   else
    
38.   {
    
39.      /* 省略 */
    7 S8 h" A9 E; S% H1 D/ u
40.   }
    
41. 
    / `# T0 {% J& s8 e4 t# P2 M
42.   htim->State = HAL_TIM_STATE_READY;
    
43. 
    
44.   __HAL_UNLOCK(htim);
    * j8 X  x4 l% @& G# O
45. 
    
46.   return HAL_OK;
    : Z$ ^9 B# n/ g
47. }

复制代码

& @4 m1 z" F4 d* y/ R. S函数描述：
1 M1 @3 h" B; N1 Q8 l
, x; a" }/ @) l8 D7 ?! B此函数用于配置定时器的输入捕获通道。

, i6 o* [# x8 T1 D* e函数参数：

/ ?$ \; t- z- X) D0 ]0 O/ k  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置
  第2个参数是TIM_IC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
TIM_CHANNEL_1
" y7 a- ]$ }) |! {8 }
1 ?+ i6 X) v1 Y* j. W6 b' m0 _TIM_CHANNEL_2
7 h, A! z5 u9 |) r/ g$ A# H
) k1 w& x4 Q- b1 U8 x1 x8 _TIM_CHANNEL_3
, k' j  U  @+ ^/ f% q# x. S# S
TIM_CHANNEL_4
' p& A- ^: Q% v2 ~! a  `# _
6 E1 {) Q$ j8 G; g! W* H0 N  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
0 L- H7 k  z# D( d0 x9 B9 S6 t
6 W, L1 X, K& ?' x7 J/ D1 ~32.4.8 函数HAL_TIM_IC_Start_IT
函数原型：

1. HAL_StatusTypeDef HAL_TIM_IC_Start_IT (TIM_HandleTypeDef *htim, uint32_t Channel)
   
2. {
   
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   9 ~0 t2 T2 o( I2 T8 e
5. 
   
6.   switch (Channel)
   
7.   {
   
8.     case TIM_CHANNEL_1:
   , V6 ^1 n$ g2 k% M' N0 e" W
9.     {      
   + {: ]1 ?" ]" i7 t
10.       /* 使能CC1（Capture/Compare 1）中断 */
    
11.       __HAL_TIM_ENABLE_IT(htim, TIM_IT_CC1);
    
12.     }
    
13.     break;
    1 P5 |( w# j/ K, t( f
14. 
    1 i1 k+ B) Y& x1 u7 c+ h+ o* J, G
15.     case TIM_CHANNEL_2:
    # V& I# Z0 V" _3 h2 F  f( ?1 o6 H: v
16.     {
    9 {) O/ z7 P- b- u' Z3 ~
17.    /* 省略 */
    1 }  o: @. ?& I+ s: a4 y
18.     }
    
19.     break;
    ' x& K  _8 J( T, w
20. 
    
21.     case TIM_CHANNEL_3:
    
22.     {
    
23.   /* 省略 */
    
24.     }
    6 `7 z0 }2 _& r* H
25.     break;
    0 X$ ~" f& P1 D+ B) m
26. 
    & a- a5 D* O9 e
27.     case TIM_CHANNEL_4:
    ( h. D5 X. l$ F# y& C4 T
28.     {
    
29.   /* 省略 */
    & s6 u) e; c' ~, F4 L
30.     }
    
31.     break;
    
32. 
    
33.     default:
    3 d$ y& ~3 C; x& s; Z
34.     break;
    " k/ u( j+ v  R7 R' \
35.   }  
    
36.   /* 使能输入捕获通道 */
    5 W+ ^. v9 E" E8 W5 g
37.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
38. 
    & c7 |, D1 `8 J6 r6 h0 O
39.   /* 使能定时器 */
    - j# Y7 }4 [. h! C
40.   __HAL_TIM_ENABLE(htim);  
    
41. 
      |. ~% z/ W. C) l7 n
42.   /* 返回状态 */
    
43.   return HAL_OK;  
    . g0 V' T/ g8 O# i) h
44. }

复制代码

  D1 u( [4 u  Y  B8 V7 L7 H函数描述：

此函数用于启动定时器输入捕获模式，采用定时器方式。
/ K! q# p+ N3 I# P* B: B  @+ a$ M
函数参数：
' F. _2 F( k0 A" G' s
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  第2个参数是通道设置，支持以下参数：
TIM_CHANNEL_1

TIM_CHANNEL_2
4 y, l- k6 X) U0 R# h3 K
) J2 l- Z3 D% uTIM_CHANNEL_3
8 X" _- z2 d* Z  [" X7 r5 o; m# s
: k4 Z: Z, M1 ~) k: Y, RTIM_CHANNEL_4

) q* a! ^, y7 w. Z0 c2 A: k; ~  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
  c! q4 N3 I+ K/ H1 P! p1 A
32.4.9 函数HAL_TIM_OC_Init
函数原型：
% H" c) B9 \) V  _  O9 H
" h& i, ^, G; c& a

1. HAL_StatusTypeDef HAL_TIM_OC_Init(TIM_HandleTypeDef* htim)
   
2. {
   7 N# q& u5 g" ]5 q
3.   /* 检测形参是否有效 Check */
   
4.   if(htim == NULL)
   ; u* @/ W4 C" B5 `
5.   {
   : M& D& a5 x: `" z/ o$ f
6.     return HAL_ERROR;
   6 h3 A4 d0 F  G) @
7.   }
   
8. 
   
9.   /* 检查参数 */
   
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));
    
13. 
    
14.   if(htim->State == HAL_TIM_STATE_RESET)
    
15.   {
    
16. /* 默认取消锁 */
    
17.     htim->Lock = HAL_UNLOCKED;
    
18. 
      ~! x% {: ?! O
19. /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    0 m) t" L6 e8 r9 R
20.     HAL_TIM_OC_MspInit(htim);
    
21.   }
    , @) A) N' F- q, P" y3 A
22. 
    & G7 M" I0 r/ b4 l/ {
23.   /* 设置定时器状态Set the TIM state */
    
24.   htim->State= HAL_TIM_STATE_BUSY;
    % s2 f8 X0 ?; r; M/ H) T
25. 
    
26.   /* 配置定时器为输出比较模式Init the base time for the Output Compare */  
    . F4 Z8 @, k4 @/ C) v& ?
27.   TIM_Base_SetConfig(htim->Instance,  &htim->Init);
    
28. 
    ! H7 c/ j7 m1 M" m0 ?' j1 {* Z
29.   /* 设置定时器状态 */
    
30.   htim->State= HAL_TIM_STATE_READY;
    % Z6 r" ~# H$ B1 \1 x) |' ^0 P
31. 
    
32.   return HAL_OK;
    . [( v( [3 `& w) d, i; P% U, Y
33. }

复制代码

函数描述：
' j( l6 D1 x# h
9 ^9 }7 L* |, T" h4 n6 ^# v此函数用于定时器输出比较初始化。
# t; P! q* j& P) z# h) {7 a  W# a$ K
函数参数：
- u! U: D* u  m& d0 ?
6 Z  i' O/ }# ]1 v2 N% w: N# s  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
! R, d1 f/ X8 p2 l  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
! l: X: i- Y+ G; a注意事项：

函数HAL_TIM_OC_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
' S" I9 }/ `! i' W# _3 h% H如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
7 u8 j7 G6 ]: _% G6 B# Z对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个HAL_TIM_STATE_RESET  = 0x00U。

解决办法有三：
0 L: E) p: ?7 a0 R1 R
) _; o. }) K( Y5 M  N' H- P7 A* F9 y8 e方法1：用户自己初始定时器和涉及到的GPIO等。

. g& L, k6 Q# E6 a& C方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
4 H* A6 b  S; p0 `
方法3；下面的方法

+ n+ Z- n: p- j. t5 [

1. if(HAL_TIM_OC_DeInit(&UartHandle) != HAL_OK)
   
2. {
   1 W" s- F2 X' k* Q$ f( T$ V
3.     Error_Handler();
   $ y" _' l1 O2 Z2 u' P' C
4. }  
   
5. if(HAL_TIM_OC_Init(&UartHandle) != HAL_OK)
   8 W# F# J# U9 U; o/ R# b7 f  c
6. {
   - {5 U$ k7 I& W& H- }
7.     Error_Handler();
   ) ?7 H! X: g+ M% V( w! t
8. }

复制代码

32.4.10   函数HAL_TIM_OC_ConfigChannel
函数原型：
8 D6 E3 k, x  q+ {0 n( f2 B
" X/ G4 B' N! k- W( ]# s9 M

1. HAL_StatusTypeDef HAL_TIM_OC_ConfigChannel(TIM_HandleTypeDef *htim,
   
2.                                            TIM_OC_InitTypeDef* sConfig,
   . A# }! C+ r9 h& Y
3.                                            uint32_t Channel)
   
4. {  
   
5.   /* Check the parameters */
   
6.   assert_param(IS_TIM_CHANNELS(Channel));
   
7.   assert_param(IS_TIM_OC_MODE(sConfig->OCMode));
   5 g/ i7 w+ Q1 y6 J8 V0 X( t
8.   assert_param(IS_TIM_OC_POLARITY(sConfig->OCPolarity));
   3 g: ?% N" h' @; h4 Z
9. 
   
10.   /* Process Locked */
    5 i3 k, o& {* K- V% U- p+ r4 M/ t8 D
11.   __HAL_LOCK(htim);
    
12. 
    ( P0 Q0 M! X2 x% i) x3 H' T4 \7 q
13.   htim->State = HAL_TIM_STATE_BUSY;
    & l' F* p7 d( b2 @2 O1 R
14. 
    ; Q7 U+ {6 R6 a- o
15.   switch (Channel)
    
16.   {
    ! d: O0 _. K, F, ~# d: `2 B" y
17.     case TIM_CHANNEL_1:
    
18.     {
    
19.       /* 检测参数Check the parameters */
    9 n& m& z# ]% c3 b" W
20.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    
21. 
    / V/ R+ }9 x, l0 g; ~1 h& j. D
22.      /* 配置定时器输出比较通道1 */
    / I( A! b( a- T9 ^) n; t
23.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    ' I6 ?; P9 }( |4 r4 g' h( c1 p
24.     }
    
25.     break;
    
26. 
    
27.     case TIM_CHANNEL_2:
    ( S5 u; m  N" j/ o' A% \
28.     {
    
29.       /* 省略 */
    
30.     }
    ' R6 g+ ~% G9 [" z, J1 D% m
31.     break;
    1 T3 L- r7 _6 @  Y
32. 
    ) D2 z: j; X7 @7 I9 _; I" Y
33.     case TIM_CHANNEL_3:
    ; Y" J$ i$ n8 q2 R7 U$ H& T( s
34.     {
    
35.       /* 省略 */
    0 f4 b5 T3 n/ m/ |* b% j8 Q: \, h5 Q
36.     }
    
37.     break;
    ! U: U+ Z9 A" V4 m3 B
38. 
    
39.     case TIM_CHANNEL_4:
    . G9 H+ `2 _+ w1 U1 k
40.     {
    $ ?9 k9 n% |9 x1 \$ n4 B6 B
41.       /* 省略 */
    
42.     }
    
43.     break;
    5 F5 Z- F! B3 Q$ Y+ z2 H/ X
44. 
    
45.     case TIM_CHANNEL_5:
    1 \: R4 H- r- E1 W- Y( `. |$ x4 A
46.     {
    
47.       /* 省略 */
    
48.     }
    
49.     break;
    
50. 
    - F, n( K+ w( F) w2 |6 h! c
51.     case TIM_CHANNEL_6:
    # h$ X1 u- j( c( Q1 ~# v+ t
52.     {
    " ?. n8 K3 G; c6 e9 ]
53.       /* 省略 */
    5 u; ~+ |. o1 h. ~# b6 p9 r+ m
54.     }
    * M- e( y: Y# h' C2 p5 v
55.     break;
    
56. 
    
57.     default:
    4 I3 s* V, f+ I5 M' w  H4 I
58.     break;   
    , _) E9 b" {+ D  B/ Q% s* A
59.   }
    ) Z  Y2 q5 _7 H& M; K
60. 
    
61.   htim->State = HAL_TIM_STATE_READY;
    
62. 
    
63.   __HAL_UNLOCK(htim);
    
64. 
    
65.   return HAL_OK;
    5 O& I: ^3 ^8 P! v
66. }

复制代码

7 I( I/ d- a; Z/ E" E+ P, S' G$ q函数描述：
1 s* n. I3 R8 C1 |0 Y! _
此函数用于初始化串口的基础特性和高级特性。

函数参数：

' N  ?. o3 r! t+ D3 P6 c. F- j  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
2 B8 `) W+ }: L% r' }8 O1 g1 @1 @  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
! b/ x+ P1 m; c4 x; b: u4 n  第3个参数是通道设置，支持以下参数：
TIM_CHANNEL_1
. }7 X6 @+ K) g6 u. N- }% Y
7 R4 K  a1 L/ B! ?) O. E9 BTIM_CHANNEL_2
, W- L) ]8 \8 c; P3 Y4 f6 H( D
TIM_CHANNEL_3
2 t, d$ T) y0 X0 g( h7 ~
TIM_CHANNEL_4

TIM_CHANNEL_5

& T1 K$ O$ d$ {1 w0 `3 wTIM_CHANNEL_6

  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
  C' X+ w, D# Z- D# u  a
32.4.11   函数HAL_TIM_OC_Start
函数原型：

1. HAL_StatusTypeDef HAL_TIM_OC_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
   8 T0 N" I% d$ s" Z5 b" t+ P+ n
2. {
   
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   
5. 
   * c' _8 W- E0 b8 f8 i: K* d
6.   /* 使能输出比较通道 */
   , o& c& w! S+ D1 T
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
8. 
   
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
   ; {. a/ @& h7 ~( I% J" t- b
10.   {
    
11.     /* 使能主输出 */
    : e8 {& {1 X. R$ Y  C
12.     __HAL_TIM_MOE_ENABLE(htim);
    / @( D0 d2 G5 g' }2 \! h5 Z! X2 J
13.   }
    - Q+ R: G' j# k9 O, N5 [
14. 
    
15.   /* 使能定时器 */
    3 h5 @4 z  {7 s/ `7 x3 J% x
16.   __HAL_TIM_ENABLE(htim);
    
17. 
    : F' S1 q/ r* Q; t
18.   /* 返回状态 */
    " R4 m1 ~- T9 ^+ P& f
19.   return HAL_OK;
    
20. }

复制代码

+ J8 F2 W. u5 h8 `/ S; e9 m, J函数描述：

5 K/ H* j) J# t( F6 c0 n此函数用于启动定时器输出比较模式。

函数参数：

" Q' ?& _1 T7 Y. T* K7 O  E2 _; \; J8 B  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
0 E* @; ~% Z2 |3 F* |5 t. c  第2个参数是通道设置，支持以下参数：
7 h. q, l! o, \) I3 E& m9 g( eTIM_CHANNEL_1

TIM_CHANNEL_2

TIM_CHANNEL_3

TIM_CHANNEL_4
- Q+ l3 {  H" a
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
4 o- p8 o5 r- Y0 |0 d! G
32.5 总结
3 ]6 M7 ^8 C0 o( r本章节就为大家讲解这么多，建议大家将GPIO的驱动源码结合参考手册中的寄存器通读一遍，对于我们后面章节的学习大有裨益。

, k8 `6 B6 E: A% J# p
# t  K( w: U' s% ]) v
2 b5 Y# R$ w! |