32.1 初学者重要提示
  学习定时器外设推荐从硬件框图开始了解基本的功能特性，然后逐步深入了解各种特性，这种方式方便记忆和以后查阅。
% d4 X/ ^  r& l3 S' D. ~  STM32H7的定时器输出100MHz方波是完全没问题。
" r. a- ?1 U9 B+ x8 A  STM32H7定时器进出中断的速度能跑到12.5MHz，所有程序在TCM和Flash运行没差别。
  STM32H7的定时器输入捕获可以实现12MHz方波的双边沿捕获，单边沿可以做到24MHz。
  特别注意STM32H7的TIM1,8,15,16,17才有RCR重复计数器，其它都没用的。
1 q$ }% e7 Q. _$ ?: R2 J% N  STM32H7的单个定时器中不同通道可以配置不同频率PWM。
2 r9 x0 a! Q( A: T2 Y7 y' Q1 ~  STM32H7的TIM1-TIM17中断入口函数名使用时要注意，别搞错了：
* d4 i( l* @& s- ?# p% _' M; [

1. TIM1_BRK_IRQHandler            
   
2. TIM1_UP_IRQHandler              
   
3. TIM1_TRG_COM_IRQHandler        
   9 q, \8 K- P( `2 a4 s
4. TIM1_CC_IRQHandler                                                   
   
5. TIM2_IRQHandler                                          
   8 b( V% e; n% T$ H& |8 G
6. TIM3_IRQHandler                                                
   
7. TIM4_IRQHandler                 
   
8. TIM5_IRQHandler            
   
9. TIM6_DAC_IRQHandler           <------------------要注意            
   ) l; m5 p; k" S: q' t
10. TIM7_IRQHandler
    
11. TIM8_BRK_TIM12_IRQHandler      <------------------要注意，定时器12也是用的这个
    ( a8 T/ u: K2 p  ^6 ^: G
12. TIM8_UP_TIM13_IRQHandler       <------------------要注意，定时器13也是用的这个
    ' o6 R/ _- Z/ T2 K/ H
13. TIM8_TRG_COM_TIM14_IRQHandler  <------------------要注意，定时器14也是用的这个
    6 R& `" p" j9 e) [2 v: D4 X2 x5 C
14. TIM8_CC_IRQHandler         
    
15. TIM15_IRQHandler
    " c: z7 z$ w3 h0 c$ V% K6 q
16. TIM16_IRQHandler
    5 i$ {' j7 d! [' Z: L  q
17. TIM17_IRQHandler

复制代码

. y& E& g2 j8 j$ X, {! o5 ^32.2 定时器基础知识
注，不同定时支持的功能略有区别，基础定时器功能较少，TIM1和TIM8高级定时器功能多些。
$ t: x& Y& X9 x6 m) h* J
9 S3 b# o5 d( R; O6 d* L) b# _  TIM2和TIM5是32位定时器，其它定时器都是16位定时器。16位和32位的区别是CNT计数器范围不同，32位的范围是0 到2^32 – 1，而16位的是0到65535；它们支持的分频是范围是一样的，都是1到65535。
  计数器支持递增、递减和递增/递减二合一。
  多个独立通道，可用于：
– 输入捕获。

7 K) D7 m, F" I% g' Z– 输出比较。
( a, o  A& x6 f! [, l- t2 x
$ P! M! J4 W/ O' S3 M– PWM 生成（边沿和中心对齐模式）。

% b! Y2 X2 G; N! f) E– 单脉冲模式输出。

7 {6 T$ {  a# Z% `, b  带死区插入，断路功能和PWM互补输出
3 N% `' Q7 h& [  发生如下事件时生成中断/DMA 请求：
7 I' ^: [4 ^. d% e% ~– 更新：计数器上溢/下溢、计数器初始化（通过软件或内部/外部触发）
) C/ S' d7 {8 \9 S2 C- S4 Q
– 触发事件（计数器启动、停止、初始化或通过内部/外部触发计数）
7 R, z- }# ^3 h3 Y! `2 a! C3 R
  a/ s6 T/ w- `: i; t– 输入捕获
' r6 A: O7 I: U4 q
- S7 D) w6 p* I" l; R0 s– 输出比较

2 p& r8 E) R" M% j  支持增量式编码器和霍尔传感器。
% O1 D" i0 f/ ^% ^32.2.1 定时器TIM1-TIM17的区别
STM32H7支持的定时器有点多，要简单的区分下。STM32H7支持TIM1-TIM8，TIM12-TIM17共14个定时器，而中间的TIM9，TIM10，TIM11是不存在的，这点要注意。
1 n; s. v( J* U" e1 k
粗略的比较如下：
& ^/ X% F, I7 u  W& D
+ _/ X# T1 ^; W& b/ ~) ]

' i/ V4 G- G/ t! L4 o7 Y

7 K" e' K( n- P7 ?7 M通过上面的表格，至少要了解到以下两点：
0 w( d5 F& `  @- C6 {
  STM32H7的定时器主要分为高级定时器，通用定时器，基础定时器和低功耗定时器。
  TIM2和TIM5是32位定时器，其它都是16位定时器。

32.2.2 定时器的硬件框图
5 I5 m6 q, J2 q" w' [) T认识一个外设，最好的方式就是看他的框图，方便我们快速的了解定时器的基本功能，然后再看手册了解细节。

下面我们直接看最复杂的高级定时器TIM1&TIM8框图：
' a( A' e+ @: j

通过这个框图，我们可以得到如下信息：
2 p$ Q- n$ q" Y' ~3 c
  TIMx_ETR接口
& U5 j/ b8 \( s+ v外部触发输入接口。ETR支持多种输入源：输入引脚（默认配置）、比较器输出和模拟看门狗。
2 S) M  k0 n  `! i' L: P
3 v" {6 Z( A, w% t) f4 c. o

0 e0 l+ ^% _* ?, i/ w+ R  截图左侧的TIMx_CH1，TIMx_CH2，TIMx_CH3和TIMx_CH4接口
! q1 E7 W, w3 _5 h$ L9 M这四个通道主要用于输入捕获，可以计算波形频率和脉宽。                                                                                                                             
+ w/ k0 P# b1 K! E% \2 w( _
& h. D7 ~6 B* E- \  TIMx_BKIN和TIMx_BKIN2接口
- O# W* [1 y' a断路功能，主要用于保护由 TIM1 和 TIM8 定时器产生的 PWM 信号所驱动的功率开关

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

  k4 E: J5 i9 l3 }) F4 `4 |( B# i  6组输出比较单元OC1到OC6
9 j) A  Y: f+ E' POC1到OC4有对应的输出引脚，而OC5和OC6没有对应的输出引脚，主要用于内部控制。

* U' b8 q: b/ J7 f0 l) j  截图右侧的输出比较通道TIMx_CH1，TIMx_CH1N，TIMx_CH2，TIMx_CH2N，TIMx_CH3，TIMx_CH3N和TIMx_CH4
* X6 z8 J/ y  x8 _9 l3 D2 J: U' L, v主要用于PWM输出，注意CH1到CH3有互补输出，而CH4没有互补输出。
( ^3 h$ Q6 r4 S' \$ ~. S. [
/ w* G, C4 |) |) a; [  其它框图里面未展示出来功能
定时器TIM1&TIM8还支持的其它功能在用到的时候再做说明。

# u0 h3 m: M8 h6 t1 J" h32.2.3 定时器的时基单元
: Z9 W/ M$ V$ @* v! A3 I定时器要工作就需要一个基本时基单元，而基本的时基单元是由下面几个寄存器组成的：

8 u" g; ]  y2 F9 N  预分频器寄存器 (TIMx_PSC)
6 P8 E; o" ^  D8 d) O: p用于设置定时器的分频，比如定时器的主频是200MHz，通过此寄存器可以将其设置为100MHz，50MHz，25MHz等分频值。

注：预分频器有个缓冲功能，可以让用户实时更改，新的预分频值将在下一个更新事件发生时被采用（以递增计数模式为例，就是CNT计数值达到ARR自动重装寄存器的数值时会产生更新事件）。

8 ^* f0 H1 ~) S' I$ p6 y: Z  g$ z  计数器寄存器 (TIMx_CNT)
( A+ p( ~+ A2 e& g( `  x计数器是最基本的计数单元，计数值是建立在分频的基础上面，比如通过TIMx_PSC设置分频后的频率为100MHz，那么计数寄存器计一次数就是10ns。

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

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

: y# A: F; H/ V' {+ g8 }  重复计数器寄存器 (TIMx_RCR)
以递增计数模式为例，当CNT计数器数值达到ARR自动重载数值时，重复计数器的数值加1，重复次数达到TIMx_RCR+ 1后就，将生成更新事件。
: L, P7 g; F; |' o. Z
' x' L% ~; s$ ^' d注，只有TIM1，TIM8，TIM15，TIM16，TIM17有此寄存器。

+ q- N1 Y2 F$ J7 L比如我们要配置定时器实现周期性的中断，主要使用这几个寄存器即可。

32.2.4 定时器输出比较（PWM）
3 z2 E6 m) i: [使用定时器时基单元的那几个寄存器仅仅能设置周期，还不能设置占空比。针对这个问题，还需要比较捕获寄存CCR的参与，这样就可以设置占空比了。
  e- L- G9 N2 f9 e$ w7 J7 L
+ p0 W  {  x% G3 e/ r为了方便大家理解，以PWM 边沿对齐模式，递增计数配置为例：
% r! J  G) c# h: N( @9 d
  当计数器TIMx_CNT < 比较捕获寄存器TIMx_CCRx期间，PWM参考信号OCxREF输出高电平。
  当计数器TIMx_CNT >= 比较捕获寄存器TIMx_CCRx期间， PWM参考信号OCxREF输出低电平。
/ h/ ?% _2 d% {) e  当比较捕获寄存器TIMx_CCRx > 自动重载寄存器TIMx_ARR，OCxREF保持为1。
, r- O$ R5 {7 q, q) d  G7 _9 j  当比较捕获寄存器TIMx_CCRx = 0，则OCxRef保持为0。
! S8 G; z- j$ _/ z! z( m( U; |, C) _下面是TIMx_ARR=8的波形效果：
# E  i0 M+ m* u  i- S0 h3 O/ K2 l

' h# _: }$ T; D$ R4 `
32.2.5 定时器输入捕获
. t. L: O: G' y  u. Z& ^+ [( N与PWM一样，使用定时器实现输入捕获，仅靠时基单元的那几个寄存器是不行的，我们需要一个寄存器来记录发生捕获时的具体时间，这个寄存器依然由比较捕获寄存器TIMx_CCRx来实现。

( }3 w! W, {3 q9 O3 j  f# K比如我们要测量一路方波的周期：
  y" i$ X0 s! t/ k2 `* `
  }! x6 d8 u% Y" o7 A; L% {  配置定时器为输入捕获模式，上升沿触发，设置分频，自动重装等寄存器，比如设置的CNT计数器计数1次是1微秒。
  当有上升沿触发的时候，TIMx_CCRx寄存器就会自动记录当前的CNT数值，然后用户就可以通过CC中断，在中断复位程序里面保存当前的TIMx_CCRx寄存器数值。等下次再检测到上升沿触发，两次时间求差就可以得到方波的周期。
不过这里要特别注意一点，如果CNT发生溢出（比如16位定时器，计数到65535就溢出了）就需要特别处理下，将CNT计数溢出考虑进来。

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

) U& ~. l" A7 Q  K: y/ x32.3.1 定时器寄存器结构体TIM_TypeDef
( S2 [5 H; S. Y( |& i# Y定时器相关的寄存器是通过HAL库中的结构体TIM_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：
; h8 c$ M" ?* B6 k; M

1. typedef struct
   3 {  l( t2 a9 p1 v
2. {
   0 a0 Y! i- ^7 Z0 F! z- |
3.   __IO uint16_t CR1;         /*!< TIM control register 1,                   Address offset: 0x00 */
   
4.   uint16_t      RESERVED0;   /*!< Reserved, 0x02                                                 */
   4 o# e6 I  t! G" w" X: W2 V/ B8 N
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 */
   + _. i4 ~) k5 t: v
10.   __IO uint32_t CCMR1;       /*!< TIM capture/compare mode register 1,      Address offset: 0x18 */
    
11.   __IO uint32_t CCMR2;       /*!< TIM capture/compare mode register 2,      Address offset: 0x1C */
    4 v' ]! ]+ E, i- n7 M1 k
12.   __IO uint32_t CCER;        /*!< TIM capture/compare enable register,      Address offset: 0x20 */
    
13.   __IO uint32_t CNT;         /*!< TIM counter register,                     Address offset: 0x24 */
    7 b  A5 t. q( r+ a  D& r% N& h& E
14.   __IO uint16_t PSC;         /*!< TIM prescaler,                            Address offset: 0x28 */
    
15.   uint16_t      RESERVED9;   /*!< Reserved, 0x2A                                                 */
    # W/ {) `9 c& p6 [& y. q3 ]5 p! G% [
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                                                 */
    
19.   __IO uint32_t CCR1;        /*!< TIM capture/compare register 1,           Address offset: 0x34 */
    ; Y& L0 V; M4 M/ S6 T+ G
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 */
    ' _9 g. L/ U( v
22.   __IO uint32_t CCR4;        /*!< TIM capture/compare register 4,           Address offset: 0x40 */
    & d" d- W$ X  v
23.   __IO uint32_t BDTR;        /*!< TIM break and dead-time register,         Address offset: 0x44 */
    , Z) g+ L' `$ b1 @( r
24.   __IO uint16_t DCR;         /*!< TIM DMA control register,                 Address offset: 0x48 */
    ' m. f: m1 H+ i" d; G
25.   uint16_t      RESERVED12;  /*!< Reserved, 0x4A                                                 */
    
26.   __IO uint16_t DMAR;        /*!< TIM DMA address for full transfer,        Address offset: 0x4C */
    ; d) `7 `" s, p8 a' b
27.   uint16_t      RESERVED13;  /*!< Reserved, 0x4E                                                 */
    . Q. O/ Q( D" f( n) p% A0 _
28.   uint16_t      RESERVED14;  /*!< Reserved, 0x50                                                 */
    * M% G" h. B$ s! G* C: V9 _8 f
29.   __IO uint32_t CCMR3;       /*!< TIM capture/compare mode register 3,      Address offset: 0x54 */
    4 A8 d' v2 t" `" i6 i& W
30.   __IO uint32_t CCR5;        /*!< TIM capture/compare register5,            Address offset: 0x58 */
    7 Z' ~: s6 ^7 g) I% Q& L$ s
31.   __IO uint32_t CCR6;        /*!< TIM capture/compare register6,            Address offset: 0x5C */
    % ~* S. X- ^! t9 t2 g8 T2 p
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 */
    4 U+ O& p2 a: y3 E2 E& D7 Q$ z
34.   __IO uint32_t TISEL;       /*!< TIM Input Selection register,             Address offset: 0x68 */
    
35. } TIM_TypeDef;

复制代码

这个结构体的成员名称和排列次序和CPU的定时器寄存器是一 一对应的。
% A5 h# U3 _$ q) ~8 n, C! i
__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
* o! k. S  O: X2 T' }8 L+ b& ^; F

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

复制代码

2 G, }1 V2 S# J9 j下面我们看下定时器的定义，在stm32h743xx.h文件。

1. #define PERIPH_BASE         ((uint32_t)0x40000000)
   
2. #define D2_APB1PERIPH_BASE   PERIPH_BASE
   
3. #define D2_APB2PERIPH_BASE   (PERIPH_BASE + 0x00010000)
   
4. 
   
5. /*!< D2_APB1PERIPH 外设 */
   ! @) m, I  {. x) S5 |% b- l/ d
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)
   9 b5 t$ e! E$ J) f  s* z4 I- _/ a
9. #define TIM5_BASE             (D2_APB1PERIPH_BASE + 0x0C00)
   $ _7 D7 S6 ]& e1 `+ R9 @- b. h: O
10. #define TIM6_BASE             (D2_APB1PERIPH_BASE + 0x1000)
    
11. #define TIM7_BASE             (D2_APB1PERIPH_BASE + 0x1400)
    5 X/ {- {$ f' H/ p  r2 f$ X7 X8 @( `
12. #define TIM12_BASE            (D2_APB1PERIPH_BASE + 0x1800)
    
13. #define TIM13_BASE            (D2_APB1PERIPH_BASE + 0x1C00)
    
14. #define TIM14_BASE            (D2_APB1PERIPH_BASE + 0x2000)
    
15. 
      S( K/ Q% t& @; s& E" S
16. /*!< D2_APB1PERIPH 外设 */
    
17. #define TIM1_BASE             (D2_APB2PERIPH_BASE + 0x0000)
    ; C# b" n3 W% h, Z9 L& k% G7 l- h
18. #define TIM8_BASE             (D2_APB2PERIPH_BASE + 0x0400)
    
19. #define TIM15_BASE            (D2_APB2PERIPH_BASE + 0x4000)
    1 D- [. B7 O7 v. h
20. #define TIM16_BASE            (D2_APB2PERIPH_BASE + 0x4400)
    / k$ d5 b8 @' M5 @8 j
21. #define TIM17_BASE            (D2_APB2PERIPH_BASE + 0x4800)
    
22. 
    
23. #define TIM1                ((TIM_TypeDef *) TIM1_BASE)
    # D" R; j8 S( e/ ]$ N* L
24. #define TIM2                ((TIM_TypeDef *) TIM2_BASE)
    ( d, O# B1 C8 T% n; M
25. #define TIM3                ((TIM_TypeDef *) TIM3_BASE)
    ( }1 \0 |6 Q6 M  Z( l
26. #define TIM4                ((TIM_TypeDef *) TIM4_BASE)
    
27. #define TIM5                ((TIM_TypeDef *) TIM5_BASE)
    6 R/ n7 V( l7 L6 a, ^* ^1 D
28. #define TIM6                ((TIM_TypeDef *) TIM6_BASE)
    
29. #define TIM7                ((TIM_TypeDef *) TIM7_BASE)
    
30. #define TIM8                ((TIM_TypeDef *) TIM8_BASE)
    
31. #define TIM12               ((TIM_TypeDef *) TIM12_BASE)
    $ c& ~. S+ m, Z# z4 ~6 X+ G* m. B& d
32. #define TIM13               ((TIM_TypeDef *) TIM13_BASE)
    / H4 z. i+ o( }, b1 g
33. #define TIM14               ((TIM_TypeDef *) TIM14_BASE)
    ) x# E* P; ^' J" X4 y8 l8 v% c
34. #define TIM15               ((TIM_TypeDef *) TIM15_BASE)
    ! P. P. w6 U" W( r4 K3 r
35. #define TIM16               ((TIM_TypeDef *) TIM16_BASE)
    # D4 y. p) Q, L0 `
36. #define TIM17               ((TIM_TypeDef *) TIM17_BASE)

复制代码

我们访问TIM2的CR1寄存器可以采用这种形式：TIM2->CR1 = 0；
1 J1 I" O. @' g. C9 @
32.3.2 定时器句柄结构体TIM_HandleTypeDef
HAL库在TIM_TypeDef的基础上封装了一个结构体TIM_HandleTypeDef，定义如下：

1. typedef struct
   
2. {
   
3.   TIM_TypeDef              *Instance;     /*!< Register base address             */
   
4.   TIM_Base_InitTypeDef     Init;          /*!< TIM Time Base required parameters */
   
5.   HAL_TIM_ActiveChannel    Channel;       /*!< Active channel                    */
   7 c  U5 g) U5 |1 h; G  N, @
6. 
   
7. /*!< DMA Handlers array This array is accessed by a @ref DMA_Handle_index */
   
8.   DMA_HandleTypeDef        *hdma[7];      
   
9.   HAL_LockTypeDef          Lock;          /*!< Locking object                    */
   
10.   __IO HAL_TIM_StateTypeDef   State;      /*!< TIM operation state               */  
    
11. }TIM_HandleTypeDef;

复制代码

; s$ I7 B1 s* b: Y7 v* u这里重点介绍前四个参数，其它参数主要是HAL库内部使用的。
8 h$ y- ?- b) j+ o0 [5 b; T
, a8 {7 J' e  j/ C# P  TIM_TypeDef  *Instance

5 x3 K, ~" V. l8 C% }) k) P这个参数是寄存器的例化，方便操作寄存器，比如使能定时器的计数器。

  S  D5 u* d# {, I$ h3 z  x: q4 lSET_BIT(huart->Instance->CR1,  TIM_CR1_CEN)。

  TIM_Base_InitTypeDef  Init

" F) g- ?- ~, ]* f& Z: ?5 p8 U% v" A; m* h这个参数是用户接触最多的，用于配置定时器的基本参数。

/ l+ N# u/ Q' m1 I/ gTIM_Base_InitTypeDef结构体的定义如下：
; ^$ r3 c9 |* \5 S

1. typedef struct
   5 k9 A( C  h, U! T: ^0 e' B0 J: R
2. {
   6 I8 f" }) Y4 O; ?: F
3.   uint32_t Prescaler;      
   
4.   uint32_t CounterMode;   
   
5.   uint32_t Period;         
   . m, e+ w; ~- s
6.   uint32_t ClockDivision;   
   
7.   uint32_t RepetitionCounter;
   4 {4 m  W: y9 I
8.   uint32_t AutoReloadPreload;  
   
9. } TIM_Base_InitTypeDef;

复制代码

  成员Prescaler
# U+ ~  K0 h# s, [用于设置定时器分频，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。
% l" }! p# k& W* [
8 Z( k! x* h' }# z  成员CounterMode
用于设置计数模式，向上计数模式、向下计数模式和中心对齐模式。

: Y, N& B8 D4 @2 S4 O2 E9 a# Z

1. #define TIM_COUNTERMODE_UP                ((uint32_t)0x0000U)   /*!< Up counting mode */
   
2. #define TIM_COUNTERMODE_DOWN               TIM_CR1_DIR          /*!< Down counting mode */
   
3. #define TIM_COUNTERMODE_CENTERALIGNED1     TIM_CR1_CMS_0        /*!< Center-aligned counting mode 1 */
   6 _, l; ]' b2 s$ q
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 */

复制代码

$ M% S# [" T0 L4 j  成员Period
用于设置定时器周期，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。
  J; |7 J  V+ I- U# n7 S
  成员ClockDivision
用于指示定时器时钟 (CK_INT) 频率与死区发生器以及数字滤波器（ETR、TIx）所使用的死区及采样时钟 (tDTS) 之间的分频比。
# A3 K5 B3 m% x4 O
* V' r& Q5 x* ^" }& A5 X1 w* w+ T

1. #define TIM_CLOCKDIVISION_DIV1       ((uint32_t)0x0000U)        /*!< Clock Division DIV1 */
   
2. #define TIM_CLOCKDIVISION_DIV2       (TIM_CR1_CKD_0)            /*!< Clock Division DIV2 */
   * ^5 `  S, c; _) U2 Q
3. #define TIM_CLOCKDIVISION_DIV4       (TIM_CR1_CKD_1)             /*!< Clock Division DIV4 */

复制代码

" G# p6 M. g. Q! c' n/ ?  R  成员RepetitionCounter
% r; j# t+ ]* g" x- L用于设置重复计数器，仅TIM1和TIM8有，其它定时器没有。作用是每当计数器上溢/下溢时，重复计数器减1，当减到零时，才会生成更新事件，这个在生成PWM时比较有用。

4 k8 O/ }9 o0 X( |& N% ]: z  成员AutoReloadPreload
用于设置定时器的ARR自动重装寄存器是更新事件产生时写入有效还是立即写入有效。如果使能了表示更新事件产生时写入有效，否则反之。
5 j1 M- g0 h" q5 g

1. #define TIM_AUTORELOAD_PRELOAD_DISABLE   ((uint32_t)0x0000U)   /*!< TIMx_ARR register is not buffered */
   8 D, j$ C( a+ n
2. #define TIM_AUTORELOAD_PRELOAD_ENABLE    (TIM_CR1_ARPE)        /*!< TIMx_ARR register is buffered */

复制代码

  HAL_TIM_ActiveChannel    Channel;

用于设置定时器通道，比如TIM1和TIM8都是6个通道。
* E, e" t7 G% T) T, q, P6 W
+ d: i; x' y. d/ f5 ?. b# ^+ r

1. typedef enum
   
2. {
   4 j7 i: w7 y0 E1 B
3.   HAL_TIM_ACTIVE_CHANNEL_1        = 0x01U,    /*!< The active channel is 1     */
   7 k2 G6 e7 S4 ]
4.   HAL_TIM_ACTIVE_CHANNEL_2        = 0x02U,    /*!< The active channel is 2     */
   
5.   HAL_TIM_ACTIVE_CHANNEL_3        = 0x04U,    /*!< The active channel is 3     */   
   
6.   HAL_TIM_ACTIVE_CHANNEL_4        = 0x08U,    /*!< The active channel is 4     */
   / q/ x1 M' ~2 r0 x, k2 i* k
7.   HAL_TIM_ACTIVE_CHANNEL_5        = 0x10U,    /*!< The active channel is 5     */
   
8.   HAL_TIM_ACTIVE_CHANNEL_6        = 0x20U,    /*!< The active channel is 6     */
   $ a3 d3 v' o+ q, E8 |7 i  I
9.   HAL_TIM_ACTIVE_CHANNEL_CLEARED  = 0x00U     /*!< All active channels cleared */   
   
10. }HAL_TIM_ActiveChannel;
    
11.   DMA_HandleTypeDef        *hdma[7];

复制代码

用于关联DMA。
$ z2 V* o. }3 R3 A* `* `
" r& L0 J' c1 q  ]+ C0 G配置定时器参数，其实就是配置结构体TIM_HandleTypeDef的成员。
8 M; B% s$ N  R" d6 V2 s) ]4 P8 L

1. TIM_HandleTypeDef   TimHandle = {0};
   7 O# d4 F7 }  C4 H$ x
2. 
   
3. /*
   # L4 B% q' [- H5 ^0 h; ^
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   8 y# ^0 o  k- {) s( w
6. TimHandle.Instance = TIMx;
   - P, c( L! r( H8 {
7. TimHandle.Init.Prescaler         = usPrescaler;
   ( N6 d3 d1 \' m* ]3 o9 V/ ?0 s; @
8. TimHandle.Init.Period            = usPeriod;        
   4 K6 H2 P' e0 X5 d7 U
9. TimHandle.Init.ClockDivision     = 0;
   
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    ) w+ h7 b1 n' U, l
11. TimHandle.Init.RepetitionCounter = 0;
    % b2 Q& s" ]7 c
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    5 {7 \; L+ P+ q/ W9 V: i# o
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    
14. {
    
15.         Error_Handler(__FILE__, __LINE__);
    
16. }

复制代码

- I! ^) P4 T% Q% Z9 u6 f32.3.3 定时器输出比较结构体TIM_OC_InitTypeDef
此结构体主要用于定时器的输出比较，定义如下：

; b4 Y0 W3 a: a6 o( n. c! y

1. typedef struct
   + Z* _1 \5 J& J0 L
2. {                                 
   ' s9 u, b3 D; J" D
3.   uint32_t OCMode;      
   
4.   uint32_t Pulse;      
   
5.   uint32_t OCPolarity;   
   # `5 _" S9 N! P/ q3 ^
6.   uint32_t OCNPolarity;   
   3 _' f! r8 R( [1 V1 s
7.   uint32_t OCFastMode;  
   
8.   uint32_t OCIdleState;   
   
9.   uint32_t OCNIdleState;  
   8 Y  a8 r- G! p! O+ [8 n" a# n
10. } TIM_OC_InitTypeDef;  

复制代码

1 t8 }7 n) ]) E  ^9 [$ H下面将这几个参数一 一做个说明。

  OCMode
$ B3 E( G" h0 i9 x1 i: v用于配置输出比较模式，支持的模式较多：

  }1 N3 C% e" J) A7 M

1. /*!< TIM Output timing mode */
   
2. #define TIM_OCMODE_TIMING                ((uint32_t)0x0000U)      
   # H: b/ }( r$ M# E. A/ N' W
3. 
   ! ~; L- y4 z* g- m: V) ^
4. /*!< TIM Output Active mode */                          
   5 F+ d9 x  [( Q/ `
5. #define TIM_OCMODE_ACTIVE                ((uint32_t)TIM_CCMR1_OC1M_0)
   
6. 
   6 V: j( J+ r" ?9 d2 z3 g' e
7. /*!< TIM Output Inactive mode */                       
   
8. #define TIM_OCMODE_INACTIVE              ((uint32_t)TIM_CCMR1_OC1M_1)           
   
9. 
   
10. /*!< TIM Output Toggle mode */               
    
11. #define TIM_OCMODE_TOGGLE                 ((uint32_t)TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)         
    8 {6 `# y  [% s
12. 
    
13. /*!< TIM PWM mode 1 */
    " f1 i! r& {9 }& o1 K7 J
14. #define TIM_OCMODE_PWM1                   ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1)
    
15. 
    - g7 a, m) L& \$ M1 V1 h9 w3 X% F) G: ~
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. 
    ; ~) k  z$ v3 c5 ~  y4 p
19. /*!< TIM Forced Active mode */   
    
20. #define TIM_OCMODE_FORCED_ACTIVE           ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0)         
    
21. 
    
22. /*!< TIM Forced Inactive mode */            
    
23. #define TIM_OCMODE_FORCED_INACTIVE         ((uint32_t)TIM_CCMR1_OC1M_2)                                       
    / w$ P2 j$ P. h* w/ e! U" `
24. 
    5 ~6 m- ^+ j: D2 T! P
25. /*!< TIM Rettrigerrable OPM mode 1 */  
    8 @* n' |, ~4 Y+ L* p& ?
26. #define TIM_OCMODE_RETRIGERRABLE_OPM1      ((uint32_t)TIM_CCMR1_OC1M_3)   
    
27. 
    $ y3 I1 S& l* T3 U  o
28. /*!< TIM Rettrigerrable OPM mode 2 */                                       
    
29. #define TIM_OCMODE_RETRIGERRABLE_OPM2      ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0)   
    ( r1 Z/ u* t6 J4 [
30. 
    
31. /*!< TIM Combined PWM mode 1 */                     
    
32. #define TIM_OCMODE_COMBINED_PWM1           ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_2)     
    , E. G& Y$ A7 G8 Z/ K  H
33. 
    ! t9 S( r# P" r
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)   
    # P4 W- |0 P9 s+ S5 e8 J4 j4 F: ^
36. 
    $ I! b9 n3 P# y& l' i0 Q
37. /*!< TIM Asymetruc PWM mode 1 */  
    
38. #define TIM_OCMODE_ASSYMETRIC_PWM1         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2)  
    ( ~; Y8 K: G/ I; K- w- _; z& H
39. 
    
40. /*!< TIM Asymetruc PWM mode 2 */   
    # f* k2 k3 ~8 [) E% B3 `
41. #define TIM_OCMODE_ASSYMETRIC_PWM2         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M)  

复制代码

& O. Z" C) @7 D+ w5 \& l% g4 H' S  
" B( n% C) r- j+ f  Pulse
8 l. P7 p6 n1 Y0 R) j, P可用于设置占空比，对应定时器的CCR寄存器，32位的TIM2和TIM5范围是0到0xFFFFFFFF。

  OCPolarity
设置输出极性，可选高电平或低电平有效。

. `* o9 p, D1 k; W8 i, `. S2 u

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

复制代码

  OCNPolarity
互补输出极性设置，可选高电平或者低电平有效。

( M( h/ C3 K" @, D0 R

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

复制代码

# z7 w# t  E, T6 o3 X  OCFastMode
/ F# J$ \  ?" A$ ^+ ~2 C" a快速输出模式使能，仅OCMode配置为PWM1或者PWM2模式时才有意义。

3 u, B/ @0 L4 H& q

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

复制代码

4 Z3 z$ a& y* b) ]  OCIdleState
/ N" H& M  p' a" Y! i0 v$ b空闲状态时，设置输出比较引脚的电平状态。

1. #define TIM_OCIDLESTATE_SET                (TIM_CR2_OIS1)
   ' b: \) i7 ]& W' b, I
2. #define TIM_OCIDLESTATE_RESET              ((uint32_t)0x0000U)

复制代码

: G5 R* }% y  D. J5 |3 N( s! H  OCNIdleState
8 t- O2 m0 i+ j$ Y# e8 `/ O空闲状态时，设置互补输出引脚的电平状态。

1. #define TIM_OCNIDLESTATE_SET               (TIM_CR2_OIS1N)
   2 I1 B, t: Q( I
2. #define TIM_OCNIDLESTATE_RESET             ((uint32_t)0x0000U)

复制代码

32.3.4 定时器输入捕获结构体TIM_IC_InitTypeDef
$ C. S: `1 ^( I: g& R, i; \/ F7 S4 @此结构体主要用于定时器的输入捕获，定义如下：

1. typedef struct
   % X8 V2 _2 p  F: ^: B
2. {                                 
   
3.   uint32_t ICPolarity;   
   4 l, A4 K$ K9 A6 S
4.   uint32_t ICSelection;
   
5.   uint32_t ICPrescaler;
   
6.   uint32_t ICFilter;   
   4 @4 c5 W0 h0 F0 s
7. } TIM_IC_InitTypeDef;

复制代码

下面将这几个参数一 一做个说明。
4 k" I2 S' w: v. h
7 _  v0 Q, G4 Y7 z3 g8 g  ICPolarity
9 C+ D# E* U0 }! E. W5 j, L输入触发极性，可以选择上升沿，下降沿或者双沿触发。
1 f+ \& C! I0 g) z$ H& v) @

1. #define  TIM_ICPOLARITY_RISING             TIM_INPUTCHANNELPOLARITY_RISING
   " X) E* ^8 l6 R, P1 b# r: _5 h
2. #define  TIM_ICPOLARITY_FALLING            TIM_INPUTCHANNELPOLARITY_FALLING
   6 _& [$ x. s6 _
3. #define  TIM_ICPOLARITY_BOTHEDGE           TIM_INPUTCHANNELPOLARITY_BOTHEDGE

复制代码

  ICSelection
输入捕获通道选择，可以选择直接输入（即CC1选择TI1，CC2选择TI2等），间接输入（CC1选择TI2，CC3选择TI4等）或者TRC。

1. #define TIM_ICSELECTION_DIRECTTI       (TIM_CCMR1_CC1S_0)   
   ( c" R! q0 m$ T; Y- K
2. #define TIM_ICSELECTION_INDIRECTTI     (TIM_CCMR1_CC1S_1)  
   1 s7 d5 ]7 U' A- L2 e
3. #define TIM_ICSELECTION_TRC            (TIM_CCMR1_CC1S)   

复制代码

  `5 C; A) F$ ~% q0 N2 g. |2 q0 ^  ICPrescaler
输入捕获分频，表示每捕获1，2，4或8个事件后表示一次捕获。
* _' f0 I5 \! T9 F/ C/ U, }; C, J1 T
: G6 b9 ^$ c) p( T1 ]7 \

1. #define TIM_ICPSC_DIV1       ((uint32_t)0x0000U)                 
   % r( k$ z: r# A  O
2. #define TIM_ICPSC_DIV2       (TIM_CCMR1_IC1PSC_0)   
   
3. #define TIM_ICPSC_DIV4       (TIM_CCMR1_IC1PSC_1)   
   
4. #define TIM_ICPSC_DIV8       (TIM_CCMR1_IC1PSC)

复制代码

  ICFilter
. o% ~" t7 H5 K+ M输入捕获滤波器，可以定义采样频率和多少个连续事件才视为有效的触发，参数范围0到15。具体定义如下，其中fCK_INT表示定时器时钟，fDTS表示死区时间采样率，N表示这么多个事件代表一次有效边沿。

' X4 @3 e! `3 W* z

1. 0000：无滤波器，按 fDTS 频率进行采样
   
2. 0001： fSAMPLING=fCK_INT， N=2
   9 U- V; V. O- t: h) K
3. 0010： fSAMPLING=fCK_INT， N=4
   
4. 0011： fSAMPLING=fCK_INT， N=8
   
5. 0100： fSAMPLING=fDTS/2， N=6
   - w  |% s( _5 w( A. |. w7 j0 v
6. 0101： fSAMPLING=fDTS/2， N=8
   
7. 0110： fSAMPLING=fDTS/4， N=6
   
8. 0111： fSAMPLING=fDTS/4， N=8
   
9. 1000： fSAMPLING=fDTS/8， N=6
   
10. 1001： fSAMPLING=fDTS/8， N=8
    
11. 1010： fSAMPLING=fDTS/16， N=5
    ; z, K; B2 c3 ]- g2 ]5 `- [: k' `/ p% j
12. 1011： fSAMPLING=fDTS/16， N=6
    2 o, X5 H; u2 L' a
13. 1100： fSAMPLING=fDTS/16， N=8
    3 O8 Q$ h7 C! J7 x& B( k: ~* v7 i# R
14. 1101： fSAMPLING=fDTS/32， N=5
    ! I0 u' ?/ Q' _/ v: R
15. 1110： fSAMPLING=fDTS/32， N=6

复制代码

32.3.5 定时器的底层配置（GPIO，时钟，中断等）
) f' s. a2 O5 O: i" k. IHAL库有个自己的底层初始化回调函数，比如调用函数HAL_TIM_Base_Init就会调用HAL_TIM_Base_MspInit，此函数是弱定义的。
6 [$ W* L0 j( Q7 J) [8 n- i

1. __weak void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
   1 y9 A3 `- `  G. z5 E5 a
2. {
   
3.   /* Prevent unused argument(s) compilation warning */
   
4.   UNUSED(htim);
   ( Z+ W2 w& G! Q
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.    */
   1 S1 `' P! k- H& t, j" [+ r, x
8. }

复制代码

  O, q/ a$ B2 j0 R: r用户可以在其它的C文件重定向，并将相对的底层初始化在里面实现。对应的底层复位函数HAL_TIM_Base_DeInit是在函数HAL_TIM_Base_MspDeInit里面被调用的，也是弱定义的。
, j% y/ ]- a9 c4 _/ ^
/ @* N- U+ u/ }& [$ e- l当然，用户也可以自己初始化，不限制必须在两个函数里面实现。
8 w' j% n6 y4 t) q+ ?. d
0 O5 \/ ?3 D: X. W3 n定时器外设的基本参数配置完毕后还不能使用，还需要配置GPIO、时钟、中断等参数，比如下面配置TIM1使用PA8做PWM输出。
8 [6 P  [; ]" J9 q' v, `% J
$ q; J: E& v- E. ?, L8 J: G

1. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
   & z( S2 o8 |+ j: x
2. {
   $ M  q8 E- B9 t
3.   GPIO_InitTypeDef   GPIO_InitStruct;
   
4. 
   
5.   /* 使能TIM1时钟 */
   
6.   __HAL_RCC_TIM1_CLK_ENABLE ();
   
7. 
   + |+ C7 t$ \$ ~& y' B1 V3 ]
8.   /* 使能GPIOA时钟 */
   
9.   __HAL_RCC_GPIOA_CLK_ENABLE ();
   ( V% L( C( C! _9 Q, M$ |  B
10. 
    7 K5 _. G& k$ a3 i2 T1 q
11.   /* 设置TIM1使用PA8做PWM输出引脚，将其配置为输出，推挽，复用模式 */
    
12.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    2 P, C# A7 s5 m
13.   GPIO_InitStruct.Pull = GPIO_PULLUP;
    
14.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
15. 
    & v3 M5 |8 N. K( `3 t
16.   GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
    7 e  @8 S+ M9 s7 ]0 N* F
17.   GPIO_InitStruct.Pin = GPIO_PIN_8;
    
18.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    ) }3 B9 E+ K" B+ j7 G: ~$ k
19. 
    0 a+ z5 u! H9 x, U. L6 s" V
20. }

复制代码

& q: p* H4 o& D总结下来就是以下几点：
: k1 {' g! @8 o
' T% h/ ^" X' h6 M4 s. S  配置TIM时钟。
  配置TIM所用到引脚和对应的GPIO时钟。
. A$ t1 s% E* I; U, Q  如果用到定时器中断，还需要通过NVIC配置中断。
- l! ~6 m" C- X% ]$ ?  如果用到DMA，还要配置DMA。
关于这个底层配置有以下几点要着重说明下：

) y, e. L6 A2 M( _1 i( U  定时器所使用引脚的复用模式选择已经被HAL库定义好，放在了stm32h7xx_hal_gpio_ex.h文件里面。比如TIM1有一个复用，

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

复制代码

0 f. s8 `. ~( m* B$ w6 s# c但是却有4个输出通道，每个通道都有几个支持的输出引脚：

1. TIM1_CH1,  PA8   PE9    PK1
   $ u: y2 m  k# `7 [
2. TIM1_CH2,  PA9   PE11
   
3. TIM1_CH3,  PA10  PE13   PJ9
   
4. TIM1_CH4,  PA11  PE14   PJ11

复制代码

具体使用哪个，配置对应引脚的复用即可：

32.3.6 定时器的状态标志清除问题
下面我们介绍__HAL_TIM_GET_FLAG函数。这个函数用来检查定时器标志位是否被设置。

1. 
   
2. /** @brief  Check whether the specified TIM interrupt flag is set or not.
   
3.   * @param  __HANDLE__: specifies the TIM Handle.
   . X3 M- a$ P8 T# g9 k
4.   * @param  __FLAG__: specifies the TIM interrupt flag to check.
   + o. l" c4 @+ y) ?
5.   *        This parameter can be one of the following values:
   $ b9 ~0 q. \  U' b
6.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag
   ) J# M3 c- {+ O: {
7.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
   # D3 D2 o7 g$ X3 l- P" ?$ w; p
8.   *            @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
   
9.   *            @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
   ! L+ {8 i, ^; i, C, ~
10.   *            @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
    
11.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag
    ; g, c& i6 m1 q$ K. e- v
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
    * x2 g# g! z8 ]' B- l
15.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   
    * G; j6 [; w8 _1 B5 t! b
16.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    : y" ?  E# {. h' @' M
17.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
    
18.   *            @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
    ) O* ^9 G& p" t$ N: w$ g
19.   *            @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
    - @2 f& Q( O4 u
20.   *            @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
    ' m* j% [- f) k5 s% b1 X/ b4 i
21.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    - r, q0 G% ~4 _3 ^7 w
22.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    ( |/ g0 h, ~# [% k* z: m- X
23.   */
    
24. #define __HAL_TIM_GET_FLAG(__HANDLE__, __FLAG__)   (((__HANDLE__)->Instance->SR &(__FLAG__)) == (__FLAG__))

复制代码

5 [6 ~) g9 ~' x9 N8 v% B0 B前5个是比较常用的中断标志。

  TIM_FLAG_UPDATE
" A0 v! f: s+ z1 R定时器更新标准，配置一个周期性的定时器中断要用到。

     TIM_FLAG_CC1
TIM_FLAG_CC2

TIM_FLAG_CC3
" V+ I5 x9 Y$ x8 o# H; B
& x7 `& Z/ a7 dTIM_FLAG_CC4

捕获/比较标志，配置了捕获/比较中断要用到。
& P, f1 I9 w: W. o' h
9 ^6 {) G- q2 E与标志获取函数__HAL_TIM_GET_FLAG对应的清除函数是__HAL_TIM_CLEAR_FLAG：

; d  `. m' f2 D$ O

1. /** @brief  Clear the specified TIM interrupt flag.
   
2.   * @param  __HANDLE__: specifies the TIM Handle.
   " I& r2 Q* a3 j- F5 D4 s
3.   * @param  __FLAG__: specifies the TIM interrupt flag to clear.
   
4.   *        This parameter can be one of the following values:
   " g; n0 B) H- B+ E0 P
5.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag
   
6.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
   5 B& r7 u0 y) m; y+ U( u" N5 B
7.   *            @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
   # c' ^6 P4 q+ O/ }- I
8.   *            @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
   : W4 I+ @$ T- I: m: C1 |
9.   *            @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
   - {$ H9 a5 J5 t7 R
10.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag
    
11.   *            @arg TIM_FLAG_CC6: Compare 6 interrupt flag
    0 g5 d, i/ E  Q4 z9 g: `' @5 ~
12.   *            @arg TIM_FLAG_COM:  Commutation interrupt flag
    ( n+ j, J+ r+ Z" G1 P0 z! l7 P
13.   *            @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
    0 D" n5 a5 [8 U# J
14.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   
    
15.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    $ }% V& g+ d' q. e  R& ]5 L
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
    6 Y% W3 ]5 k% d0 o) Y
20.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    2 ?$ H/ w' v  e
21.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    + n4 t4 G; ]% _4 g4 \9 v, l7 g/ Q! e
22.   */
    % B+ B9 S' L7 b8 N2 X3 y) O# H2 m, K
23. #define __HAL_TIM_CLEAR_FLAG(__HANDLE__, __FLAG__)       ((__HANDLE__)->Instance->SR = ~(__FLAG__))

复制代码

+ ?2 J! P' w* o6 I$ |3 q& a) S清除标志函数所支持的参数跟获取函数是一 一对应的。除了这两个函数，还是定时器的中断开启和中断关闭函数用的也比较多。

1. /** @brief  Enable the specified TIM interrupt.
   ' W6 c. C# V+ G+ T2 h; e+ Z
2. * @param  __HANDLE__: specifies the TIM Handle.
   ' c/ Z' i+ T/ }$ H  x4 X
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
   
7. *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt
   
8. *            @arg TIM_IT_CC3:  Capture/Compare 3 interrupt
   
9. *            @arg TIM_IT_CC4:  Capture/Compare 4 interrupt
   
10. *            @arg TIM_IT_COM:   Commutation interrupt
    6 L5 W5 C3 F# N8 o  t- n# i7 R6 w
11. *            @arg TIM_IT_TRIGGER: Trigger interrupt
    
12. *            @arg TIM_IT_BREAK: Break interrupt
    
13. * @retval None
    
14. */
    
15. #define __HAL_TIM_ENABLE_IT(__HANDLE__, __INTERRUPT__)  ((__HANDLE__)->Instance->DIER |= (__INTERRUPT__))
    8 S- X; H- k& s& Z; u% l- Q
16. 
    
17.   /** @brief  Disable the specified TIM interrupt.
    1 S6 l3 j! ]3 q
18.   * @param  __HANDLE__: specifies the TIM Handle.
    % Y: q$ P; ^  e( V5 M( v  o6 k2 X" G
19.   * @param  __INTERRUPT__: specifies the TIM interrupt source to disable.
    - t6 W& d3 O; j) u5 z1 w% i9 }
20.   *          This parameter can be one of the following values:
    
21.   *            @arg TIM_IT_UPDATE: Update interrupt
    
22.   *            @arg TIM_IT_CC1:   Capture/Compare 1 interrupt
    
23.   *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt
    , T( H6 ?- r% ^) v/ U6 J! F
24.   *            @arg TIM_IT_CC3:  Capture/Compare 3 interrupt
    
25.   *            @arg TIM_IT_CC4:  Capture/Compare 4 interrupt
    * c+ P$ t# i4 m
26.   *            @arg TIM_IT_COM:   Commutation interrupt
    , b, }3 V9 C/ j' D+ P  D; B) z
27.   *            @arg TIM_IT_TRIGGER: Trigger interrupt
    ; I" c9 L; Q) J6 U: H. O
28.   *            @arg TIM_IT_BREAK: Break interrupt
    
29.   * @retval None
    
30.   */
    1 Y! y7 Q+ e" l9 V: I6 O' a  J( n
31. #define __HAL_TIM_DISABLE_IT(__HANDLE__, __INTERRUPT__)   ((__HANDLE__)->Instance->DIER &= ~(__INTERRUPT__))

复制代码

常用的也是前五个参数，1个定时器更新中断以及4个CC中断 。

注意：操作定时器的寄存器不限制必须要用HAL库提供的API，比如要操作寄存器CR1，直接调用TIM1->CR1操作即可。
% S2 w$ A7 |* q
. R+ q$ j6 N% h4 M  V32.3.7 定时器初始化流程总结
6 C' }$ `# ?, d: j7 U2 m4 `使用方法由HAL库提供：
& W2 D; I3 M; ~" I3 u+ U  y' N: D+ M4 I0 c5 c
* Q$ _3 s; d, g% S/ M# B  第1步：通过下面几个函数配置定时器工作在相应的模式
! B% K$ v9 F- k$ f% b$ o/ U
1 `8 e5 R2 e4 A( G( y( q  HAL_TIM_Base_Init
+ o  _1 B# y/ r2 n0 r/ F# m* V$ Q简单的定时器时基础功能
9 Y  A2 ]  t$ f  \/ j, W* W
. e. M7 J( j0 Y8 }7 p; y  HAL_TIM_OC_Init 和 HAL_TIM_OC_ConfigChannel
配置定时器产生输出比较信号

& `1 t4 b8 \, i9 V3 d  HAL_TIM_PWM_Init 和 HAL_TIM_PWM_ConfigChannel
$ ?0 B6 K3 G2 Y# K, ]1 N配置定时器产生PWM信号
- I% d0 v" ?7 F7 p
  HAL_TIM_IC_Init 和 HAL_TIM_IC_ConfigChannel
配置定时器测量外部信号

/ Z2 J* h% ^) p) J& n  HAL_TIM_OnePulse_Init 和 HAL_TIM_OnePulse_ConfigChannel
配置定时器工作在单脉冲模式
) c) }1 q. t! B7 W# I: W
' m9 ~4 o% v; h  HAL_TIM_Encoder_Init
: n# m. n7 N* \: m9 R+ ]9 Q配置定时器使用编码器接口
# R* r# p* |2 Y1 S% z4 w
1 w  A# p3 w, B; Y; I8 X( W8 S  第2步：定时器几个常用功能的底层初始化API，这个里面需要用户自己填
% H, S* r) F" J+ f* |
/ p$ K& m) j5 u/ T3 \; M, M" G7 F  b第1步里面的几个函数会调用下面的API。
+ |& l2 o! `. A
1 j8 ^/ p2 Z+ X! ?# q3 |  定时器基本功能 : HAL_TIM_Base_MspInit()
" w* z& @& X. V1 G  输入捕获 : HAL_TIM_IC_MspInit()
; w2 ?; n. E0 ^9 S% k5 r  K  输出比较 : HAL_TIM_OC_MspInit()
  PWM输出 : HAL_TIM_PWM_MspInit()
1 J4 N" c! x8 i  单脉冲输出模式: HAL_TIM_OnePulse_MspInit()
, ?, H/ s2 B2 j2 q, g5 v2 g# @+ t  编码器模式 : HAL_TIM_Encoder_MspInit()
2 J  v5 O& Y- U# g4 D! H& O  第3步：底层初始化具体实现
/ r' m9 y3 Y, A' [7 r/ F! K
- {2 `7 Z  _. h第2步中函数的具体实现。
. l: ~5 q5 N) D4 E9 ~8 J- ]
$ ^1 a+ Q" ~% n  Q  使用函数__HAL_RCC_TIMx_CLK_ENABLE()使能定时器时钟。
, d8 ]& ^( t( G% O  使用函数__HAL_RCC_GPIOx_CLK_ENABLE()使能定时器使用到的引脚时钟。
  使用函数HAL_GPIO_Init()配置GPIO的复用功能。
  如果使能了定时器中断，调用函数HAL_NVIC_SetPriority和HAL_NVIC_EnableIRQ配置。
  如果使能了DMA，还需要做DMA的配置。
  定时器默认使用APB时钟，如果使用外部时钟，调用函数HAL_TIM_ConfigClockSource可以配置。
  第4步：启动定时器外设
( |+ I% W' d% W: D6 g0 M- C
  定时器基础功能:
, s$ s: G/ e# tHAL_TIM_Base_Start()

HAL_TIM_Base_Start_DMA()

HAL_TIM_Base_Start_IT()
' A) j2 Q; N% @- ~* g. F
8 s0 \( s& Y4 [3 @  输入捕获 :
HAL_TIM_IC_Start()
& N. M) u) A; u6 ]
HAL_TIM_IC_Start_DMA()

HAL_TIM_IC_Start_IT()
, ^6 x6 ~" g! n
  输出比较 :
HAL_TIM_OC_Start()

0 k3 o! V( d- w2 ~; ~" IHAL_TIM_OC_Start_DMA()

HAL_TIM_OC_Start_IT()
7 m! ~  y! w2 Q0 X+ j7 d8 b" _$ J
3 D2 `. L! u: n" b+ R! b  PWM输出：
HAL_TIM_PWM_Start()
  A5 P3 [/ `3 }. o
HAL_TIM_PWM_Start_DMA()
4 M# n' {; A3 z
. t% R/ E0 I- R3 N/ D8 R' nHAL_TIM_PWM_Start_IT()

  单脉冲模式：
1 h0 V. ]9 p; u. w* Q( c* oHAL_TIM_OnePulse_Start()

" {* Z4 b( F' g1 ~HAL_TIM_OnePulse_Start_IT().
' _0 q8 H; i/ J+ ]0 U( K
  V  k2 C5 O$ h5 V7 k: i  编码器模式：
HAL_TIM_Encoder_Start()

HAL_TIM_Encoder_Start_DMA()

& f% v% [; {2 n& \- H: aHAL_TIM_Encoder_Start_IT().
. u& Q5 i8 g( Z# T! R
* |! y! v" T' H" C5 [6 |6 w8 j  第5步：定时器的DMA突发使用下面两个函数

( k: {# G3 z2 w7 O4 x  HAL_TIM_DMABurst_WriteStart()
  HAL_TIM_DMABurst_ReadStart()
定时器常用的功能，通过上面这几步即可实现。
6 e  R0 R+ h5 W
32.4 源文件stm32h7xx_hal_tim.c
此文件涉及到的函数非常多，这里把几个常用的函数做个说明：
2 F. q; n5 ~1 d8 A4 |& H* T7 G
  HAL_TIM_Base_Init
5 S7 Q" i- k. c! [; S  HAL_TIM_Base_Start
2 e# b% ]" m) D  HAL_TIM_PWM_Init
  HAL_TIM_PWM_ConfigChannel
  HAL_TIM_PWM_Start
4 R! S. t, {' x& e, Q  HAL_TIM_IC_Init
3 q: _$ c  V2 Q  Y  HAL_TIM_IC_ConfigChannel
) q, M9 Q# R1 g8 E* }+ p  HAL_TIM_IC_Start_IT
  HAL_TIM_OC_Init
  HAL_TIM_OC_ConfigChannel
# e# Y, Q4 I5 I- N  HAL_TIM_OC_Start
0 `) x0 y( {# N! t, K) u" L32.4.1 函数HAL_TIM_Base_Init
" [% n; Q& E# q) I! p6 l* L函数原型：
! t( p' E/ {  {4 h, u- [5 j

1. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   4 K* L/ b) N0 q! p
2. {
   7 h. b2 }5 t$ Q9 s
3.   /* 检测是否是有效句柄 */
   
4.   if(htim == NULL)
   , T$ p/ }0 ~+ E. X
5.   {
   
6.     return HAL_ERROR;
   % S# O  A' o3 ?- U3 c$ E
7.   }
   
8. 
   
9.   /* 检测参数 */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    ( T; |3 Q; ~" ~0 F) e
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    3 K0 T7 l  R4 Y) w7 V4 G% F& y+ t
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    - i/ r1 p* j/ E! u
13. 
    
14.   if(htim->State == HAL_TIM_STATE_RESET)
    
15.   {
    
16.     /* 默认取消锁 */
    
17.     htim->Lock = HAL_UNLOCKED;
    
18.     /* 初始化底层硬件 : GPIO, CLOCK, NVIC */
    5 |4 I5 Z5 d& S4 I( p4 E7 c
19.     HAL_TIM_Base_MspInit(htim);
    
20.   }
    
21. 
    
22.   /* 设置TIM状态 */
    
23.   htim->State= HAL_TIM_STATE_BUSY;
    : _! E) h! ^! p3 x. n' E
24. 
    
25.   /* 基本参数配置 */
      S- Q, N+ q' u
26.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
27. 
    
28.   /* 设置TIM就绪 */
    1 k, v0 h9 c' I2 `: z0 {4 m. B
29.   htim->State= HAL_TIM_STATE_READY;
    ; x# P7 [2 S9 @, n" w
30. 
    / ]. E5 p$ {+ @' q: F
31.   return HAL_OK;
    
32. }

复制代码

) B: f  H& Q/ o7 }函数描述：
+ n- n* W! Y% S3 [; u% O9 ~7 A
* _8 \8 F" i4 ~$ x7 a! W9 f此函数用于初始化定时器用于PWM。
/ f+ n4 K9 t' F8 r8 c1 m8 k8 Y6 q
6 ~, Z9 V) n9 D+ b! c9 N函数参数：
% h3 P0 e( N# \4 Z5 i, K
- }' t- f/ E' K5 }) N& B  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
* u/ ?0 X( N$ a5 T: N! y& ]  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
. n, [% I( M+ |: r$ |5 H注意事项：

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

解决办法有三：

+ ~( A9 D0 G8 k方法1：用户自己初始定时器和涉及到的GPIO等。

  E) c$ Z1 A! V方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

方法3：下面的方法

1. if(HAL_TIM_Base_DeInit(&TimHandle) != HAL_OK)
   * v* {" n; r  G. V8 J0 F
2. {
   ) o# x, l9 M; W1 w
3.     Error_Handler();
   " T1 c5 j  q; K/ Z. f( k' f8 g. ^
4. }  
   ; l, F8 L. f2 y" z; O
5. if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
   
6. {
   
7.     Error_Handler();
   5 {3 u" C  f" ]% C
8. }

复制代码

使用举例：
1 @2 L) q6 u- u3 ?$ ?/ R

1. TIM_HandleTypeDef   TimHandle = {0};
   ! \+ c0 @; t$ Z
2. 
   
3. /*
   $ m) v. A) m! ~0 I0 [# a
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   5 g+ t. I9 v; M' J$ S
5. */
   
6. TimHandle.Instance = TIMx;
   
7. TimHandle.Init.Prescaler         = usPrescaler;
   , p+ X3 Z" Z3 j
8. TimHandle.Init.Period            = usPeriod;        
   + J5 f0 i5 l4 J  j5 l
9. TimHandle.Init.ClockDivision     = 0;
   ! x9 d; o3 L2 I1 g1 k+ B1 w* j8 Z
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    
11. TimHandle.Init.RepetitionCounter = 0;
    
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    2 c% q) p5 ~8 k- O- ^" ?) t: L9 ~0 v
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    
14. {
    
15.         Error_Handler(__FILE__, __LINE__);
    
16. }

复制代码

32.4.2 函数HAL_TIM_Base_Start
( ?: a5 t3 f. |9 B2 l8 F函数原型：
! A" Q% z  |( m' g

1. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   
2. {
   
3.   /* 检测参数状态 */
   , @. ~# q; ^; D- U$ a# C  o
4.   assert_param(IS_TIM_INSTANCE(htim->Instance));
   : j0 g* H" U' Z' O' W
5. 
   
6.   /* 设置定时器状态 */
   3 n( h( ~8 ?& A; [7 L# I
7.   htim->State= HAL_TIM_STATE_BUSY;
   " }3 `/ _& y* J( E8 R  q; ]) n2 O" O; W
8. 
   # Z0 {9 S% ?( `4 J, w2 _- ]& T- z! H
9.   /* 使能定时器 */
   ' D) ^: D- |8 f# X$ F/ l
10.   __HAL_TIM_ENABLE(htim);
    ' U  s/ p& a- r: |; W5 i/ X; B$ c- D
11. 
    
12.   /* 设置定时器状态 */
    
13.   htim->State= HAL_TIM_STATE_READY;
    . y& Q- q3 |) p- {1 U1 V5 M8 G
14. 
    % d3 C' J. ]1 f; k5 I
15.   /* 返回HAL_OK */
    " H' Y8 I; {6 t+ t) p# U
16.   return HAL_OK;
    
17. }

复制代码

函数描述：

( O2 F! G/ [, n此函数比较简单，调用函数HAL_TIM_Base_Init配置了基础功能后，启动定时器。
* A. J/ f/ W- d) K# Z3 j! }
函数参数：
4 M9 s; O4 Q, K$ }0 J
7 c1 q) r; S8 U3 p% T9 @; O  第1个参数是TIM_HandleTypeDef类型结构体指针变量。
- b! k0 Y- z% K! E. J! l+ h  返回值，固定返回HAL_OK，表示初始化成功。
! t7 V, T  l. W9 O& r. j使用举例：
' f: ^  x2 A) p* T; R! d6 J+ h- O/ j
0 b. b$ O$ h& _  L

1. TIM_HandleTypeDef   TimHandle = {0};
     Q* ]1 {5 e9 {0 C) }. C
2. 
   8 b: ^+ l3 S+ _* q: b) J
3. /*
   
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   . P' H7 q) W. y" g: P/ V
6. TimHandle.Instance = TIMx;
   % M) s  f5 t$ o$ x
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;
    # @$ N+ J& |0 a8 k+ J# @9 D# w, D' k
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    
14. {
    ' V9 G6 Z( {! {0 B1 }
15.         Error_Handler(__FILE__, __LINE__);
    
16. }
    + J# W- ?5 ~+ |5 H. `" u2 |) Y
17. 
    
18. /* 启动定时器 */
    
19. if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
    
20. {
    7 ^. `# e' l4 F7 ^3 C0 o
21. Error_Handler(__FILE__, __LINE__);
    0 `: _) ~" w# I$ o7 x
22. }

复制代码

1 E2 q6 N, x  M: A  W, ~32.4.3 函数HAL_TIM_PWM_Init
8 D" Z4 x2 ]7 `, R$ C1 C4 T函数原型：
+ ?: T7 ^# n/ d+ k% Z4 }; D+ T

1. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
   
2. {
   / {5 e1 H9 ~* A4 J7 ?: U
3.   /* 检查句柄是否有效 */
   
4.   if(htim == NULL)
   
5.   {
   
6.     return HAL_ERROR;
   # x4 [" _" @, x( a2 U" C; b- m, }
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. 
    8 r6 ^: @6 a& {1 H
14.   if(htim->State == HAL_TIM_STATE_RESET)
    4 x% r& e3 a8 o0 \! g4 e
15.   {
    
16.     /* 默认取消锁 */
    
17.     htim->Lock = HAL_UNLOCKED;
    
18. 
    
19.     /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_PWM_MspInit(htim);
    
21.   }
    
22. 
    # v$ q. O, D( u7 L' Y: ]
23.   /* 设置定时状态 */
    # V3 M: G% \' M" s/ E- ~* }% |
24.   htim->State= HAL_TIM_STATE_BUSY;
    
25. 
    * C8 B7 [4 i: V# z0 q
26.   /* 配置定时器用于PWM */  
    ! ^1 B" N! \$ {" t  O
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    . o1 e2 K. f( Z6 l( U
28. 
    
29.   /* 设置定时器状态 */
    0 G( {# }$ T  X8 Q3 T
30.   htim->State= HAL_TIM_STATE_READY;
    + c7 I% y, p  w
31. 
    
32.   return HAL_OK;
    9 r. Z# ^) @! Y
33. }

复制代码

: J+ g7 u" ~4 t函数描述：
' X! Y+ d! A$ ^8 |0 E! `, a. Q: A
% G/ q' v5 q) E4 q此函数用于初始化定时为PWM方式。

函数参数：
5 p7 q4 s- [; W  k) o5 s8 n3 z
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
) W* p% J- q" r  k$ T7 z1 c  N, N2 w  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：

: A  p1 k9 Q$ |8 V9 v函数HAL_TIM_PWM_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
0 R# O4 b% Y, |8 N0 V4 x( W对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_TIM_STATE_RESET  = 0x00U。

7 I! Y, ~( o" i" W解决办法有三：
! R% U- u+ W( ]$ V  x- Q: \4 A
4 D0 ?/ G6 W: ~1 N* [* `" a. m方法1：用户自己初始定时器和涉及到的GPIO等。
! l- F5 Z9 l' }
$ R1 C$ u3 D3 S! B8 N& o方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

方法3：下面的方法

1. if(HAL_TIM_PWM_DeInit(&TimHandle) != HAL_OK)
   2 E+ p, r+ h  d( g1 D, L
2. {
   - Q7 g$ Q+ }+ m  L' q; [( @9 V
3.     Error_Handler();
   & U" M/ U1 o" K+ W6 \/ l
4. }  
     Z2 e  I3 r) }: L6 L6 f+ @
5. if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
   
6. {
   
7.     Error_Handler();
   
8. }

复制代码

使用举例：
! S7 s8 @) r) j- q; W) X
! \. S: ~' P7 Q

1. TIM_HandleTypeDef  TimHandle = {0};
   
2. 
   
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   
4. TimHandle.Instance = TIM1;
     G% {& k, p- C& `7 g6 K1 W
5. TimHandle.Init.Prescaler         = usPrescaler;
   
6. TimHandle.Init.Period            = usPeriod;
   " z1 Y: |1 r" S9 M
7. TimHandle.Init.ClockDivision     = 0;
   ) x( E& j0 W7 b+ R7 f/ u- i
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   ) O+ C6 z/ C. u$ V9 s1 b
9. TimHandle.Init.RepetitionCounter = 0;
   
10. TimHandle.Init.AutoReloadPreload = 0;
    
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    6 J  E% ~: ]; I7 K1 N/ M$ g$ |
12. {
    5 S- h3 `, d! Z1 a& a" k1 j5 s( L0 @
13.     Error_Handler(__FILE__, __LINE__);
    
14. }

复制代码

32.4.4 函数HAL_TIM_PWM_ConfigChannel
3 j5 j) [! {1 E' X( o; h+ G函数原型：

3 S, S9 i  r- ^) U* Z

1. HAL_StatusTypeDef HAL_TIM_PWM_ConfigChannel(TIM_HandleTypeDef *htim,
   
2.                                             TIM_OC_InitTypeDef* sConfig,
   
3.                                             uint32_t Channel)
   
4. {
   
5.    /* 省略 */
   7 n1 V" J3 J8 E& i3 c: y  W
6. 
     B4 y1 \9 k! H, b& u+ v2 k$ H
7.   /* 开锁 */
   % a/ X# K5 \4 M- Q9 f; I
8.   __HAL_LOCK(htim);
   
9. 
   
10.   htim->State = HAL_TIM_STATE_BUSY;
    6 e# W5 }2 {& C9 a& H9 a/ K! I& S' l5 I
11. 
    
12.   switch (Channel)
    
13.   {
    6 n9 O6 L3 s: u+ I  N8 F
14.     case TIM_CHANNEL_1:
    8 r, g( R4 _% Q4 d8 u: Z8 M
15.     {
    
16.       /* 检查参数 */
    / {! V; ?& j& s. z
17.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    
18. 
      }) u) X! r5 x  b# {# C; O* y7 h% N
19.       /* 配置通道1的PWM模式 */
    
20.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    # W" S) I. t  g9 Y% b/ a9 q
21. 
    
22.       /*预装载使能，更新事件产生时写入有效 */
    9 ?, K+ K9 r; J5 h2 |
23.       htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;
    # [4 Q8 A; H$ `. s# L
24. 
    ' `; M  ]7 ~- Y+ o: {
25.       /* 配置是快速输出模式 */
    
26.       htim->Instance->CCMR1 &= ~TIM_CCMR1_OC1FE;
    
27.       htim->Instance->CCMR1 |= sConfig->OCFastMode;
    
28.     }
    5 |* x+ n9 L: J/ b2 H" e  x) K0 n
29.     break;
    
30. 
    4 L/ S# F" E  f4 Q7 t$ j" j5 S" a
31.     case TIM_CHANNEL_2:
    
32.     {
    
33.        /* 省略 */
    8 o* U9 k9 I; ~8 `
34.     }
    
35.     break;
    
36. 
    
37.     case TIM_CHANNEL_3:
    4 J+ g  w# h5 h' J/ i4 v
38.     {
    
39.        /* 省略 */
    % F' O$ t( X  _" D4 C. R
40.     }
    * ?. j' {9 g0 g* r1 C) n* F0 `4 f
41.     break;
    * `0 h+ v# d4 u. Q
42. 
    2 b/ W# K2 Z5 Z$ x
43.     case TIM_CHANNEL_4:
    
44.     {
    , a1 ~( G1 L2 r- _& W8 x8 H* d
45.       /* 省略 */
    & @) Y1 O9 v2 X5 x* u7 L+ V5 f
46.     }
    6 {1 t: v7 Z4 k! M; ^
47.     break;
    
48. 
    
49.     case TIM_CHANNEL_5:
    
50.     {
    % H) _8 V. |. a+ C
51.        /* 省略 */
    
52.     }
    
53.     break;
      r; F; I5 y3 m' C
54. 
    * B8 h& |. H* W5 X6 ~; a, s: G. c5 o
55.     case TIM_CHANNEL_6:
    7 X0 E5 D. ^' Q$ z0 v2 [
56.     {
    3 K# {! q+ v+ v$ @" r/ W+ A6 d
57.         /* 省略 */
    
58.     }
    , h/ o3 ]# ^6 _- U) r
59.     break;
    
60. 
    
61.     default:
    ; J, x0 ]5 g; Y1 R; q- E8 n& k& E# D
62.     break;
    : u9 }; ~. c/ D, |8 [/ E: Z
63.   }
    2 ], |1 s( c9 n
64. 
    , @5 L1 w7 T# u! \
65.   htim->State = HAL_TIM_STATE_READY;
    - L1 m  ^$ J/ Z! L5 z8 P1 g
66. 
    
67.   /* 关锁 */
    $ c2 \; b; Q9 c. l3 v) {
68.   __HAL_UNLOCK(htim);
    / \* z; @6 s4 C8 K: A
69. 
    
70.   return HAL_OK;
    % M% W/ _1 p8 |9 n2 Q  y
71. }

复制代码

  d6 Y% b9 v8 @- i  {函数描述：
, J7 m2 @( O& L$ q, U
8 w& p/ ]& f. q& N) q) n  B此函数用于配置定时器的PWM通道。
  I3 q- v. Q; F5 f' b" R
7 h% z5 p3 G4 L" b函数参数：
$ n2 B( n, e' d
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
% ?2 X* s$ R7 b6 l  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
- T) w) h5 B  b2 T9 Q  第3个参数是通道设置，支持以下参数：
& f' Z5 o# S5 A, GTIM_CHANNEL_1

& W1 R5 f3 l) |  R% rTIM_CHANNEL_2
7 d8 ?& T5 Y' y; P
TIM_CHANNEL_3
( L! o. l- x4 D6 q
TIM_CHANNEL_4

TIM_CHANNEL_5

% C0 y: k- M5 J8 x0 b8 ]TIM_CHANNEL_6
( F+ e- C- D' W& h/ Z
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
使用举例：

7 Z' y4 c3 i* }1 z8 Z; R! x

1. TIM_HandleTypeDef  TimHandle = {0};
   4 |' K% Z, I  S9 f8 n( i& M
2. 
   
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   
4. TimHandle.Instance = TIM1;
   
5. TimHandle.Init.Prescaler         = usPrescaler;
   0 _6 a. ~! v, l& M
6. TimHandle.Init.Period            = usPeriod;
   . {7 [: \. H( }: D$ [( q
7. TimHandle.Init.ClockDivision     = 0;
   0 {5 j0 Z7 U8 W1 b4 g
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   
9. TimHandle.Init.RepetitionCounter = 0;
   ' \. r! F+ X$ u& M' P% o2 x' i  e
10. TimHandle.Init.AutoReloadPreload = 0;
    # \' D& x$ y3 J: m& ~( h; o+ g. \1 `
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    
12. {
    4 q0 f! f3 _' Z" X
13.     Error_Handler(__FILE__, __LINE__);
    4 u4 p& [# Y, Q; c9 q+ K# E
14. }
    9 w7 o+ C( v. g& y! C
15. 
      \6 ^9 |1 y, k/ c3 {
16. /* 配置定时器PWM输出通道 */
    2 B$ a! Z5 U$ m. t* ~3 T
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    4 n! N* h, E8 w2 E
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    : c7 r5 b! P0 f) }# @) E& {2 c5 q
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    4 M0 Y1 T6 F, @  r6 E5 c
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
    
23. 
    
24. /* 占空比 */
    * n7 K0 }9 b4 k; k  l
25. sConfig.Pulse = pulse;
    
26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    
27. {
    
28.     Error_Handler(__FILE__, __LINE__);
    
29. }

复制代码

32.4.5 函数HAL_TIM_PWM_Start
' ]) l  b. l! V; {函数原型：

1. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
   1 F% L( h* Q9 t2 f3 f/ h. x
2. {
   5 g2 K: u7 V# r- E; {+ i
3.   /* 检测参数 */
   8 }% p. M8 A, Y: X4 @; J
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
     {) O3 |; V. x9 n  g0 C4 B1 x
5. 
   % B8 @- e8 R+ I4 ]
6.   /* 使能捕获比较通道 */
   * g9 T4 {9 M1 M, r) n$ b. g
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
8. 
   : p3 O7 P3 a; @# P
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
   
10.   {
    4 V; }+ |. S) s' I0 P0 p* |
11.     /* 使能主输出 */
    , N! y4 j) X& v, |  Q
12.     __HAL_TIM_MOE_ENABLE(htim);
    
13.   }
    
14. 
    
15.   /* 使能定时器 */
    ! l; t/ P0 l3 `" t& f& H
16.   __HAL_TIM_ENABLE(htim);
    , \! [, Y3 V( F; T$ Z7 ]5 ^8 k
17. 
    : O3 H' ?2 s. c6 K) @
18.   /* 返回状态*/
    ) i4 d& k. @9 \" p0 Y; C/ H3 n
19.   return HAL_OK;
    
20. }

复制代码

- s4 I4 k2 q" v/ Z9 [0 e函数描述：

此函数用于启动PWM。

: x8 X" l3 B  J+ [  Q函数参数：

+ D- \: L$ x# }* m! O: d( F  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  第2个参数是通道设置，支持以下参数：
TIM_CHANNEL_1

2 v. s- d$ t" d" R; [TIM_CHANNEL_2

TIM_CHANNEL_3

8 X/ G( A8 O; p7 yTIM_CHANNEL_4
3 m4 H$ \0 W% W
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
使用举例：

1. TIM_HandleTypeDef  TimHandle = {0};
   / B) X1 {; f. D. s  W) z
2. 
   4 [, j  M5 A- I! \) t, B3 a
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   ! O( T6 V% }7 k: n2 o
4. TimHandle.Instance = TIM1;
   / J2 I2 x6 a' a/ B& f! R* K
5. TimHandle.Init.Prescaler         = usPrescaler;
   
6. TimHandle.Init.Period            = usPeriod;
   0 Z  N8 J# c+ q" _9 W( Y" q- R
7. TimHandle.Init.ClockDivision     = 0;
   
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   # X* X( K6 t' Q/ n4 ^! s! A2 L
9. TimHandle.Init.RepetitionCounter = 0;
   
10. TimHandle.Init.AutoReloadPreload = 0;
    . Z4 a0 ^; A( |! `4 G
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    
12. {
    
13.     Error_Handler(__FILE__, __LINE__);
    0 j2 v9 G* C" ^: _
14. }
    ! F9 ?3 N1 ?6 \7 }
15. 
      u) W) o3 M, G
16. /* 配置定时器PWM输出通道 */
    6 X: e+ @4 s& g5 m) w7 P3 d
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    7 `6 [4 Q! F) h( P6 Z* X5 A
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    , q8 h0 g1 z8 a' x# q1 f
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
    * m4 D" Q( `1 G# s$ I3 w
23. 
    
24. /* 占空比 */
      L8 j! G' @1 B$ X' Z+ R
25. sConfig.Pulse = pulse;
    ' h2 K1 F# L6 [4 Q5 o4 Q3 ^
26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    
27. {
    
28.     Error_Handler(__FILE__, __LINE__);
    
29. }
    & S4 K( O- l, C  a; L+ V" s
30. 
    $ D: ~9 Z" C1 [+ K4 z) N( ^
31. /* 启动PWM输出 */
    ( Q1 K8 e+ k0 {3 Z
32. if (HAL_TIM_PWM_Start(&TimHandle, TimChannel[_ucChannel]) != HAL_OK)
    
33. {
    : Q3 c  O/ y  A) q% Q5 M! [6 @
34.         Error_Handler(__FILE__, __LINE__);
      I3 q6 O2 C4 p4 _. O+ V4 o' x
35. }

复制代码

32.4.6 函数HAL_TIM_IC_Init
函数原型：
- A2 f+ K/ I# f2 o5 d& ]
2 V' o- G+ q# V( l, p% l6 [

1. HAL_StatusTypeDef HAL_TIM_IC_Init(TIM_HandleTypeDef *htim)
   
2. {
   
3.   /* 检测形参是否有效 */
   ( a! I* C6 {! B3 `: o/ Y
4.   if(htim == NULL)
   . b% t2 c) c1 p& v' Y  |3 c! n
5.   {
     j& u. A9 |# {& g3 J
6.     return HAL_ERROR;
   
7.   }
   9 k& l7 i, S0 ~9 B
8. 
   $ L! m0 k: n7 }
9.   /* 检测参数 */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    6 ~2 `1 |5 f. n- l7 L3 R
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    + h$ t6 D  }: w
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
13. 
    
14.   if(htim->State == HAL_TIM_STATE_RESET)
    
15.   {
    
16. /* 默认取消锁 */
    " @3 i3 s' ~: E1 W' J
17.     htim->Lock = HAL_UNLOCKED;
    
18. 
    
19.      /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_IC_MspInit(htim);
    
21.   }
    
22. 
    ! I2 h; x1 m# {
23.   /* 设置定时器状态 */
    ! ?9 v1 j& p9 J" o* X) L9 R- o
24.   htim->State= HAL_TIM_STATE_BUSY;
    # m, h3 n- ~& h9 S: q; J. ]4 _6 a
25. 
    
26.   /* 配置定时器为输入捕获模式 */  
    
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
28. 
    / ]( M. U1 B' z3 z8 y1 H, b& G
29.   /* 设置定时器状态 */
    
30.   htim->State= HAL_TIM_STATE_READY;
    
31. 
    , \: {4 |4 q* ^& I, ^( Z
32.   return HAL_OK;
    7 K% _: [" Q: S, S$ _
33. }

复制代码

函数描述：
* G7 W8 J2 l( n
此函数用于定时器输入捕获初始化。
  w  Q4 x( M4 P1 Q2 Q: v8 f' i7 E
4 E) U2 g" m" k( _0 Y' H函数参数：

6 }4 i" f( S& X7 ?8 A( ?- b: ?* W  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
& P' Y! ^6 l3 Q9 P+ }9 C" @注意事项：

+ E/ \" Z0 ^" r+ S* n! V函数HAL_TIM_IC_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个HAL_TIM_STATE_RESET  = 0x00U。
5 q; D: P! d, Z  h* N1 h2 P
解决办法有三：
6 B9 ?) U1 b$ e9 _
, d2 ~  x* W# y; U方法1：用户自己初始定时器和涉及到的GPIO等。
6 ~7 V. K% |. I- E  s
方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
( S( c- T1 X& V( w8 L4 w! w" b
方法3；下面的方法

) Q% i) c& r. D1 A% x

1. if(HAL_TIM_IC_DeInit(&UartHandle) != HAL_OK)
   : |1 _" l1 n) H9 W
2. {
   - v2 A3 m. e& s, C3 t9 K
3.     Error_Handler();
   - Y1 D  I. w  x
4. }  
   ! @9 {/ E8 f8 S! p7 f
5. if(HAL_TIM_IC_Init(&UartHandle) != HAL_OK)
   
6. {
   # M7 p' ~+ e4 A$ K9 H/ Q
7.     Error_Handler();
   ' a4 R1 H7 P: a* Z! h9 `
8. }

复制代码

32.4.7 函数HAL_TIM_IC_ConfigChannel
  y8 M% |* y; i9 a函数原型：

0 F1 @. @. b; ]( E1 C. t

1. HAL_StatusTypeDef HAL_TIM_IC_ConfigChannel(TIM_HandleTypeDef *htim, TIM_IC_InitTypeDef* sConfig, uint32_t Channel)
   ; e' `) q. u9 I" g6 Z) |
2. {
   7 v# P8 i. M- V
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
   * f& N1 M0 r3 K& T/ L% _( W! ~
5.   assert_param(IS_TIM_IC_POLARITY(sConfig->ICPolarity));
   
6.   assert_param(IS_TIM_IC_SELECTION(sConfig->ICSelection));
   2 A7 b% _- ]4 G9 E! t7 G
7.   assert_param(IS_TIM_IC_PRESCALER(sConfig->ICPrescaler));
   4 Q1 n! S+ B- k6 a4 X! n- {' P
8.   assert_param(IS_TIM_IC_FILTER(sConfig->ICFilter));
   
9. 
   
10.   /* 开锁 */  
    $ S/ l( S" _8 r, D- b% G2 y; D% \4 F
11.   __HAL_LOCK(htim);
    7 F; ?# r* b, Q5 N( k( o* }
12. 
    
13.   htim->State = HAL_TIM_STATE_BUSY;
    
14. 
    9 d% j" I$ ]2 k. G2 K4 U+ H
15.   if (Channel == TIM_CHANNEL_1)
    
16.   {
    
17.     /* 配置输入通道1 */
    ! L2 r  _7 k$ T" i8 G7 `. {
18.     TIM_TI1_SetConfig(htim->Instance,
    / x7 L" \+ b0 [) Q4 `& X
19.                sConfig->ICPolarity,
    
20.                sConfig->ICSelection,
    
21.                sConfig->ICFilter);
    1 |8 c( a" O4 a% m. e- G
22. 
    9 c* S% @' S8 Z% V# j
23.     /* 清零IC1PSC位 */
    0 R7 ~$ l* a0 q: @
24.     htim->Instance->CCMR1 &= ~TIM_CCMR1_IC1PSC;
    
25. 
    1 o3 n, u4 @  K3 T* ~
26.     /* 根据用户配置，设置分频 */
    
27.     htim->Instance->CCMR1 |= sConfig->ICPrescaler;
    
28.   }
    
29.   else if (Channel == TIM_CHANNEL_2)
    
30.   {
    % `3 J3 k6 }0 H: P
31. /* 省略 */
    0 h' Y! g3 z5 t5 A1 k# \
32.   }
    
33.   else if (Channel == TIM_CHANNEL_3)
    
34.   {
    
35.      /* 省略 */
    
36.   }
    
37.   else
    
38.   {
    
39.      /* 省略 */
    0 |% ^9 |  A$ D1 A# E
40.   }
    % z& A0 F+ Q/ a
41. 
    
42.   htim->State = HAL_TIM_STATE_READY;
    ' |" E& C! U, o( P9 A
43. 
    
44.   __HAL_UNLOCK(htim);
    8 C$ w1 S. @7 D5 K% E
45. 
    ( `; h$ d8 i5 }' N2 k1 Z
46.   return HAL_OK;
    , V- U8 R. s* ~
47. }

复制代码

函数描述：
, @( y1 C7 k8 Z5 W! ^7 P2 V
7 G- V- R2 W5 S$ [8 e* Y6 v此函数用于配置定时器的输入捕获通道。

! c/ ]3 \: C- j: Y. B- _1 E函数参数：

. ~: R  A' N/ D  ]( A  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置
6 x9 y1 s9 T9 ^# j& [9 g  第2个参数是TIM_IC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
# d+ q6 G$ X  L3 o/ b7 l6 v3 v: j  第3个参数是通道设置，支持以下参数：
% Y9 @4 r% M. i6 LTIM_CHANNEL_1

TIM_CHANNEL_2
/ n) V! b4 [* F" l# R
TIM_CHANNEL_3

, |. T- c1 Z/ L% k6 r! LTIM_CHANNEL_4

  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。

32.4.8 函数HAL_TIM_IC_Start_IT
函数原型：
: h9 P0 J* n& I. ~! g

1. HAL_StatusTypeDef HAL_TIM_IC_Start_IT (TIM_HandleTypeDef *htim, uint32_t Channel)
   8 j4 m& K% ~6 @, `
2. {
   / U; l% B- @6 D  Y# J
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   2 v$ ^8 t$ {) N8 ?
5. 
   
6.   switch (Channel)
   
7.   {
   0 r) a, q# s. i3 j5 Q6 D
8.     case TIM_CHANNEL_1:
   
9.     {      
   ' D. D6 S+ [( p: \5 p
10.       /* 使能CC1（Capture/Compare 1）中断 */
      d- V" |$ F' t5 g6 i0 L
11.       __HAL_TIM_ENABLE_IT(htim, TIM_IT_CC1);
    
12.     }
    
13.     break;
    ) H% I/ J" J* o, C+ T& H
14. 
    
15.     case TIM_CHANNEL_2:
    
16.     {
    
17.    /* 省略 */
    
18.     }
    6 R' p. W: ^; i4 l$ |% m& C
19.     break;
    
20. 
    / t6 |- }2 m* t& |: c$ L
21.     case TIM_CHANNEL_3:
    $ ]3 f( @$ `/ e1 b2 h
22.     {
    0 F  l* z( @  U- P9 K* v
23.   /* 省略 */
    
24.     }
    ! w, h* d* b: Z: [7 {2 h
25.     break;
    / K4 C7 s, q0 F, s  Y/ D4 M
26. 
    
27.     case TIM_CHANNEL_4:
    ' X4 h! Z* Y1 _0 w! D( A9 [6 z
28.     {
    . Z) k2 H# q% ?7 g( ^8 |' G4 e
29.   /* 省略 */
    9 h) ^7 G6 T9 F! F0 m! m
30.     }
    
31.     break;
    
32. 
      e: @9 e! M% X5 q& y
33.     default:
    * P0 c* g0 P1 N5 o7 Z% T& j
34.     break;
    - X* T; {) h* g5 ~! z. M
35.   }  
    $ l2 @. b8 A) [- c
36.   /* 使能输入捕获通道 */
    . `& h2 `+ B! Q7 p) n' O$ _
37.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
38. 
    ! o) h$ _$ U; R
39.   /* 使能定时器 */
    
40.   __HAL_TIM_ENABLE(htim);  
    * l3 K1 M$ M$ p" E
41. 
    4 L% T* _( P6 @% k0 p! i
42.   /* 返回状态 */
    + N+ z6 m4 i8 k
43.   return HAL_OK;  
    
44. }

复制代码

函数描述：

此函数用于启动定时器输入捕获模式，采用定时器方式。
  N) L2 G  p* m
, A; P, _0 L" [+ y4 C函数参数：
. L* z$ Q: i; e
! n  A$ Y0 Z* D( B6 X0 _) V  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
8 t% n1 `; W; |3 S4 N) P8 T  第2个参数是通道设置，支持以下参数：
$ _% |2 R5 N9 _8 [$ PTIM_CHANNEL_1
! L5 V: g' h$ Y  j  m" J
TIM_CHANNEL_2

  z. t7 E7 ~, K/ r0 CTIM_CHANNEL_3
4 a% Z8 }, O8 e% n
TIM_CHANNEL_4
( _! g( |: O+ z2 }* d
# E* ^$ R9 [- s- Y  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。

32.4.9 函数HAL_TIM_OC_Init
9 ~, K  q$ G7 |$ O: n函数原型：

1. HAL_StatusTypeDef HAL_TIM_OC_Init(TIM_HandleTypeDef* htim)
   
2. {
   
3.   /* 检测形参是否有效 Check */
   
4.   if(htim == NULL)
   
5.   {
   
6.     return HAL_ERROR;
   : n! B. s$ e% G" Y$ `. E# T
7.   }
   7 u: V. T* Y5 R  q
8. 
   
9.   /* 检查参数 */
   ; `4 k) ?/ Y# g
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    4 z7 q7 {. D5 @/ t; A5 K
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)
    ' P6 Z2 u6 h" [2 F0 v8 O7 X0 Y
15.   {
    
16. /* 默认取消锁 */
    
17.     htim->Lock = HAL_UNLOCKED;
    3 m% `4 Q  A$ |9 S2 X. n
18. 
    
19. /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_OC_MspInit(htim);
    ) A6 z% [  Q! o
21.   }
    
22. 
    ( V2 M, G2 Q5 V
23.   /* 设置定时器状态Set the TIM state */
    % M  O8 n0 A  h+ v! |5 w
24.   htim->State= HAL_TIM_STATE_BUSY;
    7 P4 ]$ J9 S$ f/ N  g
25. 
    9 q. k: A2 B) K8 ^+ V) O0 Z
26.   /* 配置定时器为输出比较模式Init the base time for the Output Compare */  
    9 ]8 X8 I& t% f* Z( X
27.   TIM_Base_SetConfig(htim->Instance,  &htim->Init);
    4 B: G, q. O( ^+ h4 f, j2 i9 Z
28. 
    
29.   /* 设置定时器状态 */
    
30.   htim->State= HAL_TIM_STATE_READY;
    
31. 
    
32.   return HAL_OK;
    
33. }

复制代码

函数描述：
2 y8 I" G1 P3 E* @) ]
此函数用于定时器输出比较初始化。
& [( K) [7 H8 l9 q, `
函数参数：
& l* H9 L6 e+ P- s- s6 D& z$ _% B
: }- l  ~! c. ~+ o, A: j0 G  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：
& H1 z' {& e" I( E6 t7 a
# F. A9 t# N# u函数HAL_TIM_OC_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
. e( [( S+ J2 Z( `对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个HAL_TIM_STATE_RESET  = 0x00U。

; Z: s, ]$ ~# d6 H# z6 b解决办法有三：
2 x+ F! N. n3 R2 }
5 C0 i+ b8 D3 O: ^  j# H3 }4 k方法1：用户自己初始定时器和涉及到的GPIO等。
) b; _8 X* T& _( E# Z" j2 `
' \5 d" G* Y0 {8 C3 O方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

# V8 }& a2 L) N  M方法3；下面的方法

/ Y' b4 [$ V3 e9 g& o7 U

1. if(HAL_TIM_OC_DeInit(&UartHandle) != HAL_OK)
   
2. {
   % d& g: ]! o& S' J* Y" t
3.     Error_Handler();
   ( V/ `  w( o' Z' i7 e: ^0 N; }! W/ P0 I
4. }  
   : d8 F4 j( \4 L" a) e7 w* i4 }2 ~
5. if(HAL_TIM_OC_Init(&UartHandle) != HAL_OK)
   
6. {
   9 b1 {/ f+ A6 @
7.     Error_Handler();
   
8. }

复制代码

4 r& v; g$ S9 u' h32.4.10   函数HAL_TIM_OC_ConfigChannel
函数原型：
! o( \5 T& ]6 j2 D9 q6 u0 y
( Z% d9 o; [8 }

1. HAL_StatusTypeDef HAL_TIM_OC_ConfigChannel(TIM_HandleTypeDef *htim,
   
2.                                            TIM_OC_InitTypeDef* sConfig,
   
3.                                            uint32_t Channel)
   5 f( {9 b! y5 z& F' k& K
4. {  
   
5.   /* Check the parameters */
   
6.   assert_param(IS_TIM_CHANNELS(Channel));
   
7.   assert_param(IS_TIM_OC_MODE(sConfig->OCMode));
   - Z; u( U$ g% N" M; e
8.   assert_param(IS_TIM_OC_POLARITY(sConfig->OCPolarity));
   4 y, P7 Y4 R7 [( {* q8 @3 s
9. 
   - o: H; z7 p5 b" p
10.   /* Process Locked */
    8 s0 n. \& L; \' y: F: `2 r
11.   __HAL_LOCK(htim);
    
12. 
    
13.   htim->State = HAL_TIM_STATE_BUSY;
    
14. 
    ! x. H# ?) ]  a& G
15.   switch (Channel)
    6 u& Z8 X" l9 H3 Y, K  A
16.   {
    - B* E$ I7 b4 l. D! d' Z2 ]
17.     case TIM_CHANNEL_1:
    
18.     {
    
19.       /* 检测参数Check the parameters */
    # g; b4 C* w5 T9 ], z
20.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    
21. 
    * E  O  R3 R; V) ~" O6 [
22.      /* 配置定时器输出比较通道1 */
    ' ^* [! a( }$ L! L& U7 A
23.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    5 d* A! ^% C: i, u9 u# a
24.     }
    
25.     break;
    
26. 
    
27.     case TIM_CHANNEL_2:
    
28.     {
    
29.       /* 省略 */
    
30.     }
    5 T/ A) t' _7 W7 X: u
31.     break;
    
32. 
    
33.     case TIM_CHANNEL_3:
    5 ~; [; J9 q& N
34.     {
    
35.       /* 省略 */
    " u6 y0 a. \: G; ~
36.     }
    # k, r5 ]$ t* {
37.     break;
    
38. 
    , ]. ^8 G& P! D& ]& I- w
39.     case TIM_CHANNEL_4:
    * `" S- _% T' Y9 V: m5 I' s5 \
40.     {
    
41.       /* 省略 */
    
42.     }
    
43.     break;
    
44. 
    
45.     case TIM_CHANNEL_5:
    
46.     {
    : D( {' R1 C6 c8 ~4 s  j
47.       /* 省略 */
    
48.     }
      {) l$ ]; n8 z3 j0 h) j
49.     break;
    6 @, w' M" q' h
50. 
    $ Q$ R% r0 M" `! G+ X
51.     case TIM_CHANNEL_6:
    2 e) G* H3 m0 I8 E7 T9 G$ H- V0 S! m
52.     {
    
53.       /* 省略 */
    
54.     }
    8 P% M. f6 y( ^) q0 @
55.     break;
    
56. 
    
57.     default:
    : V+ q# F* v4 Q2 e1 h
58.     break;   
    8 b6 y$ {3 R- K2 i& N% z
59.   }
    
60. 
    
61.   htim->State = HAL_TIM_STATE_READY;
    . Q6 A! H  |$ m. c4 ~. P; a
62. 
    
63.   __HAL_UNLOCK(htim);
    
64. 
    ; Q% \& S! m0 P+ d+ @, W0 B9 @- c( ?2 b
65.   return HAL_OK;
    $ l: c1 j2 A) w0 M! b
66. }

复制代码

函数描述：
( |2 I+ \! m2 k# Z
此函数用于初始化串口的基础特性和高级特性。
" o* w9 w' z( V% X
函数参数：
0 E4 S# c( w, T3 F* l" }2 c% w
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
TIM_CHANNEL_1

& p: w" G- @- [2 W5 Q' v3 jTIM_CHANNEL_2

; P& d0 i3 x1 j7 @1 s: s0 uTIM_CHANNEL_3
. x1 L( n* t5 K2 w
TIM_CHANNEL_4

4 q6 z' j$ E5 r! @& ^TIM_CHANNEL_5

: U% R& Q/ P0 O) vTIM_CHANNEL_6

  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
( k+ z4 s% |+ Q) E, X
1 w; n2 l0 ]8 Q. A( O- ^32.4.11   函数HAL_TIM_OC_Start
函数原型：
( x" K7 c$ {4 h  E$ l8 {

1. HAL_StatusTypeDef HAL_TIM_OC_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
   
2. {
   8 E4 a. s5 m. p; U& y+ t
3.   /* 检查参数 */
   7 ~% D# A: ]2 d7 O2 K  T: K
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   8 d9 ?! C9 R- K: n9 E2 f( p! p
5. 
   
6.   /* 使能输出比较通道 */
   # C0 D8 t* H* n9 ?. T4 O
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
8. 
   & |& m- r& p6 \' n1 O
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
   
10.   {
    5 H. V7 J4 F! L3 S7 b2 }
11.     /* 使能主输出 */
    0 O# o! g0 |1 I7 n2 V
12.     __HAL_TIM_MOE_ENABLE(htim);
    ) u# K$ g2 l! `9 n/ X: M
13.   }
    
14. 
    
15.   /* 使能定时器 */
    # @/ |! ]: N8 V. H% y
16.   __HAL_TIM_ENABLE(htim);
    6 o$ Y0 h8 ^. u7 \3 V
17. 
    " Z$ C) B# k4 s# D" S
18.   /* 返回状态 */
    # y! U5 E) ~+ U# ?
19.   return HAL_OK;
    ! ?9 \1 X$ H' l& }) _9 X; ~( @
20. }

复制代码

函数描述：
! f1 R8 i2 k( T. G3 {* P
* |3 e! u6 s( t此函数用于启动定时器输出比较模式。
' Z2 N4 {& R6 s0 l
: e8 _5 o6 s4 N& x函数参数：

' }/ c* c' h+ N, B* D) \, e' l  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  第2个参数是通道设置，支持以下参数：
TIM_CHANNEL_1
4 L6 N' u+ q$ p& V; {/ U4 q" z
6 m# I3 {) u' pTIM_CHANNEL_2
' B# t+ }- S8 j- g& ~0 a
  F9 m0 A& r1 b2 R0 X+ R* wTIM_CHANNEL_3
1 \+ B7 R/ {' N! P( C
3 K6 k, K0 k; X1 l6 ^+ Q! [TIM_CHANNEL_4

3 r/ l" i' s) L3 X, G# v5 T  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
/ p( x+ l, A( `& z! c
32.5 总结
本章节就为大家讲解这么多，建议大家将GPIO的驱动源码结合参考手册中的寄存器通读一遍，对于我们后面章节的学习大有裨益。
% a6 O3 W- g9 m( H- d: w
! J  H0 @- M; B, W' F1 y
4 a! ?! \# S2 ^/ ~& ^  l