32.1 初学者重要提示
1 E7 B0 j3 r& C" I  学习定时器外设推荐从硬件框图开始了解基本的功能特性，然后逐步深入了解各种特性，这种方式方便记忆和以后查阅。
  STM32H7的定时器输出100MHz方波是完全没问题。
6 f0 l! I' d. @1 X2 l3 @: e  STM32H7定时器进出中断的速度能跑到12.5MHz，所有程序在TCM和Flash运行没差别。
% O5 v4 r* i  s$ F2 t/ }) Q6 V  STM32H7的定时器输入捕获可以实现12MHz方波的双边沿捕获，单边沿可以做到24MHz。
  特别注意STM32H7的TIM1,8,15,16,17才有RCR重复计数器，其它都没用的。
+ n* D' r% M4 O  STM32H7的单个定时器中不同通道可以配置不同频率PWM。
2 \5 n/ _4 u& j' @  G  STM32H7的TIM1-TIM17中断入口函数名使用时要注意，别搞错了：

1. TIM1_BRK_IRQHandler            
   
2. TIM1_UP_IRQHandler              
   
3. TIM1_TRG_COM_IRQHandler        
   
4. TIM1_CC_IRQHandler                                                   
   - M7 z! f, g3 ]/ C  J' i
5. TIM2_IRQHandler                                          
   
6. TIM3_IRQHandler                                                
   5 ~6 A3 ~2 g6 ^  a8 L3 Y
7. TIM4_IRQHandler                 
   . F& r9 d( \; j/ S8 }: s- ^
8. TIM5_IRQHandler            
   4 B& A' e$ y7 c7 b! F/ w* J: P9 e
9. TIM6_DAC_IRQHandler           <------------------要注意            
     z4 M* H" X9 ~; |- {& [& C2 |
10. TIM7_IRQHandler
    1 D! ^0 L, C; W% Q" ]# T; o: V
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

复制代码

4 o( Z- z, W6 R* Z/ q6 Q: Z6 x+ z32.2 定时器基础知识
% P, q" Q1 R8 O% C/ Y注，不同定时支持的功能略有区别，基础定时器功能较少，TIM1和TIM8高级定时器功能多些。
: g3 {8 T. I2 v0 v  E. @
  TIM2和TIM5是32位定时器，其它定时器都是16位定时器。16位和32位的区别是CNT计数器范围不同，32位的范围是0 到2^32 – 1，而16位的是0到65535；它们支持的分频是范围是一样的，都是1到65535。
  计数器支持递增、递减和递增/递减二合一。
3 x- ~. X. X- r" I5 G. l, h  多个独立通道，可用于：
0 o" {9 Q$ `1 L; I) i( |9 G– 输入捕获。

– 输出比较。

3 A# \8 _5 `0 _* Z3 Z– PWM 生成（边沿和中心对齐模式）。
4 T+ ?$ J6 B! J5 U
– 单脉冲模式输出。

  带死区插入，断路功能和PWM互补输出
2 h, g" O+ E) i" x  发生如下事件时生成中断/DMA 请求：
– 更新：计数器上溢/下溢、计数器初始化（通过软件或内部/外部触发）

– 触发事件（计数器启动、停止、初始化或通过内部/外部触发计数）
! C8 W7 k6 G  `' p8 ^+ j: e
6 \' V0 u" x( X1 |! V% e– 输入捕获
" b4 B: a: J% i3 j8 \9 @
– 输出比较

  支持增量式编码器和霍尔传感器。
; [/ f% A. j- P6 s" }6 C32.2.1 定时器TIM1-TIM17的区别
STM32H7支持的定时器有点多，要简单的区分下。STM32H7支持TIM1-TIM8，TIM12-TIM17共14个定时器，而中间的TIM9，TIM10，TIM11是不存在的，这点要注意。

粗略的比较如下：

% h! _3 H1 H2 p" H$ N通过上面的表格，至少要了解到以下两点：
- d2 c* s- x6 U9 N' O/ u  c0 B
  STM32H7的定时器主要分为高级定时器，通用定时器，基础定时器和低功耗定时器。
  TIM2和TIM5是32位定时器，其它都是16位定时器。
6 D" F3 y3 o: |' ~8 Y
6 ]# X. A' A( R, V32.2.2 定时器的硬件框图
5 s1 e: G# e8 f1 i, ~& c4 @9 j认识一个外设，最好的方式就是看他的框图，方便我们快速的了解定时器的基本功能，然后再看手册了解细节。

下面我们直接看最复杂的高级定时器TIM1&TIM8框图：

7 {( U! _" s) K' C: X' ?

, f# a, [2 }4 ^通过这个框图，我们可以得到如下信息：
! o5 O. i3 }4 b- i% B
5 t2 }9 l2 a1 @  z9 ^7 @$ ?  TIMx_ETR接口
* ^; ^  G- x7 x$ f外部触发输入接口。ETR支持多种输入源：输入引脚（默认配置）、比较器输出和模拟看门狗。
- e5 H0 S* K9 T6 l# k% [
: e) q6 I6 Q  h, Q7 a4 }% g5 O

- J- o6 E, A& m: h9 @6 X
. {* h' f- o# m5 e' u  截图左侧的TIMx_CH1，TIMx_CH2，TIMx_CH3和TIMx_CH4接口
% L1 d5 ~3 n& N7 ?& f& |5 [) }6 L2 g. U9 q这四个通道主要用于输入捕获，可以计算波形频率和脉宽。                                                                                                                             
& Z: q; M( J2 j# D7 k7 k/ C
( w( j8 G/ R  ^/ ?: g  TIMx_BKIN和TIMx_BKIN2接口
3 Y$ W: [$ [5 }断路功能，主要用于保护由 TIM1 和 TIM8 定时器产生的 PWM 信号所驱动的功率开关
0 D; _7 M" G: g" S: ]/ w2 R( ~
  TRGO内部输出通道
* `: [9 K4 F4 D4 g1 d1 ~主要用于定时器级联，ADC和DAC的定时器触发。
! n$ }3 B# t. |" Z
  6组输出比较单元OC1到OC6
OC1到OC4有对应的输出引脚，而OC5和OC6没有对应的输出引脚，主要用于内部控制。
  ^: }! \; ]% L7 \9 ~
  截图右侧的输出比较通道TIMx_CH1，TIMx_CH1N，TIMx_CH2，TIMx_CH2N，TIMx_CH3，TIMx_CH3N和TIMx_CH4
. T4 Y" G( G; C% U8 l主要用于PWM输出，注意CH1到CH3有互补输出，而CH4没有互补输出。

  其它框图里面未展示出来功能
定时器TIM1&TIM8还支持的其它功能在用到的时候再做说明。

32.2.3 定时器的时基单元
& o1 |4 u/ C4 W% Z定时器要工作就需要一个基本时基单元，而基本的时基单元是由下面几个寄存器组成的：

+ X" d0 t/ h% G* A3 N: Z  预分频器寄存器 (TIMx_PSC)
5 v' {% i& a! V, x用于设置定时器的分频，比如定时器的主频是200MHz，通过此寄存器可以将其设置为100MHz，50MHz，25MHz等分频值。
* I3 L% E9 L: b! e7 I, k2 s
" m2 n, V4 T! S注：预分频器有个缓冲功能，可以让用户实时更改，新的预分频值将在下一个更新事件发生时被采用（以递增计数模式为例，就是CNT计数值达到ARR自动重装寄存器的数值时会产生更新事件）。

  计数器寄存器 (TIMx_CNT)
8 o$ N4 j( ^3 t- \8 _计数器是最基本的计数单元，计数值是建立在分频的基础上面，比如通过TIMx_PSC设置分频后的频率为100MHz，那么计数寄存器计一次数就是10ns。
% a  Q, P/ ^, {* H* k) R
2 \3 A8 V! _1 d* b/ m  自动重载寄存器 (TIMx_ARR)
' q. q6 J$ M" O) r2 i" H* t自动重装寄存器是CNT计数寄存器能达到的最大计数值，以递增计数模式为例，就是CNT计数器达到ARR寄存器数值时，重新从0开始计数。

+ @& l6 h9 v5 p0 i4 J3 ]$ I注，自动重载寄存器是预装载的。对自动重载寄存器执行写入或读取操作时会访问预装载寄存器。预装载寄存器的内容既可以立即传送到影子寄存器（让设置立即起到效果的寄存器），也可以在每次发生更新事件时传送到影子寄存器。简单的说就是让ARR寄存器的数值立即更新还是更新事件发送的时候更新。
* J/ b; t& H) Z- z9 P
, U+ I; E2 ^% }  重复计数器寄存器 (TIMx_RCR)
以递增计数模式为例，当CNT计数器数值达到ARR自动重载数值时，重复计数器的数值加1，重复次数达到TIMx_RCR+ 1后就，将生成更新事件。

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

; j; |8 t4 B& _' E比如我们要配置定时器实现周期性的中断，主要使用这几个寄存器即可。
2 N/ G) [* j4 ~
32.2.4 定时器输出比较（PWM）
使用定时器时基单元的那几个寄存器仅仅能设置周期，还不能设置占空比。针对这个问题，还需要比较捕获寄存CCR的参与，这样就可以设置占空比了。
# N& l" D8 b2 U* D6 h7 y
, g5 F& i% @1 o4 f( a1 f8 [9 [为了方便大家理解，以PWM 边沿对齐模式，递增计数配置为例：

  当计数器TIMx_CNT < 比较捕获寄存器TIMx_CCRx期间，PWM参考信号OCxREF输出高电平。
  当计数器TIMx_CNT >= 比较捕获寄存器TIMx_CCRx期间， PWM参考信号OCxREF输出低电平。
% W* [& Z+ Y+ `; C  k: c, n& d  当比较捕获寄存器TIMx_CCRx > 自动重载寄存器TIMx_ARR，OCxREF保持为1。
  当比较捕获寄存器TIMx_CCRx = 0，则OCxRef保持为0。
: m* S+ F5 I) f! A6 \3 w) I下面是TIMx_ARR=8的波形效果：

32.2.5 定时器输入捕获
4 c( b! \$ w" L( k( t2 d: {与PWM一样，使用定时器实现输入捕获，仅靠时基单元的那几个寄存器是不行的，我们需要一个寄存器来记录发生捕获时的具体时间，这个寄存器依然由比较捕获寄存器TIMx_CCRx来实现。

比如我们要测量一路方波的周期：

  配置定时器为输入捕获模式，上升沿触发，设置分频，自动重装等寄存器，比如设置的CNT计数器计数1次是1微秒。
. \, @. s3 K7 |% M; Q  当有上升沿触发的时候，TIMx_CCRx寄存器就会自动记录当前的CNT数值，然后用户就可以通过CC中断，在中断复位程序里面保存当前的TIMx_CCRx寄存器数值。等下次再检测到上升沿触发，两次时间求差就可以得到方波的周期。
4 q) d$ c+ _/ _9 {' K; [7 o6 s不过这里要特别注意一点，如果CNT发生溢出（比如16位定时器，计数到65535就溢出了）就需要特别处理下，将CNT计数溢出考虑进来。

* Q, w& x) V# ?# c5 u5 r8 ^32.3 定时器的HAL库用法
; d$ A3 o$ E7 h' o4 A7 h! K, B) [定时器的HAL库用法其实就是几个结构体变量成员的配置和使用，然后配置GPIO、时钟，并根据需要配置NVIC、中断和DMA。下面我们逐一展开为大家做个说明。
+ j) w: L( Z  X" G9 ^
4 ~/ Y, b' z! v' F! K  s8 u8 @/ O) A32.3.1 定时器寄存器结构体TIM_TypeDef
& z9 n; z. e/ n9 ?定时器相关的寄存器是通过HAL库中的结构体TIM_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：

8 m$ W: L" d$ G( ~

1. typedef struct
     E6 B8 b4 _5 v
2. {
   ) U6 j/ ^8 L  V- T
3.   __IO uint16_t CR1;         /*!< TIM control register 1,                   Address offset: 0x00 */
   ' z. O7 m  E2 _& F* f; `
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 */
   
8.   __IO uint32_t SR;          /*!< TIM status register,                      Address offset: 0x10 */
   
9.   __IO uint32_t EGR;         /*!< TIM event generation register,            Address offset: 0x14 */
   ' Q# S" q( S9 q1 l+ G' u' \
10.   __IO uint32_t CCMR1;       /*!< TIM capture/compare mode register 1,      Address offset: 0x18 */
    ' e( Q' C* \# e- k$ i
11.   __IO uint32_t CCMR2;       /*!< TIM capture/compare mode register 2,      Address offset: 0x1C */
    ' A2 h1 b/ M& q- W
12.   __IO uint32_t CCER;        /*!< TIM capture/compare enable register,      Address offset: 0x20 */
    ' P8 G, Y) u; M2 t4 \, Y: _/ d4 X* i
13.   __IO uint32_t CNT;         /*!< TIM counter register,                     Address offset: 0x24 */
    
14.   __IO uint16_t PSC;         /*!< TIM prescaler,                            Address offset: 0x28 */
    
15.   uint16_t      RESERVED9;   /*!< Reserved, 0x2A                                                 */
    4 e+ _. c/ L5 u3 _. ~# f
16.   __IO uint32_t ARR;         /*!< TIM auto-reload register,                 Address offset: 0x2C */
    
17.   __IO uint16_t RCR;         /*!< TIM repetition counter register,          Address offset: 0x30 */
    
18.   uint16_t      RESERVED10;  /*!< Reserved, 0x32                                                 */
    ! S& ]: y9 B, E0 P
19.   __IO uint32_t CCR1;        /*!< TIM capture/compare register 1,           Address offset: 0x34 */
      o# x* `' w2 j; C
20.   __IO uint32_t CCR2;        /*!< TIM capture/compare register 2,           Address offset: 0x38 */
    / Y) t. k6 ]6 P' ?# t" h# {; J. j
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 */
    
24.   __IO uint16_t DCR;         /*!< TIM DMA control register,                 Address offset: 0x48 */
    - V, r9 Y2 U7 z! ]. m2 K
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                                                 */
    
28.   uint16_t      RESERVED14;  /*!< Reserved, 0x50                                                 */
    4 v& a' N- `* t
29.   __IO uint32_t CCMR3;       /*!< TIM capture/compare mode register 3,      Address offset: 0x54 */
    - d  w0 P0 t3 P) j" W. e$ H1 p; {
30.   __IO uint32_t CCR5;        /*!< TIM capture/compare register5,            Address offset: 0x58 */
    * Y0 L1 V: p" q- a, V' C$ V* `) u
31.   __IO uint32_t CCR6;        /*!< TIM capture/compare register6,            Address offset: 0x5C */
    # B1 A1 T; F& _
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 */
    3 t2 v7 N0 U3 |5 q' c; j
34.   __IO uint32_t TISEL;       /*!< TIM Input Selection register,             Address offset: 0x68 */
    ! ^, u3 F' z5 c
35. } TIM_TypeDef;

复制代码

这个结构体的成员名称和排列次序和CPU的定时器寄存器是一 一对应的。
* v) W/ R: o+ v/ y  q  m" R: l3 E
__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
: m% Q5 K- |3 Y9 a; c" z

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

复制代码

& v# `) k+ u  L; R8 t" o6 Z; \/ E下面我们看下定时器的定义，在stm32h743xx.h文件。
: M% c! C9 F& q! \

1. #define PERIPH_BASE         ((uint32_t)0x40000000)
   : \" w2 I9 x( _) Q2 j" Q
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
   
7. #define TIM3_BASE             (D2_APB1PERIPH_BASE + 0x0400)
   
8. #define TIM4_BASE             (D2_APB1PERIPH_BASE + 0x0800)
   8 }  L, w  A' S
9. #define TIM5_BASE             (D2_APB1PERIPH_BASE + 0x0C00)
   ' k* f7 d1 S, q- R; J
10. #define TIM6_BASE             (D2_APB1PERIPH_BASE + 0x1000)
    
11. #define TIM7_BASE             (D2_APB1PERIPH_BASE + 0x1400)
    8 N$ t: t  X  r; n$ E
12. #define TIM12_BASE            (D2_APB1PERIPH_BASE + 0x1800)
    
13. #define TIM13_BASE            (D2_APB1PERIPH_BASE + 0x1C00)
    
14. #define TIM14_BASE            (D2_APB1PERIPH_BASE + 0x2000)
    
15. 
    0 Y3 e4 I+ L6 a- h
16. /*!< D2_APB1PERIPH 外设 */
    
17. #define TIM1_BASE             (D2_APB2PERIPH_BASE + 0x0000)
    6 ]" o% S# U" E+ D5 C
18. #define TIM8_BASE             (D2_APB2PERIPH_BASE + 0x0400)
    
19. #define TIM15_BASE            (D2_APB2PERIPH_BASE + 0x4000)
    6 U* _2 C2 y' c* L1 p. U/ q
20. #define TIM16_BASE            (D2_APB2PERIPH_BASE + 0x4400)
    3 @1 I2 A4 ~, [) z# t
21. #define TIM17_BASE            (D2_APB2PERIPH_BASE + 0x4800)
      x- j" x: ?; G' i1 r% p
22. 
    
23. #define TIM1                ((TIM_TypeDef *) TIM1_BASE)
    & |( A2 t" b# q* }1 w" d
24. #define TIM2                ((TIM_TypeDef *) TIM2_BASE)
    0 L4 r4 s  G* c* A
25. #define TIM3                ((TIM_TypeDef *) TIM3_BASE)
    
26. #define TIM4                ((TIM_TypeDef *) TIM4_BASE)
    5 t: w0 U/ Q+ v
27. #define TIM5                ((TIM_TypeDef *) TIM5_BASE)
    3 Y3 Q$ F' V5 }# p8 L
28. #define TIM6                ((TIM_TypeDef *) TIM6_BASE)
    " H1 u$ }# x) S6 ?% [
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)
    : R4 b% m% P% N" q! X
33. #define TIM14               ((TIM_TypeDef *) TIM14_BASE)
    
34. #define TIM15               ((TIM_TypeDef *) TIM15_BASE)
    
35. #define TIM16               ((TIM_TypeDef *) TIM16_BASE)
    . R5 Q/ n' c+ Y: A$ @$ @2 G
36. #define TIM17               ((TIM_TypeDef *) TIM17_BASE)

复制代码

7 |3 v- e4 u+ S我们访问TIM2的CR1寄存器可以采用这种形式：TIM2->CR1 = 0；

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

1. typedef struct
   
2. {
   - D, a0 Z, {- d" [
3.   TIM_TypeDef              *Instance;     /*!< Register base address             */
   7 @3 p6 v8 [7 l2 {
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 */
   . g: [! h  u1 Z' o+ F; u% n7 ?4 d
8.   DMA_HandleTypeDef        *hdma[7];      
   
9.   HAL_LockTypeDef          Lock;          /*!< Locking object                    */
   
10.   __IO HAL_TIM_StateTypeDef   State;      /*!< TIM operation state               */  
    
11. }TIM_HandleTypeDef;

复制代码

3 R# @- W( h6 E  `, n; b这里重点介绍前四个参数，其它参数主要是HAL库内部使用的。
7 _+ e* H8 y/ p3 d5 n+ [- p: T, i
  TIM_TypeDef  *Instance
& v/ F$ C/ ?% C$ }: A1 L
这个参数是寄存器的例化，方便操作寄存器，比如使能定时器的计数器。
. |  n% ]/ m1 Q
- }" C9 j, }0 FSET_BIT(huart->Instance->CR1,  TIM_CR1_CEN)。

2 }- u( o4 _4 P3 t' l$ p( i  TIM_Base_InitTypeDef  Init

这个参数是用户接触最多的，用于配置定时器的基本参数。

TIM_Base_InitTypeDef结构体的定义如下：

1. typedef struct
   0 w9 z& q. I5 I  y" Y
2. {
   
3.   uint32_t Prescaler;      
   8 v8 R7 s! X  b( }6 w9 n
4.   uint32_t CounterMode;   
   - v5 J0 |& i' ~# p
5.   uint32_t Period;         
   ; ?+ m3 W& k$ n0 c, N0 v5 M4 l
6.   uint32_t ClockDivision;   
   
7.   uint32_t RepetitionCounter;
   7 }# L  i, @. C# k# x! x
8.   uint32_t AutoReloadPreload;  
   
9. } TIM_Base_InitTypeDef;

复制代码

9 H; j4 `( m) [7 x' J  成员Prescaler
% j7 J9 L. X* G, U! [1 p用于设置定时器分频，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。
8 O/ k( a6 h) |/ z
  成员CounterMode
. A% X7 h  q" }0 R7 {' Z: \8 \# F用于设置计数模式，向上计数模式、向下计数模式和中心对齐模式。
+ T/ ?' W$ ]4 t! K3 X* y8 G
. P3 T' Z2 L1 S: t

1. #define TIM_COUNTERMODE_UP                ((uint32_t)0x0000U)   /*!< Up counting mode */
   2 r8 P- C" m+ a! D/ E2 Q. Z
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 */
   : I& a+ J1 a) S+ j
4. #define TIM_COUNTERMODE_CENTERALIGNED2     TIM_CR1_CMS_1        /*!< Center-aligned counting mode 2 */
   
5. #define TIM_COUNTERMODE_CENTERALIGNED3     TIM_CR1_CMS          /*!< Center-aligned counting mode 3 */

复制代码

9 w3 r( ]0 F, @  成员Period
用于设置定时器周期，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。
- T! q; {  c0 K1 ~
  成员ClockDivision
; a) P$ k9 a& R8 s用于指示定时器时钟 (CK_INT) 频率与死区发生器以及数字滤波器（ETR、TIx）所使用的死区及采样时钟 (tDTS) 之间的分频比。
" |: ~7 m8 K! B* K4 F0 T# m
; _, C  k0 U9 i

1. #define TIM_CLOCKDIVISION_DIV1       ((uint32_t)0x0000U)        /*!< Clock Division DIV1 */
   ' W' F: M  d" {/ G
2. #define TIM_CLOCKDIVISION_DIV2       (TIM_CR1_CKD_0)            /*!< Clock Division DIV2 */
   
3. #define TIM_CLOCKDIVISION_DIV4       (TIM_CR1_CKD_1)             /*!< Clock Division DIV4 */

复制代码

  成员RepetitionCounter
用于设置重复计数器，仅TIM1和TIM8有，其它定时器没有。作用是每当计数器上溢/下溢时，重复计数器减1，当减到零时，才会生成更新事件，这个在生成PWM时比较有用。
$ G$ E9 b. J+ w
' ]: {' \3 a2 [. p  成员AutoReloadPreload
用于设置定时器的ARR自动重装寄存器是更新事件产生时写入有效还是立即写入有效。如果使能了表示更新事件产生时写入有效，否则反之。

' S2 O  j  _% a8 p" S! c

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

复制代码

6 }% z0 F0 @; B# o( R  HAL_TIM_ActiveChannel    Channel;

* ~& z, Z! H4 x* V6 J# H. F6 V0 B用于设置定时器通道，比如TIM1和TIM8都是6个通道。

3 N$ k! S" g5 x! h9 O/ ?# U  E7 k- c

1. typedef enum
   3 Y0 x' L. {. \3 Q# {+ @; ~+ x+ A
2. {
   
3.   HAL_TIM_ACTIVE_CHANNEL_1        = 0x01U,    /*!< The active channel is 1     */
   
4.   HAL_TIM_ACTIVE_CHANNEL_2        = 0x02U,    /*!< The active channel is 2     */
   . f7 c- o/ r' J5 d8 |
5.   HAL_TIM_ACTIVE_CHANNEL_3        = 0x04U,    /*!< The active channel is 3     */   
   
6.   HAL_TIM_ACTIVE_CHANNEL_4        = 0x08U,    /*!< The active channel is 4     */
   
7.   HAL_TIM_ACTIVE_CHANNEL_5        = 0x10U,    /*!< The active channel is 5     */
   
8.   HAL_TIM_ACTIVE_CHANNEL_6        = 0x20U,    /*!< The active channel is 6     */
   / K, k' _; c4 m, G) g
9.   HAL_TIM_ACTIVE_CHANNEL_CLEARED  = 0x00U     /*!< All active channels cleared */   
   
10. }HAL_TIM_ActiveChannel;
    0 a5 O! x3 r0 L- z* Y0 ]
11.   DMA_HandleTypeDef        *hdma[7];

复制代码

用于关联DMA。
5 |) D" M( A$ b
' U! C" I1 S- `- @配置定时器参数，其实就是配置结构体TIM_HandleTypeDef的成员。

1. TIM_HandleTypeDef   TimHandle = {0};
   
2. 
   
3. /*
   
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   ( B! \) V1 C  O
6. TimHandle.Instance = TIMx;
   
7. TimHandle.Init.Prescaler         = usPrescaler;
   
8. TimHandle.Init.Period            = usPeriod;        
   4 F7 Z0 ^% A5 g5 [' y
9. TimHandle.Init.ClockDivision     = 0;
   & R) S# X& s* K, E! T8 N5 `
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    9 ~6 h1 ?  y5 H" n2 `
11. TimHandle.Init.RepetitionCounter = 0;
    6 {" p. R/ {, n/ `/ H+ I, z% M& S( D
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    ' a* ]" r0 t' y0 ]2 Y' M
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    
14. {
    6 e% N% d- Z& v
15.         Error_Handler(__FILE__, __LINE__);
    
16. }

复制代码

32.3.3 定时器输出比较结构体TIM_OC_InitTypeDef
& F; s' ]$ T6 u9 _& C此结构体主要用于定时器的输出比较，定义如下：

1. typedef struct
   & J0 ^# y/ ^. T" L
2. {                                 
   
3.   uint32_t OCMode;      
   
4.   uint32_t Pulse;      
   
5.   uint32_t OCPolarity;   
   
6.   uint32_t OCNPolarity;   
   ( o& `0 ?! f' J) w
7.   uint32_t OCFastMode;  
   ' ?6 n) k4 m: c) F$ L' A9 z
8.   uint32_t OCIdleState;   
   
9.   uint32_t OCNIdleState;  
   
10. } TIM_OC_InitTypeDef;  

复制代码

下面将这几个参数一 一做个说明。

8 H* e- e8 I/ i  OCMode
+ J, Q* z7 B" |3 y用于配置输出比较模式，支持的模式较多：
8 u" O0 K$ F. [

1. /*!< TIM Output timing mode */
   
2. #define TIM_OCMODE_TIMING                ((uint32_t)0x0000U)      
   7 E& k! f) g$ |! R, ]7 c
3. 
   - n6 y/ V( Z( z' {6 }1 m0 S6 b5 }
4. /*!< TIM Output Active mode */                          
   # U3 U; g1 _2 ]& }
5. #define TIM_OCMODE_ACTIVE                ((uint32_t)TIM_CCMR1_OC1M_0)
   9 K9 K% M3 G) D) r9 I, D
6. 
   
7. /*!< TIM Output Inactive mode */                       
   
8. #define TIM_OCMODE_INACTIVE              ((uint32_t)TIM_CCMR1_OC1M_1)           
   ! K$ `: x( P. i$ N6 q" A, @
9. 
   
10. /*!< TIM Output Toggle mode */               
    
11. #define TIM_OCMODE_TOGGLE                 ((uint32_t)TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)         
    ' k. M. F7 W( }& |8 Z. D  R' W
12. 
    
13. /*!< TIM PWM mode 1 */
    
14. #define TIM_OCMODE_PWM1                   ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1)
    
15. 
    
16. /*!< TIM PWM mode 2 */                    
    
17. #define TIM_OCMODE_PWM2                    ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)   
    ' B) p: t1 v: k3 w& B% Z1 Q
18. 
    3 G$ i. Y. _6 z
19. /*!< TIM Forced Active mode */   
    6 `  j; A' }% d8 [% C! Z
20. #define TIM_OCMODE_FORCED_ACTIVE           ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0)         
    
21. 
    
22. /*!< TIM Forced Inactive mode */            
    
23. #define TIM_OCMODE_FORCED_INACTIVE         ((uint32_t)TIM_CCMR1_OC1M_2)                                       
    
24. 
    
25. /*!< TIM Rettrigerrable OPM mode 1 */  
    ; a, p" i5 u6 u
26. #define TIM_OCMODE_RETRIGERRABLE_OPM1      ((uint32_t)TIM_CCMR1_OC1M_3)   
    - ?' \6 j) `' `# Y
27. 
    2 p6 K. g$ {8 j% G" Q
28. /*!< TIM Rettrigerrable OPM mode 2 */                                       
    + X+ W0 L0 m. l, _" ]# E
29. #define TIM_OCMODE_RETRIGERRABLE_OPM2      ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0)   
    
30. 
    
31. /*!< TIM Combined PWM mode 1 */                     
    
32. #define TIM_OCMODE_COMBINED_PWM1           ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_2)     
    
33. 
    6 |, w& ?7 X7 X3 K& \
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 ]7 e+ O  J2 ^+ z5 ?! Y
36. 
    . K  q3 y( g# j! o9 {
37. /*!< TIM Asymetruc PWM mode 1 */  
    
38. #define TIM_OCMODE_ASSYMETRIC_PWM1         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2)  
    
39. 
    ! E% O) [0 f& P9 @; J4 y
40. /*!< TIM Asymetruc PWM mode 2 */   
    2 _' Y- a" S) p1 \, `6 {( j
41. #define TIM_OCMODE_ASSYMETRIC_PWM2         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M)  

复制代码

  
  Pulse
4 W$ K: u/ ]) ~; y6 Y# p可用于设置占空比，对应定时器的CCR寄存器，32位的TIM2和TIM5范围是0到0xFFFFFFFF。
, _) i5 v5 E' i& J  x
7 m, e1 Y+ w6 \2 h0 I1 g& R, y6 }& l  OCPolarity
+ W+ g1 k9 a. k3 y( V设置输出极性，可选高电平或低电平有效。
/ n# g, y" w0 G6 f& ?# P$ c1 w7 [6 X
7 `, m  z; V' B9 _/ J8 k1 `3 N

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

复制代码

  OCNPolarity
互补输出极性设置，可选高电平或者低电平有效。
* N) {3 s  \* P7 `; W9 T5 J
8 @' e5 L7 ?' Y, h

1. #define TIM_OCNPOLARITY_HIGH               ((uint32_t)0x0000U)
   & b, r% ^: X7 N& M7 J0 M
2. #define TIM_OCNPOLARITY_LOW                (TIM_CCER_CC1NP)

复制代码

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

* o3 M# J9 |$ M& w$ Q0 d* [

1. #define TIM_OCFAST_DISABLE                ((uint32_t)0x0000U)
   ) c6 Z. j7 d& h
2. #define TIM_OCFAST_ENABLE                 (TIM_CCMR1_OC1FE)

复制代码

  OCIdleState
0 ]' s+ f2 K4 Z9 H" M空闲状态时，设置输出比较引脚的电平状态。

1. #define TIM_OCIDLESTATE_SET                (TIM_CR2_OIS1)
   
2. #define TIM_OCIDLESTATE_RESET              ((uint32_t)0x0000U)

复制代码

% c7 M5 I+ K1 e  OCNIdleState
. ]4 W# h! l  I# _& [空闲状态时，设置互补输出引脚的电平状态。

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

复制代码

32.3.4 定时器输入捕获结构体TIM_IC_InitTypeDef
此结构体主要用于定时器的输入捕获，定义如下：
( `0 B2 x" z2 y
' V% k/ k, n1 _' l) {: D% Z

1. typedef struct
   
2. {                                 
   & Z0 ]/ n0 Y9 A, }9 c/ q, a$ ~
3.   uint32_t ICPolarity;   
   1 l' V% c" M- ?0 d3 H
4.   uint32_t ICSelection;
   7 q- s. Y, \: @
5.   uint32_t ICPrescaler;
   
6.   uint32_t ICFilter;   
   
7. } TIM_IC_InitTypeDef;

复制代码

$ a6 r4 O3 D, e( l2 f! B1 ]8 L下面将这几个参数一 一做个说明。
, ^" Q" ^) i6 K- E8 M8 n& p
  ICPolarity
% h# {. ]# w' h" J; d) q# B: W输入触发极性，可以选择上升沿，下降沿或者双沿触发。

' @$ L1 D1 V6 F4 @' T& y1 S$ X6 A

1. #define  TIM_ICPOLARITY_RISING             TIM_INPUTCHANNELPOLARITY_RISING
   
2. #define  TIM_ICPOLARITY_FALLING            TIM_INPUTCHANNELPOLARITY_FALLING
   $ \2 q9 M/ i& U7 U4 ~! b: Q. [
3. #define  TIM_ICPOLARITY_BOTHEDGE           TIM_INPUTCHANNELPOLARITY_BOTHEDGE

复制代码

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

4 K% N) v6 g! T: }% Y: P! I

1. #define TIM_ICSELECTION_DIRECTTI       (TIM_CCMR1_CC1S_0)   
   7 l" `5 H( h( i) ]( L1 I' ?+ d
2. #define TIM_ICSELECTION_INDIRECTTI     (TIM_CCMR1_CC1S_1)  
   
3. #define TIM_ICSELECTION_TRC            (TIM_CCMR1_CC1S)   

复制代码

" W% a5 u# t  R7 n' Q+ c  ICPrescaler
1 \/ F) T# X- `, i: [输入捕获分频，表示每捕获1，2，4或8个事件后表示一次捕获。
7 [0 `$ Z5 s0 P% m! u( a) _" ?( y  e
# z* z; M/ [2 a

1. #define TIM_ICPSC_DIV1       ((uint32_t)0x0000U)                 
   
2. #define TIM_ICPSC_DIV2       (TIM_CCMR1_IC1PSC_0)   
   3 d7 I) h  Z. B% ~" a! t  X; a
3. #define TIM_ICPSC_DIV4       (TIM_CCMR1_IC1PSC_1)   
   ; I' }7 K5 f2 i4 @! O' A- U, S
4. #define TIM_ICPSC_DIV8       (TIM_CCMR1_IC1PSC)

复制代码

  ICFilter
; {% X; h5 c8 b- r1 o% ^输入捕获滤波器，可以定义采样频率和多少个连续事件才视为有效的触发，参数范围0到15。具体定义如下，其中fCK_INT表示定时器时钟，fDTS表示死区时间采样率，N表示这么多个事件代表一次有效边沿。
4 Z3 o) B4 r5 J
5 f" k9 g- D! D/ U

1. 0000：无滤波器，按 fDTS 频率进行采样
   
2. 0001： fSAMPLING=fCK_INT， N=2
   - X$ q6 S; N  c/ ]+ F$ B. B
3. 0010： fSAMPLING=fCK_INT， N=4
   
4. 0011： fSAMPLING=fCK_INT， N=8
   6 B% A0 W" x8 }$ P( M  _
5. 0100： fSAMPLING=fDTS/2， N=6
   
6. 0101： fSAMPLING=fDTS/2， N=8
   
7. 0110： fSAMPLING=fDTS/4， N=6
   1 A6 H1 p. H: |5 A9 A
8. 0111： fSAMPLING=fDTS/4， N=8
   : y: L! c3 G1 o5 m) \; |' M1 s0 H
9. 1000： fSAMPLING=fDTS/8， N=6
   0 [( }, X# Z4 Y! H& C
10. 1001： fSAMPLING=fDTS/8， N=8
    + m2 k5 K: @/ z# e# }( [
11. 1010： fSAMPLING=fDTS/16， N=5
    & V: {0 P6 w) K, C9 O
12. 1011： fSAMPLING=fDTS/16， N=6
    
13. 1100： fSAMPLING=fDTS/16， N=8
    6 F  J. q5 S$ r2 D
14. 1101： fSAMPLING=fDTS/32， N=5
    
15. 1110： fSAMPLING=fDTS/32， N=6

复制代码

1 ]0 K( R% r# t7 X! ]32.3.5 定时器的底层配置（GPIO，时钟，中断等）
; b/ E1 h* \' c5 I) ?HAL库有个自己的底层初始化回调函数，比如调用函数HAL_TIM_Base_Init就会调用HAL_TIM_Base_MspInit，此函数是弱定义的。

1. __weak void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
   
2. {
   
3.   /* Prevent unused argument(s) compilation warning */
   . t( x* \+ L2 o# P' g
4.   UNUSED(htim);
   / g& H- e  `+ p
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
   1 H% q" s, I& A, z" j
7.    */
   
8. }

复制代码

用户可以在其它的C文件重定向，并将相对的底层初始化在里面实现。对应的底层复位函数HAL_TIM_Base_DeInit是在函数HAL_TIM_Base_MspDeInit里面被调用的，也是弱定义的。
7 T, L9 {! r$ Y! ^2 w6 |6 v
当然，用户也可以自己初始化，不限制必须在两个函数里面实现。

定时器外设的基本参数配置完毕后还不能使用，还需要配置GPIO、时钟、中断等参数，比如下面配置TIM1使用PA8做PWM输出。
/ Q( s& Z8 X$ F/ [

1. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
   % k/ \" g3 P. N
2. {
   1 S/ N' |; Q  G$ y- C2 \
3.   GPIO_InitTypeDef   GPIO_InitStruct;
   
4. 
   
5.   /* 使能TIM1时钟 */
   
6.   __HAL_RCC_TIM1_CLK_ENABLE ();
   ( \* `3 f! W# p9 X' e$ P
7. 
   + z/ V; j6 R! d
8.   /* 使能GPIOA时钟 */
   5 ?, `8 k" {6 @! ^  N' [: d
9.   __HAL_RCC_GPIOA_CLK_ENABLE ();
   
10. 
    
11.   /* 设置TIM1使用PA8做PWM输出引脚，将其配置为输出，推挽，复用模式 */
    
12.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    ' |/ B6 W* I) o& g5 j# {% m6 J9 t
13.   GPIO_InitStruct.Pull = GPIO_PULLUP;
    + @* D# j# u! a& m! |
14.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    ! q" ]1 A7 U: o4 z. w  }
15. 
    
16.   GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
    ) t9 |9 I# X7 s9 n5 l8 D
17.   GPIO_InitStruct.Pin = GPIO_PIN_8;
    & S. r" i0 X& u: @2 @$ e9 Y' `$ @
18.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
19. 
    ( J5 E# {+ {* o9 q
20. }

复制代码

% L! |. Q- A8 K& o9 j- C总结下来就是以下几点：

- n  {$ ~( I2 D4 L& e- V  配置TIM时钟。
- D& ?8 k5 P0 w+ u1 e  配置TIM所用到引脚和对应的GPIO时钟。
. _9 h3 o0 M! r8 z$ ]# Q0 L/ Y8 L2 E  如果用到定时器中断，还需要通过NVIC配置中断。
+ b: C' n- H' ~$ r' S1 E  如果用到DMA，还要配置DMA。
2 H/ r" G9 }" Z  M6 g  u关于这个底层配置有以下几点要着重说明下：
5 f- {0 J, q9 d1 h" ]
% O3 O/ x" ^! }7 w. v6 @  定时器所使用引脚的复用模式选择已经被HAL库定义好，放在了stm32h7xx_hal_gpio_ex.h文件里面。比如TIM1有一个复用，
6 X" x! \) w7 x  x

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

复制代码

但是却有4个输出通道，每个通道都有几个支持的输出引脚：
: M" I) q$ L4 \  D; a

1. TIM1_CH1,  PA8   PE9    PK1
   3 C# B, o' u$ M' u# Q& u' V! y1 C, V
2. TIM1_CH2,  PA9   PE11
   2 C, K5 H5 `' T6 ]; M4 b6 Z
3. TIM1_CH3,  PA10  PE13   PJ9
   
4. TIM1_CH4,  PA11  PE14   PJ11

复制代码

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

32.3.6 定时器的状态标志清除问题
下面我们介绍__HAL_TIM_GET_FLAG函数。这个函数用来检查定时器标志位是否被设置。
- u" U3 f7 ]8 Y5 B% @

1. 
   0 D( w7 p! L$ `. c: `% r' t
2. /** @brief  Check whether the specified TIM interrupt flag is set or not.
   + _4 {% @* P+ R# o/ f. C
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:
   ! n$ i1 Y& O  r7 a$ V( m* {
6.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag
   / l8 d. x3 X/ z! B
7.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
   
8.   *            @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
   
9.   *            @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
   
10.   *            @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
    . z% T8 H' X4 n+ v# B" A
11.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag
    ) Z4 S! ~: w7 }/ U
12.   *            @arg TIM_FLAG_CC6: Compare 6 interrupt flag
    1 y% H; ?) S2 k! @( `. [+ L- ?
13.   *            @arg TIM_FLAG_COM:  Commutation interrupt flag
    
14.   *            @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
    + `! V1 R4 `7 ^/ A
15.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   
    " h$ O: J5 @/ p( A
16.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    . l7 t% g/ a$ `* H4 ~
17.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
    
18.   *            @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
    
19.   *            @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
    : I: x7 l/ W9 I" |( U8 T3 }
20.   *            @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
    
21.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    
22.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    + k0 G( c" P# W/ U
23.   */
      r  R$ x, ~2 R) S& R
24. #define __HAL_TIM_GET_FLAG(__HANDLE__, __FLAG__)   (((__HANDLE__)->Instance->SR &(__FLAG__)) == (__FLAG__))

复制代码

" i/ c9 W  P. ]% i0 U6 T前5个是比较常用的中断标志。
" p% X+ ]' @. z; H& G) O% [; m4 t
5 |+ q! q! g- q/ w2 r( k9 l  TIM_FLAG_UPDATE
5 A# S* @5 y) ]9 {/ y9 I: U2 z定时器更新标准，配置一个周期性的定时器中断要用到。

' y& l8 T' N' u8 v0 ]$ c     TIM_FLAG_CC1
TIM_FLAG_CC2

TIM_FLAG_CC3
4 M( ]0 Q& t3 p6 X
TIM_FLAG_CC4

捕获/比较标志，配置了捕获/比较中断要用到。
) ^' w0 \' m$ S
与标志获取函数__HAL_TIM_GET_FLAG对应的清除函数是__HAL_TIM_CLEAR_FLAG：

- X$ v0 T9 b, B+ \/ S" D  N

1. /** @brief  Clear the specified TIM interrupt flag.
   4 T9 f( ?, f; z! A* `
2.   * @param  __HANDLE__: specifies the TIM Handle.
   : I* A' A" w1 [) Q* d( H- j2 h
3.   * @param  __FLAG__: specifies the TIM interrupt flag to clear.
   
4.   *        This parameter can be one of the following values:
   
5.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag
   : o3 [- G" I: f) F' S6 D
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
   
9.   *            @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
   . j* M" z' O% h- t( U3 Q( p9 |
10.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag
    + x; u5 y, O- \  l- m0 y9 i5 E+ ]
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   
    
15.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    
16.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
    ; W9 I% w& ]8 [. r; E3 U
17.   *            @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
    
18.   *            @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
    , C; A  ]& k: `7 |& }$ E
19.   *            @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
    
20.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    
21.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    
22.   */
    1 l! a2 Q' J2 d* a4 R
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.
   7 m5 f. Y! r+ E  Q7 v! E9 [% J
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
   ; \+ ?% Z" x- R2 |- |3 ?9 `
7. *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt
   " {% m$ Y# M& J! r7 G& F4 N
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
    
12. *            @arg TIM_IT_BREAK: Break interrupt
    
13. * @retval None
    
14. */
    7 ^7 t2 e  ~8 e* n* V
15. #define __HAL_TIM_ENABLE_IT(__HANDLE__, __INTERRUPT__)  ((__HANDLE__)->Instance->DIER |= (__INTERRUPT__))
    
16. 
    
17.   /** @brief  Disable the specified TIM interrupt.
    
18.   * @param  __HANDLE__: specifies the TIM Handle.
    2 s; R0 U# s; M8 n* D0 M- ~% k
19.   * @param  __INTERRUPT__: specifies the TIM interrupt source to disable.
    8 D1 s/ F3 X7 O4 J
20.   *          This parameter can be one of the following values:
    0 F! Y! }8 z3 z" t# y
21.   *            @arg TIM_IT_UPDATE: Update interrupt
    ) w! w( C7 ]4 [, J1 [, s4 N8 h/ X: g
22.   *            @arg TIM_IT_CC1:   Capture/Compare 1 interrupt
    
23.   *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt
    8 @% C/ P7 B* n" k
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
    + X& E$ u6 ~( q1 c. ]1 y( C
27.   *            @arg TIM_IT_TRIGGER: Trigger interrupt
    
28.   *            @arg TIM_IT_BREAK: Break interrupt
    2 @, N9 h  c) D1 U3 j9 F" Y8 J. w
29.   * @retval None
    
30.   */
    / P1 e* e# r/ ?3 e! |" E( M1 u8 k
31. #define __HAL_TIM_DISABLE_IT(__HANDLE__, __INTERRUPT__)   ((__HANDLE__)->Instance->DIER &= ~(__INTERRUPT__))

复制代码

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

注意：操作定时器的寄存器不限制必须要用HAL库提供的API，比如要操作寄存器CR1，直接调用TIM1->CR1操作即可。

32.3.7 定时器初始化流程总结
使用方法由HAL库提供：
8 T0 z0 _* k- P  q7 r
  第1步：通过下面几个函数配置定时器工作在相应的模式
9 P8 ?8 ^! b. k# T1 l7 f
  HAL_TIM_Base_Init
/ N9 A% R# @/ J+ g3 B简单的定时器时基础功能
/ ]0 c# H# ~  y; ]$ h$ h5 ~
  HAL_TIM_OC_Init 和 HAL_TIM_OC_ConfigChannel
配置定时器产生输出比较信号

( H( n# G4 ?5 ?0 m# R$ u1 x. O4 K  HAL_TIM_PWM_Init 和 HAL_TIM_PWM_ConfigChannel
! I) P& N: U+ ~6 W$ V配置定时器产生PWM信号

/ C# V9 s" h  T  HAL_TIM_IC_Init 和 HAL_TIM_IC_ConfigChannel
配置定时器测量外部信号
5 `( K* b5 G* S  w: j
8 R6 f+ g9 t7 F4 P& u" n% w. a3 B& N  HAL_TIM_OnePulse_Init 和 HAL_TIM_OnePulse_ConfigChannel
配置定时器工作在单脉冲模式

  HAL_TIM_Encoder_Init
$ ]$ x% \2 ~1 U% Q+ Z2 P, J/ A3 d3 N配置定时器使用编码器接口
$ P5 T9 m3 D  K3 A, i) ^
  第2步：定时器几个常用功能的底层初始化API，这个里面需要用户自己填

第1步里面的几个函数会调用下面的API。
& U, @+ Q1 p( |2 {. v4 D; X
  定时器基本功能 : HAL_TIM_Base_MspInit()
: A% d1 q. W8 [  输入捕获 : HAL_TIM_IC_MspInit()
  输出比较 : HAL_TIM_OC_MspInit()
  PWM输出 : HAL_TIM_PWM_MspInit()
  单脉冲输出模式: HAL_TIM_OnePulse_MspInit()
  编码器模式 : HAL_TIM_Encoder_MspInit()
  第3步：底层初始化具体实现
9 s8 K* d* ?7 q
4 H* m  H/ j" p( |: V- H- P第2步中函数的具体实现。
, c1 C9 M  m+ Y2 P9 H7 o
  使用函数__HAL_RCC_TIMx_CLK_ENABLE()使能定时器时钟。
  使用函数__HAL_RCC_GPIOx_CLK_ENABLE()使能定时器使用到的引脚时钟。
  使用函数HAL_GPIO_Init()配置GPIO的复用功能。
: k0 k2 t: V; g# R* S6 v! C; z  如果使能了定时器中断，调用函数HAL_NVIC_SetPriority和HAL_NVIC_EnableIRQ配置。
  如果使能了DMA，还需要做DMA的配置。
  定时器默认使用APB时钟，如果使用外部时钟，调用函数HAL_TIM_ConfigClockSource可以配置。
) O: B; q+ _7 ], `, ]! }, d  第4步：启动定时器外设

  定时器基础功能:
HAL_TIM_Base_Start()
% ?+ W! f; _2 n9 S' k! c) v
HAL_TIM_Base_Start_DMA()
* Y' x+ s( W9 E7 y
HAL_TIM_Base_Start_IT()
! b0 [( x$ r( ?$ I! \2 r: a) K
  输入捕获 :
1 }) x$ e( G6 O0 B. x2 h- `+ bHAL_TIM_IC_Start()

HAL_TIM_IC_Start_DMA()
5 {& Q" O+ V5 P, ]3 {7 s
, H/ W. L, S! y6 S& oHAL_TIM_IC_Start_IT()

- g: [5 @, G& a! I: X  输出比较 :
HAL_TIM_OC_Start()
4 v& F% L: ~) k- o9 S) {
. a/ T- R2 P( i* W- a; qHAL_TIM_OC_Start_DMA()

HAL_TIM_OC_Start_IT()

+ f% z* V- A  Q3 N5 r% k6 B% P1 x  PWM输出：
HAL_TIM_PWM_Start()

0 W* Z' o+ E+ y6 B* d; l/ F# u3 K2 AHAL_TIM_PWM_Start_DMA()
( {" K. c4 A* A5 h' f* r& e4 [
HAL_TIM_PWM_Start_IT()

# b: L& q6 k% R3 Q, r+ \  Z# G  单脉冲模式：
! N) _" q0 w$ u" y% Q% L% XHAL_TIM_OnePulse_Start()

HAL_TIM_OnePulse_Start_IT().
0 V; l" Y7 @/ D  D# U
  编码器模式：
HAL_TIM_Encoder_Start()
1 B2 K' \0 W1 K0 q. E
HAL_TIM_Encoder_Start_DMA()

* F! r$ A. P4 v) m/ jHAL_TIM_Encoder_Start_IT().

  第5步：定时器的DMA突发使用下面两个函数

. ~) k3 m- y% T& l) r& _  HAL_TIM_DMABurst_WriteStart()
  HAL_TIM_DMABurst_ReadStart()
定时器常用的功能，通过上面这几步即可实现。
3 b% K& T. `6 U. U
32.4 源文件stm32h7xx_hal_tim.c
8 F. U$ ]) J2 U1 L' [8 [此文件涉及到的函数非常多，这里把几个常用的函数做个说明：

  HAL_TIM_Base_Init
  HAL_TIM_Base_Start
  HAL_TIM_PWM_Init
  HAL_TIM_PWM_ConfigChannel
3 N" C9 v: [: A8 ~* X$ `" N0 `  HAL_TIM_PWM_Start
  j8 I$ m) k+ g6 |  HAL_TIM_IC_Init
  HAL_TIM_IC_ConfigChannel
  HAL_TIM_IC_Start_IT
) u( A+ `; C, Y3 ?  HAL_TIM_OC_Init
# R) n" s. Z8 ^) l! _1 O! t  HAL_TIM_OC_ConfigChannel
& Z: n! \% c" y( u/ X  HAL_TIM_OC_Start
32.4.1 函数HAL_TIM_Base_Init
函数原型：

( j% E- m8 T* Z" Y) b$ c5 Y- O

1. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   * H% A: e8 L% E% V
2. {
   
3.   /* 检测是否是有效句柄 */
   ' M6 f! h3 d9 {0 \3 b% Y
4.   if(htim == NULL)
   5 I. b# f* m. p
5.   {
   ' Q  X4 R8 ?  O$ h
6.     return HAL_ERROR;
   / T. i4 ~4 q* S6 j
7.   }
   
8. 
   
9.   /* 检测参数 */
   ! v( J. |& n, S9 x* ], v
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    - O. ^& X" }! v5 N
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    1 G# Y( z5 N+ ^: P( W
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    8 t8 `+ y, A# l# P! M8 H) u8 `
13. 
    
14.   if(htim->State == HAL_TIM_STATE_RESET)
    ; \% v. [1 @) r. m- T, n& Z
15.   {
    ; L3 p2 R8 u% d; q; @, {
16.     /* 默认取消锁 */
    
17.     htim->Lock = HAL_UNLOCKED;
    
18.     /* 初始化底层硬件 : GPIO, CLOCK, NVIC */
    3 G$ ^  K- j/ R5 A) g* J  i
19.     HAL_TIM_Base_MspInit(htim);
    
20.   }
    + w5 |( ~9 E, E% D6 Y! Q6 \) D3 ^7 ^
21. 
    
22.   /* 设置TIM状态 */
    
23.   htim->State= HAL_TIM_STATE_BUSY;
    ; X4 G+ z% \2 ^5 F
24. 
    1 r  {7 [' R4 g& Z! H( q  x2 K9 K- t
25.   /* 基本参数配置 */
    9 _" |- x" N2 s. c/ i
26.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
      D; c/ e, X% J1 X' Z! k
27. 
    5 v$ \" W$ [% u  u
28.   /* 设置TIM就绪 */
    ; n* D, B) q/ e- v- i0 L
29.   htim->State= HAL_TIM_STATE_READY;
    9 q( Y) K8 S! J8 }  ^/ U% l  m
30. 
    ) v! A/ |- w, M9 N( c
31.   return HAL_OK;
    
32. }

复制代码

: v* P5 _5 x! g- w函数描述：

( Z; T' ~& s$ b! _此函数用于初始化定时器用于PWM。

函数参数：
9 ]9 `. ^/ k$ Y
: `1 R! `* B* I  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：
8 p4 `" }# b8 s+ [! h* w
/ @0 f: S/ ^# y. b+ n2 T函数HAL_TIM_Base_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
2 ^" F8 I# Z/ F; m7 m' ]如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_TIM_STATE_RESET  = 0x00U。

解决办法有三：
. Z6 x5 \2 v/ D- U& P4 V7 x
方法1：用户自己初始定时器和涉及到的GPIO等。

  m# I6 q  H- \+ R方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
, b* x9 _) @# o- w0 A
) b. {/ t6 v& p7 q3 ~& E  o2 S( M方法3：下面的方法

1. if(HAL_TIM_Base_DeInit(&TimHandle) != HAL_OK)
   
2. {
   
3.     Error_Handler();
   
4. }  
   
5. if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
   
6. {
   
7.     Error_Handler();
   & f3 E7 j3 _1 _- }0 G; u& A
8. }

复制代码

使用举例：

1 U. ?0 g6 g( d3 [

1. TIM_HandleTypeDef   TimHandle = {0};
   % I/ S6 B( U. q* [7 X
2. 
   
3. /*
   ( B. W! O( B: j8 {* N5 P
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   # r/ J5 y5 `) y9 s3 E9 W3 D" C
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;
    3 w$ s( b  x! h5 \1 s& w
11. TimHandle.Init.RepetitionCounter = 0;
    4 ^, E) o5 S* x( D2 n( L: v; m
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    : F; n, N2 z; X9 [( n( M, m( D
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    
14. {
    
15.         Error_Handler(__FILE__, __LINE__);
    
16. }

复制代码

  A7 Z2 L" R0 f4 h3 k  b5 U- U# T32.4.2 函数HAL_TIM_Base_Start
$ B$ H! j6 N+ x' W. X: u函数原型：

) G; s' I8 }9 o0 T% a2 Y8 ^5 D! q

1. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   % g2 K  J3 Q: y: B3 `( J
2. {
   1 k. j' ?- Q$ S6 S
3.   /* 检测参数状态 */
   
4.   assert_param(IS_TIM_INSTANCE(htim->Instance));
   ' S$ C8 R; _/ q+ j& A
5. 
     G3 h1 p1 x  B% N' `! H
6.   /* 设置定时器状态 */
   & d8 @8 o! T* Z4 q' g" e! O
7.   htim->State= HAL_TIM_STATE_BUSY;
   
8. 
   
9.   /* 使能定时器 */
   - M0 u  {6 N, n+ {' C+ s# e$ Y5 B
10.   __HAL_TIM_ENABLE(htim);
    & T  X# J: M; t, J( v
11. 
      ^$ y& ?, D3 x. I8 R% U+ R. D" ]
12.   /* 设置定时器状态 */
    
13.   htim->State= HAL_TIM_STATE_READY;
    3 ]; y1 B7 H4 Q+ j0 H* E
14. 
    
15.   /* 返回HAL_OK */
    
16.   return HAL_OK;
    % l, G6 u3 \" n
17. }

复制代码

/ A! G! q: I8 o1 R" j函数描述：
: X% c0 K1 _9 T
7 h- M3 V9 b7 b+ ]& v+ E此函数比较简单，调用函数HAL_TIM_Base_Init配置了基础功能后，启动定时器。

7 B& q0 A5 N; k9 f函数参数：

8 S. `, v8 p, [9 j  第1个参数是TIM_HandleTypeDef类型结构体指针变量。
: L+ A" S" k" z+ n  返回值，固定返回HAL_OK，表示初始化成功。
使用举例：

, b1 i9 ?( ~) K5 k9 l

1. TIM_HandleTypeDef   TimHandle = {0};
   
2. 
   
3. /*
   
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   
6. TimHandle.Instance = TIMx;
   
7. TimHandle.Init.Prescaler         = usPrescaler;
   
8. TimHandle.Init.Period            = usPeriod;        
   
9. TimHandle.Init.ClockDivision     = 0;
   8 }, A* \( w0 |/ }1 \
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    / j1 ?  |9 F( O* d1 v! o
11. TimHandle.Init.RepetitionCounter = 0;
    
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    + B# {. X' U- ~: s# n
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    5 }: c  p% [$ X- D
14. {
    
15.         Error_Handler(__FILE__, __LINE__);
    
16. }
    
17. 
    9 z0 L: [# u1 F3 t3 d2 P
18. /* 启动定时器 */
    + C8 ]9 O' |. J3 ~1 c* E! h* z
19. if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
    
20. {
    
21. Error_Handler(__FILE__, __LINE__);
    
22. }

复制代码

32.4.3 函数HAL_TIM_PWM_Init
函数原型：

1. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
   9 i5 t8 R3 m/ E1 b& Y& o# d) p
2. {
   3 w. e, o6 {) J: H
3.   /* 检查句柄是否有效 */
   ! z( @5 w/ D' q6 V9 u' I5 E
4.   if(htim == NULL)
   
5.   {
   % E  ^! e8 x6 s3 m! R
6.     return HAL_ERROR;
   
7.   }
   & d( ]' O; ^/ G9 z0 N% ]) l5 W
8. 
   / D- s5 l2 @% n% }1 P2 X0 s( c
9.   /* 检测参数 */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    ) p, y( n! H! V& D. U3 E
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
13. 
    . E- `; U! ?0 e+ r6 }! A
14.   if(htim->State == HAL_TIM_STATE_RESET)
    
15.   {
    ; j% }6 d; J* G+ i1 x
16.     /* 默认取消锁 */
    9 k' {0 |) D* W/ I0 {# M& J
17.     htim->Lock = HAL_UNLOCKED;
    & z' u6 d) L$ _4 F( V+ W5 }; k
18. 
    
19.     /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    ' x' g) b* Q2 M% v. X0 u& A
20.     HAL_TIM_PWM_MspInit(htim);
    
21.   }
    
22. 
    4 i+ W" S& `( u* k0 T! ]
23.   /* 设置定时状态 */
    
24.   htim->State= HAL_TIM_STATE_BUSY;
    ; i. F5 X; C$ G5 N! g- G
25. 
    
26.   /* 配置定时器用于PWM */  
    
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
28. 
    
29.   /* 设置定时器状态 */
    3 D# J; K1 U5 F. M, d5 m3 f
30.   htim->State= HAL_TIM_STATE_READY;
    6 S3 D9 ^. c4 u/ u2 {1 i
31. 
    
32.   return HAL_OK;
    
33. }

复制代码

+ @0 Z6 J: q. z+ h$ E: C0 Z6 c函数描述：
' P, t" c6 `3 s1 p- U/ h: g
此函数用于初始化定时为PWM方式。
8 g5 I: H2 N3 _
函数参数：

4 ^4 q: i: Z7 ^; h  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
  P, y& h# `/ d$ _( q! n3 D+ X注意事项：
: R+ p( I- J0 F2 e, F' U2 B9 }
7 y+ ]3 x* p/ q2 S% I函数HAL_TIM_PWM_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
' E+ W) `7 N+ c5 ^对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_TIM_STATE_RESET  = 0x00U。
1 b  n( H4 g+ }
解决办法有三：
( c. K5 L! ^& {9 f
+ w. p2 n" U1 ^( T  k% I方法1：用户自己初始定时器和涉及到的GPIO等。

方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

方法3：下面的方法

1. if(HAL_TIM_PWM_DeInit(&TimHandle) != HAL_OK)
   
2. {
   7 w5 S1 |' I5 _
3.     Error_Handler();
   
4. }  
   
5. if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
   
6. {
   & x& n: V& L7 a2 r, q
7.     Error_Handler();
   0 p* N8 {% i8 @/ m
8. }

复制代码

使用举例：

1. TIM_HandleTypeDef  TimHandle = {0};
   
2. 
   
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   
4. TimHandle.Instance = TIM1;
   
5. TimHandle.Init.Prescaler         = usPrescaler;
   
6. TimHandle.Init.Period            = usPeriod;
   / z. [$ D1 i2 C2 W* \
7. TimHandle.Init.ClockDivision     = 0;
   0 i7 r' C  r/ h
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   
9. TimHandle.Init.RepetitionCounter = 0;
   " G* s) [5 B5 @% q1 S- B  W
10. TimHandle.Init.AutoReloadPreload = 0;
    ! u' w  n4 L- ?- i! F
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    
12. {
    
13.     Error_Handler(__FILE__, __LINE__);
    5 [9 z: F! k+ `8 k# ]
14. }

复制代码

0 E6 e  ]( W! o5 c1 h32.4.4 函数HAL_TIM_PWM_ConfigChannel
函数原型：
& z) n6 |: ^5 ?/ ~$ |; X( s, z

1. HAL_StatusTypeDef HAL_TIM_PWM_ConfigChannel(TIM_HandleTypeDef *htim,
   ; i) J' U: V: d  \' C
2.                                             TIM_OC_InitTypeDef* sConfig,
   
3.                                             uint32_t Channel)
   % `( e( p6 r( X% F# v; K; g5 d+ `
4. {
   
5.    /* 省略 */
   
6. 
   " B1 y/ u, H4 n1 j9 }3 T7 ~) l
7.   /* 开锁 */
   8 Y+ M8 B' m* y' ]. [5 r1 X! k9 Z
8.   __HAL_LOCK(htim);
   ( q/ }% L" k) O5 G5 \3 e# z2 g% T
9. 
   
10.   htim->State = HAL_TIM_STATE_BUSY;
    # k3 J$ s* b# x# x9 l- a% _( E# k: o5 o
11. 
    
12.   switch (Channel)
    4 F# B* F! p6 ~; w4 S% Y
13.   {
    
14.     case TIM_CHANNEL_1:
    
15.     {
    
16.       /* 检查参数 */
    / K! w, M# H0 o$ l8 p0 O6 T$ K, Q" [
17.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    
18. 
    2 W2 k" x+ r6 P; L" _" d3 N; h
19.       /* 配置通道1的PWM模式 */
    4 X1 G9 S1 e7 z
20.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    ( B3 w; i2 |: p9 w1 p
21. 
    5 e2 E; q* b; x2 ?$ t
22.       /*预装载使能，更新事件产生时写入有效 */
    $ W7 J  x1 k7 j# r
23.       htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;
      P) N. U4 F3 m" D1 W
24. 
    ' U, O8 v0 q8 G  i7 ^2 e
25.       /* 配置是快速输出模式 */
    8 l8 t, f% o% ]
26.       htim->Instance->CCMR1 &= ~TIM_CCMR1_OC1FE;
    ; \1 n) J2 Z/ f7 k, G0 }
27.       htim->Instance->CCMR1 |= sConfig->OCFastMode;
    
28.     }
    
29.     break;
    3 V$ Q2 g6 k# ?
30. 
    
31.     case TIM_CHANNEL_2:
    
32.     {
    
33.        /* 省略 */
    
34.     }
    
35.     break;
    1 H& B  W' y% T7 W+ T
36. 
    : O! y) M2 o% D; C; h. m/ T
37.     case TIM_CHANNEL_3:
    + S" H$ k9 j0 f5 e
38.     {
    5 a" [8 H5 O; A: e7 Y2 [* h
39.        /* 省略 */
    
40.     }
    5 o& s5 u9 M5 |. P0 e, @( Q
41.     break;
    
42. 
    5 g; l1 a* [% {! T9 C8 D4 ]
43.     case TIM_CHANNEL_4:
    / ?: L9 k# B& ]2 Z  m) D) T
44.     {
    
45.       /* 省略 */
    4 }, Y; }& J: }$ c* d8 N7 r
46.     }
    ' H9 P# o7 O; V; Y
47.     break;
    1 ^  _1 M- Q/ v4 H: a
48. 
    : V& V7 B  `2 r0 e/ Q  [9 T
49.     case TIM_CHANNEL_5:
    
50.     {
    
51.        /* 省略 */
    " ?, c* u7 c, u# s- i' b6 \2 L
52.     }
    
53.     break;
    ( w  P0 N5 {. U, u6 c* A# m3 @9 y
54. 
    
55.     case TIM_CHANNEL_6:
    * w% k! V, z7 i: W( Q
56.     {
    
57.         /* 省略 */
    7 u& ?: p% V+ s1 O/ p% o6 P
58.     }
    
59.     break;
    - R+ s" [  c, d- ^# u  {4 L
60. 
    
61.     default:
    
62.     break;
    * R4 {: r2 \3 Q  e
63.   }
    9 R/ ~# n% ^! z( t, s+ W& f( [
64. 
    
65.   htim->State = HAL_TIM_STATE_READY;
    
66. 
    $ g% {! z6 I9 z5 q; p
67.   /* 关锁 */
    : Y& [9 Q' \- d& m) \  e6 e
68.   __HAL_UNLOCK(htim);
    $ ^  J. S2 D' a) {4 Q. O
69. 
    
70.   return HAL_OK;
    9 F, t6 E& x4 R6 d7 l' t3 K
71. }

复制代码

函数描述：

; [+ T: G( P3 e/ N8 S4 p此函数用于配置定时器的PWM通道。
( O- K7 h! O$ A* ^5 D9 u) v2 O; F
函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
5 s7 A8 Q% Y7 T8 R' HTIM_CHANNEL_1
# T3 S% V$ c: z" Z
TIM_CHANNEL_2
3 |6 B& y9 _9 s/ U. @* P
TIM_CHANNEL_3

TIM_CHANNEL_4

* n* j. i5 g7 k( xTIM_CHANNEL_5

( B: G, D8 w* b: M. y3 X- pTIM_CHANNEL_6
& b/ z4 d( b9 n% i' K- Q7 k7 h
2 X& s9 P% c$ ]# q  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
6 u/ p/ g& \- ?& y8 }) F6 y使用举例：

" b! W( m5 w; Z' x4 ~, D% h1 t

1. TIM_HandleTypeDef  TimHandle = {0};
   8 o8 J- D! h/ R$ m0 A8 b6 E/ t
2. 
   
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   
4. TimHandle.Instance = TIM1;
   
5. TimHandle.Init.Prescaler         = usPrescaler;
   
6. TimHandle.Init.Period            = usPeriod;
   ) l+ C9 U$ X$ s- p: i. X2 |$ G4 |
7. TimHandle.Init.ClockDivision     = 0;
   
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)
    
12. {
    4 A9 @2 Z$ ]& Z; b+ K8 T
13.     Error_Handler(__FILE__, __LINE__);
    
14. }
    * r+ L9 o! f9 w& N( R, A$ N$ {
15. 
    ) V$ ^) E! i" ~) z5 e
16. /* 配置定时器PWM输出通道 */
    
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    8 u  p7 p: }/ `, l- R
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    0 }7 k1 S7 g. h1 G
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
    
23. 
    " ~4 p! G/ m# k" p
24. /* 占空比 */
    ; i+ ]5 }8 o# z/ R% P  I
25. sConfig.Pulse = pulse;
    $ c9 ?( }% |# X/ J" @
26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    ! [( h  J3 v; O' F& c* T' }
27. {
    % Q; ^, I( J5 S) E
28.     Error_Handler(__FILE__, __LINE__);
    
29. }

复制代码

32.4.5 函数HAL_TIM_PWM_Start
函数原型：
3 a) Z) I- b, `1 N

1. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
   
2. {
   
3.   /* 检测参数 */
   
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   7 {3 f% R, c3 _+ Q0 G
5. 
   
6.   /* 使能捕获比较通道 */
   
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
8. 
   
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
   7 v# [& e% J4 r
10.   {
    
11.     /* 使能主输出 */
    
12.     __HAL_TIM_MOE_ENABLE(htim);
    
13.   }
    
14. 
    
15.   /* 使能定时器 */
    ' Q5 ^1 G  F  ~
16.   __HAL_TIM_ENABLE(htim);
    $ l% N+ |* m* X* P+ Z
17. 
      v( x  T' k+ k5 h
18.   /* 返回状态*/
      k6 S5 u8 F" o. M( @/ P1 Q: G
19.   return HAL_OK;
    7 Z4 V) w  T" k: f# x" b
20. }

复制代码

函数描述：
' R4 v8 O8 I3 H4 B" H- O7 Q8 y
1 X  f9 F) U7 J& i, K. u0 |此函数用于启动PWM。
0 R; T6 ~7 S; w) H& ?" s
函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  第2个参数是通道设置，支持以下参数：
) [1 N5 N1 Z% L- R+ ^; r' `( R0 KTIM_CHANNEL_1
# v* l7 _8 f- }* J1 v6 u
- p$ R- j5 Y" p2 @9 i6 F- OTIM_CHANNEL_2
  Z: g! ?5 R) P' E
4 H& |0 Z2 t" T, zTIM_CHANNEL_3

TIM_CHANNEL_4
4 V) k8 D7 a! N4 |: m" ~2 Q* y5 u, O4 w
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
) h) R: d1 o. m0 }$ q1 R) e使用举例：
1 y+ v% L% O$ L$ O% C; h6 H4 z

1. TIM_HandleTypeDef  TimHandle = {0};
   
2. 
   7 h2 K9 ]: x3 i: k& w: f5 M
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   ; l! L/ T' a# {
4. TimHandle.Instance = TIM1;
   
5. TimHandle.Init.Prescaler         = usPrescaler;
   
6. TimHandle.Init.Period            = usPeriod;
   
7. TimHandle.Init.ClockDivision     = 0;
   - p, \# t1 A( O8 m5 J+ I: @& o
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   
9. TimHandle.Init.RepetitionCounter = 0;
   * g. b4 L! K; n
10. TimHandle.Init.AutoReloadPreload = 0;
    ; V: f9 q) b. |+ j5 W: i- O  w
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    ( c6 K- ?# t- |% ~
12. {
    $ ?' T* ~8 C* w, a( {4 C
13.     Error_Handler(__FILE__, __LINE__);
    
14. }
    - ~6 s0 C) U- N; [3 ]  b
15. 
    2 c; l" \: z- O# R  M# ?- t2 d
16. /* 配置定时器PWM输出通道 */
    % u1 f) s& c3 l  y/ _3 C
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    + q; [$ `" E* e4 {
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    ( W' V; |) L) g/ I0 l, }7 x7 z
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
    * ^7 F+ s9 A- `/ [2 O+ q. v
23. 
    
24. /* 占空比 */
    
25. sConfig.Pulse = pulse;
    5 S# z; ?1 x( h9 e( Q0 I! J7 [) y
26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    $ x* |+ c, \' @  L5 D* ?5 k& {
27. {
    
28.     Error_Handler(__FILE__, __LINE__);
    " j3 N- n# O0 q# S. @2 O9 m
29. }
    ! P. x0 t" {& g/ J
30. 
    7 S6 ?% r8 C4 W1 I  R" k
31. /* 启动PWM输出 */
    
32. if (HAL_TIM_PWM_Start(&TimHandle, TimChannel[_ucChannel]) != HAL_OK)
    5 U2 Q* |8 Y. r. Y+ `0 ^+ D/ E3 ^
33. {
    
34.         Error_Handler(__FILE__, __LINE__);
    4 u1 u! H0 x3 l6 C: `
35. }

复制代码

$ e( B6 J' ?2 x: A  P6 v32.4.6 函数HAL_TIM_IC_Init
# X0 h3 m# c4 t* ~+ w9 u4 m0 d' J函数原型：
4 Y8 \2 }; w: c- ~6 }

1. HAL_StatusTypeDef HAL_TIM_IC_Init(TIM_HandleTypeDef *htim)
   
2. {
   6 O9 C4 I9 g* E6 `
3.   /* 检测形参是否有效 */
   
4.   if(htim == NULL)
   * e( [5 H5 E6 h0 ]. X
5.   {
   
6.     return HAL_ERROR;
   
7.   }
   & l( n; J) v! z3 Z7 @& a4 ]# n$ R
8. 
   
9.   /* 检测参数 */
   , S* h* H$ Y$ {: p
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));
    2 ?" E0 h% h- i' h' Z# x
13. 
    0 d% u0 f* m- D) Y( ]7 \3 l! F6 e$ f
14.   if(htim->State == HAL_TIM_STATE_RESET)
    
15.   {
    + U7 D# r8 k0 n7 `6 j  N3 M
16. /* 默认取消锁 */
    # j  p# D  B, P
17.     htim->Lock = HAL_UNLOCKED;
    
18. 
    2 V4 s: T& H6 h. |& m
19.      /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_IC_MspInit(htim);
    9 f- V2 m( m3 C3 i$ K# |
21.   }
    + _+ P* B( y8 Y" @  y) {4 T
22. 
    
23.   /* 设置定时器状态 */
    5 g; a/ y9 b6 W: |' a" U
24.   htim->State= HAL_TIM_STATE_BUSY;
    
25. 
    ; x) C5 [/ q5 `7 c/ D5 A$ k5 r7 _
26.   /* 配置定时器为输入捕获模式 */  
    
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
28. 
    
29.   /* 设置定时器状态 */
    
30.   htim->State= HAL_TIM_STATE_READY;
    
31. 
    
32.   return HAL_OK;
    
33. }

复制代码

8 q' o: g* b( D# ?1 l函数描述：
5 y* h$ W! s4 P
* `+ I0 A) n' v2 K$ W" X  Q, Y此函数用于定时器输入捕获初始化。
7 Z2 C/ z. {2 U& F
函数参数：
7 q! J# P! k4 ?4 y# o1 r- R+ h1 j7 v
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
8 r2 O, a: [. g- s6 X: i0 h  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
, Q) f; V# Y0 h. h9 Q2 B& X1 w注意事项：

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

  o( W$ I& Q- A( `( N解决办法有三：
0 i' T5 O9 u# \! V, p/ Y# L
  Z. l. t0 C3 n' x! Q方法1：用户自己初始定时器和涉及到的GPIO等。

方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
4 F# s: u: h. K
* a6 |5 o+ g: p方法3；下面的方法
/ u# Y" E; M8 r7 M& A: i5 N1 |
( N/ Z: d  C6 N% z" L- g5 \

1. if(HAL_TIM_IC_DeInit(&UartHandle) != HAL_OK)
   4 F  V+ G2 B& Q# @
2. {
   
3.     Error_Handler();
   , Q8 |) Z+ \6 V& Z6 `4 O8 I
4. }  
   * `1 }" J) A/ H# T4 T* j3 K) D
5. if(HAL_TIM_IC_Init(&UartHandle) != HAL_OK)
   
6. {
   9 M4 v7 [/ X) Q  [0 l: W8 `3 ?
7.     Error_Handler();
   % Z. Y+ W) i$ q  @5 k
8. }

复制代码

, C* ^. i7 y: I7 e0 ?7 a* z+ A32.4.7 函数HAL_TIM_IC_ConfigChannel
函数原型：
  T' w, ?2 ~# o. q2 T0 u; o# O  x

1. HAL_StatusTypeDef HAL_TIM_IC_ConfigChannel(TIM_HandleTypeDef *htim, TIM_IC_InitTypeDef* sConfig, uint32_t Channel)
   8 z2 X7 l: i3 S6 ]
2. {
   
3.   /* 检查参数 */
   # z$ Q% G. \) D
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));
   ( y/ O% y* _9 x0 q' Y
7.   assert_param(IS_TIM_IC_PRESCALER(sConfig->ICPrescaler));
   
8.   assert_param(IS_TIM_IC_FILTER(sConfig->ICFilter));
   
9. 
   
10.   /* 开锁 */  
    
11.   __HAL_LOCK(htim);
    " p) P. @% q/ ^3 x4 r
12. 
    2 I) T& Q, i$ |
13.   htim->State = HAL_TIM_STATE_BUSY;
    
14. 
    6 \% P. I" b- F# X
15.   if (Channel == TIM_CHANNEL_1)
    
16.   {
    
17.     /* 配置输入通道1 */
    
18.     TIM_TI1_SetConfig(htim->Instance,
    $ I& C& y! ?" s+ `7 g6 \2 `# \
19.                sConfig->ICPolarity,
    0 M$ M! t3 K. n0 g9 h+ B$ D
20.                sConfig->ICSelection,
    : ?7 D6 @' q& q$ A0 v- S' a
21.                sConfig->ICFilter);
    
22. 
    
23.     /* 清零IC1PSC位 */
      t  ~$ Q$ @( s( Y9 e
24.     htim->Instance->CCMR1 &= ~TIM_CCMR1_IC1PSC;
    5 |$ c  f' o8 @5 N8 _
25. 
    
26.     /* 根据用户配置，设置分频 */
    " d: ]; o8 u! l) t* o- x( v- F% g0 P
27.     htim->Instance->CCMR1 |= sConfig->ICPrescaler;
    
28.   }
    
29.   else if (Channel == TIM_CHANNEL_2)
    
30.   {
    
31. /* 省略 */
    9 D. R# Z( P! V: [6 q4 D
32.   }
    
33.   else if (Channel == TIM_CHANNEL_3)
    9 ?' q3 E6 E7 h% K3 p
34.   {
    
35.      /* 省略 */
    5 {9 D3 t. h; S& m- n
36.   }
    ; U" n6 j( B0 q8 N
37.   else
    + @" ]% D2 k& S$ t
38.   {
    
39.      /* 省略 */
    
40.   }
    4 g, r) ]( ~/ R1 T
41. 
    ' e* ~) o5 A+ v1 ?
42.   htim->State = HAL_TIM_STATE_READY;
    
43. 
    
44.   __HAL_UNLOCK(htim);
    : @: ^* O" Q6 [/ z, K+ [' _- }
45. 
    2 q: A! ^5 U* A3 J/ w
46.   return HAL_OK;
    1 b4 _! ]! b9 o0 w
47. }

复制代码

. d& r% G: T+ S& U0 g函数描述：

此函数用于配置定时器的输入捕获通道。
" N0 j, @5 e4 s5 I# s
函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置
  N1 y# f7 N( C+ `$ c  第2个参数是TIM_IC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
1 y- m* [& E. l% w7 m( KTIM_CHANNEL_1

+ O, m) ?' O5 `3 b6 g: _TIM_CHANNEL_2

) V7 b- L* K5 g) V$ iTIM_CHANNEL_3
, P, [1 l' P9 N; ^
5 b" K; |9 F9 }3 Z, m  y1 {TIM_CHANNEL_4

4 w1 y' V( V5 n9 d! I  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。

32.4.8 函数HAL_TIM_IC_Start_IT
函数原型：

1 M: p7 v) m: L# J7 x& V: ]

1. HAL_StatusTypeDef HAL_TIM_IC_Start_IT (TIM_HandleTypeDef *htim, uint32_t Channel)
   & z& x2 u: N; k* C3 Y! ?
2. {
   
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   9 m/ v7 \/ ~! ~+ y% i3 B7 t
5. 
   
6.   switch (Channel)
   $ i5 l+ B* q, y. q% Z# y/ e
7.   {
   & O% G0 d7 M" h1 ~) t
8.     case TIM_CHANNEL_1:
   ! L  H& {/ {9 K# e9 _6 c
9.     {      
   ( c- x- h- W6 p: \
10.       /* 使能CC1（Capture/Compare 1）中断 */
    
11.       __HAL_TIM_ENABLE_IT(htim, TIM_IT_CC1);
    # R1 X( ~& D( s7 m" z
12.     }
    ) n" w- ^, n5 ]/ I$ e
13.     break;
    
14. 
    
15.     case TIM_CHANNEL_2:
    
16.     {
    , _$ Z4 N0 H. ^# |. A
17.    /* 省略 */
    # J6 i$ P6 U8 `; R
18.     }
    ) F# z" c+ {, A- ?# X- O, R
19.     break;
    . t/ u. w& d0 k5 H: ?$ |# @
20. 
    0 M4 K( |' _7 k7 h& ~) ^$ [& k& J( j
21.     case TIM_CHANNEL_3:
    ( v0 j5 P& X$ x
22.     {
    
23.   /* 省略 */
    
24.     }
    
25.     break;
    
26. 
    
27.     case TIM_CHANNEL_4:
    8 m& u" N2 Z4 E
28.     {
    + r! [5 e! N6 u6 h
29.   /* 省略 */
    5 N' T) {9 I, J
30.     }
    . J  c- O8 _4 ?2 p! s3 Y
31.     break;
    $ e6 m; s4 v9 W2 b$ w( q' G
32. 
    
33.     default:
    
34.     break;
    
35.   }  
    & t( F% C! i1 }3 y$ o1 P
36.   /* 使能输入捕获通道 */
    
37.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
38. 
      U. f5 Q3 o2 c
39.   /* 使能定时器 */
    
40.   __HAL_TIM_ENABLE(htim);  
    ; P. L; A( L+ }2 n9 B) p3 r
41. 
    
42.   /* 返回状态 */
    * G8 m5 V/ v9 u- M
43.   return HAL_OK;  
    ' A! \# v; n; e3 r/ N
44. }

复制代码

. G& G9 U9 O5 s0 L* V) l函数描述：

, ]: u9 j5 K8 B! c此函数用于启动定时器输入捕获模式，采用定时器方式。
* A: }% r. y) B# m- r
函数参数：

! C& D1 u  A. f7 x. |  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  第2个参数是通道设置，支持以下参数：
TIM_CHANNEL_1
3 D1 y1 n+ p; U1 Q
1 J4 v1 ^7 k; h# M' y: p9 BTIM_CHANNEL_2

% _2 q5 I' D% o5 d  Y1 OTIM_CHANNEL_3

% t+ G" b7 h1 {+ L. FTIM_CHANNEL_4

4 K7 w# }" J; H: j7 F8 y5 [  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。

$ |* b- T1 w' K% B7 j* a32.4.9 函数HAL_TIM_OC_Init
. c" A: ?- ~# A, O3 A- l- X1 \函数原型：
$ ^& h4 U- J1 X9 E5 v8 s; N

1. HAL_StatusTypeDef HAL_TIM_OC_Init(TIM_HandleTypeDef* htim)
   
2. {
   " `8 m1 ~, n# e
3.   /* 检测形参是否有效 Check */
   
4.   if(htim == NULL)
   3 `1 @, y! [+ j% D
5.   {
   
6.     return HAL_ERROR;
   
7.   }
   : R5 f0 n0 g$ W, [+ P
8. 
   % {# }) W- {+ J4 {% B6 y
9.   /* 检查参数 */
   2 V! r4 v" s. q- h( o* r: {9 w
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    8 [  v# G5 [$ X1 w
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    ' Q$ J' m1 ]$ ]# o& K% m4 E- @
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
13. 
    ' }  D9 d; {- z# F9 {' [8 r* O+ [
14.   if(htim->State == HAL_TIM_STATE_RESET)
    9 Z+ j. I/ d- c; D* }0 ]
15.   {
    
16. /* 默认取消锁 */
    
17.     htim->Lock = HAL_UNLOCKED;
    % F. D  X/ `, ], @6 M% P( [9 t- a
18. 
    3 e% V# |  r: K
19. /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    + s$ D1 ]  `% T
20.     HAL_TIM_OC_MspInit(htim);
    + h* D( z0 t% O* I* _9 _
21.   }
    
22. 
    2 i: J/ Z5 K* h1 F6 M8 A- `. q
23.   /* 设置定时器状态Set the TIM state */
    
24.   htim->State= HAL_TIM_STATE_BUSY;
    
25. 
    ) K! v/ o+ g9 K$ ~7 J7 G/ r
26.   /* 配置定时器为输出比较模式Init the base time for the Output Compare */  
    2 B2 T$ h9 W8 h# r8 o
27.   TIM_Base_SetConfig(htim->Instance,  &htim->Init);
    . _% N' u' e+ i  ^8 R$ {7 e* s
28. 
    % p  b8 s+ F1 q& y8 L+ P
29.   /* 设置定时器状态 */
    1 |; ~6 x1 j  W' i/ `" k. m
30.   htim->State= HAL_TIM_STATE_READY;
    
31. 
    
32.   return HAL_OK;
    ; O2 d5 ~% _! y! \: ]
33. }

复制代码

' i" a' J, Q( t0 ~' f3 I- n函数描述：

此函数用于定时器输出比较初始化。
* q/ e/ S/ L* ^+ }3 e
函数参数：
+ j* V; q3 f- Q, D/ k: w9 K/ l9 t
: i8 t6 s/ v, W7 ~1 x4 J& G  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
) P7 I# q: w1 t% z& W" p! ^. f1 y  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
8 P' q1 D8 g: A& X0 |. z$ N注意事项：
( |. K; R* [4 z& W
函数HAL_TIM_OC_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
" K9 `6 `2 P- u7 d如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
2 R& r4 o, p% W6 X  |! V对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个HAL_TIM_STATE_RESET  = 0x00U。

* [# G4 b, C, O4 n: G; X解决办法有三：
3 x* D) K6 k1 o0 M) d
7 g4 k; d" i4 e" M3 @5 f方法1：用户自己初始定时器和涉及到的GPIO等。

$ V: S; p1 j4 V0 k7 x' c* e* R5 z方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
2 H5 J  w+ ?3 r& d. t4 S
* Q* a; C$ l3 T& q. T方法3；下面的方法

1. if(HAL_TIM_OC_DeInit(&UartHandle) != HAL_OK)
   
2. {
   
3.     Error_Handler();
   
4. }  
   & c* }+ {: T8 Q6 q2 F0 K
5. if(HAL_TIM_OC_Init(&UartHandle) != HAL_OK)
   ! L  m; d$ M0 m
6. {
   
7.     Error_Handler();
   ; A3 v& u, O3 o+ w% N( h4 l, W7 N
8. }

复制代码

3 V" A% I2 B- @% f$ k' j  P0 e32.4.10   函数HAL_TIM_OC_ConfigChannel
函数原型：

% C$ v% I' n+ c3 _$ S7 X

1. HAL_StatusTypeDef HAL_TIM_OC_ConfigChannel(TIM_HandleTypeDef *htim,
   
2.                                            TIM_OC_InitTypeDef* sConfig,
   
3.                                            uint32_t Channel)
   
4. {  
   , ^8 w8 K5 S( Y5 G' p
5.   /* Check the parameters */
   
6.   assert_param(IS_TIM_CHANNELS(Channel));
   0 C7 H- y, R: {1 k- A
7.   assert_param(IS_TIM_OC_MODE(sConfig->OCMode));
   3 `, w% {& P+ p2 p
8.   assert_param(IS_TIM_OC_POLARITY(sConfig->OCPolarity));
   
9. 
   1 I$ p: K" M; W$ ?' T
10.   /* Process Locked */
    
11.   __HAL_LOCK(htim);
    . o* R" w; z7 O. c2 E
12. 
    3 X. d% ?! M: ^2 j0 r
13.   htim->State = HAL_TIM_STATE_BUSY;
    ; e6 ?7 r: v' z! D
14. 
    
15.   switch (Channel)
    
16.   {
    ) ]  y: r/ R! d8 b' P7 t6 ^
17.     case TIM_CHANNEL_1:
    
18.     {
    0 T0 d2 k6 }. j2 f) M, p8 |; O
19.       /* 检测参数Check the parameters */
    
20.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    9 j% x) ^4 V, t3 f' U0 A
21. 
    2 Q3 U3 d4 G% T' d9 l
22.      /* 配置定时器输出比较通道1 */
    
23.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    
24.     }
    
25.     break;
    
26. 
    
27.     case TIM_CHANNEL_2:
    & k$ O9 V( i/ S
28.     {
    
29.       /* 省略 */
    
30.     }
    
31.     break;
    3 C( s* ?! e+ e# n
32. 
    4 x/ H3 M% k  D% ^" U# @- g/ l
33.     case TIM_CHANNEL_3:
    
34.     {
    
35.       /* 省略 */
      {/ c/ ^0 ^) K) c0 V, {3 R& D
36.     }
    3 O* W3 `! T3 V) ]5 P* u% N
37.     break;
    
38. 
    
39.     case TIM_CHANNEL_4:
    8 H  f8 M+ \0 k  o5 H% v# p. ~
40.     {
    
41.       /* 省略 */
    
42.     }
    
43.     break;
    7 d0 [- Z( f* I3 |/ M
44. 
    
45.     case TIM_CHANNEL_5:
    
46.     {
    ( R  t* _* g. W- B9 h5 o
47.       /* 省略 */
    
48.     }
    ( K$ ^' N6 K9 o: h9 V
49.     break;
    
50. 
    5 ^5 K( q% E& v$ l
51.     case TIM_CHANNEL_6:
    1 T" W3 D& r# Y2 R5 b. c4 m
52.     {
    " O( v% ?4 b, F/ Q$ W" {7 }
53.       /* 省略 */
    5 m3 W" K1 `! K" P! f& }
54.     }
    
55.     break;
    $ S7 x5 }( I  b' T1 s
56. 
    
57.     default:
    
58.     break;   
    ) G7 E0 M5 ^" ]
59.   }
    
60. 
    
61.   htim->State = HAL_TIM_STATE_READY;
    ! S3 ]8 R6 m1 X. v9 C
62. 
    * W% c8 n% h1 k- R% I, C; N
63.   __HAL_UNLOCK(htim);
    0 f: a# |1 G' b' W% ~
64. 
    0 m+ R) x' z& S) Z3 @: _
65.   return HAL_OK;
    " H/ H( @  B( ^6 z; }9 L% j
66. }

复制代码

, u8 @+ E; V' u$ w) t% q% |. P4 \函数描述：
: A4 x0 J! @4 `& p4 f2 F5 l
2 V  T5 C0 R$ U! P此函数用于初始化串口的基础特性和高级特性。
. q4 e: c6 F( B
; X  ?( S/ ~3 s  W. B4 z$ k. S: {函数参数：
( ~: H' Z3 p7 _0 M
& @4 n! I8 r: X. F* P4 {2 G4 C. G$ J# }  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
TIM_CHANNEL_1

6 ]% s% t2 z) B) \6 OTIM_CHANNEL_2
; {  m1 y& P, d9 @' R, Z
TIM_CHANNEL_3
/ o  b' f5 F- Q' X) m3 n
$ |% _  n+ M$ ~3 DTIM_CHANNEL_4

6 O- `/ z" m; P5 u- _TIM_CHANNEL_5
, ]- s4 |* `: j3 C0 ?& K
# c( D' W# C# i( ?TIM_CHANNEL_6

% z2 G8 }2 G& ]9 Y  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
2 I0 R! c+ e& O/ S- F
32.4.11   函数HAL_TIM_OC_Start
' |5 H) Q+ V9 O: L; U函数原型：

, h$ l# @2 h5 t) _

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));
   ! f. ?4 m1 [0 u4 s
5. 
   9 B5 T* A: L: [0 R
6.   /* 使能输出比较通道 */
   
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
8. 
   8 ?% I4 p+ p* F& x$ g+ S
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
   
10.   {
    
11.     /* 使能主输出 */
    / p$ Z0 \1 e( W% D7 z' Y) I
12.     __HAL_TIM_MOE_ENABLE(htim);
    $ g6 r' y( a1 M0 C  K1 G
13.   }
    ' s, p9 T$ O; f4 a. s* G/ D/ ]
14. 
    + v) F) |2 f$ k9 j& ?* @/ m
15.   /* 使能定时器 */
    ( _$ f: }; `- I+ Q# [4 `2 R
16.   __HAL_TIM_ENABLE(htim);
    4 }3 H# m3 p0 I0 G
17. 
    
18.   /* 返回状态 */
    
19.   return HAL_OK;
    % q; X& y6 r& U& b
20. }

复制代码

函数描述：
1 g9 l) s; Q; I+ ], C
此函数用于启动定时器输出比较模式。

函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
3 @5 t6 l- \# V9 O, R) G+ F3 h0 B  第2个参数是通道设置，支持以下参数：
( J% @6 B3 [7 q; _, cTIM_CHANNEL_1
. B5 i8 G9 g8 S& B
TIM_CHANNEL_2
8 q8 E2 Q3 U5 b  y+ t
TIM_CHANNEL_3

/ b8 D$ J1 y  g- b* q+ XTIM_CHANNEL_4

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

32.5 总结
本章节就为大家讲解这么多，建议大家将GPIO的驱动源码结合参考手册中的寄存器通读一遍，对于我们后面章节的学习大有裨益。
# ~, ^+ ]/ n- P0 i( }( j
+ [( }# v/ I/ m* b; Y' O

! X4 n: ?& w0 J- u/ H# J$ Y