32.1 初学者重要提示
  学习定时器外设推荐从硬件框图开始了解基本的功能特性，然后逐步深入了解各种特性，这种方式方便记忆和以后查阅。
6 \- w- I' |; P3 V  y& l9 z! C: @  STM32H7的定时器输出100MHz方波是完全没问题。
/ Y( A9 c- F  B- u$ O  STM32H7定时器进出中断的速度能跑到12.5MHz，所有程序在TCM和Flash运行没差别。
9 t+ V9 u* V" }7 _8 v/ ]% C' o  STM32H7的定时器输入捕获可以实现12MHz方波的双边沿捕获，单边沿可以做到24MHz。
! R  X5 b- ?4 h  特别注意STM32H7的TIM1,8,15,16,17才有RCR重复计数器，其它都没用的。
1 _9 [: o5 W7 V& U" ~$ A! B  STM32H7的单个定时器中不同通道可以配置不同频率PWM。
  STM32H7的TIM1-TIM17中断入口函数名使用时要注意，别搞错了：
+ _0 M% w9 O  |, d/ T5 b; X& G( H

1. TIM1_BRK_IRQHandler            
   0 y9 l+ d: x, m2 D% q2 A3 }; a
2. TIM1_UP_IRQHandler              
   
3. TIM1_TRG_COM_IRQHandler        
   
4. TIM1_CC_IRQHandler                                                   
   
5. TIM2_IRQHandler                                          
   
6. TIM3_IRQHandler                                                
   
7. TIM4_IRQHandler                 
   
8. TIM5_IRQHandler            
   
9. TIM6_DAC_IRQHandler           <------------------要注意            
   
10. TIM7_IRQHandler
    : {0 L  N0 C7 r. H6 u) s, K
11. TIM8_BRK_TIM12_IRQHandler      <------------------要注意，定时器12也是用的这个
    
12. TIM8_UP_TIM13_IRQHandler       <------------------要注意，定时器13也是用的这个
    
13. TIM8_TRG_COM_TIM14_IRQHandler  <------------------要注意，定时器14也是用的这个
    
14. TIM8_CC_IRQHandler         
    2 V, |  O* i% z; |; f  \2 a6 {
15. TIM15_IRQHandler
    
16. TIM16_IRQHandler
    
17. TIM17_IRQHandler

复制代码

8 a/ X; U4 a/ Q' k4 B32.2 定时器基础知识
$ L  k+ ]9 x3 `3 Z6 t) w6 S8 n注，不同定时支持的功能略有区别，基础定时器功能较少，TIM1和TIM8高级定时器功能多些。
1 |) C* A+ x7 `1 H% _
) a% q, @5 }$ D% A8 y6 [  TIM2和TIM5是32位定时器，其它定时器都是16位定时器。16位和32位的区别是CNT计数器范围不同，32位的范围是0 到2^32 – 1，而16位的是0到65535；它们支持的分频是范围是一样的，都是1到65535。
% A2 D) q. J2 I  计数器支持递增、递减和递增/递减二合一。
  多个独立通道，可用于：
– 输入捕获。

3 b$ x9 k4 @" t2 c- Q– 输出比较。

% l* ~1 m( d- u  \( z% N+ W6 O– PWM 生成（边沿和中心对齐模式）。
& v/ W, [5 [6 h! l
– 单脉冲模式输出。
4 d$ M# r# `2 D# X+ C( }$ C7 J$ T
* Z% z+ A4 u; a" G) l! S9 P  带死区插入，断路功能和PWM互补输出
" S0 ]0 L( e% D: u% D  发生如下事件时生成中断/DMA 请求：
7 p0 F1 r& d- H/ _. R5 H' Q* K' c– 更新：计数器上溢/下溢、计数器初始化（通过软件或内部/外部触发）

– 触发事件（计数器启动、停止、初始化或通过内部/外部触发计数）

– 输入捕获
0 @( T" t8 t9 ?: k
1 i. M- r! {3 C+ ~3 I– 输出比较
6 j1 c' F9 ~8 W
3 S! r* B% L' p; ~! Y. ^' e/ @  支持增量式编码器和霍尔传感器。
32.2.1 定时器TIM1-TIM17的区别
STM32H7支持的定时器有点多，要简单的区分下。STM32H7支持TIM1-TIM8，TIM12-TIM17共14个定时器，而中间的TIM9，TIM10，TIM11是不存在的，这点要注意。

: z7 \: j, e, |- ~1 S" {粗略的比较如下：

+ K8 F8 u" z% M0 j

% {+ K  {5 K# s
/ t* S& Z3 [3 H4 W, U+ J" ?9 i通过上面的表格，至少要了解到以下两点：
: L* {9 R. ^/ i
  STM32H7的定时器主要分为高级定时器，通用定时器，基础定时器和低功耗定时器。
" f6 J3 l% f9 f$ D5 @( W  TIM2和TIM5是32位定时器，其它都是16位定时器。
' S" x/ z9 q8 [! z( a
) P; ?- t5 r# d32.2.2 定时器的硬件框图
! i+ l3 F7 P& F2 D* S认识一个外设，最好的方式就是看他的框图，方便我们快速的了解定时器的基本功能，然后再看手册了解细节。

: l& x4 G6 X! H0 b3 L- k下面我们直接看最复杂的高级定时器TIM1&TIM8框图：

' L; ~" ~" Y/ e

6 Q5 O4 k; n- o# f$ [/ a
通过这个框图，我们可以得到如下信息：
5 _8 E4 f, c* {) F: F& K
  TIMx_ETR接口
外部触发输入接口。ETR支持多种输入源：输入引脚（默认配置）、比较器输出和模拟看门狗。
3 d! _1 Y( V- d( }1 S1 L
; _$ W/ d- x( j. ?& [2 X

0 i; g# _, E5 P8 c9 \  截图左侧的TIMx_CH1，TIMx_CH2，TIMx_CH3和TIMx_CH4接口
这四个通道主要用于输入捕获，可以计算波形频率和脉宽。                                                                                                                             
1 U  {) A7 Y+ v
. O  G" [  j8 w" l9 f8 k" p5 b3 H  TIMx_BKIN和TIMx_BKIN2接口
断路功能，主要用于保护由 TIM1 和 TIM8 定时器产生的 PWM 信号所驱动的功率开关
* U  u. v: E9 s2 A& U* w# ^
: L' B" t. e+ i) G  TRGO内部输出通道
7 J  K% U8 T/ R( H主要用于定时器级联，ADC和DAC的定时器触发。
, C# Z: A4 o% h5 S3 P5 t, L
  6组输出比较单元OC1到OC6
4 t8 g. ^: y3 @4 P# xOC1到OC4有对应的输出引脚，而OC5和OC6没有对应的输出引脚，主要用于内部控制。

9 M" h8 p/ i/ D2 R, h1 n  截图右侧的输出比较通道TIMx_CH1，TIMx_CH1N，TIMx_CH2，TIMx_CH2N，TIMx_CH3，TIMx_CH3N和TIMx_CH4
主要用于PWM输出，注意CH1到CH3有互补输出，而CH4没有互补输出。
) b" u4 ?  H' X4 d3 O
  K8 S2 \! ^! d& H/ N- \; @3 S  其它框图里面未展示出来功能
; @. ^/ }2 G4 ~' ^* q' h( ?定时器TIM1&TIM8还支持的其它功能在用到的时候再做说明。

32.2.3 定时器的时基单元
. ~6 v1 {2 X% x: G9 i定时器要工作就需要一个基本时基单元，而基本的时基单元是由下面几个寄存器组成的：

2 W) m' R. H. N8 F5 L* s, S  预分频器寄存器 (TIMx_PSC)
8 b( [0 v* m- N' J2 O6 m  T8 Y9 o用于设置定时器的分频，比如定时器的主频是200MHz，通过此寄存器可以将其设置为100MHz，50MHz，25MHz等分频值。
" G3 v6 S" o" \; ~/ O3 C
9 C. {8 X0 [& h注：预分频器有个缓冲功能，可以让用户实时更改，新的预分频值将在下一个更新事件发生时被采用（以递增计数模式为例，就是CNT计数值达到ARR自动重装寄存器的数值时会产生更新事件）。

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

  自动重载寄存器 (TIMx_ARR)
自动重装寄存器是CNT计数寄存器能达到的最大计数值，以递增计数模式为例，就是CNT计数器达到ARR寄存器数值时，重新从0开始计数。
+ X7 N( e4 m2 G* G/ g5 W7 N$ c
注，自动重载寄存器是预装载的。对自动重载寄存器执行写入或读取操作时会访问预装载寄存器。预装载寄存器的内容既可以立即传送到影子寄存器（让设置立即起到效果的寄存器），也可以在每次发生更新事件时传送到影子寄存器。简单的说就是让ARR寄存器的数值立即更新还是更新事件发送的时候更新。
' ]/ u. t% W7 j' m4 j8 R
  重复计数器寄存器 (TIMx_RCR)
以递增计数模式为例，当CNT计数器数值达到ARR自动重载数值时，重复计数器的数值加1，重复次数达到TIMx_RCR+ 1后就，将生成更新事件。

. q* X; Q2 X7 b  S; ^注，只有TIM1，TIM8，TIM15，TIM16，TIM17有此寄存器。
  ^8 ]2 T- _: s% S! |3 o! t) l
比如我们要配置定时器实现周期性的中断，主要使用这几个寄存器即可。

! C* u* u7 l3 L7 ?% K4 d32.2.4 定时器输出比较（PWM）
使用定时器时基单元的那几个寄存器仅仅能设置周期，还不能设置占空比。针对这个问题，还需要比较捕获寄存CCR的参与，这样就可以设置占空比了。
3 c. `6 l2 v  V9 p' H5 F
为了方便大家理解，以PWM 边沿对齐模式，递增计数配置为例：
7 x) U2 T, M5 e* o) u; ]- H
  当计数器TIMx_CNT < 比较捕获寄存器TIMx_CCRx期间，PWM参考信号OCxREF输出高电平。
3 z7 g  ^; ^' \  y( g3 r  当计数器TIMx_CNT >= 比较捕获寄存器TIMx_CCRx期间， PWM参考信号OCxREF输出低电平。
" D+ n3 b, U4 U% f2 H7 [  当比较捕获寄存器TIMx_CCRx > 自动重载寄存器TIMx_ARR，OCxREF保持为1。
# \5 k, w% z, G0 E  当比较捕获寄存器TIMx_CCRx = 0，则OCxRef保持为0。
  H$ l' A! a2 f) U  O- g下面是TIMx_ARR=8的波形效果：

) a9 [$ z1 n/ d# d; R+ a

7 l& L  c4 Y/ y* E2 }. d32.2.5 定时器输入捕获
与PWM一样，使用定时器实现输入捕获，仅靠时基单元的那几个寄存器是不行的，我们需要一个寄存器来记录发生捕获时的具体时间，这个寄存器依然由比较捕获寄存器TIMx_CCRx来实现。
  f; L! r: Q/ C: E. O( |4 `6 p
比如我们要测量一路方波的周期：

  配置定时器为输入捕获模式，上升沿触发，设置分频，自动重装等寄存器，比如设置的CNT计数器计数1次是1微秒。
6 X7 E% F& u0 c. @: Q  当有上升沿触发的时候，TIMx_CCRx寄存器就会自动记录当前的CNT数值，然后用户就可以通过CC中断，在中断复位程序里面保存当前的TIMx_CCRx寄存器数值。等下次再检测到上升沿触发，两次时间求差就可以得到方波的周期。
不过这里要特别注意一点，如果CNT发生溢出（比如16位定时器，计数到65535就溢出了）就需要特别处理下，将CNT计数溢出考虑进来。
% Y* n. B  E" A+ A* r7 `
2 _: t; {' ^7 f# M* S3 F0 T32.3 定时器的HAL库用法
定时器的HAL库用法其实就是几个结构体变量成员的配置和使用，然后配置GPIO、时钟，并根据需要配置NVIC、中断和DMA。下面我们逐一展开为大家做个说明。

& V* @+ P$ q( E7 i4 f32.3.1 定时器寄存器结构体TIM_TypeDef
4 u. A) E5 f, w1 }: N% j8 y定时器相关的寄存器是通过HAL库中的结构体TIM_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：
1 T; L. `' r! G$ L8 c

1. typedef struct
   ( I/ ~( k: p1 ]
2. {
   0 F: v% z4 q( v1 l+ x
3.   __IO uint16_t CR1;         /*!< TIM control register 1,                   Address offset: 0x00 */
   
4.   uint16_t      RESERVED0;   /*!< Reserved, 0x02                                                 */
   
5.   __IO uint32_t CR2;         /*!< TIM control register 2,                   Address offset: 0x04 */
   ! ?! S+ K) w( {. J' Y/ e7 d' A' l
6.   __IO uint32_t SMCR;        /*!< TIM slave mode control register,          Address offset: 0x08 */
   7 u& y" H, k8 K! O: ]
7.   __IO uint32_t DIER;        /*!< TIM DMA/interrupt enable register,        Address offset: 0x0C */
   
8.   __IO uint32_t SR;          /*!< TIM status register,                      Address offset: 0x10 */
   : w" z0 K0 q* K
9.   __IO uint32_t EGR;         /*!< TIM event generation register,            Address offset: 0x14 */
   ( j4 E0 u" N$ V- W+ E, h# m
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 */
    * H( d) [$ T( H; L. w% j
12.   __IO uint32_t CCER;        /*!< TIM capture/compare enable register,      Address offset: 0x20 */
    ; {1 S( {2 q9 Y6 s' G0 u$ [  X
13.   __IO uint32_t CNT;         /*!< TIM counter register,                     Address offset: 0x24 */
    
14.   __IO uint16_t PSC;         /*!< TIM prescaler,                            Address offset: 0x28 */
    
15.   uint16_t      RESERVED9;   /*!< Reserved, 0x2A                                                 */
    + \# B8 t; z- L( f2 o
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                                                 */
    + x, z9 N) O% Y: x' D
19.   __IO uint32_t CCR1;        /*!< TIM capture/compare register 1,           Address offset: 0x34 */
    ) v. J1 @* x5 |' K! c
20.   __IO uint32_t CCR2;        /*!< TIM capture/compare register 2,           Address offset: 0x38 */
    : K9 |2 F4 l; \; N1 C8 K
21.   __IO uint32_t CCR3;        /*!< TIM capture/compare register 3,           Address offset: 0x3C */
    5 Y7 ^& T( \- r
22.   __IO uint32_t CCR4;        /*!< TIM capture/compare register 4,           Address offset: 0x40 */
    / i+ c, m3 w$ t  n
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 */
    2 _+ t1 Q' h% ~3 C- Z& y
27.   uint16_t      RESERVED13;  /*!< Reserved, 0x4E                                                 */
    
28.   uint16_t      RESERVED14;  /*!< Reserved, 0x50                                                 */
    ( b1 b# I' d6 j/ g1 e0 i
29.   __IO uint32_t CCMR3;       /*!< TIM capture/compare mode register 3,      Address offset: 0x54 */
    4 {+ X* }" Q- o/ ^. ^1 e
30.   __IO uint32_t CCR5;        /*!< TIM capture/compare register5,            Address offset: 0x58 */
    
31.   __IO uint32_t CCR6;        /*!< TIM capture/compare register6,            Address offset: 0x5C */
    * w' ~9 @: I( C( H
32.   __IO uint32_t AF1;         /*!< TIM alternate function option register 1, Address offset: 0x60 */
    
33.   __IO uint32_t AF2;         /*!< TIM alternate function option register 2, Address offset: 0x64 */
    
34.   __IO uint32_t TISEL;       /*!< TIM Input Selection register,             Address offset: 0x68 */
    * k6 U% U* D0 Y7 H$ ~3 Z
35. } TIM_TypeDef;

复制代码

: W) H. I6 w8 C; f) u这个结构体的成员名称和排列次序和CPU的定时器寄存器是一 一对应的。
% ^- M0 W. c# g$ G8 V) |8 W
__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   , s3 B0 x1 @1 _6 v/ z9 K" y3 I
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

  C7 |' q. i1 ]. c下面我们看下定时器的定义，在stm32h743xx.h文件。

# R9 e5 `+ n0 l, H  X6 |9 M8 B

1. #define PERIPH_BASE         ((uint32_t)0x40000000)
   " K) Q4 S$ a* i: E8 |
2. #define D2_APB1PERIPH_BASE   PERIPH_BASE
   
3. #define D2_APB2PERIPH_BASE   (PERIPH_BASE + 0x00010000)
   
4. 
   ( Z) b* N( }6 ~2 b
5. /*!< D2_APB1PERIPH 外设 */
   
6. #define TIM2_BASE             (D2_APB1PERIPH_BASE + 0x0000) <----- 展开这个宏，(TIM_TypeDef *) 0x40000000
   
7. #define TIM3_BASE             (D2_APB1PERIPH_BASE + 0x0400)
   2 m# f5 N; e! m( T
8. #define TIM4_BASE             (D2_APB1PERIPH_BASE + 0x0800)
   
9. #define TIM5_BASE             (D2_APB1PERIPH_BASE + 0x0C00)
   
10. #define TIM6_BASE             (D2_APB1PERIPH_BASE + 0x1000)
    
11. #define TIM7_BASE             (D2_APB1PERIPH_BASE + 0x1400)
    
12. #define TIM12_BASE            (D2_APB1PERIPH_BASE + 0x1800)
    ! W: X0 w* `- T: v1 B' }
13. #define TIM13_BASE            (D2_APB1PERIPH_BASE + 0x1C00)
    
14. #define TIM14_BASE            (D2_APB1PERIPH_BASE + 0x2000)
    
15. 
    
16. /*!< D2_APB1PERIPH 外设 */
    
17. #define TIM1_BASE             (D2_APB2PERIPH_BASE + 0x0000)
    8 t9 i: t% y" ~
18. #define TIM8_BASE             (D2_APB2PERIPH_BASE + 0x0400)
    9 ^  W( l1 z$ r
19. #define TIM15_BASE            (D2_APB2PERIPH_BASE + 0x4000)
    3 E6 m1 ]) ~1 ^+ _& R! ~, g
20. #define TIM16_BASE            (D2_APB2PERIPH_BASE + 0x4400)
    / b# c- d; M6 s- p" A, h
21. #define TIM17_BASE            (D2_APB2PERIPH_BASE + 0x4800)
    
22. 
    " Z  i0 Y4 M4 V" X% `( Y" g$ r
23. #define TIM1                ((TIM_TypeDef *) TIM1_BASE)
    5 p# ^$ u' C, E/ S
24. #define TIM2                ((TIM_TypeDef *) TIM2_BASE)
    
25. #define TIM3                ((TIM_TypeDef *) TIM3_BASE)
    , k) i* Y- J# [; }
26. #define TIM4                ((TIM_TypeDef *) TIM4_BASE)
    
27. #define TIM5                ((TIM_TypeDef *) TIM5_BASE)
    
28. #define TIM6                ((TIM_TypeDef *) TIM6_BASE)
    % }+ O9 o0 v5 y+ x2 v  M
29. #define TIM7                ((TIM_TypeDef *) TIM7_BASE)
    
30. #define TIM8                ((TIM_TypeDef *) TIM8_BASE)
    
31. #define TIM12               ((TIM_TypeDef *) TIM12_BASE)
    
32. #define TIM13               ((TIM_TypeDef *) TIM13_BASE)
    
33. #define TIM14               ((TIM_TypeDef *) TIM14_BASE)
    
34. #define TIM15               ((TIM_TypeDef *) TIM15_BASE)
    % A: ^7 C: R( e8 X! @
35. #define TIM16               ((TIM_TypeDef *) TIM16_BASE)
    
36. #define TIM17               ((TIM_TypeDef *) TIM17_BASE)

复制代码

我们访问TIM2的CR1寄存器可以采用这种形式：TIM2->CR1 = 0；

32.3.2 定时器句柄结构体TIM_HandleTypeDef
HAL库在TIM_TypeDef的基础上封装了一个结构体TIM_HandleTypeDef，定义如下：
# g2 Z8 {5 A4 f. ]
- S- E) }) I: e) \, @. A3 _

1. typedef struct
   
2. {
   5 ]+ u3 M2 O. k3 N% S6 p
3.   TIM_TypeDef              *Instance;     /*!< Register base address             */
   
4.   TIM_Base_InitTypeDef     Init;          /*!< TIM Time Base required parameters */
   & w; s$ P+ e2 e1 z5 k
5.   HAL_TIM_ActiveChannel    Channel;       /*!< Active channel                    */
   
6. 
   # J2 w0 X) Q5 v. }2 J- J
7. /*!< DMA Handlers array This array is accessed by a @ref DMA_Handle_index */
   3 `1 K! x5 U* Y) V
8.   DMA_HandleTypeDef        *hdma[7];      
   
9.   HAL_LockTypeDef          Lock;          /*!< Locking object                    */
   / J. ~0 B2 }3 J$ t
10.   __IO HAL_TIM_StateTypeDef   State;      /*!< TIM operation state               */  
    
11. }TIM_HandleTypeDef;

复制代码

' W" w6 M# e- n' x这里重点介绍前四个参数，其它参数主要是HAL库内部使用的。

% i$ s! n$ d0 {9 w( a  TIM_TypeDef  *Instance

+ u6 F6 c$ p! W6 J$ E1 S$ ~这个参数是寄存器的例化，方便操作寄存器，比如使能定时器的计数器。
5 j5 u; ^3 a  \8 l0 e
SET_BIT(huart->Instance->CR1,  TIM_CR1_CEN)。
" Y! F  ~$ K+ Y7 v% P7 ^5 Y
/ _. S! q7 a. o* z- L, L2 p& P  TIM_Base_InitTypeDef  Init

这个参数是用户接触最多的，用于配置定时器的基本参数。
/ M. R% K5 e$ Z# Z/ X
/ k4 j; U4 G8 T$ G5 N) UTIM_Base_InitTypeDef结构体的定义如下：

1. typedef struct
   
2. {
   ' q5 p1 w) u8 T2 i# G+ z1 T
3.   uint32_t Prescaler;      
   " I' U9 t1 e/ W4 O) w5 @$ L8 T
4.   uint32_t CounterMode;   
   
5.   uint32_t Period;         
   8 a! u: s& M$ L
6.   uint32_t ClockDivision;   
   / k' ?/ k% I' h
7.   uint32_t RepetitionCounter;
   ) G6 H2 I/ y! x; V1 E+ H9 H
8.   uint32_t AutoReloadPreload;  
   
9. } TIM_Base_InitTypeDef;

复制代码

  成员Prescaler
+ A3 o5 F& @! h9 P" U1 V$ l用于设置定时器分频，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。

! Q+ m! p6 h. m  o( i- q" ]3 D  成员CounterMode
用于设置计数模式，向上计数模式、向下计数模式和中心对齐模式。

* f, O+ h  U. j

1. #define TIM_COUNTERMODE_UP                ((uint32_t)0x0000U)   /*!< Up counting mode */
   / e  [% [0 v/ f- B2 Q/ d+ R
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 */
   ' y% z0 z$ V  x5 |" u1 {
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 */

复制代码

  成员Period
用于设置定时器周期，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。
, p8 O$ @: e" a' n7 \5 o
  成员ClockDivision
0 j3 G+ h0 t' n用于指示定时器时钟 (CK_INT) 频率与死区发生器以及数字滤波器（ETR、TIx）所使用的死区及采样时钟 (tDTS) 之间的分频比。

1. #define TIM_CLOCKDIVISION_DIV1       ((uint32_t)0x0000U)        /*!< Clock Division DIV1 */
   & E! |7 v) W4 J  z& x
2. #define TIM_CLOCKDIVISION_DIV2       (TIM_CR1_CKD_0)            /*!< Clock Division DIV2 */
   $ r  n6 c" w; ~& R! Z
3. #define TIM_CLOCKDIVISION_DIV4       (TIM_CR1_CKD_1)             /*!< Clock Division DIV4 */

复制代码

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

  成员AutoReloadPreload
0 p* \' b4 j- Z用于设置定时器的ARR自动重装寄存器是更新事件产生时写入有效还是立即写入有效。如果使能了表示更新事件产生时写入有效，否则反之。

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

复制代码

! y) r* w( ~/ Q2 H: @! y; d& t  HAL_TIM_ActiveChannel    Channel;

用于设置定时器通道，比如TIM1和TIM8都是6个通道。
5 Y. X! K* [& E6 f; e

1. typedef enum
   
2. {
   6 h0 t- O. Y  o) b% U
3.   HAL_TIM_ACTIVE_CHANNEL_1        = 0x01U,    /*!< The active channel is 1     */
   ; R/ x6 w, x5 L& D- S
4.   HAL_TIM_ACTIVE_CHANNEL_2        = 0x02U,    /*!< The active channel is 2     */
     S6 E* h8 L! [+ e9 Y1 B  Y/ S
5.   HAL_TIM_ACTIVE_CHANNEL_3        = 0x04U,    /*!< The active channel is 3     */   
   & O5 {" P+ \- h
6.   HAL_TIM_ACTIVE_CHANNEL_4        = 0x08U,    /*!< The active channel is 4     */
   5 c0 V0 d  ^" t# _' b
7.   HAL_TIM_ACTIVE_CHANNEL_5        = 0x10U,    /*!< The active channel is 5     */
   ) I) j, ?# \$ T2 K  X5 y; L9 ]: V+ m$ _7 Y
8.   HAL_TIM_ACTIVE_CHANNEL_6        = 0x20U,    /*!< The active channel is 6     */
   * W; v$ U- h4 s9 M6 F& u- o0 I7 R
9.   HAL_TIM_ACTIVE_CHANNEL_CLEARED  = 0x00U     /*!< All active channels cleared */   
   
10. }HAL_TIM_ActiveChannel;
    
11.   DMA_HandleTypeDef        *hdma[7];

复制代码

  X1 J' l% [7 m5 w. g用于关联DMA。
) V' J  ]5 w3 k8 ]
配置定时器参数，其实就是配置结构体TIM_HandleTypeDef的成员。
1 ~5 L# y$ u4 e4 v  u- m
6 a* \  p, X, e4 k; a& z) l

1. TIM_HandleTypeDef   TimHandle = {0};
   ( ]2 Z' s% E& R* L% c
2. 
   6 o' c5 O  F$ R  L) ^
3. /*
   + I" J+ H; I' d! N; }/ q  z2 d0 [
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   / ?/ c; c# P! N+ V( C5 q
6. TimHandle.Instance = TIMx;
   
7. TimHandle.Init.Prescaler         = usPrescaler;
   0 v( N! ^% ]$ I$ |
8. TimHandle.Init.Period            = usPeriod;        
   
9. TimHandle.Init.ClockDivision     = 0;
   # l- g8 J: U8 o! i7 Q1 n5 ^
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    - a; u; e* w; d
11. TimHandle.Init.RepetitionCounter = 0;
    5 z' l$ T8 n5 d5 ~9 F4 h, q
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    8 f7 w+ a" ~9 h# y1 C! J3 n
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    
14. {
    
15.         Error_Handler(__FILE__, __LINE__);
    
16. }

复制代码

32.3.3 定时器输出比较结构体TIM_OC_InitTypeDef
; E6 c, ^. P0 g7 L. Z7 Y: c" N此结构体主要用于定时器的输出比较，定义如下：

1 W; l* ~  U6 K8 C

1. typedef struct
   6 u8 `( s& z, C5 ?; m  Y" B
2. {                                 
   
3.   uint32_t OCMode;      
   
4.   uint32_t Pulse;      
   
5.   uint32_t OCPolarity;   
   
6.   uint32_t OCNPolarity;   
   
7.   uint32_t OCFastMode;  
   
8.   uint32_t OCIdleState;   
   
9.   uint32_t OCNIdleState;  
   
10. } TIM_OC_InitTypeDef;  

复制代码

* s7 i5 K- E( H下面将这几个参数一 一做个说明。
7 s4 n& G' _& i2 G# R2 T  D0 M' ^
  OCMode
* `) j$ W. d. y- Y用于配置输出比较模式，支持的模式较多：
# `+ x2 m" N, [; ?1 J' N3 U. I
: r  i( D. s, j* y

1. /*!< TIM Output timing mode */
   
2. #define TIM_OCMODE_TIMING                ((uint32_t)0x0000U)      
   
3. 
   
4. /*!< TIM Output Active mode */                          
   
5. #define TIM_OCMODE_ACTIVE                ((uint32_t)TIM_CCMR1_OC1M_0)
     J. U& t+ r$ n5 L0 {
6. 
   
7. /*!< TIM Output Inactive mode */                       
   4 u- p2 ^: _3 I( Z( C4 V" n
8. #define TIM_OCMODE_INACTIVE              ((uint32_t)TIM_CCMR1_OC1M_1)           
   , S1 F8 k1 y* N" j' [# E) \: C9 b
9. 
   
10. /*!< TIM Output Toggle mode */               
    * ?- U, I! A3 U( Z3 y' Y6 R  D
11. #define TIM_OCMODE_TOGGLE                 ((uint32_t)TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)         
    
12. 
    
13. /*!< TIM PWM mode 1 */
    % ]: F. _  G$ W; k- D6 A4 w: L
14. #define TIM_OCMODE_PWM1                   ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1)
    
15. 
    
16. /*!< TIM PWM mode 2 */                    
    
17. #define TIM_OCMODE_PWM2                    ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)   
      {5 t7 k3 h# u$ C) y) b9 I& Z' A
18. 
    
19. /*!< TIM Forced Active mode */   
    % v  c: c3 D& D$ [1 |
20. #define TIM_OCMODE_FORCED_ACTIVE           ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0)         
    * Y2 p- M' W9 J  ~# j& }. Z* Q
21. 
    ! h- W0 Q9 O: {% {) t( {
22. /*!< TIM Forced Inactive mode */            
    
23. #define TIM_OCMODE_FORCED_INACTIVE         ((uint32_t)TIM_CCMR1_OC1M_2)                                       
    - N5 B1 J/ n: V6 m/ a4 J+ ~
24. 
    
25. /*!< TIM Rettrigerrable OPM mode 1 */  
    
26. #define TIM_OCMODE_RETRIGERRABLE_OPM1      ((uint32_t)TIM_CCMR1_OC1M_3)   
    / Y/ G6 C, N4 k# ~' V5 Y7 {5 R
27. 
    
28. /*!< TIM Rettrigerrable OPM mode 2 */                                       
    + o( }1 T7 u- H' K3 ?
29. #define TIM_OCMODE_RETRIGERRABLE_OPM2      ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0)   
    
30. 
    
31. /*!< TIM Combined PWM mode 1 */                     
    6 U3 Q( `6 z5 O) {
32. #define TIM_OCMODE_COMBINED_PWM1           ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_2)     
    . t3 i1 k  u. ]% e* B! d& ]9 O- z
33. 
    
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. 
    * c" n, ]( ~5 S8 T
37. /*!< TIM Asymetruc PWM mode 1 */  
    , d& Y  a' N9 X6 ~
38. #define TIM_OCMODE_ASSYMETRIC_PWM1         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2)  
    : e3 M! u1 {" T; w3 N% G  q1 s
39. 
    1 {6 u/ K+ V( P* v- k
40. /*!< TIM Asymetruc PWM mode 2 */   
    & M7 [$ x# F' t
41. #define TIM_OCMODE_ASSYMETRIC_PWM2         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M)  

复制代码

  
- c7 p$ ]7 S$ }( C  Pulse
可用于设置占空比，对应定时器的CCR寄存器，32位的TIM2和TIM5范围是0到0xFFFFFFFF。
! L, x/ w* q, i1 n* D' r0 d, T& E
4 z. ^) \; i& z% m  OCPolarity
. [- v& E( b( `( u1 A& d# q. v& y1 U设置输出极性，可选高电平或低电平有效。
2 `% r7 [9 N$ N2 r+ M! z

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

复制代码

% @) _7 }" m0 Z1 }  OCNPolarity
互补输出极性设置，可选高电平或者低电平有效。

2 a  i) j7 u" [, ?( z

1. #define TIM_OCNPOLARITY_HIGH               ((uint32_t)0x0000U)
   - ~- C1 B' q2 I$ Q7 d, K, o& U2 q
2. #define TIM_OCNPOLARITY_LOW                (TIM_CCER_CC1NP)

复制代码

  OCFastMode
7 F7 x. g  i) ?快速输出模式使能，仅OCMode配置为PWM1或者PWM2模式时才有意义。

& |+ O9 F0 H8 ^8 t% u( c

1. #define TIM_OCFAST_DISABLE                ((uint32_t)0x0000U)
   8 k; l2 O, f% {$ I
2. #define TIM_OCFAST_ENABLE                 (TIM_CCMR1_OC1FE)

复制代码

' l! V4 S: I8 y; E" H2 O. S4 V  OCIdleState
空闲状态时，设置输出比较引脚的电平状态。

1. #define TIM_OCIDLESTATE_SET                (TIM_CR2_OIS1)
   6 Y- W% j4 v, @/ Q# T
2. #define TIM_OCIDLESTATE_RESET              ((uint32_t)0x0000U)

复制代码

* F# K+ ~4 K  t3 u/ G. a  A- q  OCNIdleState
空闲状态时，设置互补输出引脚的电平状态。

1. #define TIM_OCNIDLESTATE_SET               (TIM_CR2_OIS1N)
   0 b1 D3 q7 p  J# F5 a2 @
2. #define TIM_OCNIDLESTATE_RESET             ((uint32_t)0x0000U)

复制代码

32.3.4 定时器输入捕获结构体TIM_IC_InitTypeDef
此结构体主要用于定时器的输入捕获，定义如下：

6 X  S; {( K7 s/ X, n+ F  _9 |

1. typedef struct
   1 o0 b8 u) v0 A9 c* n& [
2. {                                 
   
3.   uint32_t ICPolarity;   
   3 R. e0 M' A# c6 X5 y  b
4.   uint32_t ICSelection;
   
5.   uint32_t ICPrescaler;
   
6.   uint32_t ICFilter;   
   7 z2 j: X/ D/ N8 M7 N
7. } TIM_IC_InitTypeDef;

复制代码

# D% ^$ F( C; o! [  P. P下面将这几个参数一 一做个说明。

  ICPolarity
输入触发极性，可以选择上升沿，下降沿或者双沿触发。

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

复制代码

  ICSelection
输入捕获通道选择，可以选择直接输入（即CC1选择TI1，CC2选择TI2等），间接输入（CC1选择TI2，CC3选择TI4等）或者TRC。
# U( u0 t- K" a* n& \
5 h3 G$ d( X! k8 \* N. M4 \

1. #define TIM_ICSELECTION_DIRECTTI       (TIM_CCMR1_CC1S_0)   
   
2. #define TIM_ICSELECTION_INDIRECTTI     (TIM_CCMR1_CC1S_1)  
   ; A) z$ O, @# }* Q: T1 [
3. #define TIM_ICSELECTION_TRC            (TIM_CCMR1_CC1S)   

复制代码

  ICPrescaler
& O( w7 A- O8 Y$ k* w/ A8 r输入捕获分频，表示每捕获1，2，4或8个事件后表示一次捕获。

9 O0 o$ l7 M. Y2 q  N' w

1. #define TIM_ICPSC_DIV1       ((uint32_t)0x0000U)                 
   3 e; W. s  ]$ k+ v/ m0 @% H* f
2. #define TIM_ICPSC_DIV2       (TIM_CCMR1_IC1PSC_0)   
   
3. #define TIM_ICPSC_DIV4       (TIM_CCMR1_IC1PSC_1)   
   + P& h6 z6 \2 T! H8 b( N
4. #define TIM_ICPSC_DIV8       (TIM_CCMR1_IC1PSC)

复制代码

0 k) A" O% x! t; r! _  ICFilter
) X4 ]7 U$ \4 _4 p输入捕获滤波器，可以定义采样频率和多少个连续事件才视为有效的触发，参数范围0到15。具体定义如下，其中fCK_INT表示定时器时钟，fDTS表示死区时间采样率，N表示这么多个事件代表一次有效边沿。

2 k( D! X1 s. `+ I. F% a7 x; V

1. 0000：无滤波器，按 fDTS 频率进行采样
   
2. 0001： fSAMPLING=fCK_INT， N=2
   * u4 U- e3 C4 B) q1 F6 ]$ X( a$ [
3. 0010： fSAMPLING=fCK_INT， N=4
   8 n& `# A7 U) a- J4 n
4. 0011： fSAMPLING=fCK_INT， N=8
   
5. 0100： fSAMPLING=fDTS/2， N=6
   ) w- h  g3 h5 }- E8 O
6. 0101： fSAMPLING=fDTS/2， N=8
   * ]! G' r& X# L) p
7. 0110： fSAMPLING=fDTS/4， N=6
   + M3 V0 G$ W* U$ X; P" t6 f
8. 0111： fSAMPLING=fDTS/4， N=8
   " e. d/ ~' T; [5 y8 N/ H+ J
9. 1000： fSAMPLING=fDTS/8， N=6
   8 ^; D3 @* O- R! i
10. 1001： fSAMPLING=fDTS/8， N=8
    
11. 1010： fSAMPLING=fDTS/16， N=5
    
12. 1011： fSAMPLING=fDTS/16， N=6
    ! {5 l% G( p( |- u3 d8 \5 l
13. 1100： fSAMPLING=fDTS/16， N=8
    ' P$ {* I6 m+ ?9 T
14. 1101： fSAMPLING=fDTS/32， N=5
    
15. 1110： fSAMPLING=fDTS/32， N=6

复制代码

32.3.5 定时器的底层配置（GPIO，时钟，中断等）
4 j3 t3 @' N$ o  |HAL库有个自己的底层初始化回调函数，比如调用函数HAL_TIM_Base_Init就会调用HAL_TIM_Base_MspInit，此函数是弱定义的。

' ^: q) I5 u. A. K

1. __weak void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
   
2. {
   $ |8 j) x2 M. j" Z+ P
3.   /* Prevent unused argument(s) compilation warning */
   
4.   UNUSED(htim);
   
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
   + r3 F+ z1 a0 j* h
7.    */
   0 ~6 {- S8 n6 ?( {! ^& n
8. }

复制代码

+ \, {% o3 m2 P% a7 g- g用户可以在其它的C文件重定向，并将相对的底层初始化在里面实现。对应的底层复位函数HAL_TIM_Base_DeInit是在函数HAL_TIM_Base_MspDeInit里面被调用的，也是弱定义的。

当然，用户也可以自己初始化，不限制必须在两个函数里面实现。

5 S# h3 L3 f& @, B定时器外设的基本参数配置完毕后还不能使用，还需要配置GPIO、时钟、中断等参数，比如下面配置TIM1使用PA8做PWM输出。

1. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
   - M! @' r/ i# P
2. {
   7 Z$ P7 r! D1 b6 B
3.   GPIO_InitTypeDef   GPIO_InitStruct;
   ) {0 q/ T# w( t% E9 m+ O* R3 E
4. 
   ) g% O$ Q+ s2 K
5.   /* 使能TIM1时钟 */
   & a8 s7 v6 T  C# h
6.   __HAL_RCC_TIM1_CLK_ENABLE ();
   
7. 
   
8.   /* 使能GPIOA时钟 */
   
9.   __HAL_RCC_GPIOA_CLK_ENABLE ();
   
10. 
    " A# c: G- e" H0 ]
11.   /* 设置TIM1使用PA8做PWM输出引脚，将其配置为输出，推挽，复用模式 */
    1 B4 E) c. Q! L, P* q0 j
12.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    3 r+ T6 i( t9 [- C& k
13.   GPIO_InitStruct.Pull = GPIO_PULLUP;
    
14.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    + n' o* o: k4 c
15. 
    
16.   GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
    
17.   GPIO_InitStruct.Pin = GPIO_PIN_8;
    4 l( u" O" H+ e3 e6 o" U) b& Y
18.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    ; b5 \' Z! q9 K
19. 
    
20. }

复制代码

  @. S2 `& G' s3 }1 b9 n总结下来就是以下几点：

  配置TIM时钟。
% [6 b5 P. @: g" X* ?  配置TIM所用到引脚和对应的GPIO时钟。
" m. W2 P# Y: D2 A- G  }+ x  如果用到定时器中断，还需要通过NVIC配置中断。
  如果用到DMA，还要配置DMA。
关于这个底层配置有以下几点要着重说明下：
1 i. F: N/ `# e5 s% y/ K
) l" p7 u) N& ^& t! M  定时器所使用引脚的复用模式选择已经被HAL库定义好，放在了stm32h7xx_hal_gpio_ex.h文件里面。比如TIM1有一个复用，
. g  v" k3 R2 B3 ]3 P& d2 b

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

复制代码

但是却有4个输出通道，每个通道都有几个支持的输出引脚：
% o$ n5 P0 F. m: B4 p: ~

1. TIM1_CH1,  PA8   PE9    PK1
   
2. TIM1_CH2,  PA9   PE11
   
3. TIM1_CH3,  PA10  PE13   PJ9
   
4. TIM1_CH4,  PA11  PE14   PJ11

复制代码

8 ^. M* w# @$ H1 h. G) i$ {, P具体使用哪个，配置对应引脚的复用即可：
& v8 h6 z( r# z
9 W$ w; G% ^! P, q. t* n

. q$ v5 `; J/ D# E  K' g
32.3.6 定时器的状态标志清除问题
1 O6 D3 F. i) c5 a  k6 X9 I" E下面我们介绍__HAL_TIM_GET_FLAG函数。这个函数用来检查定时器标志位是否被设置。
. p3 j+ Y. @6 g5 b7 E- V

1. 
   
2. /** @brief  Check whether the specified TIM interrupt flag is set or not.
   8 e. C8 \6 L$ u, D4 u- ^$ Y
3.   * @param  __HANDLE__: specifies the TIM Handle.
   % \+ K/ n$ }% s3 N
4.   * @param  __FLAG__: specifies the TIM interrupt flag to check.
   3 D: i2 Z* N; W: }6 K
5.   *        This parameter can be one of the following values:
   
6.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag
   
7.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
   7 V) [3 z# G4 X
8.   *            @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
   
9.   *            @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
   
10.   *            @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
    
11.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag
    
12.   *            @arg TIM_FLAG_CC6: Compare 6 interrupt flag
    6 A* D& N6 M: S4 m: t2 v
13.   *            @arg TIM_FLAG_COM:  Commutation interrupt flag
    8 P- I' B3 J9 l, `( a3 @: B
14.   *            @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
    & r7 Z. o, T2 r7 i! [
15.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   
    
16.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    
17.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
    
18.   *            @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
    ( ?3 N8 {* X5 p9 F
19.   *            @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
    
20.   *            @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
    3 Z) A1 ]2 c2 `" ?1 ~0 d3 I6 [
21.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    + E) K1 y9 ?- z, q! a
22.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    - g, Y4 ^8 G7 s: d
23.   */
    ) s' j4 n# M3 n6 a
24. #define __HAL_TIM_GET_FLAG(__HANDLE__, __FLAG__)   (((__HANDLE__)->Instance->SR &(__FLAG__)) == (__FLAG__))

复制代码

$ O" g/ m1 J9 K2 T前5个是比较常用的中断标志。
( k  k. Q) F3 o! B
7 S# Z0 S" P' V" _" G1 h  TIM_FLAG_UPDATE
: z/ [% P( y- ^( O1 P定时器更新标准，配置一个周期性的定时器中断要用到。
( g6 a. h% O4 N& D3 S% X9 J
' L2 n# b4 ]$ k) V     TIM_FLAG_CC1
TIM_FLAG_CC2

TIM_FLAG_CC3

& x5 E) t' T) S/ e# F7 a$ @- Y+ STIM_FLAG_CC4

* Y* S1 n9 {; g" X( g1 p5 H捕获/比较标志，配置了捕获/比较中断要用到。
  O# B1 _! T) }% k6 T
与标志获取函数__HAL_TIM_GET_FLAG对应的清除函数是__HAL_TIM_CLEAR_FLAG：
5 f/ Z+ n/ i4 b" B1 M

1. /** @brief  Clear the specified TIM interrupt flag.
   ( k) W* B# ~# h0 [% Y* b
2.   * @param  __HANDLE__: specifies the TIM Handle.
   ) m" o; M7 W* X. |  ~+ h* p
3.   * @param  __FLAG__: specifies the TIM interrupt flag to clear.
   
4.   *        This parameter can be one of the following values:
   
5.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag
   8 R1 u7 V. _% ~9 H% b0 Z
6.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
   
7.   *            @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
   
8.   *            @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
   + G9 J5 {3 a; ^4 u6 B
9.   *            @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
   . g' y7 t# O0 }& M# H1 f
10.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag
    5 L0 x. p+ K0 V& N* r* l. x  x
11.   *            @arg TIM_FLAG_CC6: Compare 6 interrupt flag
    - r" Y  J2 w: _* Z4 q# E" k5 ?/ Z
12.   *            @arg TIM_FLAG_COM:  Commutation interrupt flag
    
13.   *            @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
      k! G1 M8 c" D9 u
14.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   
    " {# H! ?2 k  X3 N1 i  b
15.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    . J* I  M  [, p" Y7 T, f- N5 R
16.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
    
17.   *            @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
    ' f) u5 A/ q* k, A) u" N$ ~
18.   *            @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
    : i/ a1 M% `' ~1 ^% P$ H
19.   *            @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
    
20.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    8 a; C4 H2 R: G( w' I
21.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    ' J5 \- H( o) h4 v7 x5 H
22.   */
    
23. #define __HAL_TIM_CLEAR_FLAG(__HANDLE__, __FLAG__)       ((__HANDLE__)->Instance->SR = ~(__FLAG__))

复制代码

清除标志函数所支持的参数跟获取函数是一 一对应的。除了这两个函数，还是定时器的中断开启和中断关闭函数用的也比较多。
, p" Z8 S* z5 o9 ~, v- L& q

1. /** @brief  Enable the specified TIM interrupt.
   6 H( N% i6 r' S/ e$ D
2. * @param  __HANDLE__: specifies the TIM Handle.
   8 X- G5 g1 i; Z, J( T' S) G+ B
3. * @param  __INTERRUPT__: specifies the TIM interrupt source to enable.
   
4. *          This parameter can be one of the following values:
   8 e$ Y9 L4 P2 d; n
5. *            @arg TIM_IT_UPDATE: Update interrupt
   . U# i8 N$ d1 U9 ]. |
6. *            @arg TIM_IT_CC1:   Capture/Compare 1 interrupt
   ) \  n0 p& i! ]: |) u4 J
7. *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt
   
8. *            @arg TIM_IT_CC3:  Capture/Compare 3 interrupt
   ; ~- P) Z) \) ^7 |% ^
9. *            @arg TIM_IT_CC4:  Capture/Compare 4 interrupt
   + w( W( E! |* R& Q
10. *            @arg TIM_IT_COM:   Commutation interrupt
    ) G+ H6 }% o8 w5 {% p: F# X" j* T$ c1 u
11. *            @arg TIM_IT_TRIGGER: Trigger interrupt
    
12. *            @arg TIM_IT_BREAK: Break interrupt
    
13. * @retval None
    0 \0 Z& r) U0 T7 v/ r
14. */
    
15. #define __HAL_TIM_ENABLE_IT(__HANDLE__, __INTERRUPT__)  ((__HANDLE__)->Instance->DIER |= (__INTERRUPT__))
    
16. 
    
17.   /** @brief  Disable the specified TIM interrupt.
    
18.   * @param  __HANDLE__: specifies the TIM Handle.
    $ [3 S: K. b) y4 G9 h
19.   * @param  __INTERRUPT__: specifies the TIM interrupt source to disable.
    4 I8 M9 X$ G$ L8 }: @- ^# d
20.   *          This parameter can be one of the following values:
    & r9 c- v* T4 L; B% c' b
21.   *            @arg TIM_IT_UPDATE: Update interrupt
    2 t9 e+ q' u9 n8 E& H
22.   *            @arg TIM_IT_CC1:   Capture/Compare 1 interrupt
    ! L: x1 E/ v, N" q# g
23.   *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt
    8 I% e* p6 w* Y
24.   *            @arg TIM_IT_CC3:  Capture/Compare 3 interrupt
    + o$ j1 C& ]5 p- q- j& G( }
25.   *            @arg TIM_IT_CC4:  Capture/Compare 4 interrupt
    
26.   *            @arg TIM_IT_COM:   Commutation interrupt
    8 Q0 {8 T2 S6 S  ^* x) F  ]) {
27.   *            @arg TIM_IT_TRIGGER: Trigger interrupt
    8 w1 q' x) u; N$ f
28.   *            @arg TIM_IT_BREAK: Break interrupt
    
29.   * @retval None
    
30.   */
    ) t6 U9 S% i8 x1 h) q6 N
31. #define __HAL_TIM_DISABLE_IT(__HANDLE__, __INTERRUPT__)   ((__HANDLE__)->Instance->DIER &= ~(__INTERRUPT__))

复制代码

: f& G# ~- o7 ^  h' T6 `常用的也是前五个参数，1个定时器更新中断以及4个CC中断 。
+ g% q' y0 X5 T# N7 Z4 T; U
+ ^% ~3 U: A" v- a& R/ r注意：操作定时器的寄存器不限制必须要用HAL库提供的API，比如要操作寄存器CR1，直接调用TIM1->CR1操作即可。
  k/ V2 _7 i9 }0 M1 S
32.3.7 定时器初始化流程总结
; f; w6 j( o, ?7 x使用方法由HAL库提供：

3 G% D, I+ H8 `3 [# c  第1步：通过下面几个函数配置定时器工作在相应的模式
) C) Q) Z6 H4 J4 _2 {& d" y- N' q
  HAL_TIM_Base_Init
简单的定时器时基础功能

+ M8 G( e: a- Q" p! f% B' P  HAL_TIM_OC_Init 和 HAL_TIM_OC_ConfigChannel
* Z9 P9 {1 L1 J6 d配置定时器产生输出比较信号

$ C& y6 b+ |4 L! V" c  HAL_TIM_PWM_Init 和 HAL_TIM_PWM_ConfigChannel
0 S5 h) M! d. B0 c" e9 F0 S配置定时器产生PWM信号
: Q) ~& d; h( s" X$ W, I3 J: s
  HAL_TIM_IC_Init 和 HAL_TIM_IC_ConfigChannel
9 t  t7 U6 y6 N# [配置定时器测量外部信号
6 U" ?: {, D9 p  P) Z/ b
8 G+ L& E0 o: C; W" u  HAL_TIM_OnePulse_Init 和 HAL_TIM_OnePulse_ConfigChannel
, i0 a/ {2 T# Y% P' f5 z9 @配置定时器工作在单脉冲模式
5 r. ]4 F( `( }* {+ a: `' J/ @
  HAL_TIM_Encoder_Init
. W  S) d7 ^* @6 U- M配置定时器使用编码器接口

  第2步：定时器几个常用功能的底层初始化API，这个里面需要用户自己填
& {3 n# k; X: a6 R
) M$ K: F5 w5 V  P! B0 s0 p第1步里面的几个函数会调用下面的API。
6 D  u! g- s- c+ M5 T
  定时器基本功能 : HAL_TIM_Base_MspInit()
  输入捕获 : HAL_TIM_IC_MspInit()
  输出比较 : HAL_TIM_OC_MspInit()
  PWM输出 : HAL_TIM_PWM_MspInit()
. Q; @9 A0 a$ ~2 T% q  单脉冲输出模式: HAL_TIM_OnePulse_MspInit()
  编码器模式 : HAL_TIM_Encoder_MspInit()
  第3步：底层初始化具体实现
1 x/ b( K! d) Y1 H
& {1 Y; e9 ^* @2 ]  p/ R* @第2步中函数的具体实现。
/ f* A( A' T- K3 }# @8 t
4 Y' f$ E  `6 Y; {+ c  使用函数__HAL_RCC_TIMx_CLK_ENABLE()使能定时器时钟。
  使用函数__HAL_RCC_GPIOx_CLK_ENABLE()使能定时器使用到的引脚时钟。
6 R7 Q# o8 r5 ^+ E$ c$ ~  使用函数HAL_GPIO_Init()配置GPIO的复用功能。
  如果使能了定时器中断，调用函数HAL_NVIC_SetPriority和HAL_NVIC_EnableIRQ配置。
! m. C5 A7 L8 o' ~2 i  如果使能了DMA，还需要做DMA的配置。
  定时器默认使用APB时钟，如果使用外部时钟，调用函数HAL_TIM_ConfigClockSource可以配置。
  第4步：启动定时器外设

5 s/ d% M6 W4 r1 D$ z" r. S  定时器基础功能:
+ V  I5 I& m  a2 J" T( h5 FHAL_TIM_Base_Start()

HAL_TIM_Base_Start_DMA()
* [  `8 W$ @! P/ U1 [* \
HAL_TIM_Base_Start_IT()

2 \- R4 h5 f3 v1 v  输入捕获 :
HAL_TIM_IC_Start()
- i( n' R5 Q1 V) K4 j, p
HAL_TIM_IC_Start_DMA()

9 J$ K: \- Z: yHAL_TIM_IC_Start_IT()
, P& j7 e( A& j
  输出比较 :
HAL_TIM_OC_Start()
7 \5 J2 o9 T% s1 Z9 \, W# ]
HAL_TIM_OC_Start_DMA()

HAL_TIM_OC_Start_IT()

  PWM输出：
1 b8 G: W) g4 _: AHAL_TIM_PWM_Start()
. E- N8 Q* ~' A/ T6 u
' x- A( E- ]0 M0 H: R- {HAL_TIM_PWM_Start_DMA()
$ ]! `% I+ c$ I( p
HAL_TIM_PWM_Start_IT()

7 j4 s8 T' T  h8 Y; B! o  单脉冲模式：
: {! t7 T( E8 eHAL_TIM_OnePulse_Start()
+ b5 H& ~* j" I7 Z5 R* @/ L" V
HAL_TIM_OnePulse_Start_IT().

3 @. q7 B5 V  L& }  编码器模式：
; ^7 [- }- ?/ U& a, l, Z6 A$ uHAL_TIM_Encoder_Start()

2 b! l  e; `( ~& _& p0 }. {, EHAL_TIM_Encoder_Start_DMA()

HAL_TIM_Encoder_Start_IT().

  第5步：定时器的DMA突发使用下面两个函数
* j3 r3 w: Q3 [  a' L* z! B6 V7 v
  HAL_TIM_DMABurst_WriteStart()
  HAL_TIM_DMABurst_ReadStart()
定时器常用的功能，通过上面这几步即可实现。
# f& I7 I. U( C* V% W
32.4 源文件stm32h7xx_hal_tim.c
/ `! z/ @4 ?0 m# J5 r此文件涉及到的函数非常多，这里把几个常用的函数做个说明：
0 O$ n- A: X# W* P
& F+ K: y3 v. z2 X+ y. Y: ]  HAL_TIM_Base_Init
0 Q' s& _# P& Y: h: H7 i0 \, K+ {- y  HAL_TIM_Base_Start
  HAL_TIM_PWM_Init
  HAL_TIM_PWM_ConfigChannel
  HAL_TIM_PWM_Start
  x! {  k. y- e1 l7 Q1 U& v  HAL_TIM_IC_Init
5 }5 K1 [* z( a0 l" n; P  HAL_TIM_IC_ConfigChannel
1 H. ^/ U: l- H8 S' b( p  HAL_TIM_IC_Start_IT
  x! b6 s# S" G  p( n: Z  HAL_TIM_OC_Init
2 Y, _8 X6 U6 C! }  x  HAL_TIM_OC_ConfigChannel
  l; N6 I2 z/ W( ~3 X, r) v1 J  HAL_TIM_OC_Start
/ ~9 k6 I7 e5 f2 ?" p6 m( p32.4.1 函数HAL_TIM_Base_Init
函数原型：

1. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   $ E" g! ^! k" q( m* ]/ _# b8 @
2. {
   9 W  p# f6 z8 Q9 V
3.   /* 检测是否是有效句柄 */
   ( A: F6 ~- O, \- G9 W
4.   if(htim == NULL)
   
5.   {
   
6.     return HAL_ERROR;
   + x' K+ Z' n7 m
7.   }
   6 S6 f) u. d' v/ N; _/ `# L
8. 
   
9.   /* 检测参数 */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    ! p4 w3 ]& g. i& J1 @$ \* T  A7 w
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
      ?4 n4 _' x' Z) M) B, D
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    $ M3 S8 v. j# ]
13. 
    4 H9 u; L* v* [0 x: s# R
14.   if(htim->State == HAL_TIM_STATE_RESET)
    
15.   {
    , d  A: w3 X  R' U4 G9 m  O5 V
16.     /* 默认取消锁 */
    ' V3 V" _1 o; a) U3 A
17.     htim->Lock = HAL_UNLOCKED;
    
18.     /* 初始化底层硬件 : GPIO, CLOCK, NVIC */
    
19.     HAL_TIM_Base_MspInit(htim);
    
20.   }
    $ R5 F) L' ~7 e0 J5 m' u
21. 
    / D- {) O* Q4 Z- ]! u8 A
22.   /* 设置TIM状态 */
    & ^/ o' U  i6 r6 q. B# I& Q, h" h9 ?" y
23.   htim->State= HAL_TIM_STATE_BUSY;
    " @1 H( T, y$ z6 e2 F
24. 
    - A  F& V/ S9 P8 S# }0 h
25.   /* 基本参数配置 */
    
26.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    6 l5 A& j: {' o/ u" \
27. 
    3 y3 [  W" g! o. S+ X* g2 T* Z
28.   /* 设置TIM就绪 */
    
29.   htim->State= HAL_TIM_STATE_READY;
    
30. 
    # S4 [3 N. `0 @3 x8 `
31.   return HAL_OK;
    
32. }

复制代码

函数描述：
- I/ M2 N7 b# ?5 j$ h
此函数用于初始化定时器用于PWM。
& ?9 n3 t8 d9 c' j! R8 }
函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
/ k9 l: N" U0 i( [  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
: \9 C5 I& U0 q# ?+ G4 S9 O注意事项：

函数HAL_TIM_Base_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
" v2 s* ~# _- b& c! m$ c如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
# o6 |: `4 ]" ^# I$ `  Q& ^  n对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_TIM_STATE_RESET  = 0x00U。
: u+ {1 q: b5 X' j
解决办法有三：
( s4 P, G' H/ U7 q( p6 g/ \
! p. m, J9 V0 R) y$ @. j9 Y+ r) R方法1：用户自己初始定时器和涉及到的GPIO等。

0 m3 M- c% e1 Y+ l. ^9 u6 A9 g& ?方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

方法3：下面的方法
: N2 K- T! e5 A9 {: ]. R

1. if(HAL_TIM_Base_DeInit(&TimHandle) != HAL_OK)
   
2. {
   
3.     Error_Handler();
   
4. }  
   0 L$ q4 f4 I" ?  d1 w" i
5. if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
   0 c. Z1 m4 s7 q+ x8 W
6. {
   # K6 [# S1 e2 F- p4 `
7.     Error_Handler();
   
8. }

复制代码

: p1 j8 S4 y: n: Z使用举例：
6 k+ B) [  z  \: y
& B# V8 R0 h# g, `, V

1. TIM_HandleTypeDef   TimHandle = {0};
   1 q- J  R/ q4 z  k+ j. ^$ `) y
2. 
   9 K% v3 i3 d' p3 r6 ]  H( ]
3. /*
   2 t9 r# d# v  p& [
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   ! i* _/ e! p6 d+ i" d) d
5. */
   
6. TimHandle.Instance = TIMx;
   
7. TimHandle.Init.Prescaler         = usPrescaler;
   
8. TimHandle.Init.Period            = usPeriod;        
   
9. TimHandle.Init.ClockDivision     = 0;
   $ s2 Z) L1 e# M+ `
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    - a- x9 A% F! B3 r9 h# R
11. TimHandle.Init.RepetitionCounter = 0;
    
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    % z- i# Q5 R5 _# a: T: A( E
14. {
    5 H+ R& z9 f$ ^# f2 N
15.         Error_Handler(__FILE__, __LINE__);
    & ^+ }* D8 P# x! F
16. }

复制代码

32.4.2 函数HAL_TIM_Base_Start
函数原型：

1. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   9 R1 R. P' B, }4 ~
2. {
   
3.   /* 检测参数状态 */
   
4.   assert_param(IS_TIM_INSTANCE(htim->Instance));
   ( G7 F9 ]0 s# ]
5. 
   6 C6 R4 |/ n$ [6 U9 i4 S6 W
6.   /* 设置定时器状态 */
   
7.   htim->State= HAL_TIM_STATE_BUSY;
   
8. 
   
9.   /* 使能定时器 */
   / z$ [) X! @3 ?1 W8 P4 K. y3 \
10.   __HAL_TIM_ENABLE(htim);
    " {' T" C; T& O- R
11. 
    
12.   /* 设置定时器状态 */
    
13.   htim->State= HAL_TIM_STATE_READY;
    
14. 
    
15.   /* 返回HAL_OK */
    
16.   return HAL_OK;
    
17. }

复制代码

函数描述：
6 e/ w' P' e, q- F" t8 q
此函数比较简单，调用函数HAL_TIM_Base_Init配置了基础功能后，启动定时器。
  ^8 m; q8 ~& O/ W
* W* Q' n5 m6 S8 E0 {3 O( [函数参数：

. O% I# _9 o3 N2 p5 {  第1个参数是TIM_HandleTypeDef类型结构体指针变量。
- g/ w4 \5 F! F  返回值，固定返回HAL_OK，表示初始化成功。
使用举例：

3 {# a. ~( `( p6 z9 ~% ^- ?: v

1. TIM_HandleTypeDef   TimHandle = {0};
   ! S4 g1 U9 f/ X4 l8 C  [# F3 a! _
2. 
   
3. /*
   
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   
6. TimHandle.Instance = TIMx;
   
7. TimHandle.Init.Prescaler         = usPrescaler;
   
8. TimHandle.Init.Period            = usPeriod;        
   % ?# B* _( i9 R! v; b! B
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)
    # B1 K8 ~# e4 ~% @$ ?) g
14. {
    6 Y: z, |3 L' _. ]- e
15.         Error_Handler(__FILE__, __LINE__);
    
16. }
    - S* Y, K2 l5 F' g' t0 D
17. 
    - d. A; b' M& ]( z' J
18. /* 启动定时器 */
    4 T; X  r0 _4 N$ g( e# Q
19. if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
    
20. {
    
21. Error_Handler(__FILE__, __LINE__);
    
22. }

复制代码

6 o3 p+ J0 W7 M" t32.4.3 函数HAL_TIM_PWM_Init
函数原型：
2 y3 |' A2 S7 o+ L) [
9 `+ y) D7 x2 h0 C5 d3 w

1. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
   
2. {
   
3.   /* 检查句柄是否有效 */
     N# p  O% q% J+ R! v! O
4.   if(htim == NULL)
   # D% g, [7 k4 W: O6 {
5.   {
   
6.     return HAL_ERROR;
   
7.   }
     Q- Y2 v4 u% f- V" _
8. 
   
9.   /* 检测参数 */
   3 U7 `3 p, S* ~( ~# K" K) x% P) d% L
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    ' y$ L& @3 L. S% I8 \. B
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    0 v( n# C* o7 `; _+ c' m4 S; V
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
13. 
    
14.   if(htim->State == HAL_TIM_STATE_RESET)
    9 o3 V, V- _, |$ K5 J) I; [% ^1 y6 P
15.   {
    
16.     /* 默认取消锁 */
    
17.     htim->Lock = HAL_UNLOCKED;
    : j$ p# y7 n) R1 X
18. 
    
19.     /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_PWM_MspInit(htim);
    
21.   }
    
22. 
      j& v' j7 L* B! A: |+ \4 B
23.   /* 设置定时状态 */
    / ?" Z* |8 R0 [4 f% O5 }: E6 p
24.   htim->State= HAL_TIM_STATE_BUSY;
    
25. 
    5 q& y# \6 S) Y) s0 y# l
26.   /* 配置定时器用于PWM */  
    $ c& v$ U4 e# s$ L- ]
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    # `. i; P  R. l5 L  x- A7 X; @
28. 
    
29.   /* 设置定时器状态 */
    1 Z7 I2 e, k% Q7 v2 K! e! r
30.   htim->State= HAL_TIM_STATE_READY;
    
31. 
    
32.   return HAL_OK;
    5 q+ o2 b" T3 z* W; c
33. }

复制代码

0 D) j9 e9 ?0 u1 _& l' B6 _函数描述：

! L" s' B/ y+ H% a2 ~( ]& ]此函数用于初始化定时为PWM方式。

函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：

, ^  U0 @: q. \. V函数HAL_TIM_PWM_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
1 P3 [& M; c* ~9 J. b如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_TIM_STATE_RESET  = 0x00U。
: J+ @- s" z% B& t2 u- Z+ e
解决办法有三：

9 z) P6 T/ y+ g+ t9 Z$ b6 s方法1：用户自己初始定时器和涉及到的GPIO等。
% r; m8 P/ u5 B6 g$ m$ x
方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

- Z4 B/ s# L/ |9 Z) A: w方法3：下面的方法
$ U; ~3 {. ?8 |; y
3 Q- w3 L& L' Y( n+ M; R

1. if(HAL_TIM_PWM_DeInit(&TimHandle) != HAL_OK)
   
2. {
   4 O' q9 |% T4 v/ c
3.     Error_Handler();
   # U( f7 i, u$ S
4. }  
   0 h; t4 p/ q8 d/ I" b
5. if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
   
6. {
   
7.     Error_Handler();
   
8. }

复制代码

使用举例：

  R9 t1 A  v0 M7 ~3 I) _" L" S

1. TIM_HandleTypeDef  TimHandle = {0};
   
2. 
   2 \( D" Q7 D& o6 N
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   7 `6 `8 t( @1 V0 Y3 o2 U7 `
4. TimHandle.Instance = TIM1;
   
5. TimHandle.Init.Prescaler         = usPrescaler;
   
6. TimHandle.Init.Period            = usPeriod;
   
7. TimHandle.Init.ClockDivision     = 0;
   * O+ W& y- e2 h7 p1 v
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   
9. TimHandle.Init.RepetitionCounter = 0;
   & f! d( e5 m4 `9 }  P; m7 ^
10. TimHandle.Init.AutoReloadPreload = 0;
    $ r0 E! f2 [2 }/ I' Y+ _
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    3 t) \7 g( L- R" k% u$ x
12. {
    * Z' Z1 a0 b! x7 a0 L4 c3 |$ Z
13.     Error_Handler(__FILE__, __LINE__);
    
14. }

复制代码

' h1 n- O' M7 P  I7 ?32.4.4 函数HAL_TIM_PWM_ConfigChannel
函数原型：

1. HAL_StatusTypeDef HAL_TIM_PWM_ConfigChannel(TIM_HandleTypeDef *htim,
   2 r. |$ C: g/ q
2.                                             TIM_OC_InitTypeDef* sConfig,
   
3.                                             uint32_t Channel)
   $ L; z  d+ s, {* S
4. {
   : H3 t/ i( D; |
5.    /* 省略 */
   , Z/ j- l8 d6 p  `
6. 
   
7.   /* 开锁 */
   
8.   __HAL_LOCK(htim);
   
9. 
   & z- y/ k0 J6 M6 l3 l3 E6 C
10.   htim->State = HAL_TIM_STATE_BUSY;
    
11. 
    5 T4 z( t7 C2 ]+ I# X, A) H/ F: {
12.   switch (Channel)
    
13.   {
    0 k- O8 ~* P* _1 ?$ Q. f) b' K  D. k
14.     case TIM_CHANNEL_1:
    
15.     {
    
16.       /* 检查参数 */
    ( a' r' s, @2 n( j$ T( o
17.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    , d% R# g$ y$ _  c/ c
18. 
    5 d- e) L$ y' v$ A- e
19.       /* 配置通道1的PWM模式 */
    
20.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    1 Y) j/ F* s8 g
21. 
    
22.       /*预装载使能，更新事件产生时写入有效 */
    + l, j/ k. q" \7 _( n
23.       htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;
    
24. 
    2 O, y( b/ k6 ?) S  Y$ j
25.       /* 配置是快速输出模式 */
    
26.       htim->Instance->CCMR1 &= ~TIM_CCMR1_OC1FE;
    
27.       htim->Instance->CCMR1 |= sConfig->OCFastMode;
    ; R  F1 G- r' `* q( d
28.     }
    
29.     break;
    
30. 
    ' C* A+ m# s4 D
31.     case TIM_CHANNEL_2:
    
32.     {
    
33.        /* 省略 */
    * t: t0 \; S# g
34.     }
    
35.     break;
    
36. 
    
37.     case TIM_CHANNEL_3:
    0 P/ j( r' W0 a  L5 I" ^3 j
38.     {
    
39.        /* 省略 */
    ; \) [0 ?$ U3 o& |" o
40.     }
    
41.     break;
    
42. 
    
43.     case TIM_CHANNEL_4:
    
44.     {
    
45.       /* 省略 */
    
46.     }
    5 n8 R1 e  q1 n
47.     break;
    $ E6 Z( F  t1 c  C
48. 
    
49.     case TIM_CHANNEL_5:
    , g) Y( n4 }6 [: r3 G5 D4 T+ B
50.     {
    
51.        /* 省略 */
    * D* u: |+ h0 s+ G
52.     }
    
53.     break;
    # j1 {/ n  `) d) i" E
54. 
    
55.     case TIM_CHANNEL_6:
    - E: _9 @2 q' f0 ]6 C
56.     {
    
57.         /* 省略 */
      ~1 o0 L' m5 v4 q# S+ i$ s
58.     }
    ! W/ ]1 Z5 Y7 f4 A2 m. c. b, K9 j
59.     break;
    
60. 
    3 r7 p% A) {+ B  L
61.     default:
    1 f2 q* T3 c+ k
62.     break;
    ( w: U- \0 M" l: i9 L- v9 D- S3 U
63.   }
    
64. 
    
65.   htim->State = HAL_TIM_STATE_READY;
    ( n) O4 B, ~& y
66. 
    6 o6 x0 [: ~+ I- j# L4 t
67.   /* 关锁 */
    
68.   __HAL_UNLOCK(htim);
    1 W& c5 l# I- x, V; ?
69. 
    
70.   return HAL_OK;
    
71. }

复制代码

函数描述：

. N7 Q8 [3 a& `7 I) n2 T此函数用于配置定时器的PWM通道。
2 o  N& V$ b0 }5 O
* q7 v6 R5 P$ D5 g2 `8 E/ r; R3 E函数参数：

" H/ K7 Q  q2 j6 B3 S/ Y. s( e  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
6 @* O3 \, I0 N4 w  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
2 r+ z& ?% _" i' r  第3个参数是通道设置，支持以下参数：
TIM_CHANNEL_1

TIM_CHANNEL_2

0 R& ]; S, H; p. c! z( P" BTIM_CHANNEL_3

TIM_CHANNEL_4
  `  z  Z" i: s' K) S1 p+ E. r
TIM_CHANNEL_5

2 K9 d  c! F# ^& C' k& j: hTIM_CHANNEL_6
9 F( E8 @$ m9 }3 t1 r
9 \% I- i9 N0 u2 [  o$ K  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
9 \& d" ^) E  l5 y  D$ ^使用举例：
' F9 J0 u/ J# q  w, \
$ f. M% V& C$ a" ?$ H3 [- I& v

1. TIM_HandleTypeDef  TimHandle = {0};
   ' r9 q+ W6 f6 S& k( M
2. 
   
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   
4. TimHandle.Instance = TIM1;
   , f6 m7 c7 X8 Y; A. n4 _
5. TimHandle.Init.Prescaler         = usPrescaler;
   
6. TimHandle.Init.Period            = usPeriod;
   8 L7 o4 T  J* G/ Z; j+ P" S# O0 Y
7. TimHandle.Init.ClockDivision     = 0;
   
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   7 v8 b9 @1 W; y1 S
9. TimHandle.Init.RepetitionCounter = 0;
   
10. TimHandle.Init.AutoReloadPreload = 0;
    
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    1 \, g, e, s2 X/ m0 ~. e: M; V
12. {
      Q# q9 b! @$ J; _% B
13.     Error_Handler(__FILE__, __LINE__);
    ; G# R  j* p* J
14. }
    
15. 
    9 u8 K; e' W) x) ^
16. /* 配置定时器PWM输出通道 */
    2 h3 s, U+ C, b$ m) {; o6 i: X" O
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    9 c( n; S  {( E
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    $ p  E3 i! F% H- J3 Q# e# w
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    0 |4 Q2 Y1 o* U8 h) V4 a5 U
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
    3 z, p" z) t- O( d7 ^
23. 
    0 q: W" X- ~7 Y) m
24. /* 占空比 */
    : _( c: E; C( [# C$ U
25. sConfig.Pulse = pulse;
    
26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    
27. {
    6 A" g4 I* x( n% j
28.     Error_Handler(__FILE__, __LINE__);
    2 ?8 T7 q' V2 d0 @* u% q* X
29. }

复制代码

32.4.5 函数HAL_TIM_PWM_Start
9 v  d+ v, F, y& k函数原型：

1. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
   8 R. P1 ?- v8 t8 G
2. {
   
3.   /* 检测参数 */
   
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   
5. 
   
6.   /* 使能捕获比较通道 */
   
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
8. 
   , ^8 T+ S. n! D3 D$ ~; o
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
   - ]& _, y9 ?( R9 [  |
10.   {
    ; n1 b' b- i+ V* S# a- U* u
11.     /* 使能主输出 */
    5 C8 a$ ]6 _1 C6 K/ l* O: k$ {, U
12.     __HAL_TIM_MOE_ENABLE(htim);
    
13.   }
    
14. 
    
15.   /* 使能定时器 */
    ; C1 _" x4 U- r, O
16.   __HAL_TIM_ENABLE(htim);
    
17. 
    
18.   /* 返回状态*/
    7 r- w8 e( ?% u5 X: b! E/ G3 A
19.   return HAL_OK;
    
20. }

复制代码

: R- F6 Y+ K" R1 p1 ]2 D7 ~函数描述：
: [, ~7 K% G% U0 `% {* X) c
- ~& s  b- E0 r( c0 r此函数用于启动PWM。

  x* J$ D9 Y2 e0 y9 k5 N函数参数：

0 A) u. K6 I8 }0 N5 ]' N! i  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
2 l( M: O/ S$ e) H  第2个参数是通道设置，支持以下参数：
3 H" O9 n- Z5 D. k" _' ~1 tTIM_CHANNEL_1
9 [+ \$ O# p9 W  S& m' K
TIM_CHANNEL_2
0 d9 H0 j2 ]9 R( v
TIM_CHANNEL_3
# f8 k( X+ {3 {3 z0 G( Q  J
TIM_CHANNEL_4

5 k* h0 w5 g* V8 q& j7 s  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
9 p  ^  q6 p! H使用举例：
: B) m6 O3 Z. h" U
3 b0 E9 [$ K2 ~& B) s

1. TIM_HandleTypeDef  TimHandle = {0};
   
2. 
   - T! _$ k% r& h3 z& C
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   : s7 U6 S; |" ?$ i! R3 u, ~
4. TimHandle.Instance = TIM1;
   7 Y7 N: N7 D; i: R7 l) O
5. TimHandle.Init.Prescaler         = usPrescaler;
   5 }3 t) u  m2 Z
6. TimHandle.Init.Period            = usPeriod;
   " w0 t6 _; t" c
7. TimHandle.Init.ClockDivision     = 0;
   
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   9 C5 h, `' Y' x
9. TimHandle.Init.RepetitionCounter = 0;
   
10. TimHandle.Init.AutoReloadPreload = 0;
    - k6 c6 U! G: W  T. c: Y. g+ I
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    " u& I/ e3 a& u0 K1 W% @' s
12. {
    
13.     Error_Handler(__FILE__, __LINE__);
    8 L% F% H$ b0 ]( |# N# `
14. }
    3 Y7 ~7 t5 k) b& B( m& X: T' K
15. 
    
16. /* 配置定时器PWM输出通道 */
    
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    7 F0 P0 a& S0 E4 E/ J- k5 c) P$ y
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    1 T  e) F! h0 l* ]* `* g' r9 n
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
    / n9 U* f# Z# F, M
23. 
    
24. /* 占空比 */
    
25. sConfig.Pulse = pulse;
    
26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    $ ^" N0 l6 U, [* X
27. {
    
28.     Error_Handler(__FILE__, __LINE__);
    , W) ^% V: [( @  n3 X& F) B
29. }
    - d& Y$ l! s2 ~4 B0 D3 e8 ^8 O
30. 
    ; S* O. e! L& M3 c" o
31. /* 启动PWM输出 */
    
32. if (HAL_TIM_PWM_Start(&TimHandle, TimChannel[_ucChannel]) != HAL_OK)
    8 W( I, K7 z1 m0 `+ x
33. {
    4 B5 W  e2 R! r: ^- k9 L# q5 p
34.         Error_Handler(__FILE__, __LINE__);
    
35. }

复制代码

0 j$ T5 ?4 m6 y, i4 G/ z" }) u5 L32.4.6 函数HAL_TIM_IC_Init
7 x! b  I/ h  E3 e% c2 G函数原型：

; h& ^1 K: C. M

1. HAL_StatusTypeDef HAL_TIM_IC_Init(TIM_HandleTypeDef *htim)
   / a+ \, o  n( |+ I: s: |
2. {
   0 D  A* g% N  X" t. S
3.   /* 检测形参是否有效 */
   
4.   if(htim == NULL)
   
5.   {
   " r; h7 S6 b% a2 D; N, i$ B8 N
6.     return HAL_ERROR;
   ) n3 ]( [7 J9 y: f! J1 F
7.   }
   : |6 |# C7 w% ^  w/ D3 ~/ U
8. 
   ; d' s) B7 B4 i6 @, C
9.   /* 检测参数 */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    " ^  g% }( |8 p
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)
    + x& H% o# M7 c0 _( D. f# a
15.   {
    
16. /* 默认取消锁 */
    
17.     htim->Lock = HAL_UNLOCKED;
    
18. 
    ; Q5 v/ o, ?3 G' X: H0 j
19.      /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_IC_MspInit(htim);
    
21.   }
    3 @- B/ n3 u0 L- W& h+ G5 Z0 K9 t
22. 
    / l$ ?$ j7 a0 f9 P6 G
23.   /* 设置定时器状态 */
    * M. A4 V3 v; j/ r
24.   htim->State= HAL_TIM_STATE_BUSY;
    
25. 
    0 G, a! R) T7 @: P& Q0 B6 o
26.   /* 配置定时器为输入捕获模式 */  
    ) r3 c5 [. c5 m8 e- V/ x
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
28. 
    
29.   /* 设置定时器状态 */
    7 H' Q* P: y$ k4 Y
30.   htim->State= HAL_TIM_STATE_READY;
    , D, L/ s, B; ~. {! ?  K
31. 
    
32.   return HAL_OK;
    
33. }

复制代码

, V8 @' {, h/ z2 r3 _1 N函数描述：
7 F' S; ?3 \- ]  l: Q& E
此函数用于定时器输入捕获初始化。

/ y3 [! g3 i5 p4 a( u& |函数参数：
1 f6 U/ a! F8 {4 X9 m" m, a& K
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
* O; x9 ]% D0 s$ Q; ?0 s注意事项：
9 A( G! o- M! C, R8 ]& F+ x
函数HAL_TIM_IC_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
2 k$ ]: @1 n6 b如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
, e$ v( x( l7 X; c' q% O& i对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个HAL_TIM_STATE_RESET  = 0x00U。

; M6 Q3 p8 @  I& q5 V* `解决办法有三：
% a8 H/ g" q& `! V3 g
方法1：用户自己初始定时器和涉及到的GPIO等。
! ^. x1 x2 B2 i4 I5 V# t: w
方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

方法3；下面的方法
% [+ n# \6 D( R% E6 t) _

1. if(HAL_TIM_IC_DeInit(&UartHandle) != HAL_OK)
   
2. {
   - A! B/ F1 \2 A& J  `, [0 S: n
3.     Error_Handler();
   # }" V& X4 P9 |$ Z0 T+ a1 _' q
4. }  
   , y7 P9 T5 i5 V8 A9 C5 m' f
5. if(HAL_TIM_IC_Init(&UartHandle) != HAL_OK)
   / J8 V. o6 L5 Q
6. {
   2 F9 h& ?' l3 B* A7 o, ]
7.     Error_Handler();
   1 {9 e- T, O( c; X7 L* ^. G
8. }

复制代码

% J# J' m% `  U- ?32.4.7 函数HAL_TIM_IC_ConfigChannel
函数原型：
  ]- z* K2 i: }5 |7 y
; C! I1 u' T. n

1. HAL_StatusTypeDef HAL_TIM_IC_ConfigChannel(TIM_HandleTypeDef *htim, TIM_IC_InitTypeDef* sConfig, uint32_t Channel)
   ' P( z2 z3 r+ ]2 i3 I4 T& v+ g& A
2. {
     i/ M8 Z/ c/ d0 Z
3.   /* 检查参数 */
   ( x. @2 t( i" E* p
4.   assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
   2 ]% e+ _+ q; H
5.   assert_param(IS_TIM_IC_POLARITY(sConfig->ICPolarity));
   
6.   assert_param(IS_TIM_IC_SELECTION(sConfig->ICSelection));
   : @% t" Z5 F0 G# ]* D
7.   assert_param(IS_TIM_IC_PRESCALER(sConfig->ICPrescaler));
   
8.   assert_param(IS_TIM_IC_FILTER(sConfig->ICFilter));
   ; b- J; ~! p; J8 N. |
9. 
   & M7 K+ z7 |  D0 M- d
10.   /* 开锁 */  
    . ]. t, }) f2 k' U" i
11.   __HAL_LOCK(htim);
    
12. 
    0 h1 d% Y! \5 K7 }& y
13.   htim->State = HAL_TIM_STATE_BUSY;
    
14. 
    . B' }. ?) C! _) x8 e
15.   if (Channel == TIM_CHANNEL_1)
    . i* H" Y2 X3 C' T3 q) x1 o
16.   {
    
17.     /* 配置输入通道1 */
    
18.     TIM_TI1_SetConfig(htim->Instance,
    
19.                sConfig->ICPolarity,
    
20.                sConfig->ICSelection,
    ( f; J) M- H& U$ s8 Y1 n
21.                sConfig->ICFilter);
    
22. 
    ' E0 I; Q2 Y% a3 p) d
23.     /* 清零IC1PSC位 */
    
24.     htim->Instance->CCMR1 &= ~TIM_CCMR1_IC1PSC;
    
25. 
    
26.     /* 根据用户配置，设置分频 */
    
27.     htim->Instance->CCMR1 |= sConfig->ICPrescaler;
    3 P( C0 z  k. V$ {4 s
28.   }
    
29.   else if (Channel == TIM_CHANNEL_2)
    / ^% v, j0 ]1 K7 d
30.   {
      V: e- L3 @$ ^4 [% O
31. /* 省略 */
    
32.   }
    
33.   else if (Channel == TIM_CHANNEL_3)
    ; z8 W: h  x2 t) j5 c3 P6 \/ p
34.   {
    
35.      /* 省略 */
    
36.   }
    
37.   else
    ) z* M! A' P( o9 c6 m/ Y% ~
38.   {
    - |+ ^6 \+ F- U8 r- {- ^# c
39.      /* 省略 */
    6 V, X: k; @# l9 V5 N
40.   }
    
41. 
    
42.   htim->State = HAL_TIM_STATE_READY;
    2 N/ d! J3 F: S' n8 i% k1 X
43. 
    " Z+ y( d% ]! G0 J6 V
44.   __HAL_UNLOCK(htim);
    
45. 
    3 {0 S' {1 g4 p# Y2 Z$ d/ r
46.   return HAL_OK;
    
47. }

复制代码

函数描述：
! V! H6 E4 A: T2 n
此函数用于配置定时器的输入捕获通道。
) F0 f. D+ b. ?" R8 Q4 S# m  v: @3 P  W' E3 P
8 a, M* l3 c9 v  L' c3 V函数参数：
& U. h4 [5 I# Q5 [
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置
  第2个参数是TIM_IC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
! O, L7 l' c$ e0 yTIM_CHANNEL_1

TIM_CHANNEL_2
: ]  v$ q  U3 D% P) q. U
TIM_CHANNEL_3

# |* m' S3 G( B! [. |, lTIM_CHANNEL_4

  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
( m7 V; F- }# x2 V% C' Q9 t" C
- F& q$ U3 M+ g" E32.4.8 函数HAL_TIM_IC_Start_IT
函数原型：

, B1 C1 [  L: B" M8 L

1. HAL_StatusTypeDef HAL_TIM_IC_Start_IT (TIM_HandleTypeDef *htim, uint32_t Channel)
   ; G4 C3 T& g3 I. {& H4 g* J: y
2. {
   
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   ! W' z0 b$ Z) l
5. 
   
6.   switch (Channel)
   1 o& [! s$ m2 k
7.   {
   
8.     case TIM_CHANNEL_1:
   % n* x0 }2 m' x" J" M3 x  T
9.     {      
   
10.       /* 使能CC1（Capture/Compare 1）中断 */
    9 F/ ^# b- R1 J- J* k2 h
11.       __HAL_TIM_ENABLE_IT(htim, TIM_IT_CC1);
    
12.     }
    
13.     break;
    
14. 
    # @/ x: y4 k3 ~/ b9 r/ ]3 o
15.     case TIM_CHANNEL_2:
    ( M# Q* r% P2 H7 v3 o
16.     {
    
17.    /* 省略 */
    
18.     }
    
19.     break;
    : _& W! }/ Y# [3 r! z
20. 
    
21.     case TIM_CHANNEL_3:
    2 V( I& k! O7 l2 F( I. r% p( t
22.     {
    
23.   /* 省略 */
    
24.     }
    
25.     break;
    % m& ^! k, X. y! V1 q
26. 
    
27.     case TIM_CHANNEL_4:
    
28.     {
    
29.   /* 省略 */
    ! B0 h4 u$ u, |4 v( |" {
30.     }
    0 I, ]: Z% e' w5 E9 [
31.     break;
    ( P2 Z* [3 V  i( x1 Q
32. 
    $ k4 V+ _# N$ _2 z& v2 S" R7 P7 a8 D1 {
33.     default:
    ; W% C& `0 d4 Y& e6 ]
34.     break;
    . C6 B4 b- n$ T: u
35.   }  
    # \0 o, n  K& N7 t* ^  N
36.   /* 使能输入捕获通道 */
    ! Y% E& W! G1 ~, d) R0 N- m
37.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
38. 
    1 I8 a- S. J, B+ W
39.   /* 使能定时器 */
    3 u/ w! B6 Q. ]! q- R9 r) L
40.   __HAL_TIM_ENABLE(htim);  
    
41. 
    % }4 H; H' A# @  W& v6 Q- }( E
42.   /* 返回状态 */
    & j& E8 p/ ?& v% y" D
43.   return HAL_OK;  
    
44. }

复制代码

函数描述：
7 M7 C$ s5 f& e2 Q
; Q  ]8 s3 c, ?8 Q0 g) ]' p4 R, s此函数用于启动定时器输入捕获模式，采用定时器方式。
+ D+ c' m  t# N8 n0 P* t
1 w1 z# `/ k+ T2 p2 w函数参数：

0 g" E9 @* r$ c: h% N9 t& r2 `  B  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
$ e& Y/ Z( u" N. n' p8 s  第2个参数是通道设置，支持以下参数：
! t! N; e; k* ?* B9 v8 qTIM_CHANNEL_1

0 D. W  d0 H* H7 FTIM_CHANNEL_2
$ \- C5 |( Y6 c
9 A" X9 g8 M' u3 l+ RTIM_CHANNEL_3

TIM_CHANNEL_4
7 h# ?- I9 Q7 Y3 e* Q% r# r; `
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。

32.4.9 函数HAL_TIM_OC_Init
5 k- z; U9 @5 A8 D3 n3 b函数原型：

  y) d+ b7 @$ E" g- I, V1 G/ t

1. HAL_StatusTypeDef HAL_TIM_OC_Init(TIM_HandleTypeDef* htim)
   # Q, v: ^+ n6 \1 b0 D) F$ F0 [; e% H
2. {
   
3.   /* 检测形参是否有效 Check */
   
4.   if(htim == NULL)
   
5.   {
   + m4 z  K/ R7 `6 D$ s4 U& z/ Q
6.     return HAL_ERROR;
   , z% I' a" u) c/ S) u+ {
7.   }
   
8. 
   9 l/ {! }# I9 Q! G7 z! ]4 W8 G# h
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. 
    7 a% j, S4 u% r
14.   if(htim->State == HAL_TIM_STATE_RESET)
    6 K+ W5 O( A3 x3 J2 c- v
15.   {
    
16. /* 默认取消锁 */
    ( b) V4 r) X3 u+ p5 j% ^2 n& H
17.     htim->Lock = HAL_UNLOCKED;
    
18. 
    : O* p& @) _' N6 j1 J  `* e
19. /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    & W+ ~0 |( r8 L$ c
20.     HAL_TIM_OC_MspInit(htim);
    ; P9 ^' B+ }6 p- e% p& [: s& j
21.   }
    
22. 
    5 j- ^/ V2 W: I1 j
23.   /* 设置定时器状态Set the TIM state */
    
24.   htim->State= HAL_TIM_STATE_BUSY;
    
25. 
    
26.   /* 配置定时器为输出比较模式Init the base time for the Output Compare */  
    % C( M% ~. u* f" {+ g
27.   TIM_Base_SetConfig(htim->Instance,  &htim->Init);
    0 v! b* X. n; B8 X: I
28. 
    4 a# q) l% b6 L$ [6 O2 k4 R
29.   /* 设置定时器状态 */
    
30.   htim->State= HAL_TIM_STATE_READY;
    
31. 
    
32.   return HAL_OK;
    : }4 X- ?7 u- H9 p5 B. W
33. }

复制代码

函数描述：
! p" z3 v3 Y9 o! I
此函数用于定时器输出比较初始化。

8 z$ o0 ~8 G! A- P1 Q" z) Q" f函数参数：

4 p' X0 ~3 E9 t5 A% k+ j  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
9 `5 z( y$ W* R! O! D注意事项：

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

解决办法有三：
! \) x3 O* @$ |
方法1：用户自己初始定时器和涉及到的GPIO等。
+ k2 {6 ^. W, k7 K) m" L* n
方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

& {) {7 ~+ f! M& [方法3；下面的方法
# i. ?) O9 b0 j5 V

1. if(HAL_TIM_OC_DeInit(&UartHandle) != HAL_OK)
   
2. {
   $ F$ ]# X# J* n: z' Y' ]6 E. I
3.     Error_Handler();
   
4. }  
   ' ]4 f% q4 U5 W0 |$ P' j
5. if(HAL_TIM_OC_Init(&UartHandle) != HAL_OK)
   0 N. A* B- n  I4 o
6. {
   
7.     Error_Handler();
   
8. }

复制代码

32.4.10   函数HAL_TIM_OC_ConfigChannel
函数原型：
1 q! X$ V$ U. W, C! w! J

1. HAL_StatusTypeDef HAL_TIM_OC_ConfigChannel(TIM_HandleTypeDef *htim,
   . d, ]' Z& S5 J9 M* g; Q
2.                                            TIM_OC_InitTypeDef* sConfig,
   " [3 c4 c9 |$ r* D9 `0 C! R
3.                                            uint32_t Channel)
   - `+ `0 O, C9 l8 w0 S$ G* u
4. {  
   2 m9 |7 c+ h* j  y6 v1 p) @, z
5.   /* Check the parameters */
   " n" \. e2 M% Q! a
6.   assert_param(IS_TIM_CHANNELS(Channel));
   
7.   assert_param(IS_TIM_OC_MODE(sConfig->OCMode));
     N: T: X7 y5 L+ Q+ w) w
8.   assert_param(IS_TIM_OC_POLARITY(sConfig->OCPolarity));
   . {4 D( e1 Z5 w* Z& J
9. 
   
10.   /* Process Locked */
    5 V9 r7 W1 ^- ~6 d* g
11.   __HAL_LOCK(htim);
    ) o7 Z/ P* K% v2 r- Q. `3 W
12. 
    
13.   htim->State = HAL_TIM_STATE_BUSY;
    ) E9 Y5 P6 }" h! V, Z9 |3 K& H
14. 
    . q6 |" _( ~, \; ?1 D
15.   switch (Channel)
    5 m7 ]( Z+ z4 ]% P2 ?  u- P! R
16.   {
    ; j3 Z1 y0 R+ S) o, |2 A+ Y
17.     case TIM_CHANNEL_1:
    / m) p0 ^8 v9 W2 X$ _
18.     {
    
19.       /* 检测参数Check the parameters */
    9 y7 x& z- {) {) _
20.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    ! I; V5 u6 o) U7 B
21. 
    
22.      /* 配置定时器输出比较通道1 */
    
23.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    
24.     }
    % O3 [% X1 J0 x- o. A- u
25.     break;
    
26. 
    0 U0 c- n3 @" d. ]& R" u8 |3 V) |+ C
27.     case TIM_CHANNEL_2:
    
28.     {
    " S7 G/ }  t7 I" T+ {7 ?( g# l0 i
29.       /* 省略 */
    
30.     }
    & m1 F. ]5 v+ b
31.     break;
    
32. 
    # ~+ s+ C& u% ]/ X) _- b
33.     case TIM_CHANNEL_3:
    
34.     {
    
35.       /* 省略 */
    " X8 x7 }0 n: n- D8 [0 F
36.     }
    
37.     break;
    ! v- F/ V7 _: d! u% h- w: e5 s# m
38. 
    
39.     case TIM_CHANNEL_4:
    1 i# x2 |. Q- F+ X/ S
40.     {
    * Y- f& R% p. r& p+ H9 d7 }
41.       /* 省略 */
    2 H& e$ e6 _, K% ^
42.     }
    
43.     break;
    
44. 
    
45.     case TIM_CHANNEL_5:
    / u1 q' A1 L$ O
46.     {
    ! C: ^: [6 h6 c* w8 a3 C
47.       /* 省略 */
    , [3 {; I9 Q" C! V
48.     }
    
49.     break;
    
50. 
    * J0 K2 A2 L. s
51.     case TIM_CHANNEL_6:
    
52.     {
    1 D) q; u' ^$ _5 \  ?
53.       /* 省略 */
    + G. e) v* p4 ]  h
54.     }
    
55.     break;
    8 H" m9 |( p7 X* [+ C
56. 
    " b: k7 q  Y& e7 c3 h7 `* o& k$ o
57.     default:
    ' b2 m* t) t, c) y
58.     break;   
    * s9 ^: q8 J: M6 [" W
59.   }
    
60. 
    8 h# b9 C/ Q. K/ O( b, k) o
61.   htim->State = HAL_TIM_STATE_READY;
    
62. 
    7 b, n: Z1 w8 [& B7 Y
63.   __HAL_UNLOCK(htim);
    
64. 
    
65.   return HAL_OK;
    5 _3 G( U$ r$ E5 B4 a
66. }

复制代码

函数描述：
% f. T: f4 M+ ^* N: u! G: s
, U  d, ?, c" C8 s# P此函数用于初始化串口的基础特性和高级特性。

函数参数：
* k. v1 V$ G3 f% n9 w4 [
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
  R" }/ p9 @" C1 b3 G3 Y9 s  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
/ `# h1 F+ r" q7 G/ d) F  第3个参数是通道设置，支持以下参数：
, ~& L9 S' w; vTIM_CHANNEL_1
! h  W, h; T# B& k. J4 P7 m% Y
3 T9 L1 ?; T' D0 _TIM_CHANNEL_2
! ~0 D6 r: P  z2 c6 B7 ~3 U; g
TIM_CHANNEL_3

$ u& c2 U- d4 j+ r, MTIM_CHANNEL_4

1 Q0 ?  i  t& a2 ?0 k+ fTIM_CHANNEL_5

TIM_CHANNEL_6
  D2 m5 o5 X0 K6 P2 `% ^
" o5 c" Z9 V4 a1 U% G8 a5 q  d  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
& ?8 d' P3 g; ~- ^1 X+ x* ~2 `
32.4.11   函数HAL_TIM_OC_Start
函数原型：

1. HAL_StatusTypeDef HAL_TIM_OC_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
   
2. {
   ) f3 \8 V$ G8 d
3.   /* 检查参数 */
   0 u  x! P( a7 ?6 `$ b5 S* p
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   3 d/ D# `  G) b7 w8 N
5. 
   4 X# m  ^$ V  v4 W) d/ h
6.   /* 使能输出比较通道 */
   3 D1 L% X/ n0 w6 [9 S8 M0 B
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
8. 
   5 q* l# m0 Y" s* J$ w* P/ \
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
   * R& {; m7 B/ G) {- J4 t
10.   {
    ! f. j$ z5 a8 n: Z& S
11.     /* 使能主输出 */
    
12.     __HAL_TIM_MOE_ENABLE(htim);
    
13.   }
    2 D  Y/ g+ v9 c! b' u& S
14. 
    
15.   /* 使能定时器 */
    2 ?9 w% c" z, K
16.   __HAL_TIM_ENABLE(htim);
    : L! B7 G8 Y2 }6 Y, o
17. 
    5 [; e/ K( s" ~6 S& r( T, t4 A
18.   /* 返回状态 */
    ! x. `6 e. n: T7 Y/ _' o! j
19.   return HAL_OK;
    ; Z( f5 W6 M7 N* I9 T& d
20. }

复制代码

) p6 m& G6 X6 Q% x% H* n函数描述：
( E$ g2 i$ Z8 u4 W
此函数用于启动定时器输出比较模式。
* V+ @4 ~% u# t) f
& F6 r4 f, u! Z7 Q4 o函数参数：
/ l0 O" ]9 Q% Z! f% R
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
6 ]: M) w" r8 m& C, X0 ^  第2个参数是通道设置，支持以下参数：
TIM_CHANNEL_1

TIM_CHANNEL_2

) ^5 D3 w: G, BTIM_CHANNEL_3
# E' X# h$ Z6 x
TIM_CHANNEL_4

! c0 x# q3 W. I; Y5 {0 H) I9 T! L; Y  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
" x4 v1 m9 u2 A% Z
* |' h7 A. r9 `32.5 总结
本章节就为大家讲解这么多，建议大家将GPIO的驱动源码结合参考手册中的寄存器通读一遍，对于我们后面章节的学习大有裨益。

  A. j# C2 p/ ]% O* _; N$ x
# S, h# Z' @+ I; u