32.1 初学者重要提示
' z$ K2 ~8 q1 x( @. z( R8 S6 C  学习定时器外设推荐从硬件框图开始了解基本的功能特性，然后逐步深入了解各种特性，这种方式方便记忆和以后查阅。
  STM32H7的定时器输出100MHz方波是完全没问题。
; D. O* @, t( `# P0 j, T  STM32H7定时器进出中断的速度能跑到12.5MHz，所有程序在TCM和Flash运行没差别。
; B  |& R0 H$ U* ~  STM32H7的定时器输入捕获可以实现12MHz方波的双边沿捕获，单边沿可以做到24MHz。
  特别注意STM32H7的TIM1,8,15,16,17才有RCR重复计数器，其它都没用的。
/ }, G" k6 M+ r0 R7 ~5 R% o  STM32H7的单个定时器中不同通道可以配置不同频率PWM。
0 m/ W' B; @) N/ e9 B  STM32H7的TIM1-TIM17中断入口函数名使用时要注意，别搞错了：

1. TIM1_BRK_IRQHandler            
   
2. TIM1_UP_IRQHandler              
   ! Z5 F6 C9 Z% ]5 ?5 x8 ?4 i, `
3. TIM1_TRG_COM_IRQHandler        
   
4. TIM1_CC_IRQHandler                                                   
   
5. TIM2_IRQHandler                                          
   ; r5 I3 m8 p- X* ~+ ^6 v. q
6. TIM3_IRQHandler                                                
   
7. TIM4_IRQHandler                 
   
8. TIM5_IRQHandler            
   
9. TIM6_DAC_IRQHandler           <------------------要注意            
   ! z6 F+ [' }  Q9 w5 R6 D1 `
10. TIM7_IRQHandler
    
11. TIM8_BRK_TIM12_IRQHandler      <------------------要注意，定时器12也是用的这个
    
12. TIM8_UP_TIM13_IRQHandler       <------------------要注意，定时器13也是用的这个
    
13. TIM8_TRG_COM_TIM14_IRQHandler  <------------------要注意，定时器14也是用的这个
    
14. TIM8_CC_IRQHandler         
    
15. TIM15_IRQHandler
    
16. TIM16_IRQHandler
    
17. TIM17_IRQHandler

复制代码

6 Z4 A9 Y* R* t& H32.2 定时器基础知识
注，不同定时支持的功能略有区别，基础定时器功能较少，TIM1和TIM8高级定时器功能多些。

  TIM2和TIM5是32位定时器，其它定时器都是16位定时器。16位和32位的区别是CNT计数器范围不同，32位的范围是0 到2^32 – 1，而16位的是0到65535；它们支持的分频是范围是一样的，都是1到65535。
3 g6 t. a6 j! a8 \+ P9 W' E  计数器支持递增、递减和递增/递减二合一。
  多个独立通道，可用于：
' w( n: y) A! o( ]" ]3 l* @– 输入捕获。
. Y/ `" n  W0 `5 U( u* u. r  I
– 输出比较。

– PWM 生成（边沿和中心对齐模式）。

2 q1 C1 Y! ]! T& \' z– 单脉冲模式输出。
# O( D+ M# q& Z2 Z3 Z( x7 a7 {
  带死区插入，断路功能和PWM互补输出
  发生如下事件时生成中断/DMA 请求：
9 `5 V. p+ e- h7 C0 ^( m– 更新：计数器上溢/下溢、计数器初始化（通过软件或内部/外部触发）

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

– 输入捕获
8 n# j3 _4 e. r- o
– 输出比较

  支持增量式编码器和霍尔传感器。
, L) R# y; Q5 I0 `% Z+ a32.2.1 定时器TIM1-TIM17的区别
, Y3 G( |$ O, K: |- r! bSTM32H7支持的定时器有点多，要简单的区分下。STM32H7支持TIM1-TIM8，TIM12-TIM17共14个定时器，而中间的TIM9，TIM10，TIM11是不存在的，这点要注意。
, E; \( Z) k$ X4 j
& p/ t* D3 t( A粗略的比较如下：
1 _/ A% k, d5 m! j/ Q2 G" l

* A, ]3 m6 R, }% e( N
8 y" q! s5 p' L& \# x5 E

# Y& k& K$ b0 s- D* [) C. L$ i
通过上面的表格，至少要了解到以下两点：

8 P* u) ]& f5 c1 X  STM32H7的定时器主要分为高级定时器，通用定时器，基础定时器和低功耗定时器。
/ U5 d" x2 F8 K; G  TIM2和TIM5是32位定时器，其它都是16位定时器。
$ i1 z: {" b% h2 l' F2 O8 p
; b/ D( W: ?+ |+ X, v8 B32.2.2 定时器的硬件框图
" V" V* l* \7 l# x认识一个外设，最好的方式就是看他的框图，方便我们快速的了解定时器的基本功能，然后再看手册了解细节。
( `6 n" p+ i; t# G
下面我们直接看最复杂的高级定时器TIM1&TIM8框图：

/ f* u, v" u, ~: T  {通过这个框图，我们可以得到如下信息：
$ a5 Q6 L" u3 A( A8 W( ~" k4 [
  TIMx_ETR接口
0 x3 [7 I5 S# Y; {2 `' O* n! }8 ]- |外部触发输入接口。ETR支持多种输入源：输入引脚（默认配置）、比较器输出和模拟看门狗。

8 U2 y$ H- |2 y; T8 I: h8 c

5 b5 o" h  }% H8 b, t) `  截图左侧的TIMx_CH1，TIMx_CH2，TIMx_CH3和TIMx_CH4接口
这四个通道主要用于输入捕获，可以计算波形频率和脉宽。                                                                                                                             
6 P2 e. C, B5 C5 b+ G" I+ @" ~$ K
  TIMx_BKIN和TIMx_BKIN2接口
断路功能，主要用于保护由 TIM1 和 TIM8 定时器产生的 PWM 信号所驱动的功率开关
2 @( M. ]# p. b* a# C2 U
  TRGO内部输出通道
) C9 a4 S  f; R% a, N; Q8 N4 `主要用于定时器级联，ADC和DAC的定时器触发。
' w2 c$ F7 v2 F, u( M
: [7 F* G' S* B  ~  6组输出比较单元OC1到OC6
OC1到OC4有对应的输出引脚，而OC5和OC6没有对应的输出引脚，主要用于内部控制。

- {6 J  B$ ?. k) h+ {* u2 ^- I  截图右侧的输出比较通道TIMx_CH1，TIMx_CH1N，TIMx_CH2，TIMx_CH2N，TIMx_CH3，TIMx_CH3N和TIMx_CH4
主要用于PWM输出，注意CH1到CH3有互补输出，而CH4没有互补输出。

, S' J2 K' X1 g6 p- s+ U  其它框图里面未展示出来功能
定时器TIM1&TIM8还支持的其它功能在用到的时候再做说明。
: j+ {! d! G5 K8 \4 U9 c
7 P0 a4 v2 M' Q' @6 a! l32.2.3 定时器的时基单元
. t6 s, d% |$ U定时器要工作就需要一个基本时基单元，而基本的时基单元是由下面几个寄存器组成的：

% i4 j. H& J) H" a. o! \  预分频器寄存器 (TIMx_PSC)
用于设置定时器的分频，比如定时器的主频是200MHz，通过此寄存器可以将其设置为100MHz，50MHz，25MHz等分频值。

4 d" ~! N1 m5 w9 k; l/ _  X注：预分频器有个缓冲功能，可以让用户实时更改，新的预分频值将在下一个更新事件发生时被采用（以递增计数模式为例，就是CNT计数值达到ARR自动重装寄存器的数值时会产生更新事件）。
2 i% f: H, `# e4 a) O+ y, y
- b6 W% m2 X/ O- [( V  计数器寄存器 (TIMx_CNT)
计数器是最基本的计数单元，计数值是建立在分频的基础上面，比如通过TIMx_PSC设置分频后的频率为100MHz，那么计数寄存器计一次数就是10ns。
  T9 ^1 x% e( q! A
* b4 o* e" e9 Q  自动重载寄存器 (TIMx_ARR)
0 @+ D$ [" t! I( N自动重装寄存器是CNT计数寄存器能达到的最大计数值，以递增计数模式为例，就是CNT计数器达到ARR寄存器数值时，重新从0开始计数。

注，自动重载寄存器是预装载的。对自动重载寄存器执行写入或读取操作时会访问预装载寄存器。预装载寄存器的内容既可以立即传送到影子寄存器（让设置立即起到效果的寄存器），也可以在每次发生更新事件时传送到影子寄存器。简单的说就是让ARR寄存器的数值立即更新还是更新事件发送的时候更新。
; g5 h! ^# k5 D8 t3 W
  重复计数器寄存器 (TIMx_RCR)
+ Q4 s' P1 M. B; f& c以递增计数模式为例，当CNT计数器数值达到ARR自动重载数值时，重复计数器的数值加1，重复次数达到TIMx_RCR+ 1后就，将生成更新事件。
+ Y+ i: a# k  E" i, q; g, ]3 h; @
注，只有TIM1，TIM8，TIM15，TIM16，TIM17有此寄存器。
9 @0 R8 r* D/ s& Z* t3 b
比如我们要配置定时器实现周期性的中断，主要使用这几个寄存器即可。

32.2.4 定时器输出比较（PWM）
使用定时器时基单元的那几个寄存器仅仅能设置周期，还不能设置占空比。针对这个问题，还需要比较捕获寄存CCR的参与，这样就可以设置占空比了。
4 b8 {" {; L) J5 U: H# T6 W& w, R
为了方便大家理解，以PWM 边沿对齐模式，递增计数配置为例：
* b7 j8 o5 d6 i. y) d1 l: M  [0 ^5 e2 ~
  当计数器TIMx_CNT < 比较捕获寄存器TIMx_CCRx期间，PWM参考信号OCxREF输出高电平。
  当计数器TIMx_CNT >= 比较捕获寄存器TIMx_CCRx期间， PWM参考信号OCxREF输出低电平。
  当比较捕获寄存器TIMx_CCRx > 自动重载寄存器TIMx_ARR，OCxREF保持为1。
  当比较捕获寄存器TIMx_CCRx = 0，则OCxRef保持为0。
下面是TIMx_ARR=8的波形效果：
6 s( x4 ^4 ?8 M) H

32.2.5 定时器输入捕获
与PWM一样，使用定时器实现输入捕获，仅靠时基单元的那几个寄存器是不行的，我们需要一个寄存器来记录发生捕获时的具体时间，这个寄存器依然由比较捕获寄存器TIMx_CCRx来实现。
# V& u" p, c0 E* t% X. s: c2 Z, Z
6 l- f  W0 ]! d9 g' X5 f  x比如我们要测量一路方波的周期：

  配置定时器为输入捕获模式，上升沿触发，设置分频，自动重装等寄存器，比如设置的CNT计数器计数1次是1微秒。
  当有上升沿触发的时候，TIMx_CCRx寄存器就会自动记录当前的CNT数值，然后用户就可以通过CC中断，在中断复位程序里面保存当前的TIMx_CCRx寄存器数值。等下次再检测到上升沿触发，两次时间求差就可以得到方波的周期。
  X, i$ N3 Q5 v0 R不过这里要特别注意一点，如果CNT发生溢出（比如16位定时器，计数到65535就溢出了）就需要特别处理下，将CNT计数溢出考虑进来。
+ m) ?! T- l6 Z4 y7 m  T- @
32.3 定时器的HAL库用法
$ k. ^1 F: c7 {9 I1 E; {' i定时器的HAL库用法其实就是几个结构体变量成员的配置和使用，然后配置GPIO、时钟，并根据需要配置NVIC、中断和DMA。下面我们逐一展开为大家做个说明。
+ ?8 a9 ~1 b5 K. Y* g
  T. q6 z1 y! X32.3.1 定时器寄存器结构体TIM_TypeDef
定时器相关的寄存器是通过HAL库中的结构体TIM_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：

4 h  `; O, t0 J* C/ Q: F3 p# g5 Z

1. typedef struct
   
2. {
   
3.   __IO uint16_t CR1;         /*!< TIM control register 1,                   Address offset: 0x00 */
   
4.   uint16_t      RESERVED0;   /*!< Reserved, 0x02                                                 */
   
5.   __IO uint32_t CR2;         /*!< TIM control register 2,                   Address offset: 0x04 */
   
6.   __IO uint32_t SMCR;        /*!< TIM slave mode control register,          Address offset: 0x08 */
   
7.   __IO uint32_t DIER;        /*!< TIM DMA/interrupt enable register,        Address offset: 0x0C */
   ; Y  Q# L3 [. |( i$ |
8.   __IO uint32_t SR;          /*!< TIM status register,                      Address offset: 0x10 */
   6 l% p6 A/ G+ v! b
9.   __IO uint32_t EGR;         /*!< TIM event generation register,            Address offset: 0x14 */
   
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 */
    2 l% p1 l) s5 }9 b* O9 O0 }
12.   __IO uint32_t CCER;        /*!< TIM capture/compare enable register,      Address offset: 0x20 */
    * v: a( O0 c( S2 R+ A# B
13.   __IO uint32_t CNT;         /*!< TIM counter register,                     Address offset: 0x24 */
    
14.   __IO uint16_t PSC;         /*!< TIM prescaler,                            Address offset: 0x28 */
    ' h3 v, O2 h: j6 j. Q  t
15.   uint16_t      RESERVED9;   /*!< Reserved, 0x2A                                                 */
    * G+ e3 z" c- z! E) s# r
16.   __IO uint32_t ARR;         /*!< TIM auto-reload register,                 Address offset: 0x2C */
    
17.   __IO uint16_t RCR;         /*!< TIM repetition counter register,          Address offset: 0x30 */
      @/ Z- q* j; y5 q5 L3 j
18.   uint16_t      RESERVED10;  /*!< Reserved, 0x32                                                 */
    
19.   __IO uint32_t CCR1;        /*!< TIM capture/compare register 1,           Address offset: 0x34 */
    3 f. U% Z& G' g+ \
20.   __IO uint32_t CCR2;        /*!< TIM capture/compare register 2,           Address offset: 0x38 */
    0 n# H* m( D: ]) O! F
21.   __IO uint32_t CCR3;        /*!< TIM capture/compare register 3,           Address offset: 0x3C */
    
22.   __IO uint32_t CCR4;        /*!< TIM capture/compare register 4,           Address offset: 0x40 */
    
23.   __IO uint32_t BDTR;        /*!< TIM break and dead-time register,         Address offset: 0x44 */
    2 ^  J6 l) M2 c7 e6 |6 L+ t# w' }
24.   __IO uint16_t DCR;         /*!< TIM DMA control register,                 Address offset: 0x48 */
    + \) L, F, L' s+ ?5 u
25.   uint16_t      RESERVED12;  /*!< Reserved, 0x4A                                                 */
    ; Q# S1 ]+ l; f$ a* o$ g
26.   __IO uint16_t DMAR;        /*!< TIM DMA address for full transfer,        Address offset: 0x4C */
    
27.   uint16_t      RESERVED13;  /*!< Reserved, 0x4E                                                 */
    * D. A- W& t/ \9 \/ t5 H
28.   uint16_t      RESERVED14;  /*!< Reserved, 0x50                                                 */
    
29.   __IO uint32_t CCMR3;       /*!< TIM capture/compare mode register 3,      Address offset: 0x54 */
    
30.   __IO uint32_t CCR5;        /*!< TIM capture/compare register5,            Address offset: 0x58 */
    
31.   __IO uint32_t CCR6;        /*!< TIM capture/compare register6,            Address offset: 0x5C */
    
32.   __IO uint32_t AF1;         /*!< TIM alternate function option register 1, Address offset: 0x60 */
    ' _9 k) u5 q* O3 V9 n1 o# _
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 */
    2 I& Y- F6 {/ V" q9 f/ r: V
35. } TIM_TypeDef;

复制代码

2 x0 }: S3 K6 a- q0 i% C- F这个结构体的成员名称和排列次序和CPU的定时器寄存器是一 一对应的。
! x- T; e: `& w( m: f
$ y& W6 o4 S: E__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：

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

复制代码

下面我们看下定时器的定义，在stm32h743xx.h文件。
- Z  K: ?3 A4 Z
, n  L# A2 t5 f

1. #define PERIPH_BASE         ((uint32_t)0x40000000)
   4 ^1 R4 U$ i  o* L9 ~" |- t3 C: m
2. #define D2_APB1PERIPH_BASE   PERIPH_BASE
   
3. #define D2_APB2PERIPH_BASE   (PERIPH_BASE + 0x00010000)
   
4. 
   
5. /*!< D2_APB1PERIPH 外设 */
   
6. #define TIM2_BASE             (D2_APB1PERIPH_BASE + 0x0000) <----- 展开这个宏，(TIM_TypeDef *) 0x40000000
   4 l, n6 w  g) g% V
7. #define TIM3_BASE             (D2_APB1PERIPH_BASE + 0x0400)
   5 ], `0 ?" a' ^6 @- H7 W
8. #define TIM4_BASE             (D2_APB1PERIPH_BASE + 0x0800)
   4 y& G+ A$ H! _' l& M* r
9. #define TIM5_BASE             (D2_APB1PERIPH_BASE + 0x0C00)
   
10. #define TIM6_BASE             (D2_APB1PERIPH_BASE + 0x1000)
    ' {' x8 Y- S* X4 T- y. y% y' A! I
11. #define TIM7_BASE             (D2_APB1PERIPH_BASE + 0x1400)
    
12. #define TIM12_BASE            (D2_APB1PERIPH_BASE + 0x1800)
    
13. #define TIM13_BASE            (D2_APB1PERIPH_BASE + 0x1C00)
    9 Q; x6 ^# A4 Y( ~8 F8 G5 J
14. #define TIM14_BASE            (D2_APB1PERIPH_BASE + 0x2000)
    4 o4 t  |; M8 s& ^3 Q9 f0 M
15. 
    
16. /*!< D2_APB1PERIPH 外设 */
    
17. #define TIM1_BASE             (D2_APB2PERIPH_BASE + 0x0000)
    ) S0 d5 V  \% @
18. #define TIM8_BASE             (D2_APB2PERIPH_BASE + 0x0400)
    
19. #define TIM15_BASE            (D2_APB2PERIPH_BASE + 0x4000)
    / C3 i. q- t9 p- q% f" w" T
20. #define TIM16_BASE            (D2_APB2PERIPH_BASE + 0x4400)
    
21. #define TIM17_BASE            (D2_APB2PERIPH_BASE + 0x4800)
    & w6 [  f# I6 U2 [
22. 
    
23. #define TIM1                ((TIM_TypeDef *) TIM1_BASE)
    ; L4 l9 l1 [9 p
24. #define TIM2                ((TIM_TypeDef *) TIM2_BASE)
    ' v7 {; ~0 f2 Q' f3 h
25. #define TIM3                ((TIM_TypeDef *) TIM3_BASE)
    
26. #define TIM4                ((TIM_TypeDef *) TIM4_BASE)
    
27. #define TIM5                ((TIM_TypeDef *) TIM5_BASE)
    
28. #define TIM6                ((TIM_TypeDef *) TIM6_BASE)
    
29. #define TIM7                ((TIM_TypeDef *) TIM7_BASE)
    
30. #define TIM8                ((TIM_TypeDef *) TIM8_BASE)
    
31. #define TIM12               ((TIM_TypeDef *) TIM12_BASE)
    
32. #define TIM13               ((TIM_TypeDef *) TIM13_BASE)
    * U* @' B& Z3 j8 H) L* O- R% A& L
33. #define TIM14               ((TIM_TypeDef *) TIM14_BASE)
    
34. #define TIM15               ((TIM_TypeDef *) TIM15_BASE)
    
35. #define TIM16               ((TIM_TypeDef *) TIM16_BASE)
    
36. #define TIM17               ((TIM_TypeDef *) TIM17_BASE)

复制代码

2 J& c: p& I4 y1 s1 f' _5 J我们访问TIM2的CR1寄存器可以采用这种形式：TIM2->CR1 = 0；
/ w/ R$ l; f% C$ j! o
32.3.2 定时器句柄结构体TIM_HandleTypeDef
. ^7 p/ M: ?0 l. qHAL库在TIM_TypeDef的基础上封装了一个结构体TIM_HandleTypeDef，定义如下：

$ h1 w6 S( v- Z

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                    */
   
6. 
   
7. /*!< DMA Handlers array This array is accessed by a @ref DMA_Handle_index */
   3 `' [% S+ ?5 c+ |
8.   DMA_HandleTypeDef        *hdma[7];      
   # O* w1 ]& ]( Y
9.   HAL_LockTypeDef          Lock;          /*!< Locking object                    */
   * W2 H- z3 k. h5 L: X! z; n1 e; x
10.   __IO HAL_TIM_StateTypeDef   State;      /*!< TIM operation state               */  
    0 g$ ?' ?% A) L
11. }TIM_HandleTypeDef;

复制代码

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

  TIM_TypeDef  *Instance
6 b3 C  f' [2 X, j/ Y6 B% b
这个参数是寄存器的例化，方便操作寄存器，比如使能定时器的计数器。

3 N3 R4 q# k' kSET_BIT(huart->Instance->CR1,  TIM_CR1_CEN)。
6 Q; j& R! @. v6 D
4 k2 {2 I. t4 h( A* V: g& I  TIM_Base_InitTypeDef  Init

这个参数是用户接触最多的，用于配置定时器的基本参数。
2 }! H1 P& _" ?: R( E9 ?
$ C$ }+ H3 b4 {# T6 Q8 o  ?7 {TIM_Base_InitTypeDef结构体的定义如下：
* h0 E/ s0 F  w1 {6 A4 i

1. typedef struct
   
2. {
   
3.   uint32_t Prescaler;      
   
4.   uint32_t CounterMode;   
   & b( S- }3 X; T9 j& G+ q
5.   uint32_t Period;         
   3 h, j. s& l' L' a; Z4 |1 f  k
6.   uint32_t ClockDivision;   
   9 ~4 p8 L$ k3 G6 H+ m( C4 O
7.   uint32_t RepetitionCounter;
   
8.   uint32_t AutoReloadPreload;  
   $ Y3 P/ F9 K1 `3 ?: d# A+ |
9. } TIM_Base_InitTypeDef;

复制代码

& ]* r9 g' S7 c8 P0 S( v) l  成员Prescaler
用于设置定时器分频，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。

  成员CounterMode
用于设置计数模式，向上计数模式、向下计数模式和中心对齐模式。

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 */
   
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。
0 P! d# S$ @" F5 s
  成员ClockDivision
: @6 X0 s) N9 r1 V5 L% a1 N5 E用于指示定时器时钟 (CK_INT) 频率与死区发生器以及数字滤波器（ETR、TIx）所使用的死区及采样时钟 (tDTS) 之间的分频比。
% \& W2 B' C* ]" h, X
% P0 q, u! N! i4 a1 @. k& n

1. #define TIM_CLOCKDIVISION_DIV1       ((uint32_t)0x0000U)        /*!< Clock Division DIV1 */
   
2. #define TIM_CLOCKDIVISION_DIV2       (TIM_CR1_CKD_0)            /*!< Clock Division DIV2 */
   6 g! S- X& [5 U/ P
3. #define TIM_CLOCKDIVISION_DIV4       (TIM_CR1_CKD_1)             /*!< Clock Division DIV4 */

复制代码

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

0 B  a$ ~1 |2 X% S  成员AutoReloadPreload
用于设置定时器的ARR自动重装寄存器是更新事件产生时写入有效还是立即写入有效。如果使能了表示更新事件产生时写入有效，否则反之。
; a1 ^. c+ c: L

1. #define TIM_AUTORELOAD_PRELOAD_DISABLE   ((uint32_t)0x0000U)   /*!< TIMx_ARR register is not buffered */
   , |' Z; b' h' l3 O5 X; T5 o/ G
2. #define TIM_AUTORELOAD_PRELOAD_ENABLE    (TIM_CR1_ARPE)        /*!< TIMx_ARR register is buffered */

复制代码

. S& I% ^/ v3 e, L0 F  HAL_TIM_ActiveChannel    Channel;
3 o; Q; S5 m7 _# F% R; I
用于设置定时器通道，比如TIM1和TIM8都是6个通道。
, j7 m. u: ]% k- }1 v
) J+ C' h* f& s' N# _; n; {

1. typedef enum
   
2. {
   : _' H& _' l2 c/ j  N8 U
3.   HAL_TIM_ACTIVE_CHANNEL_1        = 0x01U,    /*!< The active channel is 1     */
   ' E( ~6 ]# n5 Q0 Z
4.   HAL_TIM_ACTIVE_CHANNEL_2        = 0x02U,    /*!< The active channel is 2     */
   ! J" e' i3 E) P
5.   HAL_TIM_ACTIVE_CHANNEL_3        = 0x04U,    /*!< The active channel is 3     */   
   2 R+ M; ^; V  s; v7 Y" M8 c
6.   HAL_TIM_ACTIVE_CHANNEL_4        = 0x08U,    /*!< The active channel is 4     */
   
7.   HAL_TIM_ACTIVE_CHANNEL_5        = 0x10U,    /*!< The active channel is 5     */
   $ h. z4 s& L& \1 C4 v# Q
8.   HAL_TIM_ACTIVE_CHANNEL_6        = 0x20U,    /*!< The active channel is 6     */
   
9.   HAL_TIM_ACTIVE_CHANNEL_CLEARED  = 0x00U     /*!< All active channels cleared */   
   
10. }HAL_TIM_ActiveChannel;
    ) B9 [6 s/ ^' N
11.   DMA_HandleTypeDef        *hdma[7];

复制代码

用于关联DMA。
6 w7 U, B: X- Q
配置定时器参数，其实就是配置结构体TIM_HandleTypeDef的成员。
7 q6 t" x. [$ Y% a: T9 Z* i) }' [

1. TIM_HandleTypeDef   TimHandle = {0};
   1 A; o) F  d0 C
2. 
   ( v4 D  z! Q) D% H( d9 {$ m- _( v
3. /*
     v% a1 A/ A$ ?( [. q
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   ) E5 }) Q& n- ~9 K" p
6. TimHandle.Instance = TIMx;
   ! ~" N+ k* m) r1 u6 }2 `  @
7. TimHandle.Init.Prescaler         = usPrescaler;
   $ Z( k0 r, q1 L$ g
8. TimHandle.Init.Period            = usPeriod;        
   1 B9 x% n2 [" r- j
9. TimHandle.Init.ClockDivision     = 0;
   5 b  |% G/ t; K. u
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
      v3 }% C. p& Q( p  \  D
11. TimHandle.Init.RepetitionCounter = 0;
    
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
      ]" }+ s7 }# G: ^5 K( E/ Z: y! J
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    % I* ^+ w8 p9 }( U& f" Y0 J
14. {
    
15.         Error_Handler(__FILE__, __LINE__);
    : q/ ~: I- G/ c
16. }

复制代码

5 l0 N5 O- n* Y7 K1 f! {" r1 Q  T32.3.3 定时器输出比较结构体TIM_OC_InitTypeDef
* D, S7 U' k8 f7 D此结构体主要用于定时器的输出比较，定义如下：
- m3 |$ ]/ C0 X& H# L% t

1. typedef struct
   
2. {                                 
   ; ~3 [) Z7 V' ~! K2 [! h7 n
3.   uint32_t OCMode;      
   
4.   uint32_t Pulse;      
   
5.   uint32_t OCPolarity;   
   
6.   uint32_t OCNPolarity;   
   # e( l9 n# f: e9 Q: r) v% |1 k
7.   uint32_t OCFastMode;  
   
8.   uint32_t OCIdleState;   
   
9.   uint32_t OCNIdleState;  
   * E$ {8 c( j9 c5 k
10. } TIM_OC_InitTypeDef;  

复制代码

7 f2 s: l# A/ F% Z% O下面将这几个参数一 一做个说明。

  OCMode
用于配置输出比较模式，支持的模式较多：
& Y4 E, T4 R4 p+ @: L5 m) V  B

1. /*!< TIM Output timing mode */
   6 p# }) I) v/ x; x/ j
2. #define TIM_OCMODE_TIMING                ((uint32_t)0x0000U)      
   
3. 
   
4. /*!< TIM Output Active mode */                          
   3 r9 c3 h) r7 L
5. #define TIM_OCMODE_ACTIVE                ((uint32_t)TIM_CCMR1_OC1M_0)
     i& F( ]- B! B( g
6. 
   
7. /*!< TIM Output Inactive mode */                       
   
8. #define TIM_OCMODE_INACTIVE              ((uint32_t)TIM_CCMR1_OC1M_1)           
   
9. 
     g+ d( F# a; ?: B' F* a/ [/ h1 f
10. /*!< TIM Output Toggle mode */               
    
11. #define TIM_OCMODE_TOGGLE                 ((uint32_t)TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)         
    7 U' D1 k& m4 B. j3 m8 ^
12. 
    
13. /*!< TIM PWM mode 1 */
    , ~( _, j2 e' Z% E/ O1 o
14. #define TIM_OCMODE_PWM1                   ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1)
    
15. 
    ( I& R7 J- d+ D
16. /*!< TIM PWM mode 2 */                    
    ' \5 m8 f5 o; s  l
17. #define TIM_OCMODE_PWM2                    ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)   
    9 B3 J) C  m& ?& q+ V0 a& I! o
18. 
    6 ^% m- m1 I3 b2 \
19. /*!< TIM Forced Active mode */   
    
20. #define TIM_OCMODE_FORCED_ACTIVE           ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0)         
    4 U" [+ D9 T1 U5 l# E& r7 r
21. 
    * O: i; f3 ?% N% I2 t) O8 O' ]
22. /*!< TIM Forced Inactive mode */            
    , t2 p, P/ U0 n/ O# ?
23. #define TIM_OCMODE_FORCED_INACTIVE         ((uint32_t)TIM_CCMR1_OC1M_2)                                       
    
24. 
    % f# z2 }4 T4 L0 y3 w* Q1 Z
25. /*!< TIM Rettrigerrable OPM mode 1 */  
    
26. #define TIM_OCMODE_RETRIGERRABLE_OPM1      ((uint32_t)TIM_CCMR1_OC1M_3)   
    : [0 X2 F5 a& F% G/ r
27. 
    
28. /*!< TIM Rettrigerrable OPM mode 2 */                                       
    
29. #define TIM_OCMODE_RETRIGERRABLE_OPM2      ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0)   
    ' X4 K1 F9 S+ @: u& Y
30. 
    7 l% v+ S2 e$ i5 e& l# b
31. /*!< TIM Combined PWM mode 1 */                     
    4 W3 p; {1 v4 {7 {; e: l
32. #define TIM_OCMODE_COMBINED_PWM1           ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_2)     
    7 q" g- F5 v4 h* q$ @* g
33. 
    5 `: j/ \1 R0 x- ]* F! O% `$ n4 h9 s
34. /*!< TIM Combined PWM mode 2 */                  
    $ l# |  D; c; T+ \
35. #define TIM_OCMODE_COMBINED_PWM2           ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0 | TIM_CCMR1_OC1M_2)   
    
36. 
    
37. /*!< TIM Asymetruc PWM mode 1 */  
    , K1 [, L+ ^) r1 x! I4 {9 [
38. #define TIM_OCMODE_ASSYMETRIC_PWM1         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2)  
    $ ^4 C; ?5 i" G& [& u' V4 _
39. 
    
40. /*!< TIM Asymetruc PWM mode 2 */   
    1 l$ R- D, Z, t( ~- V3 c
41. #define TIM_OCMODE_ASSYMETRIC_PWM2         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M)  

复制代码

8 T7 H* l5 a0 A% T, K: I& b  
: M, D5 }5 P# W2 Y9 n  Pulse
可用于设置占空比，对应定时器的CCR寄存器，32位的TIM2和TIM5范围是0到0xFFFFFFFF。
2 x8 @% Z- @: [5 e! p5 V9 S
6 a6 ]) c; J3 f% R" t  OCPolarity
  U8 F/ `: S/ U/ a1 ]设置输出极性，可选高电平或低电平有效。
3 M3 ?1 B* r% ~+ B! ?& ~

1. #define TIM_OCPOLARITY_HIGH                ((uint32_t)0x0000U)
   & M- A3 W" A0 m+ V5 ]0 n" \) x9 ~; {4 p
2. #define TIM_OCPOLARITY_LOW                 (TIM_CCER_CC1P)

复制代码

( g8 |& \4 _% |3 I  OCNPolarity
4 t3 G, o0 a" i' G- _4 \/ K互补输出极性设置，可选高电平或者低电平有效。

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

复制代码

  OCFastMode
快速输出模式使能，仅OCMode配置为PWM1或者PWM2模式时才有意义。

6 m! I7 u" B: h4 D. t

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

复制代码

  OCIdleState
空闲状态时，设置输出比较引脚的电平状态。
- ]- k/ q4 u+ y. R( j  ]

1. #define TIM_OCIDLESTATE_SET                (TIM_CR2_OIS1)
   7 I4 _0 s0 ]; U
2. #define TIM_OCIDLESTATE_RESET              ((uint32_t)0x0000U)

复制代码

0 U7 T3 G5 }. V  OCNIdleState
& k7 p* X/ `5 ~  `空闲状态时，设置互补输出引脚的电平状态。

  \% I5 ~" _+ @/ k

1. #define TIM_OCNIDLESTATE_SET               (TIM_CR2_OIS1N)
   3 A4 n7 q4 r3 W6 H9 {" X0 l7 r
2. #define TIM_OCNIDLESTATE_RESET             ((uint32_t)0x0000U)

复制代码

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

1. typedef struct
     _. o; N; ?! ~3 l' c7 ~
2. {                                 
   ) W- ~; P0 z3 D$ a: O* {
3.   uint32_t ICPolarity;   
   
4.   uint32_t ICSelection;
   
5.   uint32_t ICPrescaler;
   6 u+ R* J6 k0 w1 e7 g
6.   uint32_t ICFilter;   
   ! r; E; s6 v- l2 \4 ?
7. } TIM_IC_InitTypeDef;

复制代码

下面将这几个参数一 一做个说明。
" M# j/ |; s  n, c  w
6 _/ g& V6 @2 y! L  ICPolarity
输入触发极性，可以选择上升沿，下降沿或者双沿触发。
& z1 L7 Y/ v& }. |& O; d
2 q: j$ ]# |/ l1 m6 E; i

1. #define  TIM_ICPOLARITY_RISING             TIM_INPUTCHANNELPOLARITY_RISING
   . c, J8 K/ e% q2 O, o9 q1 e/ K
2. #define  TIM_ICPOLARITY_FALLING            TIM_INPUTCHANNELPOLARITY_FALLING
   
3. #define  TIM_ICPOLARITY_BOTHEDGE           TIM_INPUTCHANNELPOLARITY_BOTHEDGE

复制代码

  ICSelection
5 w- O% _" e* L1 t5 h输入捕获通道选择，可以选择直接输入（即CC1选择TI1，CC2选择TI2等），间接输入（CC1选择TI2，CC3选择TI4等）或者TRC。

1. #define TIM_ICSELECTION_DIRECTTI       (TIM_CCMR1_CC1S_0)   
   4 s! O" i$ q+ p+ w  c
2. #define TIM_ICSELECTION_INDIRECTTI     (TIM_CCMR1_CC1S_1)  
   & |- [8 X- I3 z: K# l) x1 d" `
3. #define TIM_ICSELECTION_TRC            (TIM_CCMR1_CC1S)   

复制代码

( H1 C) B9 e# n  ICPrescaler
输入捕获分频，表示每捕获1，2，4或8个事件后表示一次捕获。

% l/ X$ K! B, r$ a, M/ C

1. #define TIM_ICPSC_DIV1       ((uint32_t)0x0000U)                 
   5 B! ?6 N3 o9 I1 e9 n. B) G( i& h/ Z$ }
2. #define TIM_ICPSC_DIV2       (TIM_CCMR1_IC1PSC_0)   
   ) Y- X; C1 g9 e% O
3. #define TIM_ICPSC_DIV4       (TIM_CCMR1_IC1PSC_1)   
   * O6 W8 U" C" ?8 H; x* \
4. #define TIM_ICPSC_DIV8       (TIM_CCMR1_IC1PSC)

复制代码

8 z. Y% X7 c" V2 L5 z5 a; |  ICFilter
$ J2 y, a6 a# V输入捕获滤波器，可以定义采样频率和多少个连续事件才视为有效的触发，参数范围0到15。具体定义如下，其中fCK_INT表示定时器时钟，fDTS表示死区时间采样率，N表示这么多个事件代表一次有效边沿。
. {: u, P6 v$ P* _8 t8 P

1. 0000：无滤波器，按 fDTS 频率进行采样
   - p( ^7 L( ~6 _+ d5 C( ]! n
2. 0001： fSAMPLING=fCK_INT， N=2
   
3. 0010： fSAMPLING=fCK_INT， N=4
   
4. 0011： fSAMPLING=fCK_INT， N=8
   / E' z; f/ A$ v9 ]
5. 0100： fSAMPLING=fDTS/2， N=6
   ) Q7 T$ V4 ~2 \" m* u" B
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
    
12. 1011： fSAMPLING=fDTS/16， N=6
    
13. 1100： fSAMPLING=fDTS/16， N=8
    
14. 1101： fSAMPLING=fDTS/32， N=5
    
15. 1110： fSAMPLING=fDTS/32， N=6

复制代码

  e2 I1 ^* j. s. K+ H0 z1 w32.3.5 定时器的底层配置（GPIO，时钟，中断等）
! m$ F7 j1 @8 v. P- @, o3 `HAL库有个自己的底层初始化回调函数，比如调用函数HAL_TIM_Base_Init就会调用HAL_TIM_Base_MspInit，此函数是弱定义的。
9 p, I8 D+ p9 g% ]

1. __weak void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
   
2. {
   
3.   /* Prevent unused argument(s) compilation warning */
   
4.   UNUSED(htim);
   
5.   /* NOTE : This function Should not be modified, when the callback is needed,
   8 q8 m0 X/ n& j( m' K9 L
6.             the HAL_TIM_Base_MspDeInit could be implemented in the user file
   # ?( u9 S- H5 O' O* {
7.    */
   " m/ S, o1 y9 ]8 y2 f
8. }

复制代码

0 `( g' b, B' l9 ^7 p用户可以在其它的C文件重定向，并将相对的底层初始化在里面实现。对应的底层复位函数HAL_TIM_Base_DeInit是在函数HAL_TIM_Base_MspDeInit里面被调用的，也是弱定义的。

8 T5 o6 w9 ]& C- H) c! ^( R6 h当然，用户也可以自己初始化，不限制必须在两个函数里面实现。
. ~: b0 H# j1 P' x
定时器外设的基本参数配置完毕后还不能使用，还需要配置GPIO、时钟、中断等参数，比如下面配置TIM1使用PA8做PWM输出。

1. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
   ! m$ k0 U% A1 _/ I  U
2. {
   ; J; [' F! D+ I& {4 L7 |1 \8 _
3.   GPIO_InitTypeDef   GPIO_InitStruct;
   
4. 
   
5.   /* 使能TIM1时钟 */
   # ^$ Q- k) l' ^
6.   __HAL_RCC_TIM1_CLK_ENABLE ();
   $ k# m( d3 b/ D! R& t& v; n
7. 
   : e; m8 b. q5 R& c
8.   /* 使能GPIOA时钟 */
   
9.   __HAL_RCC_GPIOA_CLK_ENABLE ();
   ; A9 G( R, t+ @" t
10. 
    $ P. |. ]' ]  R* H+ Q$ T: {% d: E
11.   /* 设置TIM1使用PA8做PWM输出引脚，将其配置为输出，推挽，复用模式 */
    $ U1 S/ g# |0 A/ |. X; e- [
12.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
13.   GPIO_InitStruct.Pull = GPIO_PULLUP;
    7 P: E2 v6 L* f$ V3 S9 t7 A
14.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
15. 
    3 n. e0 s5 T- q. y% r" x
16.   GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
    3 ~) L6 m0 H9 L/ Z2 t! U
17.   GPIO_InitStruct.Pin = GPIO_PIN_8;
    + H+ p$ [9 |7 |, W: O
18.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    % J- p) Z# h( D
19. 
    
20. }

复制代码

总结下来就是以下几点：

  配置TIM时钟。
2 h+ [+ P- W9 w* a  配置TIM所用到引脚和对应的GPIO时钟。
9 F! J1 k- L7 J: n+ |  如果用到定时器中断，还需要通过NVIC配置中断。
  如果用到DMA，还要配置DMA。
关于这个底层配置有以下几点要着重说明下：

; b$ z& t/ {6 }$ ~& y/ c# B  定时器所使用引脚的复用模式选择已经被HAL库定义好，放在了stm32h7xx_hal_gpio_ex.h文件里面。比如TIM1有一个复用，
0 r5 N) a2 K1 n

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

复制代码

但是却有4个输出通道，每个通道都有几个支持的输出引脚：
4 d9 A) a+ ]2 M. J) P" ^) V) C
: k4 P) S0 G- p% o7 W

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

复制代码

具体使用哪个，配置对应引脚的复用即可：
) S; Z- _" d7 ]* i7 f. }
* r5 [4 {7 W' V( k2 u: w

9 A- \: z9 x' c, t+ D32.3.6 定时器的状态标志清除问题
下面我们介绍__HAL_TIM_GET_FLAG函数。这个函数用来检查定时器标志位是否被设置。
# G3 W' _  X8 X

1. 
   
2. /** @brief  Check whether the specified TIM interrupt flag is set or not.
   ' M/ C, T) S9 J8 u
3.   * @param  __HANDLE__: specifies the TIM Handle.
   
4.   * @param  __FLAG__: specifies the TIM interrupt flag to check.
   
5.   *        This parameter can be one of the following values:
   $ ]1 Q" j3 W/ R. ]- K5 V; v
6.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag
   3 n  ~5 D$ o8 g6 t3 L+ i5 B7 h
7.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
   ; u% x* v4 |4 p" |
8.   *            @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
     O* b4 q/ H% E( K1 X. H1 R1 R" e
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
    
13.   *            @arg TIM_FLAG_COM:  Commutation interrupt flag
    
14.   *            @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
    
15.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   
    " u( D$ O: a; @5 j5 D
16.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    
17.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
    / _4 P( P- O* y, U  i( z
18.   *            @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
    
19.   *            @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
    
20.   *            @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
    # G* w: U7 Z- N% u* u" B  ~; P. ]
21.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    
22.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    3 p. s  G( _$ \
23.   */
    
24. #define __HAL_TIM_GET_FLAG(__HANDLE__, __FLAG__)   (((__HANDLE__)->Instance->SR &(__FLAG__)) == (__FLAG__))

复制代码

! N1 \: ~: t0 z/ ]- C" F3 I前5个是比较常用的中断标志。
/ V# b- D7 L& u1 D
- @( ?, W6 T; r- P  O  TIM_FLAG_UPDATE
  ]! U5 q, U: O定时器更新标准，配置一个周期性的定时器中断要用到。

; X/ n. B* v% b     TIM_FLAG_CC1
TIM_FLAG_CC2
+ R" `" o7 T! `8 w) l
" L) g% |) u# V6 g  BTIM_FLAG_CC3

8 s3 R1 L( v# y/ GTIM_FLAG_CC4

捕获/比较标志，配置了捕获/比较中断要用到。
# ~$ k7 Y/ E5 f+ V6 t' r3 C
与标志获取函数__HAL_TIM_GET_FLAG对应的清除函数是__HAL_TIM_CLEAR_FLAG：
: {( W8 @9 S% t8 D4 {' U1 @' n

1. /** @brief  Clear the specified TIM interrupt flag.
   ! l& @! G/ O" h# i: w
2.   * @param  __HANDLE__: specifies the TIM Handle.
   
3.   * @param  __FLAG__: specifies the TIM interrupt flag to clear.
   2 M: F& `* e7 l: J3 F& s. ]- p
4.   *        This parameter can be one of the following values:
   
5.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag
   
6.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
   8 r1 A2 B% {8 o6 P; l& f
7.   *            @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
   
8.   *            @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
   
9.   *            @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
   
10.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag
    
11.   *            @arg TIM_FLAG_CC6: Compare 6 interrupt flag
    
12.   *            @arg TIM_FLAG_COM:  Commutation interrupt flag
    
13.   *            @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
    
14.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   
    4 T' Z4 ]7 S4 L
15.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    
16.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
      K  g; @8 R- f) P
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
    / t2 P6 w, L, ?' @+ h, v3 u
20.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    ' |$ u0 ?! ?" |# Z! N! `7 F) n
21.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    
22.   */
    
23. #define __HAL_TIM_CLEAR_FLAG(__HANDLE__, __FLAG__)       ((__HANDLE__)->Instance->SR = ~(__FLAG__))

复制代码

清除标志函数所支持的参数跟获取函数是一 一对应的。除了这两个函数，还是定时器的中断开启和中断关闭函数用的也比较多。
* z  t) M0 g6 r+ ?2 I

1. /** @brief  Enable the specified TIM interrupt.
   
2. * @param  __HANDLE__: specifies the TIM Handle.
   . T) x3 o- l/ N1 d; O8 {
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
   $ L/ u' a  ?1 e1 R/ c5 ?/ h
10. *            @arg TIM_IT_COM:   Commutation interrupt
    
11. *            @arg TIM_IT_TRIGGER: Trigger interrupt
    5 O% A1 u0 R, P
12. *            @arg TIM_IT_BREAK: Break interrupt
    8 Q. c$ B7 o/ G
13. * @retval None
    3 h* Z+ D9 K' h$ |& p" @7 y
14. */
    
15. #define __HAL_TIM_ENABLE_IT(__HANDLE__, __INTERRUPT__)  ((__HANDLE__)->Instance->DIER |= (__INTERRUPT__))
    ' X5 ]& P$ ?# a) I
16. 
    
17.   /** @brief  Disable the specified TIM interrupt.
    - b  n$ w4 c( T" j3 c3 x
18.   * @param  __HANDLE__: specifies the TIM Handle.
    / X1 o& J1 J) h
19.   * @param  __INTERRUPT__: specifies the TIM interrupt source to disable.
    
20.   *          This parameter can be one of the following values:
    5 c: b4 i" B* V( K. G" ], T
21.   *            @arg TIM_IT_UPDATE: Update interrupt
    
22.   *            @arg TIM_IT_CC1:   Capture/Compare 1 interrupt
    $ [$ d- {6 a3 i1 e+ l; G
23.   *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt
    
24.   *            @arg TIM_IT_CC3:  Capture/Compare 3 interrupt
    & \8 u: u0 B0 Q- u: ^
25.   *            @arg TIM_IT_CC4:  Capture/Compare 4 interrupt
    
26.   *            @arg TIM_IT_COM:   Commutation interrupt
    * D9 u: I- B" D6 ]' m' D* Q+ s
27.   *            @arg TIM_IT_TRIGGER: Trigger interrupt
    
28.   *            @arg TIM_IT_BREAK: Break interrupt
    
29.   * @retval None
    
30.   */
    
31. #define __HAL_TIM_DISABLE_IT(__HANDLE__, __INTERRUPT__)   ((__HANDLE__)->Instance->DIER &= ~(__INTERRUPT__))

复制代码

2 i: }+ a6 y  R5 [% C) [1 }常用的也是前五个参数，1个定时器更新中断以及4个CC中断 。

注意：操作定时器的寄存器不限制必须要用HAL库提供的API，比如要操作寄存器CR1，直接调用TIM1->CR1操作即可。
8 t: B; K0 l: \! Z: C: H1 H  x
32.3.7 定时器初始化流程总结
. I0 K1 u" E' S: s  i使用方法由HAL库提供：

  第1步：通过下面几个函数配置定时器工作在相应的模式
) i6 Q8 [# M" I) |6 q. h1 Z) X# s' R
+ U+ F7 W1 `: h: [7 c$ O2 S  HAL_TIM_Base_Init
, B; l1 e" O8 Q& P$ ?+ `, N简单的定时器时基础功能
$ K  }0 l8 r2 ], f; J
  HAL_TIM_OC_Init 和 HAL_TIM_OC_ConfigChannel
配置定时器产生输出比较信号

  HAL_TIM_PWM_Init 和 HAL_TIM_PWM_ConfigChannel
配置定时器产生PWM信号
, o5 X/ x- q/ e6 F; i+ T
  HAL_TIM_IC_Init 和 HAL_TIM_IC_ConfigChannel
+ A$ a& s9 G$ G5 d) J0 e配置定时器测量外部信号
8 T4 \0 d- m9 S  T
  HAL_TIM_OnePulse_Init 和 HAL_TIM_OnePulse_ConfigChannel
配置定时器工作在单脉冲模式
, Q7 ~& t/ J$ w1 K1 T+ }
+ k; Y! k; M6 q) o1 p: e! |+ w8 K  G  HAL_TIM_Encoder_Init
配置定时器使用编码器接口
/ [' V( w5 a8 f$ |7 \0 e
' j& V/ n' y  o4 H8 N% Q% B  第2步：定时器几个常用功能的底层初始化API，这个里面需要用户自己填

第1步里面的几个函数会调用下面的API。
3 o. V7 s' r7 m$ }
% r' _( L0 h( P0 g& x' K0 U% [# z% V  定时器基本功能 : HAL_TIM_Base_MspInit()
" C6 k! [6 [# o4 O  输入捕获 : HAL_TIM_IC_MspInit()
/ i' \- h+ h" ]$ ]" _) R  输出比较 : HAL_TIM_OC_MspInit()
  PWM输出 : HAL_TIM_PWM_MspInit()
7 p' O4 N6 J: v; C& R* y  M  单脉冲输出模式: HAL_TIM_OnePulse_MspInit()
  编码器模式 : HAL_TIM_Encoder_MspInit()
" ], C7 F3 X2 j3 b; O. }" S  第3步：底层初始化具体实现
+ g- @( q5 r$ r
& p4 ?6 x; l8 ^; d第2步中函数的具体实现。

  使用函数__HAL_RCC_TIMx_CLK_ENABLE()使能定时器时钟。
  使用函数__HAL_RCC_GPIOx_CLK_ENABLE()使能定时器使用到的引脚时钟。
  使用函数HAL_GPIO_Init()配置GPIO的复用功能。
  如果使能了定时器中断，调用函数HAL_NVIC_SetPriority和HAL_NVIC_EnableIRQ配置。
1 d! |/ \7 F+ v  如果使能了DMA，还需要做DMA的配置。
( f9 v# o) @6 ^5 O' o2 }& ?  定时器默认使用APB时钟，如果使用外部时钟，调用函数HAL_TIM_ConfigClockSource可以配置。
) ]: a2 V" \6 D/ l1 B2 A  第4步：启动定时器外设

  定时器基础功能:
HAL_TIM_Base_Start()

7 v5 F2 K) D) zHAL_TIM_Base_Start_DMA()
9 O3 r+ `7 x7 z+ ]0 |! b# w' y
2 z1 |2 R5 {! ]7 |- y  w* GHAL_TIM_Base_Start_IT()

  输入捕获 :
HAL_TIM_IC_Start()

HAL_TIM_IC_Start_DMA()

: u/ c7 l- e* D: QHAL_TIM_IC_Start_IT()

  输出比较 :
" I( j1 g8 @; _% q( G$ v- vHAL_TIM_OC_Start()
0 K( o* o( Z  i8 K/ G
* G# Z3 j% M( |9 }% AHAL_TIM_OC_Start_DMA()

4 E# ]2 ^' b% SHAL_TIM_OC_Start_IT()
' y. O0 H0 {9 T# }  _
1 X0 {. \0 T1 w5 `& z5 Z  PWM输出：
6 T. e- H) N( @3 {" O, c& W+ t# pHAL_TIM_PWM_Start()
9 N2 s/ u! L* G5 c8 g
! t3 v, ?! n5 Z# V# k$ {HAL_TIM_PWM_Start_DMA()

0 }# |& @; y" d0 OHAL_TIM_PWM_Start_IT()

% C+ i0 D4 ]) q" y; J  单脉冲模式：
HAL_TIM_OnePulse_Start()
: k: A- B3 o8 n$ R. Q2 c1 m
7 _" g! `2 p+ P3 w+ G( r! Z- sHAL_TIM_OnePulse_Start_IT().
$ l; Q, p, z0 x, b$ S% J
  编码器模式：
HAL_TIM_Encoder_Start()
+ v' F( @4 b1 r; V$ u& `1 ~: p- ~
HAL_TIM_Encoder_Start_DMA()
7 H. U; a( ?: d; r
HAL_TIM_Encoder_Start_IT().
" b$ ~6 ^3 F- W
  第5步：定时器的DMA突发使用下面两个函数
7 ?. g8 h3 L5 `3 E  o8 y; R
  HAL_TIM_DMABurst_WriteStart()
  HAL_TIM_DMABurst_ReadStart()
定时器常用的功能，通过上面这几步即可实现。

% R& r3 H' b7 l9 {32.4 源文件stm32h7xx_hal_tim.c
) }3 U; @) z5 v3 |. [此文件涉及到的函数非常多，这里把几个常用的函数做个说明：

/ A+ ]* R  _" R, r  HAL_TIM_Base_Init
! a( g1 c7 _4 z# _: n0 }. x  HAL_TIM_Base_Start
  HAL_TIM_PWM_Init
7 f+ [5 @/ K& V+ [% D# W  HAL_TIM_PWM_ConfigChannel
1 O6 z) p6 @" R  HAL_TIM_PWM_Start
  HAL_TIM_IC_Init
  HAL_TIM_IC_ConfigChannel
9 C6 U! U5 l5 b& j& P  HAL_TIM_IC_Start_IT
# O7 @5 x2 c9 k' Z( M8 V7 A: C+ K  HAL_TIM_OC_Init
0 T' o& [5 Q! A  N  HAL_TIM_OC_ConfigChannel
  HAL_TIM_OC_Start
32.4.1 函数HAL_TIM_Base_Init
函数原型：
/ [% q9 ~5 o1 j( G0 I3 w; e) U* ~

1. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   8 p) @- \9 J  _$ q; l9 [; n& {0 ]
2. {
   5 h2 d; D/ S3 o
3.   /* 检测是否是有效句柄 */
   * F$ k8 s1 Y& z; O- @8 l
4.   if(htim == NULL)
   
5.   {
   ! r0 H; D6 L- g/ i; U- T' O  J
6.     return HAL_ERROR;
   , t# \& W) M, h- u: a0 h
7.   }
   * p# B* j% Z2 ^
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. 
    3 G' ~8 e& O$ Q/ h) \/ P- l  j0 t
14.   if(htim->State == HAL_TIM_STATE_RESET)
      y* V3 ]2 _, o* M0 X0 `9 a! p4 W
15.   {
    2 Z! m$ \7 M' f% ~0 \
16.     /* 默认取消锁 */
    
17.     htim->Lock = HAL_UNLOCKED;
    
18.     /* 初始化底层硬件 : GPIO, CLOCK, NVIC */
    
19.     HAL_TIM_Base_MspInit(htim);
    
20.   }
    
21. 
    
22.   /* 设置TIM状态 */
    ; @/ W, \( R, I8 k5 [+ r
23.   htim->State= HAL_TIM_STATE_BUSY;
    9 G& {; W9 X$ T4 a
24. 
    ! c; \' Z0 ?0 M2 ?+ \% {
25.   /* 基本参数配置 */
    
26.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    1 h4 J' I/ n; ~" X: F4 |
27. 
    
28.   /* 设置TIM就绪 */
    
29.   htim->State= HAL_TIM_STATE_READY;
    
30. 
    
31.   return HAL_OK;
    0 }. I) K3 C& [1 {2 G+ t1 I
32. }

复制代码

函数描述：

# i: D8 c! N* `. `( A1 v此函数用于初始化定时器用于PWM。

" S- c4 P. A( X: I2 z( n( E函数参数：
# K" W( p( N4 g  Z7 V
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
8 ^& c0 O  N; l, P, p注意事项：

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

) L) Q7 f& F2 @, G' X) a: J解决办法有三：
. @2 h* D9 x6 L9 Y
. j- ]3 u+ y& Z2 }; h! V方法1：用户自己初始定时器和涉及到的GPIO等。
) r% Z" A+ e2 d; Z$ s. R# _4 w  y
方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

  y' H6 J2 u3 F- s方法3：下面的方法
& x; p( d& {) B7 z) a( C( q
4 o4 s+ t* b" o7 A) M* |0 j

1. if(HAL_TIM_Base_DeInit(&TimHandle) != HAL_OK)
   
2. {
   * r! K5 F4 O, U6 W
3.     Error_Handler();
   $ D" o( r. g0 w) o7 N
4. }  
   # g  b9 }6 L- r! Z) V# F& }( d
5. if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
   ! o  _0 v# c$ [
6. {
   
7.     Error_Handler();
   8 ^2 O8 W8 }1 O
8. }

复制代码

使用举例：
, d+ \2 E& f2 t/ I& z

1. TIM_HandleTypeDef   TimHandle = {0};
   6 g* e. {. t7 \; @' m+ g, n" m
2. 
   
3. /*
   
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   
6. TimHandle.Instance = TIMx;
   & \! \- z+ y2 g) k( |) S) |1 n
7. TimHandle.Init.Prescaler         = usPrescaler;
   
8. TimHandle.Init.Period            = usPeriod;        
   4 r- P6 Q& ?0 b# U3 i0 ^, m5 V
9. TimHandle.Init.ClockDivision     = 0;
   
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    
11. TimHandle.Init.RepetitionCounter = 0;
    * _: h3 i" U3 z+ c& d
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    - ?4 y& Z. b: X8 s& U4 z
14. {
    
15.         Error_Handler(__FILE__, __LINE__);
    
16. }

复制代码

32.4.2 函数HAL_TIM_Base_Start
函数原型：
9 n& j, f  ]3 |! `8 X

1. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   2 v7 H: ~0 t, M& U1 z2 t& ~9 q0 J0 l
2. {
   
3.   /* 检测参数状态 */
   ; x) f# h( _" b) s* w! T
4.   assert_param(IS_TIM_INSTANCE(htim->Instance));
   
5. 
   5 g. y/ o" g. p& d+ a* B
6.   /* 设置定时器状态 */
   6 B: f" O/ q1 A  d6 ]6 \7 Y
7.   htim->State= HAL_TIM_STATE_BUSY;
   
8. 
   
9.   /* 使能定时器 */
   7 N! m* H. D; Z# V. G: t, T$ w
10.   __HAL_TIM_ENABLE(htim);
    
11. 
    : u* W' x/ p, Z1 I- f( [. y6 @& G
12.   /* 设置定时器状态 */
    
13.   htim->State= HAL_TIM_STATE_READY;
    , M# p% G& V( n
14. 
    ! B  Q  ]2 n) h4 t. C$ U
15.   /* 返回HAL_OK */
    3 K* d* D% _$ N* |
16.   return HAL_OK;
    
17. }

复制代码

4 G% i8 w  u( n$ m0 U" x$ J: D函数描述：
' Y. f, E% o% b1 m+ ^
此函数比较简单，调用函数HAL_TIM_Base_Init配置了基础功能后，启动定时器。

函数参数：
8 {2 G6 G7 o2 [
  第1个参数是TIM_HandleTypeDef类型结构体指针变量。
7 T# |& C& U; o6 g  返回值，固定返回HAL_OK，表示初始化成功。
使用举例：

1. TIM_HandleTypeDef   TimHandle = {0};
   
2. 
   9 q3 K' V7 j; q1 L
3. /*
   1 ~7 z! G. L  O4 m# y
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   7 V, o  q* A5 A8 p
5. */
   # k" v1 H4 t( x( X+ a6 o
6. TimHandle.Instance = TIMx;
   
7. TimHandle.Init.Prescaler         = usPrescaler;
   
8. TimHandle.Init.Period            = usPeriod;        
   
9. TimHandle.Init.ClockDivision     = 0;
   
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    . b1 I, A5 C0 ~2 a+ t9 l6 I9 c" V
11. TimHandle.Init.RepetitionCounter = 0;
    
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    
14. {
    
15.         Error_Handler(__FILE__, __LINE__);
    / f" x' v, @4 @' t* S
16. }
    1 f8 P! T4 Q2 d# C
17. 
    
18. /* 启动定时器 */
    
19. if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
      h8 d7 U7 t) {! u8 D( m* h& e4 A
20. {
    $ \+ i' Q, U& h
21. Error_Handler(__FILE__, __LINE__);
    * p8 x! ~) u* `" V9 o' R
22. }

复制代码

32.4.3 函数HAL_TIM_PWM_Init
函数原型：

1. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
   1 c: ]! f' ^" N& S+ w
2. {
   , L$ K. X/ ^( {4 A% i0 V3 }  V8 [
3.   /* 检查句柄是否有效 */
   
4.   if(htim == NULL)
   % t7 K( i# O9 x0 b* |; l& K
5.   {
   
6.     return HAL_ERROR;
   5 T; M7 B7 ?9 J, a: A
7.   }
   
8. 
   / q7 ]0 j" N7 q# ^0 [
9.   /* 检测参数 */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    % {* {) [" G! H8 d: o
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    , g+ n( U( n, d: ~( Z
13. 
    
14.   if(htim->State == HAL_TIM_STATE_RESET)
    
15.   {
    
16.     /* 默认取消锁 */
    ! S$ `! O3 Z* [) t& _9 g
17.     htim->Lock = HAL_UNLOCKED;
    
18. 
    
19.     /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    ) _+ \) f- [4 s
20.     HAL_TIM_PWM_MspInit(htim);
    
21.   }
    
22. 
    ! C$ R  s$ R! s9 h- A& R
23.   /* 设置定时状态 */
    ! R* M: r: [. y
24.   htim->State= HAL_TIM_STATE_BUSY;
    
25. 
    
26.   /* 配置定时器用于PWM */  
    
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    9 h# C: a1 W  z( O0 h& P- b) G4 o7 c
28. 
    . e" J6 V. E, e' P1 t
29.   /* 设置定时器状态 */
    * X/ {! R, ^- Y9 h3 S
30.   htim->State= HAL_TIM_STATE_READY;
    
31. 
    $ a, M) T5 E) l, q6 i: t) W- q
32.   return HAL_OK;
    % m" T. ^" [9 ^, i+ |% A
33. }

复制代码

' y- q0 G! E2 D; o函数描述：

此函数用于初始化定时为PWM方式。
& r. A. X6 A5 P
函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
( s* Z2 a: Q- r2 C$ Z* |5 @! h. V: \注意事项：

函数HAL_TIM_PWM_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
- i, P( \6 l8 j* q) v- o! G3 h如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_TIM_STATE_RESET  = 0x00U。
* w  P) l0 N7 f9 c
解决办法有三：
9 U- Q1 M0 n, A$ Y$ I
方法1：用户自己初始定时器和涉及到的GPIO等。

2 f8 J! M" s9 g! }/ Q方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

- ?! {* u7 n7 l; ]' X9 h1 e方法3：下面的方法

1. if(HAL_TIM_PWM_DeInit(&TimHandle) != HAL_OK)
   
2. {
   0 b9 t$ `2 H- X8 [1 K# g
3.     Error_Handler();
   ( m/ t: Z( ~' W6 T7 @* t  K0 [' Y+ [
4. }  
   
5. if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
   
6. {
   ( `; U. o7 r! t
7.     Error_Handler();
   5 ^- b7 R, f. g  S/ Z9 c6 D
8. }

复制代码

7 Y% D- D' E& D+ S, ?3 P使用举例：

1. TIM_HandleTypeDef  TimHandle = {0};
   4 h  i" ^. y8 K! q6 F4 m0 A5 i7 f: r
2. 
   
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   " y( F# R8 S. d* H* }' |9 c( J) ]
4. TimHandle.Instance = TIM1;
   
5. TimHandle.Init.Prescaler         = usPrescaler;
   
6. TimHandle.Init.Period            = usPeriod;
   0 }6 s( b( q9 g
7. TimHandle.Init.ClockDivision     = 0;
   1 a( M2 e2 Z0 w, X
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   % ]' {9 S9 k; O, m5 X
9. TimHandle.Init.RepetitionCounter = 0;
   ; S; s4 r7 C) j( t
10. TimHandle.Init.AutoReloadPreload = 0;
    
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    + V2 ~3 G: y) B2 v# I% t
12. {
    2 R( _9 u7 t( ]  y: B6 n1 j' ]$ |# l
13.     Error_Handler(__FILE__, __LINE__);
    , I# o' p1 X  u
14. }

复制代码

32.4.4 函数HAL_TIM_PWM_ConfigChannel
函数原型：

+ h* {8 \$ f' H5 O

1. HAL_StatusTypeDef HAL_TIM_PWM_ConfigChannel(TIM_HandleTypeDef *htim,
   
2.                                             TIM_OC_InitTypeDef* sConfig,
   3 V. k: O! i: {4 P3 m$ q/ Y
3.                                             uint32_t Channel)
   
4. {
   ( L) b# u8 I4 I3 N
5.    /* 省略 */
   
6. 
   
7.   /* 开锁 */
   
8.   __HAL_LOCK(htim);
   + c6 j/ x& N4 {  S0 _# m
9. 
   3 R+ W& _" C& |9 H% c% t
10.   htim->State = HAL_TIM_STATE_BUSY;
    
11. 
    # X4 X6 E3 ]( H& h) w9 q
12.   switch (Channel)
    
13.   {
    , Z1 R* K2 [) d6 y0 f) ~/ ~& T6 A
14.     case TIM_CHANNEL_1:
    
15.     {
    ; m6 |' c# P% B
16.       /* 检查参数 */
    . U7 \& P% W& r
17.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    6 O7 G) J" d+ v$ t! a4 b
18. 
    7 p. @3 X: u3 j" A: J
19.       /* 配置通道1的PWM模式 */
    - h/ s* `! P; Z: \$ t9 ?# D
20.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    
21. 
    
22.       /*预装载使能，更新事件产生时写入有效 */
    : c% X/ e$ U1 P# d% @/ e" [
23.       htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;
    ' U* y, j4 ^/ M. v( A. b5 Z  F
24. 
    
25.       /* 配置是快速输出模式 */
    
26.       htim->Instance->CCMR1 &= ~TIM_CCMR1_OC1FE;
    
27.       htim->Instance->CCMR1 |= sConfig->OCFastMode;
    ' O* d0 f- m0 ~, g% i( p7 j- y
28.     }
    # N0 P! Y/ F! `, p% X/ {( b. r
29.     break;
    
30. 
    
31.     case TIM_CHANNEL_2:
      {# \: U2 s& |, ~" f) f/ j
32.     {
    . }, L- d1 i# o
33.        /* 省略 */
    $ A6 b+ o- d8 w. A5 k
34.     }
    9 o' q6 Y- u3 u. a
35.     break;
    
36. 
    6 X; l$ D% i! R. ^
37.     case TIM_CHANNEL_3:
    
38.     {
    
39.        /* 省略 */
    * h/ \; S1 v- W0 _% Y8 r
40.     }
    8 n7 S) P! t1 H* q& ?) M: C, B
41.     break;
    
42. 
    
43.     case TIM_CHANNEL_4:
    
44.     {
    
45.       /* 省略 */
    
46.     }
    
47.     break;
    ' q  [8 C' `3 N
48. 
    # N8 X* o: s4 r  ~" }
49.     case TIM_CHANNEL_5:
    
50.     {
    
51.        /* 省略 */
    
52.     }
    
53.     break;
    
54. 
    
55.     case TIM_CHANNEL_6:
    : T0 O! f7 d+ G  l
56.     {
    - N; c  F4 T8 y7 B2 X8 G$ A
57.         /* 省略 */
    
58.     }
    . C- {8 m" u& e4 l
59.     break;
    
60. 
    
61.     default:
    9 v/ a" y0 B+ c# @
62.     break;
    
63.   }
    
64. 
    
65.   htim->State = HAL_TIM_STATE_READY;
    
66. 
    
67.   /* 关锁 */
    0 ~1 Z. S, V; S) T
68.   __HAL_UNLOCK(htim);
    
69. 
    
70.   return HAL_OK;
    
71. }

复制代码

* |1 K$ T' y6 I$ b! C( w2 D6 {函数描述：
. a( f  ~0 l% d! d
此函数用于配置定时器的PWM通道。
: M1 h! h2 B8 w. O
1 O/ s& ^2 T; }# P函数参数：
1 R4 e5 p+ J6 H, s# }
0 }/ G( q2 l" e; h6 M  P  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
TIM_CHANNEL_1
7 c3 `) L+ P, J) L0 C
# x7 G1 y4 @7 ]8 c4 ~TIM_CHANNEL_2

TIM_CHANNEL_3
8 w- `) r" I; E& b' [. M" P% Y' b
TIM_CHANNEL_4
5 c. \$ }+ \' b- k. @! _; }
TIM_CHANNEL_5
* f# s: L2 r+ a
0 y; a$ k1 j* m% Q) eTIM_CHANNEL_6
: A3 B+ U: b" J2 r  _; o
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
" P7 W  p0 x+ G& o; B; R& i) h使用举例：
4 z2 F4 f, M. N0 S) Z$ j& x
% u) A* B' w8 q/ \

1. TIM_HandleTypeDef  TimHandle = {0};
   
2. 
   + T  K+ Z6 ?0 \. _
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   
4. TimHandle.Instance = TIM1;
   
5. TimHandle.Init.Prescaler         = usPrescaler;
     I( P/ T" r) I" |" n2 j6 }8 ?' H+ S
6. TimHandle.Init.Period            = usPeriod;
   
7. TimHandle.Init.ClockDivision     = 0;
   ! N/ G/ l: v) d$ }: l5 Q3 X% B. U
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   
9. TimHandle.Init.RepetitionCounter = 0;
   . v' ^* N0 b& _+ [& S
10. TimHandle.Init.AutoReloadPreload = 0;
    0 j( D% k; [9 i$ G5 T' H" s
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    5 w8 w- x! R4 J3 \+ N& P
12. {
    $ E7 `" d: X6 L* O5 X2 t
13.     Error_Handler(__FILE__, __LINE__);
    
14. }
    4 l( L7 A9 P5 m0 a
15. 
    
16. /* 配置定时器PWM输出通道 */
    9 r" F. P$ s) [, I: k( a& B
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    # l3 \& }1 s& S" P+ |- z& ~
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
      L+ G! H& ?- i/ t5 d- Q
23. 
    
24. /* 占空比 */
    
25. sConfig.Pulse = pulse;
    ! ?% P5 V" @& y" }0 p% I) W
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
函数原型：
  D/ ~3 L$ {% l4 v( ]
+ e1 b% e" [) V5 I

1. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
   ; G: o( {4 d. j! C: g" a7 x9 t
2. {
   ; }6 ~- V. `4 p4 V
3.   /* 检测参数 */
   5 L3 {) ^5 z9 T, B" Z% g! ?
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   
5. 
   
6.   /* 使能捕获比较通道 */
   " u; r+ m7 K6 W, n  x
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   ) b' b# Q5 x0 O' P
8. 
   
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
   
10.   {
    
11.     /* 使能主输出 */
    + N9 D$ l: u4 \/ ?( U! w
12.     __HAL_TIM_MOE_ENABLE(htim);
    , r1 `; P5 X; [
13.   }
    * Y5 {6 D. Q! R; L  \
14. 
    * t% B2 J/ p+ W
15.   /* 使能定时器 */
    0 d0 Z1 V% O( t! [* R7 R
16.   __HAL_TIM_ENABLE(htim);
    
17. 
    
18.   /* 返回状态*/
    & @+ P/ Z2 J8 M- s2 z
19.   return HAL_OK;
    
20. }

复制代码

函数描述：

: ^3 b# J  O4 V9 Y1 I* N2 \/ G此函数用于启动PWM。

+ Q  D. ^4 S0 ^( f5 m3 ?2 L! U函数参数：

/ T. W  @8 Z* h3 x7 U  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
8 w* d- P: T( F* ?2 `. x; a: @" S  第2个参数是通道设置，支持以下参数：
, C9 v7 E4 ^" B: W; O6 CTIM_CHANNEL_1

TIM_CHANNEL_2

TIM_CHANNEL_3
* O. d1 f& k& q  O0 T( i. |
TIM_CHANNEL_4
* |- h" \0 V' f) F' Z
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
使用举例：

1. TIM_HandleTypeDef  TimHandle = {0};
   
2. 
   6 ]  u8 Z, k) o  K! T5 G0 i
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   
4. TimHandle.Instance = TIM1;
   
5. TimHandle.Init.Prescaler         = usPrescaler;
   $ D3 p# {- b; r" B* s" F
6. TimHandle.Init.Period            = usPeriod;
   
7. TimHandle.Init.ClockDivision     = 0;
   
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   
9. TimHandle.Init.RepetitionCounter = 0;
   
10. TimHandle.Init.AutoReloadPreload = 0;
    3 H1 D2 }8 u$ Y: _7 j& _6 h
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    
12. {
    
13.     Error_Handler(__FILE__, __LINE__);
    ) o) c9 [6 X5 a5 |! T5 C
14. }
    9 t0 Q) t' \/ R. G" s0 H4 D
15. 
    4 u7 ?7 g9 S: q  z7 P1 ?
16. /* 配置定时器PWM输出通道 */
    # l& Q& |7 V  T" ~2 K
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    + _0 c3 j! V/ w2 R  E2 g
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
    
23. 
    : `: V5 O4 F; r& M! u- F3 F
24. /* 占空比 */
    
25. sConfig.Pulse = pulse;
    
26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    6 @" r7 K) y7 n0 U
27. {
    
28.     Error_Handler(__FILE__, __LINE__);
    
29. }
    
30. 
    % _$ n' R+ h! L3 i9 A/ H
31. /* 启动PWM输出 */
    - b8 i9 `0 R1 }0 m5 w( v
32. if (HAL_TIM_PWM_Start(&TimHandle, TimChannel[_ucChannel]) != HAL_OK)
    
33. {
    
34.         Error_Handler(__FILE__, __LINE__);
    ! i% t" x6 _0 c& G! ?
35. }

复制代码

' m/ z" p% Q2 L* K8 J% r! m32.4.6 函数HAL_TIM_IC_Init
函数原型：

4 K2 Z: A  ^! l( M$ c" t

1. HAL_StatusTypeDef HAL_TIM_IC_Init(TIM_HandleTypeDef *htim)
   
2. {
   
3.   /* 检测形参是否有效 */
   
4.   if(htim == NULL)
   
5.   {
   
6.     return HAL_ERROR;
   # R; \0 S$ `$ }3 l0 O
7.   }
   4 }/ y, p+ F; ?; K- l% j
8. 
   
9.   /* 检测参数 */
   8 v( o+ X3 m6 D
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    4 u# I" H; T' p! d3 B; A& N" i
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    1 u0 z1 j: y" f, ~4 s' p1 N+ g4 C* [! n
13. 
    
14.   if(htim->State == HAL_TIM_STATE_RESET)
    , p6 {8 w2 p1 @1 Q7 S! C
15.   {
    
16. /* 默认取消锁 */
    + T4 \/ A6 H/ s, U- ]7 F9 s8 t
17.     htim->Lock = HAL_UNLOCKED;
    ) d; A6 Z2 |$ d
18. 
    
19.      /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    7 M8 n) ]; v( }( Y
20.     HAL_TIM_IC_MspInit(htim);
    ! ^0 }5 c* e7 Q6 T; d8 R. Q
21.   }
    & O1 D6 x5 c# r3 n4 X$ S* A# F
22. 
    ' p* _  l, W4 x0 h& @1 ~
23.   /* 设置定时器状态 */
    
24.   htim->State= HAL_TIM_STATE_BUSY;
    
25. 
    ( {0 q# K2 y. f: [+ m8 k
26.   /* 配置定时器为输入捕获模式 */  
    : A. f/ N1 y" Y% A3 `" p/ ^- P$ z' g
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
28. 
    
29.   /* 设置定时器状态 */
    
30.   htim->State= HAL_TIM_STATE_READY;
    5 p. }" t$ r, ]# T; v6 C5 l8 `
31. 
    
32.   return HAL_OK;
    ! W" [1 h' f8 ^. ~3 p8 y
33. }

复制代码

8 B" H2 ]- s9 }. V- d6 Z1 A  c函数描述：

+ h7 W; N* g" g# O! W5 N; G此函数用于定时器输入捕获初始化。

. f% i0 s$ H, {6 S函数参数：

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

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

/ C( R# M5 n5 e+ w( w, s1 {解决办法有三：
" V) y: j/ }. V" R
方法1：用户自己初始定时器和涉及到的GPIO等。
/ \% I( ]( `0 _
方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
3 N2 A3 c8 l, U$ z! j; J& _
方法3；下面的方法
' F! U; M" J# l0 e  z( J) J
; E! B3 c$ }  r' d6 T2 E: R

1. if(HAL_TIM_IC_DeInit(&UartHandle) != HAL_OK)
   
2. {
   
3.     Error_Handler();
   1 p5 s9 @8 I# c) t( h# b- b" b1 ~
4. }  
   $ D  {8 ]" U0 Q' g7 Z! _6 Y
5. if(HAL_TIM_IC_Init(&UartHandle) != HAL_OK)
   
6. {
   
7.     Error_Handler();
   
8. }

复制代码

1 @. g/ f. L5 {& {+ p% ~32.4.7 函数HAL_TIM_IC_ConfigChannel
5 T6 E# M" r* ^' p# w1 x. N函数原型：
; A; t/ ]; s1 k2 o. u
8 B7 |7 ]5 q( z* a% `6 M! O

1. HAL_StatusTypeDef HAL_TIM_IC_ConfigChannel(TIM_HandleTypeDef *htim, TIM_IC_InitTypeDef* sConfig, uint32_t Channel)
   
2. {
   $ V' s6 T; w9 x' _% e: N3 S
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
   
5.   assert_param(IS_TIM_IC_POLARITY(sConfig->ICPolarity));
   0 C' Y7 n) L$ F: n5 m+ B
6.   assert_param(IS_TIM_IC_SELECTION(sConfig->ICSelection));
   ! j- u" {0 t$ F: T4 Y7 y
7.   assert_param(IS_TIM_IC_PRESCALER(sConfig->ICPrescaler));
   
8.   assert_param(IS_TIM_IC_FILTER(sConfig->ICFilter));
   
9. 
   
10.   /* 开锁 */  
    ! s5 X; h1 z. i: X6 j
11.   __HAL_LOCK(htim);
    
12. 
    
13.   htim->State = HAL_TIM_STATE_BUSY;
    # W& ?; i7 K3 `8 q
14. 
    : z! s- F5 F- s" N" v3 G% }1 T
15.   if (Channel == TIM_CHANNEL_1)
    $ n) q* g3 `8 N* M
16.   {
    
17.     /* 配置输入通道1 */
    " `9 Q* {+ e, F( n# V' s+ D% o
18.     TIM_TI1_SetConfig(htim->Instance,
    ! S: ~' G/ h, M  [6 R
19.                sConfig->ICPolarity,
    
20.                sConfig->ICSelection,
    % T  R$ [: i5 l4 B6 |# h
21.                sConfig->ICFilter);
    ( n6 M6 Y- f0 v# o
22. 
    
23.     /* 清零IC1PSC位 */
    6 [0 I# b, Y8 Q
24.     htim->Instance->CCMR1 &= ~TIM_CCMR1_IC1PSC;
    
25. 
    / [+ t% ~: w$ c, Y, x+ X
26.     /* 根据用户配置，设置分频 */
    
27.     htim->Instance->CCMR1 |= sConfig->ICPrescaler;
    
28.   }
    
29.   else if (Channel == TIM_CHANNEL_2)
    # s# Z* U. r9 ^( d' D$ {
30.   {
    
31. /* 省略 */
    " i3 z2 ?, @7 ^. x2 A6 u4 Z
32.   }
    
33.   else if (Channel == TIM_CHANNEL_3)
    $ T4 f" b2 p% t" P& h3 ]! d
34.   {
    
35.      /* 省略 */
    
36.   }
    
37.   else
    $ ]+ U, k8 v: |( N4 V( H. ?
38.   {
    
39.      /* 省略 */
    
40.   }
    . L) Q, E5 z! }2 Z
41. 
    $ [1 ~: y6 n* \3 d
42.   htim->State = HAL_TIM_STATE_READY;
    
43. 
    * g4 f- A- N8 Z1 c' G8 f: w
44.   __HAL_UNLOCK(htim);
    * R) H4 n. h& w/ h4 X2 y
45. 
    " r* C9 w5 |  V
46.   return HAL_OK;
    5 k) K, e) q: }9 m9 @
47. }

复制代码

8 e: F! d3 N  _9 O6 u# x4 W函数描述：
, e7 G% B6 z3 C6 \; ]) M3 I
此函数用于配置定时器的输入捕获通道。
) L1 D; h5 \+ E, t
/ u! u6 E: i4 y) D+ d# M: w! X8 f函数参数：
) U: Y. R+ M" O& W; \
& T" w! B. P" ?: B% e$ @  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置
* o$ ^3 a9 E, m9 R8 Y; l) W  第2个参数是TIM_IC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
* g5 ]) r* J  Z: U6 G3 |  第3个参数是通道设置，支持以下参数：
. g, E. E5 @! n: JTIM_CHANNEL_1

9 N8 t. A9 ]" |2 `9 `TIM_CHANNEL_2

TIM_CHANNEL_3

TIM_CHANNEL_4
/ ~5 u; d) W7 z: Z# r% Q
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。

32.4.8 函数HAL_TIM_IC_Start_IT
函数原型：
' t8 ?& L# _/ h4 z! R$ k; F
3 R7 o4 K7 M; A* X3 z6 |

1. HAL_StatusTypeDef HAL_TIM_IC_Start_IT (TIM_HandleTypeDef *htim, uint32_t Channel)
   
2. {
   & R- Y, A) e2 ?* l) u
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   , h+ O3 i' ^( R2 Q/ U
5. 
   9 C, S7 i% e& O
6.   switch (Channel)
   
7.   {
   $ g0 Z* T; ~( {( N* t2 P& {
8.     case TIM_CHANNEL_1:
   % U8 Y2 R; T$ {8 N' r1 r" K
9.     {      
   
10.       /* 使能CC1（Capture/Compare 1）中断 */
    
11.       __HAL_TIM_ENABLE_IT(htim, TIM_IT_CC1);
    ( O' t8 l/ P0 a4 K; c
12.     }
    
13.     break;
    : U, v  [- F6 w4 @  [
14. 
    ' R2 B' {1 F2 @  x
15.     case TIM_CHANNEL_2:
    7 V% Q+ u! f% N/ m1 Q4 c
16.     {
    
17.    /* 省略 */
    
18.     }
    ! |5 e1 c, {2 v4 f) [
19.     break;
    
20. 
    / i/ _& W( V; O" S0 P& U
21.     case TIM_CHANNEL_3:
    4 @# P* c6 t1 U7 o& ^
22.     {
    
23.   /* 省略 */
    
24.     }
    , z- F' K' }* c& g0 v3 p
25.     break;
    $ T7 {0 i: E5 I3 l% K: ^/ `
26. 
    / D. N/ A; x, [% i# C3 J2 {* \$ p! q
27.     case TIM_CHANNEL_4:
    ' q8 j- G" W% g; ^
28.     {
    
29.   /* 省略 */
    ( C( y3 L2 l% }, O! X: a8 u
30.     }
    
31.     break;
    
32. 
    
33.     default:
    
34.     break;
    1 _: N" L( u: s9 H) A, Y* Y: N) C
35.   }  
    $ ?( g* ]+ F8 d( M: e) P& D
36.   /* 使能输入捕获通道 */
    
37.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
38. 
    % k, K  S6 \6 w" t' m: E# z; I. v
39.   /* 使能定时器 */
    5 M$ K; W9 b- b7 L7 }
40.   __HAL_TIM_ENABLE(htim);  
    + e! l( X- L( u$ E
41. 
    / ~1 c6 }4 i9 R: o- t+ q
42.   /* 返回状态 */
    
43.   return HAL_OK;  
    
44. }

复制代码

! r* n  {( m0 v0 ?7 j2 |函数描述：

此函数用于启动定时器输入捕获模式，采用定时器方式。
! l$ V5 Q; w8 h1 _4 M6 i. u
函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  第2个参数是通道设置，支持以下参数：
TIM_CHANNEL_1

7 B% m4 w1 q. l( W; g$ X7 eTIM_CHANNEL_2
5 P: X/ e$ q2 ^( ]1 J5 o
TIM_CHANNEL_3
1 `, m( C$ J; m. J* @
. E3 A  J6 k- N* n7 ETIM_CHANNEL_4
: P5 I- o/ h4 r" w# V: R/ T
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。

% W/ ?4 p! l4 _) y3 q% K- l32.4.9 函数HAL_TIM_OC_Init
函数原型：
% v$ s8 G9 H3 g3 \( E  o0 F
6 V8 T3 z1 M/ x$ f# k# X4 z3 l

1. HAL_StatusTypeDef HAL_TIM_OC_Init(TIM_HandleTypeDef* htim)
   
2. {
   ( j* [2 A/ c$ k9 [- `5 Q
3.   /* 检测形参是否有效 Check */
   
4.   if(htim == NULL)
   
5.   {
   
6.     return HAL_ERROR;
   6 @+ F6 y7 X& v4 P
7.   }
   
8. 
   
9.   /* 检查参数 */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    * O/ x8 U1 l" z  r; x8 \; U& x% u
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
      {0 X6 M) Z. R% k
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    , O+ @' m4 S8 k( X+ R
13. 
    
14.   if(htim->State == HAL_TIM_STATE_RESET)
    & }1 J" I$ t  n' u+ u: B
15.   {
    6 x5 H/ G: M$ j( W
16. /* 默认取消锁 */
    * l) A/ f- ^* V; H- Y% ~
17.     htim->Lock = HAL_UNLOCKED;
    7 h  W5 f2 }% Y
18. 
    
19. /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_OC_MspInit(htim);
    
21.   }
    
22. 
    % E7 \3 p# ]; S
23.   /* 设置定时器状态Set the TIM state */
    + E& f7 A% B6 U" t" e/ Q
24.   htim->State= HAL_TIM_STATE_BUSY;
    
25. 
    
26.   /* 配置定时器为输出比较模式Init the base time for the Output Compare */  
      Q- T: Q: m. q$ S7 c
27.   TIM_Base_SetConfig(htim->Instance,  &htim->Init);
    
28. 
    ; J  l! G( a/ Y/ t
29.   /* 设置定时器状态 */
    . V! _- W7 t0 W: A) p6 m4 \# E
30.   htim->State= HAL_TIM_STATE_READY;
    8 r2 R5 ~3 W4 ?$ T4 b- n
31. 
    
32.   return HAL_OK;
    2 y- G; P5 o* {$ S% Z0 C
33. }

复制代码

函数描述：

! V7 N) y5 c9 Q, e; H% O此函数用于定时器输出比较初始化。
, v/ l* `8 [: D8 o' K5 L
" y; P' U: y  r5 J  |函数参数：
- U" J0 O7 }/ S
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
1 {( m2 `) w; J2 X/ O0 q  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：
* X: H; @& B1 P
函数HAL_TIM_OC_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个HAL_TIM_STATE_RESET  = 0x00U。
$ Y1 o: h6 l! j6 {
解决办法有三：
- u/ G4 e2 a7 j( d# Q$ r7 s
方法1：用户自己初始定时器和涉及到的GPIO等。

方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
; `8 v; d- I1 j4 d/ T" }
方法3；下面的方法

- J/ }9 D0 K% [& K7 ]; }5 g

1. if(HAL_TIM_OC_DeInit(&UartHandle) != HAL_OK)
   
2. {
   8 ^& Y& w8 ^+ z+ }1 T, E3 Y6 T
3.     Error_Handler();
   
4. }  
     p4 m# C  N, ?! H( c
5. if(HAL_TIM_OC_Init(&UartHandle) != HAL_OK)
   
6. {
   7 \4 g. c$ V9 L" m# A5 C5 ?
7.     Error_Handler();
   ; Y) L9 k: X: H& ~8 ?" c. \
8. }

复制代码

9 Y# G- n/ |, u8 e1 {, V( u! P5 c' T9 O32.4.10   函数HAL_TIM_OC_ConfigChannel
函数原型：

+ Q6 g6 p- R  f: O; E7 j$ s

1. HAL_StatusTypeDef HAL_TIM_OC_ConfigChannel(TIM_HandleTypeDef *htim,
   9 A9 S0 |9 q4 O- o
2.                                            TIM_OC_InitTypeDef* sConfig,
   
3.                                            uint32_t Channel)
   2 W* ^0 u1 T' I5 B* z
4. {  
   
5.   /* Check the parameters */
   4 P$ L+ {! J3 F1 p) g' H( ?
6.   assert_param(IS_TIM_CHANNELS(Channel));
   5 x* j- z+ C+ l) X
7.   assert_param(IS_TIM_OC_MODE(sConfig->OCMode));
   
8.   assert_param(IS_TIM_OC_POLARITY(sConfig->OCPolarity));
   
9. 
   / S: j: R0 j9 K: |8 r
10.   /* Process Locked */
    
11.   __HAL_LOCK(htim);
    / ?9 R- h& ]* `
12. 
    % T# \% Q7 x3 |- C
13.   htim->State = HAL_TIM_STATE_BUSY;
    
14. 
    0 c8 L) N7 N9 b8 e6 m
15.   switch (Channel)
    3 o. T: D! ]4 r; ^0 m$ m
16.   {
    
17.     case TIM_CHANNEL_1:
    - J- C9 t3 G5 F6 F; b
18.     {
    
19.       /* 检测参数Check the parameters */
      W" y( k6 e% a$ d
20.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    
21. 
    
22.      /* 配置定时器输出比较通道1 */
    
23.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    
24.     }
    
25.     break;
    # z4 q) [; g  t( d
26. 
    
27.     case TIM_CHANNEL_2:
      ?( e5 V, ?) z1 `  Q: ]4 j' Y
28.     {
    
29.       /* 省略 */
    8 A; T, n5 r6 P: ]% [1 _2 ~
30.     }
    
31.     break;
    
32. 
    5 h( L' @' z" p4 Q$ G8 W  \
33.     case TIM_CHANNEL_3:
    9 ~. `9 \) t9 Y
34.     {
    ; B: o% W$ ^! t0 a. q* f
35.       /* 省略 */
    7 y; M3 ?% t; ^
36.     }
    9 ?! t3 i$ T- `) P1 {$ Z- W
37.     break;
    : F/ Q7 |' S+ d' o3 z$ F
38. 
    
39.     case TIM_CHANNEL_4:
    
40.     {
    - c- e- ~$ C; R2 z! M8 o6 H
41.       /* 省略 */
    
42.     }
      B8 x" k) P9 x' B
43.     break;
    
44. 
    & [, H/ @7 u- U* u' c
45.     case TIM_CHANNEL_5:
    ( F& I6 {2 F: n8 i
46.     {
    # `2 `! i% s4 g  D  x) k$ b+ a+ e
47.       /* 省略 */
    6 f4 X0 A2 w, _; }" a
48.     }
    
49.     break;
    - V, e& F5 A/ m, ]$ ?/ d# |
50. 
    # V- ^) Q7 z* A9 }9 R6 v2 j
51.     case TIM_CHANNEL_6:
    
52.     {
    + a8 a+ [8 w$ c8 M# |' O
53.       /* 省略 */
    4 w. W/ K3 B* S# K% `
54.     }
    
55.     break;
    
56. 
    . m3 ?0 D3 L# c7 I( F; Z" o: l
57.     default:
    9 k" ^% R" Q$ V
58.     break;   
    
59.   }
    # A) r2 ^+ e" X' x9 X4 W8 v' ^1 O
60. 
    
61.   htim->State = HAL_TIM_STATE_READY;
    9 N) G( }8 a' v0 m4 m) _
62. 
    
63.   __HAL_UNLOCK(htim);
    - w& \& z7 [6 U8 e
64. 
    7 p# T0 n. T. m3 J" Z  l
65.   return HAL_OK;
    6 a+ _6 `6 j. y( S* a5 ?/ M
66. }

复制代码

8 m9 p7 j9 D4 H7 B4 k- Z. @( A9 K0 x函数描述：

此函数用于初始化串口的基础特性和高级特性。
) R/ U* a- f: H3 p  e4 h
5 Y' ]( M2 T' Q函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
! d6 D- x$ K% W; H  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
TIM_CHANNEL_1
6 v: W: a+ T( H$ h, a5 ]" J
TIM_CHANNEL_2
9 L6 ^. y' {! X& `5 I" q( |! a( K
8 S8 ~  ~- b+ x; o( xTIM_CHANNEL_3

TIM_CHANNEL_4
$ U1 r# o; b$ G+ k8 a* L
' l- L; z0 G& X2 QTIM_CHANNEL_5
- Q. q+ m- g, G' ~) t; [
TIM_CHANNEL_6
% l# Q' y/ v. P- z3 E
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
+ j4 E' [) L) C- U1 X$ ?% t0 N
32.4.11   函数HAL_TIM_OC_Start
( ]8 J/ R0 {; \函数原型：
+ X& Z* b! @0 K- j% e0 Z, n
4 m$ O$ @( q2 R8 D2 X

1. HAL_StatusTypeDef HAL_TIM_OC_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
   
2. {
   
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   : x; O- c, G( _
5. 
   
6.   /* 使能输出比较通道 */
   7 q0 y" Z7 L% Z- d6 G# k
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   ! j) r9 o2 |1 C  b8 I
8. 
   ( G, s/ p2 C! |
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
   
10.   {
    % y+ R& e$ @9 k  m. x% A) q
11.     /* 使能主输出 */
    
12.     __HAL_TIM_MOE_ENABLE(htim);
    5 o- t: n3 Y5 Q; U! _
13.   }
    ! M& k1 U0 H; v8 g5 f
14. 
    - F. D0 @# r, w% k8 v* s
15.   /* 使能定时器 */
    . c6 S$ O3 h3 Y( ?% \2 O3 R
16.   __HAL_TIM_ENABLE(htim);
    
17. 
    ' V' g" v6 x* E  L
18.   /* 返回状态 */
    
19.   return HAL_OK;
    3 F- K4 s' G- X6 v6 o5 y7 [
20. }

复制代码

函数描述：

此函数用于启动定时器输出比较模式。

函数参数：
( V" W! o; o2 @+ @  h1 L' J
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
2 D2 v' K) D6 C. }. M  第2个参数是通道设置，支持以下参数：
& U4 Z% L  f+ c, ~! dTIM_CHANNEL_1
& @0 g/ |, t* L0 e+ _3 g
TIM_CHANNEL_2

TIM_CHANNEL_3
& D( r# D, v6 ?% ~
TIM_CHANNEL_4
! b3 D" C- a! l% u4 A8 s
& k+ A' ?/ i! B# Y* [2 }+ g. y  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
% y% ]0 J7 |9 \$ j
32.5 总结
本章节就为大家讲解这么多，建议大家将GPIO的驱动源码结合参考手册中的寄存器通读一遍，对于我们后面章节的学习大有裨益。
2 I0 w2 ~6 a8 ?2 G4 b* P
4 z. |/ @1 a" E. B
; Y% O/ G9 g  @
) A# D/ W$ p2 x5 r0 O% o2 v