32.1 初学者重要提示
9 ^2 t0 J: l, y2 y0 z* M) T  学习定时器外设推荐从硬件框图开始了解基本的功能特性，然后逐步深入了解各种特性，这种方式方便记忆和以后查阅。
. q8 k) H, A3 B3 M5 O  STM32H7的定时器输出100MHz方波是完全没问题。
  STM32H7定时器进出中断的速度能跑到12.5MHz，所有程序在TCM和Flash运行没差别。
6 F# i% x8 I/ I7 d  STM32H7的定时器输入捕获可以实现12MHz方波的双边沿捕获，单边沿可以做到24MHz。
3 N4 d# [* y8 S  特别注意STM32H7的TIM1,8,15,16,17才有RCR重复计数器，其它都没用的。
  STM32H7的单个定时器中不同通道可以配置不同频率PWM。
  STM32H7的TIM1-TIM17中断入口函数名使用时要注意，别搞错了：

1. TIM1_BRK_IRQHandler            
   , u' x9 Y* D/ ~' Q( u% [& u
2. TIM1_UP_IRQHandler              
   4 j% r7 B8 T+ q; K  {
3. TIM1_TRG_COM_IRQHandler        
   2 K- C. `2 X, `
4. TIM1_CC_IRQHandler                                                   
   
5. TIM2_IRQHandler                                          
   & ~6 t6 ?, M+ u
6. TIM3_IRQHandler                                                
   
7. TIM4_IRQHandler                 
   ; w! e# \% b1 ^
8. TIM5_IRQHandler            
   
9. TIM6_DAC_IRQHandler           <------------------要注意            
   2 ^8 v. d) y$ R% D
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
      o$ m% P& P/ Y+ ^
16. TIM16_IRQHandler
    
17. TIM17_IRQHandler

复制代码

32.2 定时器基础知识
9 E# O: N8 Y+ x- @/ h9 `2 ?注，不同定时支持的功能略有区别，基础定时器功能较少，TIM1和TIM8高级定时器功能多些。
% E1 R- V: W2 H- m% {/ r3 J' R
' T  i3 B; x9 A# \  TIM2和TIM5是32位定时器，其它定时器都是16位定时器。16位和32位的区别是CNT计数器范围不同，32位的范围是0 到2^32 – 1，而16位的是0到65535；它们支持的分频是范围是一样的，都是1到65535。
1 d* L# O9 e. k  计数器支持递增、递减和递增/递减二合一。
  多个独立通道，可用于：
9 ?. _- X8 L( B  }– 输入捕获。

' R1 M7 i+ \7 @# M. R! c– 输出比较。
, a; h) h9 d/ w! U5 T. `- F
2 o& ~- l. {3 u0 d– PWM 生成（边沿和中心对齐模式）。

– 单脉冲模式输出。

/ l0 M. H1 j4 E+ y5 Z" Z  带死区插入，断路功能和PWM互补输出
  发生如下事件时生成中断/DMA 请求：
– 更新：计数器上溢/下溢、计数器初始化（通过软件或内部/外部触发）

' m* _; n( R8 ]4 A– 触发事件（计数器启动、停止、初始化或通过内部/外部触发计数）

. C/ `9 r( _8 V* ^' i8 N8 q– 输入捕获

3 i# J1 W. B. J4 F– 输出比较
- J( f% m1 q- X0 ~6 ~, S
* o1 R; T. u: f+ [4 ^  支持增量式编码器和霍尔传感器。
: ~4 U" Z9 j. g! W32.2.1 定时器TIM1-TIM17的区别
% Y6 q; a4 r3 f6 g6 xSTM32H7支持的定时器有点多，要简单的区分下。STM32H7支持TIM1-TIM8，TIM12-TIM17共14个定时器，而中间的TIM9，TIM10，TIM11是不存在的，这点要注意。
' k1 G+ d( f4 n5 i
粗略的比较如下：

7 h$ [+ {6 Y- u( [6 u4 a# f- w

8 T6 c7 r+ m7 _: q3 V) `
, g$ m! }2 i. ^( G$ N: }6 y通过上面的表格，至少要了解到以下两点：
7 F! i& e0 C; W
7 V3 f4 h, S8 ^1 e% [' {, I  STM32H7的定时器主要分为高级定时器，通用定时器，基础定时器和低功耗定时器。
# w- y# i6 @$ J) {, d9 R- i6 Q  TIM2和TIM5是32位定时器，其它都是16位定时器。
9 `% S$ X: n) J  X. e6 @7 Y+ W32.2.2 定时器的硬件框图
$ E* F  F% ~5 r9 W. v认识一个外设，最好的方式就是看他的框图，方便我们快速的了解定时器的基本功能，然后再看手册了解细节。

下面我们直接看最复杂的高级定时器TIM1&TIM8框图：
0 S# u" J% |7 ^% g
& \4 h" E; c; I! `5 C/ W

' N6 `: t5 V, |' p+ o  P2 p4 p" m7 w' Y2 d3 B通过这个框图，我们可以得到如下信息：

  TIMx_ETR接口
" S; \4 q! [/ |+ D) v/ n. v外部触发输入接口。ETR支持多种输入源：输入引脚（默认配置）、比较器输出和模拟看门狗。
/ i8 B7 u, F' L, h6 |% b9 P: b

! ^) Y$ a8 q1 d( h/ ~6 g" Y
  截图左侧的TIMx_CH1，TIMx_CH2，TIMx_CH3和TIMx_CH4接口
这四个通道主要用于输入捕获，可以计算波形频率和脉宽。                                                                                                                             
. T# k0 U6 n; P
  TIMx_BKIN和TIMx_BKIN2接口
% O' p4 d; d( _' V9 [/ h断路功能，主要用于保护由 TIM1 和 TIM8 定时器产生的 PWM 信号所驱动的功率开关

  TRGO内部输出通道
主要用于定时器级联，ADC和DAC的定时器触发。
% B% k: S3 G2 T& v( ]; j) n
  6组输出比较单元OC1到OC6
OC1到OC4有对应的输出引脚，而OC5和OC6没有对应的输出引脚，主要用于内部控制。
9 B6 X) Z  U/ h9 x
2 Q  ?1 t$ q, _  截图右侧的输出比较通道TIMx_CH1，TIMx_CH1N，TIMx_CH2，TIMx_CH2N，TIMx_CH3，TIMx_CH3N和TIMx_CH4
主要用于PWM输出，注意CH1到CH3有互补输出，而CH4没有互补输出。

  其它框图里面未展示出来功能
5 k# h; l! }' {定时器TIM1&TIM8还支持的其它功能在用到的时候再做说明。
1 X& c; S* J+ w7 S& ~0 ^
32.2.3 定时器的时基单元
定时器要工作就需要一个基本时基单元，而基本的时基单元是由下面几个寄存器组成的：

- k1 R: M% }1 D  预分频器寄存器 (TIMx_PSC)
' {/ q9 @1 y) m6 d% L5 t用于设置定时器的分频，比如定时器的主频是200MHz，通过此寄存器可以将其设置为100MHz，50MHz，25MHz等分频值。

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

  计数器寄存器 (TIMx_CNT)
计数器是最基本的计数单元，计数值是建立在分频的基础上面，比如通过TIMx_PSC设置分频后的频率为100MHz，那么计数寄存器计一次数就是10ns。
' g' Y; x  {: c' A5 z6 ?7 v. A
8 ]1 G% @6 `* k% }0 M3 J  自动重载寄存器 (TIMx_ARR)
! g$ Z' J7 s* L0 Y: E" K自动重装寄存器是CNT计数寄存器能达到的最大计数值，以递增计数模式为例，就是CNT计数器达到ARR寄存器数值时，重新从0开始计数。
' E$ |; l" M! F# M5 D# Y
1 w2 Q& h0 ~$ N+ U注，自动重载寄存器是预装载的。对自动重载寄存器执行写入或读取操作时会访问预装载寄存器。预装载寄存器的内容既可以立即传送到影子寄存器（让设置立即起到效果的寄存器），也可以在每次发生更新事件时传送到影子寄存器。简单的说就是让ARR寄存器的数值立即更新还是更新事件发送的时候更新。

8 A8 U! k1 h- y- w  重复计数器寄存器 (TIMx_RCR)
6 D' G/ ?& b. e; z# o以递增计数模式为例，当CNT计数器数值达到ARR自动重载数值时，重复计数器的数值加1，重复次数达到TIMx_RCR+ 1后就，将生成更新事件。

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

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

7 u" D6 _: d8 L- W" }- s* ?32.2.4 定时器输出比较（PWM）
使用定时器时基单元的那几个寄存器仅仅能设置周期，还不能设置占空比。针对这个问题，还需要比较捕获寄存CCR的参与，这样就可以设置占空比了。
* u/ `1 ^# z- a+ ?3 }! ~
为了方便大家理解，以PWM 边沿对齐模式，递增计数配置为例：

* V, u( |9 m7 e9 S  当计数器TIMx_CNT < 比较捕获寄存器TIMx_CCRx期间，PWM参考信号OCxREF输出高电平。
$ w' }8 G  n8 f0 G% J  当计数器TIMx_CNT >= 比较捕获寄存器TIMx_CCRx期间， PWM参考信号OCxREF输出低电平。
  当比较捕获寄存器TIMx_CCRx > 自动重载寄存器TIMx_ARR，OCxREF保持为1。
, g9 p. d5 a; B) Y2 U( l3 U  当比较捕获寄存器TIMx_CCRx = 0，则OCxRef保持为0。
下面是TIMx_ARR=8的波形效果：
3 l, i: q' b$ F  k& i7 r
8 q! u+ m; i* r1 F/ R% E0 d$ L

  l, V* b2 S9 ^  @5 G
32.2.5 定时器输入捕获
. j$ z& y, E1 b* T与PWM一样，使用定时器实现输入捕获，仅靠时基单元的那几个寄存器是不行的，我们需要一个寄存器来记录发生捕获时的具体时间，这个寄存器依然由比较捕获寄存器TIMx_CCRx来实现。
0 Z8 r! T2 {& f4 ]; a6 q* L8 t
比如我们要测量一路方波的周期：
7 I2 M% g0 r: Q7 F( x6 x: T
  配置定时器为输入捕获模式，上升沿触发，设置分频，自动重装等寄存器，比如设置的CNT计数器计数1次是1微秒。
, G! y& x4 \( V% p) v( j* y  当有上升沿触发的时候，TIMx_CCRx寄存器就会自动记录当前的CNT数值，然后用户就可以通过CC中断，在中断复位程序里面保存当前的TIMx_CCRx寄存器数值。等下次再检测到上升沿触发，两次时间求差就可以得到方波的周期。
$ X) s; V9 r: |) O- E不过这里要特别注意一点，如果CNT发生溢出（比如16位定时器，计数到65535就溢出了）就需要特别处理下，将CNT计数溢出考虑进来。

32.3 定时器的HAL库用法
定时器的HAL库用法其实就是几个结构体变量成员的配置和使用，然后配置GPIO、时钟，并根据需要配置NVIC、中断和DMA。下面我们逐一展开为大家做个说明。
. u. d+ H) [" `+ {$ r
32.3.1 定时器寄存器结构体TIM_TypeDef
8 d/ l8 t9 O* x6 V/ E# }定时器相关的寄存器是通过HAL库中的结构体TIM_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：
0 C* a8 K8 x' h+ l
# E; Z+ A5 K% J& L7 Z0 v2 W

1. typedef struct
   
2. {
   
3.   __IO uint16_t CR1;         /*!< TIM control register 1,                   Address offset: 0x00 */
   
4.   uint16_t      RESERVED0;   /*!< Reserved, 0x02                                                 */
   3 r" d: |# s. X  G& ~
5.   __IO uint32_t CR2;         /*!< TIM control register 2,                   Address offset: 0x04 */
   
6.   __IO uint32_t SMCR;        /*!< TIM slave mode control register,          Address offset: 0x08 */
   
7.   __IO uint32_t DIER;        /*!< TIM DMA/interrupt enable register,        Address offset: 0x0C */
   
8.   __IO uint32_t SR;          /*!< TIM status register,                      Address offset: 0x10 */
   
9.   __IO uint32_t EGR;         /*!< TIM event generation register,            Address offset: 0x14 */
   
10.   __IO uint32_t CCMR1;       /*!< TIM capture/compare mode register 1,      Address offset: 0x18 */
      K/ W) Z, `* [4 Y" o/ {0 s6 `
11.   __IO uint32_t CCMR2;       /*!< TIM capture/compare mode register 2,      Address offset: 0x1C */
    9 e' ~& I1 Z/ G$ [# g0 x8 U& N
12.   __IO uint32_t CCER;        /*!< TIM capture/compare enable register,      Address offset: 0x20 */
    
13.   __IO uint32_t CNT;         /*!< TIM counter register,                     Address offset: 0x24 */
    , ~- T3 B" s# x( g4 y
14.   __IO uint16_t PSC;         /*!< TIM prescaler,                            Address offset: 0x28 */
    
15.   uint16_t      RESERVED9;   /*!< Reserved, 0x2A                                                 */
    % j  S7 q0 o' A( E; w
16.   __IO uint32_t ARR;         /*!< TIM auto-reload register,                 Address offset: 0x2C */
    " ~* G( O% n7 j1 U6 I1 F- A5 Y
17.   __IO uint16_t RCR;         /*!< TIM repetition counter register,          Address offset: 0x30 */
    5 |2 ?- F6 f; _7 x4 \4 ~! C" q9 _' ]
18.   uint16_t      RESERVED10;  /*!< Reserved, 0x32                                                 */
    # ?8 I6 Y! x' E9 p
19.   __IO uint32_t CCR1;        /*!< TIM capture/compare register 1,           Address offset: 0x34 */
    
20.   __IO uint32_t CCR2;        /*!< TIM capture/compare register 2,           Address offset: 0x38 */
    
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 ]0 w, w0 ?% p$ Q
24.   __IO uint16_t DCR;         /*!< TIM DMA control register,                 Address offset: 0x48 */
    ; {/ h7 U$ G. @( U
25.   uint16_t      RESERVED12;  /*!< Reserved, 0x4A                                                 */
    
26.   __IO uint16_t DMAR;        /*!< TIM DMA address for full transfer,        Address offset: 0x4C */
    
27.   uint16_t      RESERVED13;  /*!< Reserved, 0x4E                                                 */
    # E! ~  M* _, j0 }
28.   uint16_t      RESERVED14;  /*!< Reserved, 0x50                                                 */
    
29.   __IO uint32_t CCMR3;       /*!< TIM capture/compare mode register 3,      Address offset: 0x54 */
    - Q0 ^; x% n1 V" S
30.   __IO uint32_t CCR5;        /*!< TIM capture/compare register5,            Address offset: 0x58 */
    
31.   __IO uint32_t CCR6;        /*!< TIM capture/compare register6,            Address offset: 0x5C */
    + F2 [; U/ t  P- [
32.   __IO uint32_t AF1;         /*!< TIM alternate function option register 1, Address offset: 0x60 */
    
33.   __IO uint32_t AF2;         /*!< TIM alternate function option register 2, Address offset: 0x64 */
    5 J. s. j; T" p: W1 R. O3 h% Q) h
34.   __IO uint32_t TISEL;       /*!< TIM Input Selection register,             Address offset: 0x68 */
    
35. } TIM_TypeDef;

复制代码

: J) P4 N' ^9 ]+ V/ a7 y/ x; ~这个结构体的成员名称和排列次序和CPU的定时器寄存器是一 一对应的。

__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
9 M! Z6 u( L; U6 i

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   0 I+ r0 j" |/ d& w- W/ w
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

下面我们看下定时器的定义，在stm32h743xx.h文件。
7 \- @4 D. V' l# ]) P5 m$ m

1. #define PERIPH_BASE         ((uint32_t)0x40000000)
   3 u. ?& N3 T% s0 |) n6 J) c$ T2 O
2. #define D2_APB1PERIPH_BASE   PERIPH_BASE
   ; ^, i' _3 h/ ]" C) z7 T( T
3. #define D2_APB2PERIPH_BASE   (PERIPH_BASE + 0x00010000)
   
4. 
   0 d( W, C- M; B. y1 e9 S
5. /*!< D2_APB1PERIPH 外设 */
   
6. #define TIM2_BASE             (D2_APB1PERIPH_BASE + 0x0000) <----- 展开这个宏，(TIM_TypeDef *) 0x40000000
   
7. #define TIM3_BASE             (D2_APB1PERIPH_BASE + 0x0400)
   
8. #define TIM4_BASE             (D2_APB1PERIPH_BASE + 0x0800)
   
9. #define TIM5_BASE             (D2_APB1PERIPH_BASE + 0x0C00)
   
10. #define TIM6_BASE             (D2_APB1PERIPH_BASE + 0x1000)
    " I3 l+ f  P6 s7 P
11. #define TIM7_BASE             (D2_APB1PERIPH_BASE + 0x1400)
    5 o0 V8 J0 S5 f
12. #define TIM12_BASE            (D2_APB1PERIPH_BASE + 0x1800)
    ! Q! V9 a+ p0 g6 L* Z2 d
13. #define TIM13_BASE            (D2_APB1PERIPH_BASE + 0x1C00)
    
14. #define TIM14_BASE            (D2_APB1PERIPH_BASE + 0x2000)
    
15. 
    
16. /*!< D2_APB1PERIPH 外设 */
    ' T0 L! U" S% D6 Y5 M4 \, i
17. #define TIM1_BASE             (D2_APB2PERIPH_BASE + 0x0000)
    
18. #define TIM8_BASE             (D2_APB2PERIPH_BASE + 0x0400)
    
19. #define TIM15_BASE            (D2_APB2PERIPH_BASE + 0x4000)
    - z/ W( c5 n) D% b, ~" H# {" `
20. #define TIM16_BASE            (D2_APB2PERIPH_BASE + 0x4400)
    ; B5 D0 x/ _$ R8 F5 d+ a0 L1 T
21. #define TIM17_BASE            (D2_APB2PERIPH_BASE + 0x4800)
    
22. 
    
23. #define TIM1                ((TIM_TypeDef *) TIM1_BASE)
    
24. #define TIM2                ((TIM_TypeDef *) TIM2_BASE)
    
25. #define TIM3                ((TIM_TypeDef *) TIM3_BASE)
    # x+ F! ~! s# x2 F) e
26. #define TIM4                ((TIM_TypeDef *) TIM4_BASE)
    : D) c' k0 z$ e$ K! v
27. #define TIM5                ((TIM_TypeDef *) TIM5_BASE)
    
28. #define TIM6                ((TIM_TypeDef *) TIM6_BASE)
    , F3 r3 i8 p% l8 h
29. #define TIM7                ((TIM_TypeDef *) TIM7_BASE)
    
30. #define TIM8                ((TIM_TypeDef *) TIM8_BASE)
    
31. #define TIM12               ((TIM_TypeDef *) TIM12_BASE)
    & @/ {8 K9 U3 \' p: u8 ^1 R4 s
32. #define TIM13               ((TIM_TypeDef *) TIM13_BASE)
    , P% E4 ]% K; O9 N; A7 w
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)

复制代码

3 i) [+ S( @9 P# a2 h# _我们访问TIM2的CR1寄存器可以采用这种形式：TIM2->CR1 = 0；

32.3.2 定时器句柄结构体TIM_HandleTypeDef
HAL库在TIM_TypeDef的基础上封装了一个结构体TIM_HandleTypeDef，定义如下：

1. typedef struct
   / `( ^) c% O# [" |. }. c9 v
2. {
   
3.   TIM_TypeDef              *Instance;     /*!< Register base address             */
   
4.   TIM_Base_InitTypeDef     Init;          /*!< TIM Time Base required parameters */
   8 K: C6 e4 x0 `
5.   HAL_TIM_ActiveChannel    Channel;       /*!< Active channel                    */
   / ?$ \, C  c5 b
6. 
   # s+ E3 M0 h% V) R5 N$ c5 e' X# D
7. /*!< DMA Handlers array This array is accessed by a @ref DMA_Handle_index */
   
8.   DMA_HandleTypeDef        *hdma[7];      
   ( T/ l6 _9 x- f. w4 ^
9.   HAL_LockTypeDef          Lock;          /*!< Locking object                    */
   
10.   __IO HAL_TIM_StateTypeDef   State;      /*!< TIM operation state               */  
    
11. }TIM_HandleTypeDef;

复制代码

+ d! `5 z; p$ E. x+ V7 ?这里重点介绍前四个参数，其它参数主要是HAL库内部使用的。
" {' P' ]$ N# K( {1 L3 h' z) y% v
& u  ^, J& ]) c- v1 W# L8 g  TIM_TypeDef  *Instance

这个参数是寄存器的例化，方便操作寄存器，比如使能定时器的计数器。

* e. u; y  P5 b; O0 ?2 u2 MSET_BIT(huart->Instance->CR1,  TIM_CR1_CEN)。
4 z  d6 N  Z/ w# S& o
  TIM_Base_InitTypeDef  Init
7 f6 _* i) n: |' J( q( {* ^5 I  d
7 [3 n: d* z( U这个参数是用户接触最多的，用于配置定时器的基本参数。
! f1 d2 J; V& K! r
7 D( v$ T$ N# }/ e$ CTIM_Base_InitTypeDef结构体的定义如下：

1. typedef struct
   
2. {
   4 p# `4 ]5 I* {: y$ F1 n. i/ B: @
3.   uint32_t Prescaler;      
   
4.   uint32_t CounterMode;   
   ! Q  A; ^5 G5 m- c
5.   uint32_t Period;         
   8 k* h% {' e$ c+ B: j  ]
6.   uint32_t ClockDivision;   
   
7.   uint32_t RepetitionCounter;
   
8.   uint32_t AutoReloadPreload;  
   
9. } TIM_Base_InitTypeDef;

复制代码

+ P! u1 W; [1 U, E+ q  成员Prescaler
. G3 F* u6 z" W1 X5 n. j用于设置定时器分频，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。

  成员CounterMode
1 T3 [) }6 s0 }. y) E0 Y6 h5 F; ]- q* S用于设置计数模式，向上计数模式、向下计数模式和中心对齐模式。

1. 
   % A0 v' @$ V  ^/ ^$ Q4 }( P4 `
2. #define TIM_COUNTERMODE_UP                ((uint32_t)0x0000U)   /*!< Up counting mode */
   
3. #define TIM_COUNTERMODE_DOWN               TIM_CR1_DIR          /*!< Down counting mode */
   
4. #define TIM_COUNTERMODE_CENTERALIGNED1     TIM_CR1_CMS_0        /*!< Center-aligned counting mode 1 */
   
5. #define TIM_COUNTERMODE_CENTERALIGNED2     TIM_CR1_CMS_1        /*!< Center-aligned counting mode 2 */
   9 |& Z0 f8 v4 Q7 a3 W1 {
6. #define TIM_COUNTERMODE_CENTERALIGNED3     TIM_CR1_CMS          /*!< Center-aligned counting mode 3 */

复制代码

$ D4 q: z3 m# C# g  成员Period
用于设置定时器周期，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。
2 H" b$ X, L/ d$ V
  成员ClockDivision
用于指示定时器时钟 (CK_INT) 频率与死区发生器以及数字滤波器（ETR、TIx）所使用的死区及采样时钟 (tDTS) 之间的分频比。

1. 
   
2. #define TIM_CLOCKDIVISION_DIV1       ((uint32_t)0x0000U)        /*!< Clock Division DIV1 */
   " @* T+ G0 l. r
3. #define TIM_CLOCKDIVISION_DIV2       (TIM_CR1_CKD_0)            /*!< Clock Division DIV2 */
   4 c( U  l+ p! I6 Q6 w; E; T
4. #define TIM_CLOCKDIVISION_DIV4       (TIM_CR1_CKD_1)             /*!< Clock Division DIV4 */

复制代码

  成员RepetitionCounter
% B& F& i& \- i' c3 M) ~用于设置重复计数器，仅TIM1和TIM8有，其它定时器没有。作用是每当计数器上溢/下溢时，重复计数器减1，当减到零时，才会生成更新事件，这个在生成PWM时比较有用。
5 X: u" t: a( a. K  C8 U
  成员AutoReloadPreload
用于设置定时器的ARR自动重装寄存器是更新事件产生时写入有效还是立即写入有效。如果使能了表示更新事件产生时写入有效，否则反之。

1 l; W; ~3 s# N# |* O% k4 T6 q

1. #define TIM_AUTORELOAD_PRELOAD_DISABLE   ((uint32_t)0x0000U)   /*!< TIMx_ARR register is not buffered */
   1 O3 ?& `% T9 ?& @8 Q* u
2. #define TIM_AUTORELOAD_PRELOAD_ENABLE    (TIM_CR1_ARPE)        /*!< TIMx_ARR register is buffered */

复制代码

  HAL_TIM_ActiveChannel    Channel;

# K9 r- X2 T7 q! |# K5 H用于设置定时器通道，比如TIM1和TIM8都是6个通道。
4 X$ s. G3 F. A0 ]/ S$ C

1. typedef enum
   4 N; n  s. \4 V4 O
2. {
   $ K7 H4 o( D+ q0 k8 s' |) R5 B
3.   HAL_TIM_ACTIVE_CHANNEL_1        = 0x01U,    /*!< The active channel is 1     */
   , \( O( l0 i( ~$ ^
4.   HAL_TIM_ACTIVE_CHANNEL_2        = 0x02U,    /*!< The active channel is 2     */
   . M# w. O/ l( l; B) E: h" ?
5.   HAL_TIM_ACTIVE_CHANNEL_3        = 0x04U,    /*!< The active channel is 3     */   
   % q# K9 p$ a' j- X  ]: d3 i
6.   HAL_TIM_ACTIVE_CHANNEL_4        = 0x08U,    /*!< The active channel is 4     */
   ) P4 l" D, |! ^& h
7.   HAL_TIM_ACTIVE_CHANNEL_5        = 0x10U,    /*!< The active channel is 5     */
   
8.   HAL_TIM_ACTIVE_CHANNEL_6        = 0x20U,    /*!< The active channel is 6     */
   7 M" H: ~$ \7 M' Z# E; p' _
9.   HAL_TIM_ACTIVE_CHANNEL_CLEARED  = 0x00U     /*!< All active channels cleared */   
   
10. }HAL_TIM_ActiveChannel;

复制代码

  DMA_HandleTypeDef        *hdma[7];
! _; V9 J# j% h5 ?
8 ^. K0 P- [  y. d用于关联DMA。

配置定时器参数，其实就是配置结构体TIM_HandleTypeDef的成员。
0 w  A- {9 I8 d" H8 d' G
/ ]0 {# U; a! m4 e! M

1. TIM_HandleTypeDef   TimHandle = {0};
   ! H. k! r1 R! }
2. 
   
3. /*
   
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   
6. TimHandle.Instance = TIMx;
   1 _4 E/ ?8 h7 E+ i% I
7. TimHandle.Init.Prescaler         = usPrescaler;
   ! [0 N. e" h0 K) {6 v# T
8. TimHandle.Init.Period            = usPeriod;        
   
9. TimHandle.Init.ClockDivision     = 0;
   * t( L. e2 G5 f) W" L' s
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    ! {2 g7 U. L4 N7 r/ W$ ~
11. TimHandle.Init.RepetitionCounter = 0;
    
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    ( u( v* E8 o1 F: h) K! b
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    # D+ @6 H" Y# v
14. {
    
15.         Error_Handler(__FILE__, __LINE__);
    ! y2 H3 p$ Z* e/ S
16. }

复制代码

32.3.3 定时器输出比较结构体TIM_OC_InitTypeDef
此结构体主要用于定时器的输出比较，定义如下：

% }  @9 i6 d7 Z5 t' q

1. typedef struct
   
2. {                                 
   / a1 S: F4 C3 m1 l
3.   uint32_t OCMode;      
   
4.   uint32_t Pulse;      
   2 d- V1 q2 c5 u$ i2 S8 [9 D0 D
5.   uint32_t OCPolarity;   
   
6.   uint32_t OCNPolarity;   
   
7.   uint32_t OCFastMode;  
   
8.   uint32_t OCIdleState;   
   
9.   uint32_t OCNIdleState;  
   3 L1 p- p  \- i% Z6 x
10. } TIM_OC_InitTypeDef;  

复制代码

( @& J) x* M7 V& ~3 G( b下面将这几个参数一 一做个说明。
5 E, N" m: j/ ^6 L
  OCMode
% z  ~, F+ y" b6 z用于配置输出比较模式，支持的模式较多：
9 V  _. l0 {2 q! ?

1. /*!< TIM Output timing mode */
   , k. W) B/ r7 b) d  y* `$ ?
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)
   
6. 
   
7. /*!< TIM Output Inactive mode */                       
   : @5 K6 ]5 B" G+ z3 H) t3 q
8. #define TIM_OCMODE_INACTIVE              ((uint32_t)TIM_CCMR1_OC1M_1)           
   6 _% r# B! O( V" g5 c
9. 
   
10. /*!< TIM Output Toggle mode */               
    
11. #define TIM_OCMODE_TOGGLE                 ((uint32_t)TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)         
    9 e' B/ i* ~* i' W- M
12. 
    2 H6 u7 N+ R2 Z7 v/ G7 G( F
13. /*!< TIM PWM mode 1 */
    2 ]0 \8 I1 Z: `& G: o% C5 l5 N
14. #define TIM_OCMODE_PWM1                   ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1)
    / C% h3 l& I( p5 ]' F/ C- n$ C
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)   
    # j0 K* m; y7 V1 ]+ a) Y9 ^
18. 
    " P" |1 g- }+ H" Z
19. /*!< TIM Forced Active mode */   
    3 C7 w2 ?4 P  _( V, [) q
20. #define TIM_OCMODE_FORCED_ACTIVE           ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0)         
    ; k: D4 r9 y4 m" u/ r. e
21. 
    ) |, e* F9 a, c5 e
22. /*!< TIM Forced Inactive mode */            
    
23. #define TIM_OCMODE_FORCED_INACTIVE         ((uint32_t)TIM_CCMR1_OC1M_2)                                       
    
24. 
    9 |: j8 E8 Z8 l3 z; U  v
25. /*!< TIM Rettrigerrable OPM mode 1 */  
    # N$ U& x0 v/ l- d
26. #define TIM_OCMODE_RETRIGERRABLE_OPM1      ((uint32_t)TIM_CCMR1_OC1M_3)   
    ; U- v( O- O1 z& \
27. 
    
28. /*!< TIM Rettrigerrable OPM mode 2 */                                       
    / {; N1 }7 q) S$ u. t4 S/ T, Y
29. #define TIM_OCMODE_RETRIGERRABLE_OPM2      ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0)   
    # B7 Z! e) _8 @+ j; u. ?/ C5 v
30. 
    
31. /*!< TIM Combined PWM mode 1 */                     
    
32. #define TIM_OCMODE_COMBINED_PWM1           ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_2)     
    
33. 
    8 O  f9 ~& a: \3 O  F9 ]  k2 a
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)   
    / ~2 V9 R7 @8 s! g
36. 
    
37. /*!< TIM Asymetruc PWM mode 1 */  
    - k1 m$ h  ]4 I; `
38. #define TIM_OCMODE_ASSYMETRIC_PWM1         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2)  
    
39. 
    & |4 V' A2 K# K' O9 ^6 ^) c7 n
40. /*!< TIM Asymetruc PWM mode 2 */   
      J  {  x9 |# z" G' h/ I, n% o
41. #define TIM_OCMODE_ASSYMETRIC_PWM2         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M)   

复制代码

  Pulse
可用于设置占空比，对应定时器的CCR寄存器，32位的TIM2和TIM5范围是0到0xFFFFFFFF。

0 \) Y$ W6 L3 D, R  OCPolarity
$ ?( ]# Q- H  c& Y. P5 C; J设置输出极性，可选高电平或低电平有效。

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

复制代码

! ?; r. h4 M8 h  OCNPolarity
5 y1 m) T" \5 d$ F$ u; l互补输出极性设置，可选高电平或者低电平有效。
9 K5 Y+ T: E9 M7 J/ R# H$ B
$ u- T4 V- c, c4 E6 A

1. #define TIM_OCNPOLARITY_HIGH               ((uint32_t)0x0000U)
   1 q, n+ q8 e$ V4 @3 ^$ z
2. #define TIM_OCNPOLARITY_LOW                (TIM_CCER_CC1NP)

复制代码

  OCFastMode
快速输出模式使能，仅OCMode配置为PWM1或者PWM2模式时才有意义。
; w1 D4 \6 W! T

1. 
   5 F, J; }0 T5 Q3 P# p) f
2. #define TIM_OCFAST_DISABLE                ((uint32_t)0x0000U)
   
3. #define TIM_OCFAST_ENABLE                 (TIM_CCMR1_OC1FE)

复制代码

  OCIdleState
空闲状态时，设置输出比较引脚的电平状态。
( W$ r# f+ r/ G& h- j; a* w0 g* o  \
3 n6 f* w: w2 p- s

1. #define TIM_OCIDLESTATE_SET                (TIM_CR2_OIS1)
   7 [) _$ Y% F; D
2. #define TIM_OCIDLESTATE_RESET              ((uint32_t)0x0000U)

复制代码

+ q, X6 l2 P+ t: A( \, s) C- p9 r  OCNIdleState
空闲状态时，设置互补输出引脚的电平状态。
, c$ V: x9 n/ E$ |/ K& B
! t# s5 }1 s6 Y( K1 F. n

1. #define TIM_OCNIDLESTATE_SET               (TIM_CR2_OIS1N)
   
2. #define TIM_OCNIDLESTATE_RESET             ((uint32_t)0x0000U)

复制代码

# E% b0 i' d- n) E8 A; J32.3.4 定时器输入捕获结构体TIM_IC_InitTypeDef
此结构体主要用于定时器的输入捕获，定义如下：
# J5 i4 f: Q# _1 N

1. 
   - d) C) D9 |# a! v0 H0 v
2. typedef struct
   
3. {                                 
   6 S, J5 U/ r0 |
4.   uint32_t ICPolarity;   
   
5.   uint32_t ICSelection;
   , j# m! E5 s/ b7 `
6.   uint32_t ICPrescaler;
   
7.   uint32_t ICFilter;   
   
8. } TIM_IC_InitTypeDef;

复制代码

下面将这几个参数一 一做个说明。
& e$ n3 S" H* O) Z% W. C
2 F* q$ V% b* T" l8 `% y  ICPolarity
输入触发极性，可以选择上升沿，下降沿或者双沿触发。

# H, q+ P0 @' Y$ N  U

1. #define  TIM_ICPOLARITY_RISING             TIM_INPUTCHANNELPOLARITY_RISING
   4 ]; s7 n3 I8 p
2. #define  TIM_ICPOLARITY_FALLING            TIM_INPUTCHANNELPOLARITY_FALLING
   0 I7 x4 t& q& Y7 G0 b6 Y
3. #define  TIM_ICPOLARITY_BOTHEDGE           TIM_INPUTCHANNELPOLARITY_BOTHEDGE

复制代码

  ICSelection
/ q& ^' c  Y/ s' }. q输入捕获通道选择，可以选择直接输入（即CC1选择TI1，CC2选择TI2等），间接输入（CC1选择TI2，CC3选择TI4等）或者TRC。
$ a) K0 B. q. s9 ~9 \6 a' A# U

1. 
   
2. #define TIM_ICSELECTION_DIRECTTI       (TIM_CCMR1_CC1S_0)   
   
3. #define TIM_ICSELECTION_INDIRECTTI     (TIM_CCMR1_CC1S_1)  
   - F& {# P! d+ a1 c7 E8 Y1 B
4. #define TIM_ICSELECTION_TRC            (TIM_CCMR1_CC1S)   

复制代码

: ?/ f- c- ]2 H$ |  ICPrescaler
输入捕获分频，表示每捕获1，2，4或8个事件后表示一次捕获。

9 U5 G4 J+ D$ b

1. #define TIM_ICPSC_DIV1       ((uint32_t)0x0000U)                 
   : c6 j2 y) e4 p7 c: X$ d% ]3 }
2. #define TIM_ICPSC_DIV2       (TIM_CCMR1_IC1PSC_0)   
   4 B8 o+ p7 A" P0 R
3. #define TIM_ICPSC_DIV4       (TIM_CCMR1_IC1PSC_1)   
   4 G- t4 p: p0 H% d$ z& q' ~
4. #define TIM_ICPSC_DIV8       (TIM_CCMR1_IC1PSC)

复制代码

; S( u; A1 k! I3 h5 Z  ICFilter
输入捕获滤波器，可以定义采样频率和多少个连续事件才视为有效的触发，参数范围0到15。具体定义如下，其中fCK_INT表示定时器时钟，fDTS表示死区时间采样率，N表示这么多个事件代表一次有效边沿。
5 c& m! O: g, T7 M9 X1 B

1. 0000：无滤波器，按 fDTS 频率进行采样
   - S. M, s% f. A6 c
2. 0001： fSAMPLING=fCK_INT， N=2
   - M& u1 j, I& P6 X1 c
3. 0010： fSAMPLING=fCK_INT， N=4
   
4. 0011： fSAMPLING=fCK_INT， N=8
   
5. 0100： fSAMPLING=fDTS/2， N=6
   ! T1 t9 O; W6 e) w1 p2 `6 o
6. 0101： fSAMPLING=fDTS/2， N=8
   
7. 0110： fSAMPLING=fDTS/4， N=6
   
8. 0111： fSAMPLING=fDTS/4， N=8
   ( D5 }$ C9 Z6 y
9. 1000： fSAMPLING=fDTS/8， N=6
   * d% z! v, U* H
10. 1001： fSAMPLING=fDTS/8， N=8
    
11. 1010： fSAMPLING=fDTS/16， N=5
    5 a( Y5 _8 A* g8 C/ b2 A0 j9 D
12. 1011： fSAMPLING=fDTS/16， N=6
    
13. 1100： fSAMPLING=fDTS/16， N=8
    3 H# L( X, }1 S- C) W# z7 P
14. 1101： fSAMPLING=fDTS/32， N=5
    
15. 1110： fSAMPLING=fDTS/32， N=6

复制代码

/ ]3 f, w. y& ~' F. i32.3.5 定时器的底层配置（GPIO，时钟，中断等）
4 V; p, R& t" B& i' }HAL库有个自己的底层初始化回调函数，比如调用函数HAL_TIM_Base_Init就会调用HAL_TIM_Base_MspInit，此函数是弱定义的。

4 R1 z5 E- t! }) u

1. __weak void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
   
2. {
   ! |6 ~$ O0 G) _: q- v2 E3 m/ l
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
   
7.    */
   " o4 l3 r5 |' _! B
8. }

复制代码

用户可以在其它的C文件重定向，并将相对的底层初始化在里面实现。对应的底层复位函数HAL_TIM_Base_DeInit是在函数HAL_TIM_Base_MspDeInit里面被调用的，也是弱定义的。
) a) B7 A+ F7 I! J" h1 ?+ ]% u
6 x) c+ l$ d( v5 j当然，用户也可以自己初始化，不限制必须在两个函数里面实现。
) b- o$ k1 Q/ X1 L
+ p- ~4 ]/ m- j定时器外设的基本参数配置完毕后还不能使用，还需要配置GPIO、时钟、中断等参数，比如下面配置TIM1使用PA8做PWM输出。
7 v* [0 f, e7 ]4 M: y
' u* O1 Y+ X. V4 f8 o; D" l

1. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
   9 E/ w; v4 C" O
2. {
   " `  r9 I6 K3 r. G0 n
3.   GPIO_InitTypeDef   GPIO_InitStruct;
   2 |2 o, o" R9 s) W1 }
4. 
   
5.   /* 使能TIM1时钟 */
   4 v; [2 }+ Q; O! a) p+ n! m; k
6.   __HAL_RCC_TIM1_CLK_ENABLE ();
   
7. 
   
8.   /* 使能GPIOA时钟 */
   
9.   __HAL_RCC_GPIOA_CLK_ENABLE ();
   4 I9 ~# v9 \: ]- B' m' I
10. 
    
11.   /* 设置TIM1使用PA8做PWM输出引脚，将其配置为输出，推挽，复用模式 */
    - a, q1 F. c$ J, \6 ?' E  s% t
12.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    . F  p% V. g. J1 H0 M1 C' k
13.   GPIO_InitStruct.Pull = GPIO_PULLUP;
    
14.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
15. 
    
16.   GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
    
17.   GPIO_InitStruct.Pin = GPIO_PIN_8;
    
18.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    6 y: ^1 Z% U/ ]; O- ?2 r" m
19. 
    & V7 W) u. `3 z" H$ V( t( b$ i6 g
20. }

复制代码

总结下来就是以下几点：

  配置TIM时钟。
2 d7 e0 b( [0 S6 w3 i' a4 H( \- J  配置TIM所用到引脚和对应的GPIO时钟。
; o. b: m% b) J1 y  如果用到定时器中断，还需要通过NVIC配置中断。
  如果用到DMA，还要配置DMA。
关于这个底层配置有以下几点要着重说明下：
" j2 d7 F4 Y& I2 Z  C
' [' ]' ]- @. [& V4 a  定时器所使用引脚的复用模式选择已经被HAL库定义好，放在了stm32h7xx_hal_gpio_ex.h文件里面。比如TIM1有一个复用，
#define GPIO_AF1_TIM1      ((uint8_t)0x01)  /* TIM1 Alternate Function mapping */
- A$ a1 p1 R% p3 \* k但是却有4个输出通道，每个通道都有几个支持的输出引脚：
7 t' s, @- j) d4 s7 `/ G

1. 
   
2. TIM1_CH1,  PA8   PE9    PK1
   
3. TIM1_CH2,  PA9   PE11
   ' E' p. J$ \" r
4. TIM1_CH3,  PA10  PE13   PJ9
   / V. }* |9 ^. S3 U/ M
5. TIM1_CH4,  PA11  PE14   PJ11

复制代码

具体使用哪个，配置对应引脚的复用即可：
& B: }" P! h4 R5 I7 O9 b0 E5 w9 }

8 k  u& q1 |: N6 h* A) N7 E
' `: J$ I3 D8 F9 @" a$ k) T  M- {
: U7 b) o- j! D. ~6 w  j& [32.3.6 定时器的状态标志清除问题
下面我们介绍__HAL_TIM_GET_FLAG函数。这个函数用来检查定时器标志位是否被设置。
+ n6 E9 {% D) X; N+ K. m; H

1. /** @brief  Check whether the specified TIM interrupt flag is set or not.
   0 N/ h& u* r; V; X7 A. d2 P
2.   * @param  __HANDLE__: specifies the TIM Handle.
   $ A, n2 K# \: d6 e$ C1 |
3.   * @param  __FLAG__: specifies the TIM interrupt flag to check.
   
4.   *        This parameter can be one of the following values:
   
5.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag
   0 q/ |3 g: ^6 d4 s' j/ L
6.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
   
7.   *            @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
   1 Y+ M/ l  s' ]. D- K
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
    3 l: d1 z) @% B* C0 C
11.   *            @arg TIM_FLAG_CC6: Compare 6 interrupt flag
    : |8 }/ g0 V/ ?$ Q4 u. l7 H
12.   *            @arg TIM_FLAG_COM:  Commutation interrupt flag
    ; L. Q6 U7 j7 K8 D- H; V' |, R
13.   *            @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
    0 T7 k, a9 b4 z5 I
14.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   
    5 Q+ R# |: Q- ~5 O2 P1 d3 l, H
15.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    
16.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
    
17.   *            @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
    6 d. y) t5 s+ s" A: E. v- P) _# d3 Q
18.   *            @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
    6 o/ o9 P1 C6 Q! R4 k, m, t
19.   *            @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
    : r/ o( @3 J6 T# i$ N! C: \
20.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    
21.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    
22.   */
    ( ^2 D" b- N) Y3 ]
23. #define __HAL_TIM_GET_FLAG(__HANDLE__, __FLAG__)   (((__HANDLE__)->Instance->SR &(__FLAG__)) == (__FLAG__))

复制代码

5 x, q" A9 R5 n3 P前5个是比较常用的中断标志。
+ S/ v8 y) h% [/ _! p+ C' n; r
  TIM_FLAG_UPDATE
% g/ L0 p! h* W: s5 k7 {3 g定时器更新标准，配置一个周期性的定时器中断要用到。
- v. S' d! ?+ E
1 T- s( |$ z3 [! h8 ^2 f& f     TIM_FLAG_CC1
TIM_FLAG_CC2
; @2 E- m! @$ ?6 Q! ~$ Y8 {
1 g' `+ z2 c. f. iTIM_FLAG_CC3

TIM_FLAG_CC4

捕获/比较标志，配置了捕获/比较中断要用到。
4 i( m* f# s, f# z7 ^. T8 a# o
与标志获取函数__HAL_TIM_GET_FLAG对应的清除函数是__HAL_TIM_CLEAR_FLAG：
" V3 r6 @! \1 w9 C
. j+ j; Y2 K; ]- j6 [

1. /** @brief  Clear the specified TIM interrupt flag.
   
2.   * @param  __HANDLE__: specifies the TIM Handle.
   & r( \5 F- d0 x2 \9 P
3.   * @param  __FLAG__: specifies the TIM interrupt flag to clear.
   : J% P4 ^! s% P" @1 f8 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
   
7.   *            @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
   
8.   *            @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
     e2 p+ X' B- Y9 M- T
9.   *            @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
   * r3 S. c% y  ^3 n3 L# @
10.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag
    . @  g3 Z( D8 ^& ?9 Q" o
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
    5 b9 A8 I. n% G8 {
14.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   
    
15.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    
16.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
    
17.   *            @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
      Y! F( ^2 F5 D8 T8 g/ [# E! c3 {3 L
18.   *            @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
    & T4 R6 t' U: `$ |/ s& X
19.   *            @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
    
20.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    
21.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    . X) I2 v$ L% l
22.   */
    , a; _% _4 N, D. N: T
23. #define __HAL_TIM_CLEAR_FLAG(__HANDLE__, __FLAG__)       ((__HANDLE__)->Instance->SR = ~(__FLAG__))

复制代码

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

1. /** @brief  Enable the specified TIM interrupt.
   
2. * @param  __HANDLE__: specifies the TIM Handle.
   
3. * @param  __INTERRUPT__: specifies the TIM interrupt source to enable.
   
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 {) D9 C; a' h$ W9 T' T7 G# j) O& K9 M
8. *            @arg TIM_IT_CC3:  Capture/Compare 3 interrupt
   
9. *            @arg TIM_IT_CC4:  Capture/Compare 4 interrupt
   
10. *            @arg TIM_IT_COM:   Commutation interrupt
    
11. *            @arg TIM_IT_TRIGGER: Trigger interrupt
    2 m$ K3 |& r8 U/ Y9 r: c' {
12. *            @arg TIM_IT_BREAK: Break interrupt
    
13. * @retval None
    % X* X( j0 C& N
14. */
    
15. #define __HAL_TIM_ENABLE_IT(__HANDLE__, __INTERRUPT__)  ((__HANDLE__)->Instance->DIER |= (__INTERRUPT__))
    ' f2 q* R6 L( Z5 }% |
16. 
    
17.   /** @brief  Disable the specified TIM interrupt.
    4 D% G7 w9 L: x) U  U" J
18.   * @param  __HANDLE__: specifies the TIM Handle.
    
19.   * @param  __INTERRUPT__: specifies the TIM interrupt source to disable.
    
20.   *          This parameter can be one of the following values:
    
21.   *            @arg TIM_IT_UPDATE: Update interrupt
    & b) x$ j& |/ R3 r
22.   *            @arg TIM_IT_CC1:   Capture/Compare 1 interrupt
    
23.   *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt
    0 M# i9 j8 ^& I& ^% a% `; k, W5 T
24.   *            @arg TIM_IT_CC3:  Capture/Compare 3 interrupt
    
25.   *            @arg TIM_IT_CC4:  Capture/Compare 4 interrupt
    
26.   *            @arg TIM_IT_COM:   Commutation interrupt
    
27.   *            @arg TIM_IT_TRIGGER: Trigger interrupt
    $ ~$ ?5 z9 [0 w) g. n, R- [6 P) O% z
28.   *            @arg TIM_IT_BREAK: Break interrupt
    
29.   * @retval None
    
30.   */
    
31. #define __HAL_TIM_DISABLE_IT(__HANDLE__, __INTERRUPT__)   ((__HANDLE__)->Instance->DIER &= ~(__INTERRUPT__))

复制代码

常用的也是前五个参数，1个定时器更新中断以及4个CC中断 。
5 i& ^7 r8 M, Z! i
5 D( f& s! U  f, t) Y6 \1 Q/ g) i注意：操作定时器的寄存器不限制必须要用HAL库提供的API，比如要操作寄存器CR1，直接调用TIM1->CR1操作即可。
# d0 K; E/ t/ Q3 q2 h
- u' Y- e; V. Z- W32.3.7 定时器初始化流程总结
" X4 [3 I3 A% e* `0 d5 [$ v( Y- q使用方法由HAL库提供：

8 a2 o6 Z0 n4 q4 O6 w  第1步：通过下面几个函数配置定时器工作在相应的模式
* i, \8 D. g) t
  HAL_TIM_Base_Init
简单的定时器时基础功能

  HAL_TIM_OC_Init 和 HAL_TIM_OC_ConfigChannel
配置定时器产生输出比较信号
5 J$ f9 M& M6 \! Q; }
  HAL_TIM_PWM_Init 和 HAL_TIM_PWM_ConfigChannel
9 V0 {8 l! g. L9 V配置定时器产生PWM信号
6 P0 O. Y, c! ]1 `) m
  HAL_TIM_IC_Init 和 HAL_TIM_IC_ConfigChannel
配置定时器测量外部信号
, |# m8 P! i  G( S+ h5 h
  HAL_TIM_OnePulse_Init 和 HAL_TIM_OnePulse_ConfigChannel
配置定时器工作在单脉冲模式
* k1 A7 ?. j( v0 o
# Y! I: B7 s. D3 M* g, t1 N3 U  HAL_TIM_Encoder_Init
1 f( ~* R: f. s3 W配置定时器使用编码器接口

  第2步：定时器几个常用功能的底层初始化API，这个里面需要用户自己填

- ]. V: F/ P' S) X) u  Q第1步里面的几个函数会调用下面的API。

9 [, H: @* e* i8 c  定时器基本功能 : HAL_TIM_Base_MspInit()
  输入捕获 : HAL_TIM_IC_MspInit()
  输出比较 : HAL_TIM_OC_MspInit()
  PWM输出 : HAL_TIM_PWM_MspInit()
  单脉冲输出模式: HAL_TIM_OnePulse_MspInit()
* {9 @6 [) b4 E+ n4 q2 b  编码器模式 : HAL_TIM_Encoder_MspInit()
  第3步：底层初始化具体实现
/ Q$ s( R/ F, T, W
第2步中函数的具体实现。

  使用函数__HAL_RCC_TIMx_CLK_ENABLE()使能定时器时钟。
  使用函数__HAL_RCC_GPIOx_CLK_ENABLE()使能定时器使用到的引脚时钟。
3 u5 u( X/ F; A+ J  使用函数HAL_GPIO_Init()配置GPIO的复用功能。
% f% f# O7 K3 l4 O9 |/ J  如果使能了定时器中断，调用函数HAL_NVIC_SetPriority和HAL_NVIC_EnableIRQ配置。
  m# S$ H. t+ e; n( U9 e7 r6 r  如果使能了DMA，还需要做DMA的配置。
  定时器默认使用APB时钟，如果使用外部时钟，调用函数HAL_TIM_ConfigClockSource可以配置。
  第4步：启动定时器外设
: t( K) v( ?% q# t, `2 j. e
  定时器基础功能:
HAL_TIM_Base_Start()
5 ~6 W' i$ x" e8 C( @4 p
: m# L8 ~. g" Y( C, W. f' sHAL_TIM_Base_Start_DMA()
, Q# c; Y% W9 q$ r1 I
' K2 h4 f& G9 Z" F$ f5 BHAL_TIM_Base_Start_IT()
+ D, \5 }* C5 F
  输入捕获 :
" F+ W0 }$ m) x! v; O) xHAL_TIM_IC_Start()
; k7 x# B+ T# F/ j
+ o/ W4 T! Z0 r0 P, O6 M+ e3 wHAL_TIM_IC_Start_DMA()
+ K! e( f9 g! l! [& o+ M
1 c3 d  @' s+ @1 k4 m4 R5 PHAL_TIM_IC_Start_IT()

  输出比较 :
# ]; }6 G, a. x- R) M5 IHAL_TIM_OC_Start()
8 n: p" _3 b% U
HAL_TIM_OC_Start_DMA()

HAL_TIM_OC_Start_IT()

* J; Z& Z* T2 P; R$ @7 W% R  PWM输出：
& D4 P$ o) G; `3 U$ s0 t& r4 Q  eHAL_TIM_PWM_Start()
0 W" f8 i5 T% [
4 }. z4 v5 H) Q- x* m1 v& uHAL_TIM_PWM_Start_DMA()
' {9 |/ k0 h& l8 J
6 M# g4 b# `- XHAL_TIM_PWM_Start_IT()
0 B. M0 f: w% F: V9 [* c' G
0 T) ]7 b: i2 H$ x  单脉冲模式：
HAL_TIM_OnePulse_Start()
' t$ I, {3 h$ D. |
HAL_TIM_OnePulse_Start_IT().
) P) s8 h. S9 w' u% }$ M6 Z% f$ ^
  编码器模式：
1 h: d  r2 ?. O% S7 i+ o, B% l6 eHAL_TIM_Encoder_Start()

* Z% u9 D& I9 M- kHAL_TIM_Encoder_Start_DMA()
! y8 C) b$ s  y8 T' ^, }& q2 r
HAL_TIM_Encoder_Start_IT().

6 K  s4 A, t6 o+ z. O) q* E" F' z  第5步：定时器的DMA突发使用下面两个函数

& Y0 K4 C: a4 b6 |( Z( m  HAL_TIM_DMABurst_WriteStart()
  HAL_TIM_DMABurst_ReadStart()
- }: h$ [/ F8 c  R& z5 c- g定时器常用的功能，通过上面这几步即可实现。
3 y) M5 g, i- \2 _) r
32.4 源文件stm32h7xx_hal_tim.c
此文件涉及到的函数非常多，这里把几个常用的函数做个说明：
) r9 N/ A. q5 R- \5 r# x
0 g, y- d7 N, i- b  HAL_TIM_Base_Init
  HAL_TIM_Base_Start
0 M2 ^! W. H* D  z  @7 ^8 w  HAL_TIM_PWM_Init
  HAL_TIM_PWM_ConfigChannel
( r! E6 H+ ^/ p- J, q( q1 ^7 K  HAL_TIM_PWM_Start
  HAL_TIM_IC_Init
  HAL_TIM_IC_ConfigChannel
  HAL_TIM_IC_Start_IT
  HAL_TIM_OC_Init
' ^/ q" S9 V5 ^6 L: {0 E) c0 v  HAL_TIM_OC_ConfigChannel
  HAL_TIM_OC_Start
! P6 s" K- [8 N& i. C32.4.1 函数HAL_TIM_Base_Init
  {; ^7 f( k/ T& v$ o$ n函数原型：
+ I" ]; H5 L% @# _2 {
2 b. H; Q: z3 f$ j1 [

1. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   
2. {
   : u" C& t& A" L$ T
3.   /* 检测是否是有效句柄 */
   
4.   if(htim == NULL)
   
5.   {
   
6.     return HAL_ERROR;
   
7.   }
   
8. 
   
9.   /* 检测参数 */
   , D' I6 h$ _- v1 I  }
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    % c  l, [! b8 L' h" n9 h
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    8 d% l9 v& r5 j. H; i" u
13. 
    
14.   if(htim->State == HAL_TIM_STATE_RESET)
    " T8 }4 v( V+ }1 g8 F
15.   {
    - x6 v* S& u* E# i
16.     /* 默认取消锁 */
    . g8 }- `  [) U; a' y" E6 e  x' E
17.     htim->Lock = HAL_UNLOCKED;
    6 _% `5 G! }9 N" U3 C) R; z& j
18.     /* 初始化底层硬件 : GPIO, CLOCK, NVIC */
    : K, S3 c  W( x: k9 P# @
19.     HAL_TIM_Base_MspInit(htim);
    1 [6 W, K* ~" x* t( j! j
20.   }
    8 o. D4 X; _8 \- H! w1 U
21. 
    7 L! f  o" w! ~9 Y
22.   /* 设置TIM状态 */
    
23.   htim->State= HAL_TIM_STATE_BUSY;
    # K9 T% S1 Y; _4 H* M( l
24. 
    
25.   /* 基本参数配置 */
    3 D& L6 _- Q( G1 l% x$ r6 _0 e
26.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
27. 
    
28.   /* 设置TIM就绪 */
    * l- ~9 G. x$ _! t8 z: t
29.   htim->State= HAL_TIM_STATE_READY;
    
30. 
    
31.   return HAL_OK;
    9 t( w( Q% [# k+ T. l( |
32. }

复制代码

! Z3 @* G" B4 L% `0 f函数描述：
4 r6 f% n! [7 ?5 e+ W5 `! ^  v
此函数用于初始化定时器用于PWM。
1 {* N" O) u* j% [/ _
函数参数：

! w1 q( _, `! }- @+ e% c' k# d  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
4 X) u7 Y' V2 }1 W4 ?' ?6 Y注意事项：

! m5 L1 L; _, J5 |7 }, r5 o函数HAL_TIM_Base_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
3 K( P( `9 Z: F- q5 w* H0 K+ \如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
0 \$ f  D( k; t7 M对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_TIM_STATE_RESET  = 0x00U。
# V0 m+ l( o! d0 W% |8 e0 q! a
解决办法有三：

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

: t' O9 m2 W* y# o方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
( N: j4 Y* i; O1 f( g4 G3 w" ?$ p
方法3：下面的方法

. ~" s5 u- M) a& n& W: _7 N) P

1. if(HAL_TIM_Base_DeInit(&TimHandle) != HAL_OK)
   ; ]* H: i* R6 M7 W
2. {
   4 v* r/ R" s0 O# W6 E* S
3.     Error_Handler();
   
4. }  
   
5. if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
   
6. {
   
7.     Error_Handler();
   " s7 [0 q  J8 B5 P+ J3 S
8. }

复制代码

使用举例：

1. TIM_HandleTypeDef   TimHandle = {0};
   8 B' {9 d6 }) c; z
2. 
   
3. /*
   
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   9 X1 X* K2 Z, t$ n: x. l) m1 }7 u) z- t
5. */
   / j2 l  z6 J& Y) Q( E
6. TimHandle.Instance = TIMx;
   
7. TimHandle.Init.Prescaler         = usPrescaler;
   
8. TimHandle.Init.Period            = usPeriod;        
   7 a. Q3 Q! I/ M; S9 u, m
9. TimHandle.Init.ClockDivision     = 0;
   
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    
11. TimHandle.Init.RepetitionCounter = 0;
    1 p) [4 w" D" I* H. v: ^
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    ; [2 z5 Y3 c. I# D; H- O
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    3 d2 V1 {3 x# F& ^5 K
14. {
    9 R. D0 O7 c1 K/ d1 c6 Q
15.         Error_Handler(__FILE__, __LINE__);
    ) d% M3 X0 h6 d" g0 u
16. }

复制代码

32.4.2 函数HAL_TIM_Base_Start
函数原型：
4 ]7 l) F% J; K, w

1. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   
2. {
   
3.   /* 检测参数状态 */
   5 b5 s( b  p; @5 }8 E- P1 ?3 G2 u
4.   assert_param(IS_TIM_INSTANCE(htim->Instance));
   . ?, y. a- ?. t0 }0 w& N
5. 
   
6.   /* 设置定时器状态 */
   
7.   htim->State= HAL_TIM_STATE_BUSY;
   
8. 
   + h: O9 s3 B# v# V( L- y( n
9.   /* 使能定时器 */
   6 m, W& h1 G/ O! }8 g3 l
10.   __HAL_TIM_ENABLE(htim);
    
11. 
    % h" {; w! R0 s5 }+ g: T
12.   /* 设置定时器状态 */
    3 R6 R  N; k5 U& A+ ]& F
13.   htim->State= HAL_TIM_STATE_READY;
    
14. 
    
15.   /* 返回HAL_OK */
    ) H2 C" d. k) G9 k( _& h
16.   return HAL_OK;
    / C6 c- Q# x' A2 p3 Y' B, T: L
17. }

复制代码

  Y6 K" J2 O$ y9 b/ z函数描述：

. L! o( i- \9 g, h( `此函数比较简单，调用函数HAL_TIM_Base_Init配置了基础功能后，启动定时器。
$ [3 [2 w  P5 T
函数参数：
  b4 b! D- M" A7 j
3 o  B3 P3 z: t  第1个参数是TIM_HandleTypeDef类型结构体指针变量。
- o; `. T9 Q; |8 S: [  Q! V, u4 v  返回值，固定返回HAL_OK，表示初始化成功。
使用举例：

1. TIM_HandleTypeDef   TimHandle = {0};
   
2. 
   
3. /*
   
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   * r$ ?6 {" r% x: p8 F) @
5. */
   & I5 a2 ~2 P) ~
6. TimHandle.Instance = TIMx;
   : k' h" x0 U( u% v( ?5 t( q4 f( K' q
7. TimHandle.Init.Prescaler         = usPrescaler;
   
8. TimHandle.Init.Period            = usPeriod;        
   ' d% W: k% o2 y- ?
9. TimHandle.Init.ClockDivision     = 0;
   
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    7 `  i3 T! k. |  p( d, a
11. TimHandle.Init.RepetitionCounter = 0;
    ; k4 ?8 {1 w8 F. m
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    3 x  T1 [4 i- [
14. {
    3 V: J& }. {8 C
15.         Error_Handler(__FILE__, __LINE__);
    6 `' U% l" z8 s4 a% ]7 M
16. }
    
17. 
    
18. /* 启动定时器 */
    - b/ H4 `. j: R& A1 |  Z
19. if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
      V  J" y% h4 B: t* b
20. {
    
21. Error_Handler(__FILE__, __LINE__);
    " A; V2 Q! H% x$ L' `8 A
22. }

复制代码

32.4.3 函数HAL_TIM_PWM_Init
7 k( A( M2 v, f& p( M& q* Q函数原型：
# {5 i! D  v% _4 U
! \' E# O( Q% I

1. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
   ; u- L& P, O) z; O$ R- F6 r4 U
2. {
   
3.   /* 检查句柄是否有效 */
   ' z  b; v! f4 U( F
4.   if(htim == NULL)
   1 z1 d8 M$ H" J9 S4 Z# a, l' G
5.   {
   
6.     return HAL_ERROR;
   
7.   }
   5 T: r) [/ P. y) \9 G% x$ V6 b
8. 
   2 _( X) w/ a& ?5 r/ h6 b/ V
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));
      _: W$ t- X- Y4 p; l: v) Z
13. 
    
14.   if(htim->State == HAL_TIM_STATE_RESET)
    . i4 k1 ^$ G- Y, N4 Y! j: ~
15.   {
    " n2 Z/ G2 |1 `' r$ M' @0 q
16.     /* 默认取消锁 */
    . `1 A# _* o4 \1 M" b* `
17.     htim->Lock = HAL_UNLOCKED;
    
18. 
    
19.     /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_PWM_MspInit(htim);
    6 u  K/ i7 H- n# Y
21.   }
    
22. 
    , Q! N- F2 A: G' h3 k' C2 S
23.   /* 设置定时状态 */
    
24.   htim->State= HAL_TIM_STATE_BUSY;
    
25. 
    , \# x8 P# o/ y# f) A  |
26.   /* 配置定时器用于PWM */  
    
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
28. 
    
29.   /* 设置定时器状态 */
    
30.   htim->State= HAL_TIM_STATE_READY;
    
31. 
    
32.   return HAL_OK;
    
33. }

复制代码

" ~+ a* P- h2 o; g函数描述：

7 k8 h) w) Z: A) A# }此函数用于初始化定时为PWM方式。
+ S; x, s3 O. w8 [0 W
/ i; w: ^' D, W8 ~函数参数：

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

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

6 f7 G" D9 C  \  ~' Y" O- ], Z! f3 ^解决办法有三：
" e3 l* w# a" a  a
% n+ {. I/ j7 q) t方法1：用户自己初始定时器和涉及到的GPIO等。

- z% V! h; S' |9 Q方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

方法3：下面的方法
- ?* Y5 R' g! k4 D

1. if(HAL_TIM_PWM_DeInit(&TimHandle) != HAL_OK)
   
2. {
   
3.     Error_Handler();
   8 l; B' Z) G# D% |
4. }  
   
5. if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
   # N. X$ m2 z6 m0 f  Q) C1 W! R
6. {
   / D, N& g+ ~" S' [, b
7.     Error_Handler();
   
8. }

复制代码

1 r8 J! a! G8 q使用举例：

1. TIM_HandleTypeDef  TimHandle = {0};
   4 G8 l: o) R6 [$ @" y9 e
2. 
   ; O5 ~2 @$ J$ a' k! x& I) Y1 s
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   7 n1 h6 G% P( [5 R/ J7 r6 }0 H) Y
4. TimHandle.Instance = TIM1;
   , _- i  U7 M8 _, O+ {* A
5. TimHandle.Init.Prescaler         = usPrescaler;
   
6. TimHandle.Init.Period            = usPeriod;
   
7. TimHandle.Init.ClockDivision     = 0;
   " O7 v! e) ^" v3 f
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   ' t* ^+ ~  d2 a. R" ]$ E
9. TimHandle.Init.RepetitionCounter = 0;
   
10. TimHandle.Init.AutoReloadPreload = 0;
    
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    % L8 X  y6 A! m& m  O) P
12. {
    ! a% \  g% C' R) |6 S) ?5 ^# V( B
13.     Error_Handler(__FILE__, __LINE__);
    
14. }

复制代码

32.4.4 函数HAL_TIM_PWM_ConfigChannel
) g3 J$ o  k+ V' \  H2 N" H$ ?: A函数原型：
/ ]& g" t8 C& R3 @& e9 c

1. HAL_StatusTypeDef HAL_TIM_PWM_ConfigChannel(TIM_HandleTypeDef *htim,
   
2.                                             TIM_OC_InitTypeDef* sConfig,
   
3.                                             uint32_t Channel)
   
4. {
   
5.    /* 省略 */
   
6. 
   
7.   /* 开锁 */
   6 i0 f- K# b: }  q; }6 _
8.   __HAL_LOCK(htim);
     N1 K3 p# X3 K& Y9 ^9 K
9. 
   , ^- A# P9 Y, m; |9 Q
10.   htim->State = HAL_TIM_STATE_BUSY;
    . W; t0 Y  E7 }1 o# A" N) F7 g! @
11. 
    
12.   switch (Channel)
    8 M3 p% G8 z/ _* f+ m4 s9 {3 F2 f
13.   {
    : X$ ~% [: J8 V  P/ ~- P
14.     case TIM_CHANNEL_1:
    
15.     {
    9 k  S8 n3 v6 d+ l' I
16.       /* 检查参数 */
    
17.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    $ \3 o: `- F9 G0 ~( E8 z. X
18. 
    ; u- M) q2 {( B9 B6 T
19.       /* 配置通道1的PWM模式 */
    
20.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    
21. 
    
22.       /*预装载使能，更新事件产生时写入有效 */
    
23.       htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;
    
24. 
    
25.       /* 配置是快速输出模式 */
    & j. K% H3 p) K4 B8 I
26.       htim->Instance->CCMR1 &= ~TIM_CCMR1_OC1FE;
    
27.       htim->Instance->CCMR1 |= sConfig->OCFastMode;
    
28.     }
    
29.     break;
    
30. 
    ) ^! D, R- W; \! u
31.     case TIM_CHANNEL_2:
    
32.     {
    1 x  B8 C% ]  Y1 j; g% e2 M: m
33.        /* 省略 */
    ! e& q2 x. ?# j3 d7 b: ~
34.     }
    - z7 V! e5 ?2 ^( g2 j1 N5 }
35.     break;
    
36. 
    ( q% Y8 i, H5 F/ D" F. ~
37.     case TIM_CHANNEL_3:
    
38.     {
    
39.        /* 省略 */
    
40.     }
    
41.     break;
    
42. 
    * v7 G2 B+ F( P3 P5 Y
43.     case TIM_CHANNEL_4:
    9 B) P/ V2 E" _& }
44.     {
    
45.       /* 省略 */
    
46.     }
    ; a# `- z7 Y5 F) V3 R6 m9 h9 ~7 z
47.     break;
    
48. 
    
49.     case TIM_CHANNEL_5:
    
50.     {
    ' p% |5 _1 G0 s& x+ M, E
51.        /* 省略 */
    ! m$ E2 L0 v! {' t3 g& a& t
52.     }
    
53.     break;
    / R+ Z# \4 ?0 o5 x& _' ^1 _; C
54. 
    
55.     case TIM_CHANNEL_6:
    # l% A8 s( J9 C$ H7 Y- r
56.     {
    
57.         /* 省略 */
    
58.     }
    
59.     break;
    . q4 q: y$ N5 M8 j6 T
60. 
    
61.     default:
    2 ]# s4 k1 J2 C, g7 E
62.     break;
    ; ~' s, k. M$ G# N8 ~
63.   }
    2 X; i$ f/ `& @2 X% x
64. 
    
65.   htim->State = HAL_TIM_STATE_READY;
    # [2 w& |) E, N2 u
66. 
    ) x& m( E7 i: O# t
67.   /* 关锁 */
    
68.   __HAL_UNLOCK(htim);
    ) H7 G- f* L3 \' d! w8 Z: u
69. 
    
70.   return HAL_OK;
    . R) q" \+ ?" ?1 U# n4 O  Y
71. }

复制代码

( X! |  [, d; Y7 ?! z函数描述：

! n2 m- @' _$ B; Q: o此函数用于配置定时器的PWM通道。

函数参数：
, {9 ^7 a1 ]% {" B: D1 F7 Y
5 L. n+ J) N3 `$ ^  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
0 \: h: @" c; w2 X' iTIM_CHANNEL_1
: V  L' y7 W( {6 w7 x
TIM_CHANNEL_2

TIM_CHANNEL_3
% O: v/ U% Y( ^7 L( Q' w  b! t
TIM_CHANNEL_4
+ i7 ^) j( _, ?% N. z; _/ ~
TIM_CHANNEL_5
' v1 ~8 t% V( Q7 f( t9 a
TIM_CHANNEL_6

: |  T* D' h3 N+ c5 O  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
使用举例：
, j3 o9 a9 f& @0 d7 l" F

1. TIM_HandleTypeDef  TimHandle = {0};
   & j6 y# d, ?. X6 t7 ~
2. 
   
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   
4. TimHandle.Instance = TIM1;
   0 c0 |% b  |0 I% ~  X2 U3 @
5. TimHandle.Init.Prescaler         = usPrescaler;
   
6. TimHandle.Init.Period            = usPeriod;
   . U- L: y: d9 A8 n) b" R2 G" P
7. TimHandle.Init.ClockDivision     = 0;
   ! p' S5 U. L  @4 b$ M/ H8 G# t
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   
9. TimHandle.Init.RepetitionCounter = 0;
   
10. TimHandle.Init.AutoReloadPreload = 0;
    
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    / G  X/ @  V7 W" A0 t
12. {
    5 c7 e. l- a" z5 ^. l0 o) z
13.     Error_Handler(__FILE__, __LINE__);
    
14. }
    . }) C! f8 T7 _$ {
15. 
    * H( G" `' X0 n/ C4 ?- ?- J
16. /* 配置定时器PWM输出通道 */
    
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    ' P6 d1 _( O8 q
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    3 u8 {6 P# y8 V- v& l4 y
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
    
23. 
    
24. /* 占空比 */
    : c, s3 ~8 _( B5 O& c0 V
25. sConfig.Pulse = pulse;
    
26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    
27. {
    & d& w+ w# ^' v8 e
28.     Error_Handler(__FILE__, __LINE__);
    
29. }

复制代码

+ ~' J9 W9 D. d* S32.4.5 函数HAL_TIM_PWM_Start
函数原型：

( T/ F( R2 c9 u/ X% e

1. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
   8 r/ y" Z. X: i6 Y2 q
2. {
   * ?4 h4 v  x$ K# p6 F
3.   /* 检测参数 */
   
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   
5. 
   
6.   /* 使能捕获比较通道 */
     a3 k7 g3 G9 `! E8 g. [. Q
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   $ z) d2 O3 G& y4 ~. p
8. 
   
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
   
10.   {
    
11.     /* 使能主输出 */
    
12.     __HAL_TIM_MOE_ENABLE(htim);
    * d5 O) m/ [" [0 c+ e  X
13.   }
    
14. 
    7 ?, h% w3 d3 b% n
15.   /* 使能定时器 */
    ' m. S6 c1 @" I6 k
16.   __HAL_TIM_ENABLE(htim);
    
17. 
    
18.   /* 返回状态*/
    6 D+ [- \& Q: r; l6 \' ?
19.   return HAL_OK;
    
20. }

复制代码

函数描述：
" i1 |* c* m/ P
7 n2 j% T5 _$ L( D7 a此函数用于启动PWM。

函数参数：
3 X& s- J# C0 O" [
: r1 N# S$ e' `! A5 Z5 U' q  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  第2个参数是通道设置，支持以下参数：
; q/ R# d# _7 {8 m$ |TIM_CHANNEL_1
/ M" }: \8 |# v. c
TIM_CHANNEL_2

6 E9 e# |* d* mTIM_CHANNEL_3

9 ?. I" [2 d7 V3 O# MTIM_CHANNEL_4
$ j9 i! ^4 q2 j7 J! V7 S& q& O
0 y: @$ G; P7 |0 m' l; b4 `3 {$ S: h0 a  L8 c  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
使用举例：

2 v3 N3 x* C2 X  H* V

1. TIM_HandleTypeDef  TimHandle = {0};
   
2. 
   ; U) L# i5 G% y& }( C5 M
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   
4. TimHandle.Instance = TIM1;
   ' K1 Q% R# @! A$ x
5. TimHandle.Init.Prescaler         = usPrescaler;
   
6. TimHandle.Init.Period            = usPeriod;
   
7. TimHandle.Init.ClockDivision     = 0;
   
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   
9. TimHandle.Init.RepetitionCounter = 0;
   2 n6 |- u; f% m2 D" {
10. TimHandle.Init.AutoReloadPreload = 0;
    
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    ; ~/ c7 O2 J0 D2 s8 ?1 n3 B
12. {
    # y# g4 h9 |7 b- }" G( @: `
13.     Error_Handler(__FILE__, __LINE__);
    
14. }
    : b2 h  o( C0 V
15. 
    
16. /* 配置定时器PWM输出通道 */
    ! m" U- C; u% _5 f
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    2 W0 ?' w- b, C/ j, k; l
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    0 y' y/ c( S2 l# x7 C# P& s
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
    ( Q% K  o' P2 p. p
23. 
    
24. /* 占空比 */
    
25. sConfig.Pulse = pulse;
    
26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    
27. {
    
28.     Error_Handler(__FILE__, __LINE__);
    
29. }
    
30. 
    6 o* s2 b0 u- M: m+ i
31. /* 启动PWM输出 */
    ; p) l0 D! K! y$ j6 a( x
32. if (HAL_TIM_PWM_Start(&TimHandle, TimChannel[_ucChannel]) != HAL_OK)
    
33. {
    % x8 l0 `) T" Q. n
34.         Error_Handler(__FILE__, __LINE__);
    - M3 ^( ~$ b5 G* R$ G# |7 l
35. }

复制代码

! x* w# e% z7 w) G% N1 j32.4.6 函数HAL_TIM_IC_Init
' x- l( ~" v  z& Z6 L0 ]3 L函数原型：
" ?" n& l* n5 q" z0 _! _- _
) \- T( F3 S( T# e  Q3 b' V

1. HAL_StatusTypeDef HAL_TIM_IC_Init(TIM_HandleTypeDef *htim)
   
2. {
   0 ~, ]. X2 F1 w7 W. N- C
3.   /* 检测形参是否有效 */
   
4.   if(htim == NULL)
   ! N- @/ w/ [+ S+ M4 A
5.   {
   ' g( C0 h# B/ n6 `
6.     return HAL_ERROR;
   
7.   }
   
8. 
   
9.   /* 检测参数 */
   1 B: y7 {& w. j2 \9 g
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. 
    $ D' h1 t; \, J" [
14.   if(htim->State == HAL_TIM_STATE_RESET)
    8 E8 x6 W- a) Y( C! i
15.   {
    9 }8 E/ ?0 U" N; ~
16. /* 默认取消锁 */
    
17.     htim->Lock = HAL_UNLOCKED;
    
18. 
    2 U% ?, B; A8 D# m/ ~; N
19.      /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_IC_MspInit(htim);
    
21.   }
    0 e4 m3 W7 u2 o  f0 |2 K7 a
22. 
    
23.   /* 设置定时器状态 */
    2 \. d4 Y8 B3 g% h9 O
24.   htim->State= HAL_TIM_STATE_BUSY;
    
25. 
    
26.   /* 配置定时器为输入捕获模式 */  
    6 M% s" `% z* F1 Z, J) f0 U7 q
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    + W1 t$ t9 u9 O
28. 
    5 i4 i. n: C8 R1 A* k) G/ f
29.   /* 设置定时器状态 */
    
30.   htim->State= HAL_TIM_STATE_READY;
      M  j3 y. y9 i# w3 x) _& p. v/ B
31. 
    5 R- l( [8 {! O( b
32.   return HAL_OK;
    
33. }

复制代码

函数描述：

, V2 o2 Z, Z) ^  U& w0 @此函数用于定时器输入捕获初始化。
0 c0 M4 b  T4 U4 H" Z( I$ p7 N
函数参数：

) {! g% R0 X' u, [+ E) R4 W" |% G  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
, ^% k# X& X% j6 W) f$ `. v1 e  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：

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

' c( G; i  k, Z4 [解决办法有三：

方法1：用户自己初始定时器和涉及到的GPIO等。
' `6 K( k1 {6 }1 q' r7 D) U
8 J% _0 D* N4 `# N- x* ?; L5 W方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
3 B3 C. Z: {4 r
% N& L: J! n2 l! `! v方法3；下面的方法
1 ?8 A+ Z1 H8 T+ B2 ]
if(HAL_TIM_IC_DeInit(&UartHandle) != HAL_OK)
{
    Error_Handler();
}  
; {4 e5 w1 T6 T9 ~6 A! q  N2 `if(HAL_TIM_IC_Init(&UartHandle) != HAL_OK)
" ]  n% ]9 D! d& S5 F1 k, t{
5 L9 R  o0 j9 |* L1 V- n    Error_Handler();
}
2 w: g, F" r# c) k1 v8 I32.4.7 函数HAL_TIM_IC_ConfigChannel
3 r+ |' m4 M3 B% G函数原型：

1. HAL_StatusTypeDef HAL_TIM_IC_ConfigChannel(TIM_HandleTypeDef *htim, TIM_IC_InitTypeDef* sConfig, uint32_t Channel)
   * l/ q- d/ P0 ?; Q7 E
2. {
   - e& X& L3 @- |& S' J
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
   
5.   assert_param(IS_TIM_IC_POLARITY(sConfig->ICPolarity));
   
6.   assert_param(IS_TIM_IC_SELECTION(sConfig->ICSelection));
   ( L2 f8 ?+ U$ I& t
7.   assert_param(IS_TIM_IC_PRESCALER(sConfig->ICPrescaler));
   6 c9 ~1 A6 L* u$ Y- L! g, n
8.   assert_param(IS_TIM_IC_FILTER(sConfig->ICFilter));
   , f3 V5 O/ }: U: _7 K
9. 
   ) i, T/ F0 u8 d9 o  L
10.   /* 开锁 */  
    
11.   __HAL_LOCK(htim);
    
12. 
    ; }! a4 E4 v  u4 i8 L( T( F
13.   htim->State = HAL_TIM_STATE_BUSY;
    " s4 K$ t5 D8 Z
14. 
    1 J! N; m2 v- H
15.   if (Channel == TIM_CHANNEL_1)
    
16.   {
    
17.     /* 配置输入通道1 */
    
18.     TIM_TI1_SetConfig(htim->Instance,
    " `+ W- `4 L4 ?1 ?" ?1 Y( l
19.                sConfig->ICPolarity,
    
20.                sConfig->ICSelection,
    
21.                sConfig->ICFilter);
    , @2 W. g3 V6 j6 H, \
22. 
    . R2 |8 u  A4 `  d& |5 F# a
23.     /* 清零IC1PSC位 */
    
24.     htim->Instance->CCMR1 &= ~TIM_CCMR1_IC1PSC;
    
25. 
    
26.     /* 根据用户配置，设置分频 */
    
27.     htim->Instance->CCMR1 |= sConfig->ICPrescaler;
    
28.   }
    
29.   else if (Channel == TIM_CHANNEL_2)
    
30.   {
    
31. /* 省略 */
    0 Y  X- U. I! F8 |. o8 j! q
32.   }
      {5 m4 ?' P- ^
33.   else if (Channel == TIM_CHANNEL_3)
    
34.   {
    # ^( k$ f+ u' c" q3 a
35.      /* 省略 */
    7 g. f( ~9 S1 z5 K" H
36.   }
    : Y* ?+ \4 L1 A2 T: ^+ e+ a
37.   else
    
38.   {
    
39.      /* 省略 */
    
40.   }
    6 [8 W, `- }* A8 s& A4 m
41. 
    
42.   htim->State = HAL_TIM_STATE_READY;
    
43. 
    8 Y8 Y4 l2 p  `$ i4 P1 m8 X( C
44.   __HAL_UNLOCK(htim);
    # D" q' k4 Q2 L5 ?& }
45. 
    
46.   return HAL_OK;
    ! l1 l9 v+ c* \7 }4 J( n2 T6 h
47. }

复制代码

函数描述：

此函数用于配置定时器的输入捕获通道。

$ i; @$ v% p/ f& z: D0 h. s函数参数：
% d/ E- O, m. {5 Q/ [0 m; S
; Z9 G9 u3 b' u8 y$ A, i4 A  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置
$ h0 U: i. x% ~  第2个参数是TIM_IC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
% N" K* ~5 _0 A5 a  第3个参数是通道设置，支持以下参数：
TIM_CHANNEL_1

TIM_CHANNEL_2

TIM_CHANNEL_3

7 ?. `+ ]- Z" Z: S5 bTIM_CHANNEL_4

  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
32.4.8 函数HAL_TIM_IC_Start_IT
0 H$ }, s% y' X' H) [6 P/ Z函数原型：
& N0 U: F& {; h; q7 M! x  P9 w3 Q
: t- `. }# c! `5 l" @9 s- z

1. HAL_StatusTypeDef HAL_TIM_IC_Start_IT (TIM_HandleTypeDef *htim, uint32_t Channel)
   7 k9 s% V$ ?) @
2. {
   
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   
5. 
   . T7 x; l9 V3 i, B- X! \: I3 v; G
6.   switch (Channel)
   + o' V1 O, L0 \* {: E: M
7.   {
   
8.     case TIM_CHANNEL_1:
   % v8 E1 S/ E! r3 ?0 X$ a' J
9.     {      
   + A7 @0 ~6 f$ Q
10.       /* 使能CC1（Capture/Compare 1）中断 */
    
11.       __HAL_TIM_ENABLE_IT(htim, TIM_IT_CC1);
    1 U  `" R% d5 n/ t& o( s0 C
12.     }
    2 j8 I) M9 T7 b$ m6 Q* c
13.     break;
    ' I- ?  `& Z. F% e5 x0 z* O
14. 
    0 Q  c3 n- u+ s( Z4 ]
15.     case TIM_CHANNEL_2:
    
16.     {
    7 p# R% f9 T& e; j0 z& L
17.    /* 省略 */
    3 ?5 G/ K# f* H: P9 C5 X9 j1 V8 O
18.     }
    1 m8 W  t* c6 w8 ]5 t7 ]  Q
19.     break;
    
20. 
    
21.     case TIM_CHANNEL_3:
    4 H' }) H: y) g* ]+ h
22.     {
    
23.   /* 省略 */
    
24.     }
    
25.     break;
    
26. 
    . a( ~4 @, e) H! ^0 F7 k+ U
27.     case TIM_CHANNEL_4:
    ) ?- I8 S5 b& W5 ?! Y' d
28.     {
    # y4 @) I7 q5 j" E1 ?1 _
29.   /* 省略 */
    
30.     }
    4 E! \: ]6 ?4 @
31.     break;
    " k; n7 n: X% l8 L; p6 M
32. 
    * k! u% s( k' q+ b
33.     default:
    
34.     break;
    
35.   }  
    
36.   /* 使能输入捕获通道 */
    
37.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    : X0 D* W* Z+ _$ n0 @/ t
38. 
    
39.   /* 使能定时器 */
    - W4 N8 a( x$ r9 H' Z+ \, _5 t
40.   __HAL_TIM_ENABLE(htim);  
    
41. 
    5 E7 ~, v. q2 X! p# p
42.   /* 返回状态 */
    4 O3 K4 x. y- K) v. ~
43.   return HAL_OK;  
    $ t$ ?( B* V7 H/ \$ {
44. }

复制代码

函数描述：
0 a4 s9 {  E) R6 U' ?
6 Z: v( s- v: f8 D8 n+ b( S此函数用于启动定时器输入捕获模式，采用定时器方式。
6 y, |4 J. B; ]+ T5 D8 _! {
函数参数：

. P( T( Z. Y: p  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  第2个参数是通道设置，支持以下参数：
TIM_CHANNEL_1
' G; v0 y, z/ J3 `$ k7 m
5 Z% g# ^, g. H3 F) C* b1 zTIM_CHANNEL_2
. D6 o" A* f2 M
TIM_CHANNEL_3
, y* h0 ~& Q; a+ e8 H! v1 l
6 R1 L7 o3 X4 d* QTIM_CHANNEL_4
( {: h2 C* b; g/ c
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
9 Z; v1 Z- E0 b4 c7 k7 L32.4.9 函数HAL_TIM_OC_Init
函数原型：

1. HAL_StatusTypeDef HAL_TIM_OC_Init(TIM_HandleTypeDef* htim)
   
2. {
   
3.   /* 检测形参是否有效 Check */
   6 ~; F- [1 C% z6 V
4.   if(htim == NULL)
   
5.   {
   
6.     return HAL_ERROR;
   
7.   }
   
8. 
   
9.   /* 检查参数 */
   9 T; ~* S8 r, E' k
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));
    5 k  k, ]/ l' @" D" a& O' e
13. 
    " C# _2 K# y! s4 T) ]% W/ V
14.   if(htim->State == HAL_TIM_STATE_RESET)
    
15.   {
    % H- {4 Q; L; v- E
16. /* 默认取消锁 */
    $ p6 N! b* O9 p: c
17.     htim->Lock = HAL_UNLOCKED;
    
18. 
    - L; k+ F7 r) ^/ I2 [& K; y; d/ l( p
19. /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_OC_MspInit(htim);
    
21.   }
    
22. 
    ( y. U# U8 a8 K! J$ \
23.   /* 设置定时器状态Set the TIM state */
    
24.   htim->State= HAL_TIM_STATE_BUSY;
    ! z% Q: e% ]0 Z/ R
25. 
    
26.   /* 配置定时器为输出比较模式Init the base time for the Output Compare */  
    ! q  H2 R0 L4 ^) p; z# z
27.   TIM_Base_SetConfig(htim->Instance,  &htim->Init);
    & C1 T9 m1 A4 Z: \
28. 
    
29.   /* 设置定时器状态 */
    3 `. g7 c: W& q& p3 }" O9 K
30.   htim->State= HAL_TIM_STATE_READY;
    
31. 
    
32.   return HAL_OK;
    
33. }

复制代码

函数描述：
: V+ L! m* v! o
此函数用于定时器输出比较初始化。

函数参数：
9 B2 L# V( N% C% x9 W1 _
$ f3 @7 a1 l7 {  L+ J. m  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
/ g+ l: L0 J7 s: F0 {1 P1 ~6 ^  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：
# c2 W! B/ c; l6 U
函数HAL_TIM_OC_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
' m2 _! q0 C! `: y" x如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个HAL_TIM_STATE_RESET  = 0x00U。

解决办法有三：
1 B- F3 u% E# P* G. f! e
方法1：用户自己初始定时器和涉及到的GPIO等。
. u2 ~( T0 {9 P7 @6 P
; S7 }( i% k! y# ?6 Q; t9 E方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
% }# p, ^7 e' Q6 }
0 T7 f  A% G) b5 G方法3；下面的方法
6 Y8 M( {! s4 `) v; v( _4 C

1. if(HAL_TIM_OC_DeInit(&UartHandle) != HAL_OK)
   , u$ w/ @8 }8 A/ i
2. {
   
3.     Error_Handler();
   ) t- \/ C. o& u( _/ m$ e
4. }  
   * l. g; b! O, |! N8 N
5. if(HAL_TIM_OC_Init(&UartHandle) != HAL_OK)
   : M( h5 Z, |: g- D: m5 D+ A# G
6. {
   3 S  H9 a' n# y" a: v' d' D3 H. @4 @
7.     Error_Handler();
   
8. }
   
9. 32.4.10   函数HAL_TIM_OC_ConfigChannel
   . c! p3 w% z/ ~' e5 w
10. 函数原型：
    * a$ ^* |' j3 j& Q1 r
11. 
    
12. HAL_StatusTypeDef HAL_TIM_OC_ConfigChannel(TIM_HandleTypeDef *htim,
    & P" m4 ]9 Y+ v6 T% `& Y" F
13.                                            TIM_OC_InitTypeDef* sConfig,
    ; N& }, p- H' i; M2 A
14.                                            uint32_t Channel)
    % T' v5 W! Q  l6 z% Y
15. {  
      E/ j0 F# s- C& P
16.   /* Check the parameters */
    7 o' E  o# h; }. l
17.   assert_param(IS_TIM_CHANNELS(Channel));
    
18.   assert_param(IS_TIM_OC_MODE(sConfig->OCMode));
    : Z/ o9 }# R( f  c. {0 Z
19.   assert_param(IS_TIM_OC_POLARITY(sConfig->OCPolarity));
    
20. 
    ' J; ^; m7 s4 e3 ?
21.   /* Process Locked */
    
22.   __HAL_LOCK(htim);
    1 f  W/ B' [0 q. Y7 @4 Z5 t& }
23. 
      x' `$ A3 X1 J% C& D" u1 s5 K
24.   htim->State = HAL_TIM_STATE_BUSY;
    
25. 
    
26.   switch (Channel)
    
27.   {
    
28.     case TIM_CHANNEL_1:
    3 j% o/ v) L8 H/ H$ l& ^
29.     {
    
30.       /* 检测参数Check the parameters */
    2 t0 L" W, n5 ]% p7 ]8 i5 l
31.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    - C5 {0 b/ [( p9 i/ X8 Z$ c
32. 
    
33.      /* 配置定时器输出比较通道1 */
    
34.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    
35.     }
    9 C# d8 z) b$ `& q6 p
36.     break;
    
37. 
      x7 Q, w( ?1 U, t0 h5 G
38.     case TIM_CHANNEL_2:
    
39.     {
    9 a' f9 I* h% Y, Q" q# |  e1 d( {
40.       /* 省略 */
    
41.     }
    
42.     break;
    
43. 
    3 h! ^0 G6 z8 d( d. h5 |
44.     case TIM_CHANNEL_3:
    
45.     {
    
46.       /* 省略 */
    
47.     }
    * V1 v7 s+ t6 }: `- e5 ]
48.     break;
    6 k5 a$ L* f; N4 ]" E
49. 
    8 |$ p% @- l% _% d9 T
50.     case TIM_CHANNEL_4:
    
51.     {
    . U% r# r* V& T9 }* \
52.       /* 省略 */
    3 k9 M- n1 Y) p# j$ C. V
53.     }
    
54.     break;
    
55. 
    
56.     case TIM_CHANNEL_5:
    
57.     {
    ! `% A& s" V9 K
58.       /* 省略 */
    
59.     }
    
60.     break;
    0 ^+ n3 @' D& w: M$ G5 r8 }
61. 
    - }  k# f  a1 D0 S6 g( g7 l
62.     case TIM_CHANNEL_6:
    # {1 ^# H( g# l
63.     {
    - h% x3 p" O+ Y# b+ J1 {# k
64.       /* 省略 */
    
65.     }
    1 L2 b( R7 V& R# a# W0 A
66.     break;
    ; {  U3 }* a) G( v0 a$ X% \; M
67. 
    
68.     default:
    $ h( z3 z* @" d# i0 D! I2 y! ~1 I
69.     break;   
    2 `' _* m3 }8 v, ~
70.   }
    
71. 
    
72.   htim->State = HAL_TIM_STATE_READY;
    
73. 
    
74.   __HAL_UNLOCK(htim);
    
75. 
    
76.   return HAL_OK;
    
77. }

复制代码

函数描述：

此函数用于初始化串口的基础特性和高级特性。
/ Z- F6 t, F) V$ S, d
0 j' L1 `6 m8 p# e# y6 y. g函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
7 s4 r) g  w; }/ {& t  第3个参数是通道设置，支持以下参数：
TIM_CHANNEL_1

TIM_CHANNEL_2

TIM_CHANNEL_3

2 ?0 r8 J, ^! _, c; O% T- hTIM_CHANNEL_4

3 V1 t% g, G7 y" VTIM_CHANNEL_5
4 U: ~, f4 b! U* S8 ?
TIM_CHANNEL_6

( r, Q& [# W& R; O) I( S, q% Y  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
0 Q; s4 Q  d) j( R32.4.11   函数HAL_TIM_OC_Start
函数原型：
4 L; @$ K6 V5 j2 @# {

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, s& n3 v8 Z; C0 M) Y
5. 
   
6.   /* 使能输出比较通道 */
   - n' L) X/ Y1 J5 V% F6 J
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
8. 
   ) W7 U8 d7 t& B' G, J; g
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
     @2 }1 G( q* u! [' {! \1 O) Z
10.   {
    $ L3 L" N% c8 B4 T5 Q
11.     /* 使能主输出 */
    ' f. V5 i/ I4 u4 h/ v6 A9 }' m
12.     __HAL_TIM_MOE_ENABLE(htim);
    
13.   }
    
14. 
    " r2 B! n. s. ]+ t0 b: @. Q; N9 P& g
15.   /* 使能定时器 */
    7 s4 J. q* Z; @0 n- J6 V
16.   __HAL_TIM_ENABLE(htim);
    . ^1 l/ ?' m9 T7 E& \% Y9 s* {
17. 
    
18.   /* 返回状态 */
      b) O# i% f' w. ?1 [) e; t: f
19.   return HAL_OK;
    
20. }

复制代码

' ^& C+ E% c4 {7 |函数描述：
. S) y$ \& c& p/ Z1 x
此函数用于启动定时器输出比较模式。
3 b4 j3 T/ D# u  m( P) G  F
" c8 Z- T8 l9 Z' X1 T' B函数参数：
$ n0 j) V& a" d4 y, U! ]- b: a
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  第2个参数是通道设置，支持以下参数：
TIM_CHANNEL_1
) H9 u0 l; u$ ^2 v* H$ g
TIM_CHANNEL_2
' q# V3 B' b) ^
# z/ E, S) C! _( s) A% P  lTIM_CHANNEL_3
* ?& I+ l; r) j; M! D- w& n) O
TIM_CHANNEL_4

  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
7 N# \5 d! K1 j) }6 D! q5 L. @32.5 总结
2 b" C, B4 e: K9 Q1 k6 W/ x本章节就为大家讲解这么多，建议大家将GPIO的驱动源码结合参考手册中的寄存器通读一遍，对于我们后面章节的学习大有裨益。
  q( a0 U+ r/ X4 s


& g0 W+ V5 M9 R- f' X