32.1 初学者重要提示
  学习定时器外设推荐从硬件框图开始了解基本的功能特性，然后逐步深入了解各种特性，这种方式方便记忆和以后查阅。
  STM32H7的定时器输出100MHz方波是完全没问题。
. |; ], c1 |9 f" P  STM32H7定时器进出中断的速度能跑到12.5MHz，所有程序在TCM和Flash运行没差别。
  STM32H7的定时器输入捕获可以实现12MHz方波的双边沿捕获，单边沿可以做到24MHz。
  特别注意STM32H7的TIM1,8,15,16,17才有RCR重复计数器，其它都没用的。
  STM32H7的单个定时器中不同通道可以配置不同频率PWM。
  STM32H7的TIM1-TIM17中断入口函数名使用时要注意，别搞错了：
7 Z3 O" A* \. A" p( W

1. TIM1_BRK_IRQHandler            
   * M$ r( b" c0 D( W
2. TIM1_UP_IRQHandler              
   
3. TIM1_TRG_COM_IRQHandler        
   
4. TIM1_CC_IRQHandler                                                   
     o" j4 }1 v* a8 j- \$ f& Q
5. TIM2_IRQHandler                                          
   
6. TIM3_IRQHandler                                                
   ( i1 Y4 r6 z& a/ u1 ^
7. TIM4_IRQHandler                 
   
8. TIM5_IRQHandler            
   - f( I; G. U/ A8 u$ [  c
9. TIM6_DAC_IRQHandler           <------------------要注意            
   
10. TIM7_IRQHandler
    $ q8 u. u" N. e$ {
11. TIM8_BRK_TIM12_IRQHandler      <------------------要注意，定时器12也是用的这个
    ( M  i$ S6 F0 O5 v$ H0 |* O
12. TIM8_UP_TIM13_IRQHandler       <------------------要注意，定时器13也是用的这个
    0 {7 v( T0 v% D
13. TIM8_TRG_COM_TIM14_IRQHandler  <------------------要注意，定时器14也是用的这个
    + R( k& T, Q% N: V  l! q
14. TIM8_CC_IRQHandler         
    . t6 \# M+ p1 s0 H2 m( R8 b2 G
15. TIM15_IRQHandler
    9 Z$ D) P! \) {; f
16. TIM16_IRQHandler
    
17. TIM17_IRQHandler

复制代码

5 a3 C" Q* ]$ T) D' n! ?32.2 定时器基础知识
注，不同定时支持的功能略有区别，基础定时器功能较少，TIM1和TIM8高级定时器功能多些。

  TIM2和TIM5是32位定时器，其它定时器都是16位定时器。16位和32位的区别是CNT计数器范围不同，32位的范围是0 到2^32 – 1，而16位的是0到65535；它们支持的分频是范围是一样的，都是1到65535。
6 J% S) U( q9 N) @( t* T  计数器支持递增、递减和递增/递减二合一。
  多个独立通道，可用于：
– 输入捕获。

/ f- w% ?/ X9 d0 P– 输出比较。

– PWM 生成（边沿和中心对齐模式）。
7 f- ^$ c: l5 N5 P8 p7 [  H* o; s
/ [% P8 l2 b( o' A- ^– 单脉冲模式输出。
4 {1 c8 v! V: T9 V- ]
  带死区插入，断路功能和PWM互补输出
  发生如下事件时生成中断/DMA 请求：
– 更新：计数器上溢/下溢、计数器初始化（通过软件或内部/外部触发）
, a! e$ d2 [4 s" S/ X% v7 j
– 触发事件（计数器启动、停止、初始化或通过内部/外部触发计数）
& ]7 s7 D, n' J, p# Y
– 输入捕获

– 输出比较

; v8 `5 Q& u9 _* i  p, }8 Y  支持增量式编码器和霍尔传感器。
32.2.1 定时器TIM1-TIM17的区别
STM32H7支持的定时器有点多，要简单的区分下。STM32H7支持TIM1-TIM8，TIM12-TIM17共14个定时器，而中间的TIM9，TIM10，TIM11是不存在的，这点要注意。
4 P4 Z, U3 {6 p0 q1 g$ A  B
粗略的比较如下：
2 ~) x$ ]! d" g; s

  W' k( b0 o# Q
8 P; m! F1 i5 G. {6 X+ y通过上面的表格，至少要了解到以下两点：

  STM32H7的定时器主要分为高级定时器，通用定时器，基础定时器和低功耗定时器。
% ^" u: {. M6 {6 g3 n* ]; S4 r5 l* Q$ M  TIM2和TIM5是32位定时器，其它都是16位定时器。
; c! C) V/ ?6 m/ l
/ z8 V) S& n( E) Z+ d" K32.2.2 定时器的硬件框图
2 }& i) F# j8 m! ?$ [认识一个外设，最好的方式就是看他的框图，方便我们快速的了解定时器的基本功能，然后再看手册了解细节。
; L, P* s0 a" X8 W( O/ c
$ @  I( P! U" Q3 J' J& d下面我们直接看最复杂的高级定时器TIM1&TIM8框图：

. q0 Q5 L0 w7 b2 g) i9 Y: W0 g

通过这个框图，我们可以得到如下信息：
: P# n4 `% Z# M. B5 D; N/ R, s
7 a" k  a6 X6 S; U* ^1 I7 \1 X. {  TIMx_ETR接口
外部触发输入接口。ETR支持多种输入源：输入引脚（默认配置）、比较器输出和模拟看门狗。
& f. O# r1 ~' P  ^0 W  R2 O+ u

) y6 G" a! T/ g/ D) s, Y# J3 F4 {  截图左侧的TIMx_CH1，TIMx_CH2，TIMx_CH3和TIMx_CH4接口
这四个通道主要用于输入捕获，可以计算波形频率和脉宽。                                                                                                                             

  TIMx_BKIN和TIMx_BKIN2接口
1 C* }. i" a" {, m4 o& C断路功能，主要用于保护由 TIM1 和 TIM8 定时器产生的 PWM 信号所驱动的功率开关
/ c- t( f. y8 X: X& W
5 ^) G" Q* y" ]3 W! O4 b$ H* ~6 {  TRGO内部输出通道
4 o: r' u+ D! j  s" F6 K8 l主要用于定时器级联，ADC和DAC的定时器触发。

  6组输出比较单元OC1到OC6
OC1到OC4有对应的输出引脚，而OC5和OC6没有对应的输出引脚，主要用于内部控制。

  截图右侧的输出比较通道TIMx_CH1，TIMx_CH1N，TIMx_CH2，TIMx_CH2N，TIMx_CH3，TIMx_CH3N和TIMx_CH4
主要用于PWM输出，注意CH1到CH3有互补输出，而CH4没有互补输出。
" K! d6 F  h, _% _# N  G( E8 u
9 p# E* a5 D- @; E4 k, K% Q  其它框图里面未展示出来功能
8 S5 h# P% N+ W定时器TIM1&TIM8还支持的其它功能在用到的时候再做说明。

. I9 X2 m) _) b6 q% Q: _- ^32.2.3 定时器的时基单元
定时器要工作就需要一个基本时基单元，而基本的时基单元是由下面几个寄存器组成的：
% K/ N, i& m6 X4 x+ d
% p  r( F% R# X8 ]8 y. i& F/ V  预分频器寄存器 (TIMx_PSC)
/ T& v+ {8 G7 @7 C6 s/ j* n用于设置定时器的分频，比如定时器的主频是200MHz，通过此寄存器可以将其设置为100MHz，50MHz，25MHz等分频值。

注：预分频器有个缓冲功能，可以让用户实时更改，新的预分频值将在下一个更新事件发生时被采用（以递增计数模式为例，就是CNT计数值达到ARR自动重装寄存器的数值时会产生更新事件）。
, K& X* c& ]6 Z/ g
3 A0 z; A0 Z  J1 ~  计数器寄存器 (TIMx_CNT)
6 q$ M+ N% s2 n2 ^, T( ^计数器是最基本的计数单元，计数值是建立在分频的基础上面，比如通过TIMx_PSC设置分频后的频率为100MHz，那么计数寄存器计一次数就是10ns。
' U4 R2 F- F, O# c5 i, j4 ~  h
  自动重载寄存器 (TIMx_ARR)
9 N9 G1 g; [; {$ ^% E2 K' k自动重装寄存器是CNT计数寄存器能达到的最大计数值，以递增计数模式为例，就是CNT计数器达到ARR寄存器数值时，重新从0开始计数。

注，自动重载寄存器是预装载的。对自动重载寄存器执行写入或读取操作时会访问预装载寄存器。预装载寄存器的内容既可以立即传送到影子寄存器（让设置立即起到效果的寄存器），也可以在每次发生更新事件时传送到影子寄存器。简单的说就是让ARR寄存器的数值立即更新还是更新事件发送的时候更新。
3 F- `, I5 _( S/ I2 s
  重复计数器寄存器 (TIMx_RCR)
以递增计数模式为例，当CNT计数器数值达到ARR自动重载数值时，重复计数器的数值加1，重复次数达到TIMx_RCR+ 1后就，将生成更新事件。
+ a' N9 V+ O  l9 ^$ ^" W+ @
: r. q  |1 k0 e9 @/ v注，只有TIM1，TIM8，TIM15，TIM16，TIM17有此寄存器。

比如我们要配置定时器实现周期性的中断，主要使用这几个寄存器即可。
4 d, X4 ]' m+ m$ n
32.2.4 定时器输出比较（PWM）
使用定时器时基单元的那几个寄存器仅仅能设置周期，还不能设置占空比。针对这个问题，还需要比较捕获寄存CCR的参与，这样就可以设置占空比了。
% ~3 H) }& P- a6 W# V" i4 z' y
为了方便大家理解，以PWM 边沿对齐模式，递增计数配置为例：
2 r+ g' ]# i4 r
# a/ [" w9 ^8 I4 P- g  当计数器TIMx_CNT < 比较捕获寄存器TIMx_CCRx期间，PWM参考信号OCxREF输出高电平。
  当计数器TIMx_CNT >= 比较捕获寄存器TIMx_CCRx期间， PWM参考信号OCxREF输出低电平。
/ n( O/ c- {5 g& c  当比较捕获寄存器TIMx_CCRx > 自动重载寄存器TIMx_ARR，OCxREF保持为1。
' d' N1 E, R) @% W: T8 P3 S  当比较捕获寄存器TIMx_CCRx = 0，则OCxRef保持为0。
下面是TIMx_ARR=8的波形效果：

4 u0 C& |; p9 V: V* v1 a
8 g2 v8 y+ `( H+ F# z32.2.5 定时器输入捕获
( Z- i' d0 m& G与PWM一样，使用定时器实现输入捕获，仅靠时基单元的那几个寄存器是不行的，我们需要一个寄存器来记录发生捕获时的具体时间，这个寄存器依然由比较捕获寄存器TIMx_CCRx来实现。
; S) w3 ~7 t; Z) J( `- o* ]" h0 e
  x9 u* ^0 ^; H" C比如我们要测量一路方波的周期：

. n6 I, t& O" c8 K( w; z  配置定时器为输入捕获模式，上升沿触发，设置分频，自动重装等寄存器，比如设置的CNT计数器计数1次是1微秒。
  当有上升沿触发的时候，TIMx_CCRx寄存器就会自动记录当前的CNT数值，然后用户就可以通过CC中断，在中断复位程序里面保存当前的TIMx_CCRx寄存器数值。等下次再检测到上升沿触发，两次时间求差就可以得到方波的周期。
不过这里要特别注意一点，如果CNT发生溢出（比如16位定时器，计数到65535就溢出了）就需要特别处理下，将CNT计数溢出考虑进来。

32.3 定时器的HAL库用法
# f# Z0 R. a' X- ]定时器的HAL库用法其实就是几个结构体变量成员的配置和使用，然后配置GPIO、时钟，并根据需要配置NVIC、中断和DMA。下面我们逐一展开为大家做个说明。

" c. k) J7 M- s( Q9 \# N32.3.1 定时器寄存器结构体TIM_TypeDef
定时器相关的寄存器是通过HAL库中的结构体TIM_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：
; _8 b% O; l! s) V3 W( j! K

1. typedef struct
   
2. {
   
3.   __IO uint16_t CR1;         /*!< TIM control register 1,                   Address offset: 0x00 */
   ) ]( N& I2 r: K
4.   uint16_t      RESERVED0;   /*!< Reserved, 0x02                                                 */
   
5.   __IO uint32_t CR2;         /*!< TIM control register 2,                   Address offset: 0x04 */
   + P. ~% B7 K" [& p" x5 N9 E$ n
6.   __IO uint32_t SMCR;        /*!< TIM slave mode control register,          Address offset: 0x08 */
   ! P% h  V% P! L3 L8 X% `- C3 D
7.   __IO uint32_t DIER;        /*!< TIM DMA/interrupt enable register,        Address offset: 0x0C */
   
8.   __IO uint32_t SR;          /*!< TIM status register,                      Address offset: 0x10 */
   # f. f" Q  a9 A9 p9 H, E) i
9.   __IO uint32_t EGR;         /*!< TIM event generation register,            Address offset: 0x14 */
   7 F5 L6 f+ W" {
10.   __IO uint32_t CCMR1;       /*!< TIM capture/compare mode register 1,      Address offset: 0x18 */
    
11.   __IO uint32_t CCMR2;       /*!< TIM capture/compare mode register 2,      Address offset: 0x1C */
    / c9 j$ d5 Z+ a( [3 e' R; |! l7 t
12.   __IO uint32_t CCER;        /*!< TIM capture/compare enable register,      Address offset: 0x20 */
    * k  g8 q$ U% v$ g5 g( R* O2 d
13.   __IO uint32_t CNT;         /*!< TIM counter register,                     Address offset: 0x24 */
    " s" `# u' j' H4 X2 p+ t: H7 P! \7 Z
14.   __IO uint16_t PSC;         /*!< TIM prescaler,                            Address offset: 0x28 */
    
15.   uint16_t      RESERVED9;   /*!< Reserved, 0x2A                                                 */
    
16.   __IO uint32_t ARR;         /*!< TIM auto-reload register,                 Address offset: 0x2C */
    
17.   __IO uint16_t RCR;         /*!< TIM repetition counter register,          Address offset: 0x30 */
    ! y- Z4 z1 n+ E$ J
18.   uint16_t      RESERVED10;  /*!< Reserved, 0x32                                                 */
    
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 */
    : M) w7 i( [8 s& g
22.   __IO uint32_t CCR4;        /*!< TIM capture/compare register 4,           Address offset: 0x40 */
    8 k  f: p0 a( X& }; m% F( y0 b1 i
23.   __IO uint32_t BDTR;        /*!< TIM break and dead-time register,         Address offset: 0x44 */
    
24.   __IO uint16_t DCR;         /*!< TIM DMA control register,                 Address offset: 0x48 */
    
25.   uint16_t      RESERVED12;  /*!< Reserved, 0x4A                                                 */
    
26.   __IO uint16_t DMAR;        /*!< TIM DMA address for full transfer,        Address offset: 0x4C */
    
27.   uint16_t      RESERVED13;  /*!< Reserved, 0x4E                                                 */
    
28.   uint16_t      RESERVED14;  /*!< Reserved, 0x50                                                 */
    
29.   __IO uint32_t CCMR3;       /*!< TIM capture/compare mode register 3,      Address offset: 0x54 */
    
30.   __IO uint32_t CCR5;        /*!< TIM capture/compare register5,            Address offset: 0x58 */
    
31.   __IO uint32_t CCR6;        /*!< TIM capture/compare register6,            Address offset: 0x5C */
    
32.   __IO uint32_t AF1;         /*!< TIM alternate function option register 1, Address offset: 0x60 */
    
33.   __IO uint32_t AF2;         /*!< TIM alternate function option register 2, Address offset: 0x64 */
    
34.   __IO uint32_t TISEL;       /*!< TIM Input Selection register,             Address offset: 0x68 */
    
35. } TIM_TypeDef;

复制代码

这个结构体的成员名称和排列次序和CPU的定时器寄存器是一 一对应的。
) ~" Y/ x( [9 D6 b# R4 E/ s# X" u
__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：

% b! e; s! |& ?# x. O1 G8 b

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

复制代码

下面我们看下定时器的定义，在stm32h743xx.h文件。

1. #define PERIPH_BASE         ((uint32_t)0x40000000)
   & Y1 U0 d) v0 z& W. V
2. #define D2_APB1PERIPH_BASE   PERIPH_BASE
   6 i3 i* p3 L+ _1 q
3. #define D2_APB2PERIPH_BASE   (PERIPH_BASE + 0x00010000)
   
4. 
   6 q7 o8 m: j, p  x' L; a
5. /*!< D2_APB1PERIPH 外设 */
   / v, m" X# o; q9 }) u0 p4 l' X
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)
   ' L. r& n0 n# |& ~- S7 n
9. #define TIM5_BASE             (D2_APB1PERIPH_BASE + 0x0C00)
   
10. #define TIM6_BASE             (D2_APB1PERIPH_BASE + 0x1000)
    
11. #define TIM7_BASE             (D2_APB1PERIPH_BASE + 0x1400)
    
12. #define TIM12_BASE            (D2_APB1PERIPH_BASE + 0x1800)
    
13. #define TIM13_BASE            (D2_APB1PERIPH_BASE + 0x1C00)
    
14. #define TIM14_BASE            (D2_APB1PERIPH_BASE + 0x2000)
    
15. 
    
16. /*!< D2_APB1PERIPH 外设 */
    , Y, i* ~  e" B0 y7 d0 m; u7 N
17. #define TIM1_BASE             (D2_APB2PERIPH_BASE + 0x0000)
    
18. #define TIM8_BASE             (D2_APB2PERIPH_BASE + 0x0400)
    & _# m/ k& N$ h9 Q2 |
19. #define TIM15_BASE            (D2_APB2PERIPH_BASE + 0x4000)
    
20. #define TIM16_BASE            (D2_APB2PERIPH_BASE + 0x4400)
    
21. #define TIM17_BASE            (D2_APB2PERIPH_BASE + 0x4800)
    ! d' Y; E' h: i8 P; H3 V
22. 
    
23. #define TIM1                ((TIM_TypeDef *) TIM1_BASE)
      g0 ?8 l5 ?& g9 L. q, ~
24. #define TIM2                ((TIM_TypeDef *) TIM2_BASE)
    4 |( G" k/ D9 r, Z! o
25. #define TIM3                ((TIM_TypeDef *) TIM3_BASE)
    
26. #define TIM4                ((TIM_TypeDef *) TIM4_BASE)
    7 t0 S" q5 y5 [8 G! l" P: U+ Z; P
27. #define TIM5                ((TIM_TypeDef *) TIM5_BASE)
    
28. #define TIM6                ((TIM_TypeDef *) TIM6_BASE)
    
29. #define TIM7                ((TIM_TypeDef *) TIM7_BASE)
    
30. #define TIM8                ((TIM_TypeDef *) TIM8_BASE)
    
31. #define TIM12               ((TIM_TypeDef *) TIM12_BASE)
    / T/ w* U5 I) O6 N0 j. W
32. #define TIM13               ((TIM_TypeDef *) TIM13_BASE)
    
33. #define TIM14               ((TIM_TypeDef *) TIM14_BASE)
    ! X9 T6 q% r/ U/ n$ [
34. #define TIM15               ((TIM_TypeDef *) TIM15_BASE)
    
35. #define TIM16               ((TIM_TypeDef *) TIM16_BASE)
    
36. #define TIM17               ((TIM_TypeDef *) TIM17_BASE)

复制代码

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

* ^9 S8 j& ^; z- _3 I8 n0 d% Q32.3.2 定时器句柄结构体TIM_HandleTypeDef
# J" q2 |% I$ b% oHAL库在TIM_TypeDef的基础上封装了一个结构体TIM_HandleTypeDef，定义如下：
5 A+ ?; _! Y9 v  G7 S9 V+ d

1. typedef struct
   0 ]9 m4 e6 i- J$ `5 z' ^, @
2. {
   3 M6 B3 M3 N9 h% d9 \2 @
3.   TIM_TypeDef              *Instance;     /*!< Register base address             */
   
4.   TIM_Base_InitTypeDef     Init;          /*!< TIM Time Base required parameters */
   
5.   HAL_TIM_ActiveChannel    Channel;       /*!< Active channel                    */
   ! T6 v* H9 p5 y
6. 
   - }/ _0 E4 ?" t, _) ~9 F
7. /*!< DMA Handlers array This array is accessed by a @ref DMA_Handle_index */
   # Y1 `! Z$ K5 `; n) v2 `8 |3 T
8.   DMA_HandleTypeDef        *hdma[7];      
   / `; |% h7 v( [1 g7 c* \4 j0 X
9.   HAL_LockTypeDef          Lock;          /*!< Locking object                    */
   5 L: b# n  i3 _7 A: ^) E; Q7 c
10.   __IO HAL_TIM_StateTypeDef   State;      /*!< TIM operation state               */  
    
11. }TIM_HandleTypeDef;

复制代码

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

  TIM_TypeDef  *Instance
, b# |- d, {1 P! d
这个参数是寄存器的例化，方便操作寄存器，比如使能定时器的计数器。

7 ~' X4 E3 x6 b* zSET_BIT(huart->Instance->CR1,  TIM_CR1_CEN)。
, d( }+ V# f9 W, p
- b( y- I+ F( g9 H& N  TIM_Base_InitTypeDef  Init
3 K' }0 j# l5 O5 V' \- x/ Y
0 F9 N5 f" e) m) M5 X( \! l- W这个参数是用户接触最多的，用于配置定时器的基本参数。
. N4 @, s8 |2 z) I
. s, B2 X# M& b+ jTIM_Base_InitTypeDef结构体的定义如下：
- n7 t# D1 _# _5 K/ ^

1. typedef struct
   
2. {
   
3.   uint32_t Prescaler;      
   5 i& `1 Y7 G9 L/ u' o: b
4.   uint32_t CounterMode;   
   
5.   uint32_t Period;         
   
6.   uint32_t ClockDivision;   
   : O5 S; Q2 R7 E) ?( w
7.   uint32_t RepetitionCounter;
   ; W. l( ~' J$ T
8.   uint32_t AutoReloadPreload;  
   
9. } TIM_Base_InitTypeDef;

复制代码

, T: d% u/ e+ U4 v  b9 c  成员Prescaler
用于设置定时器分频，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。

& z* ~# D! A$ `6 c# F! h  成员CounterMode
用于设置计数模式，向上计数模式、向下计数模式和中心对齐模式。
3 j9 m5 L2 i5 U& N: P

1. #define TIM_COUNTERMODE_UP                ((uint32_t)0x0000U)   /*!< Up counting mode */
   % D) n$ x5 Q& N, q. C; b( K" _
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 */
   & ?  p+ x+ ~' Q! M
4. #define TIM_COUNTERMODE_CENTERALIGNED2     TIM_CR1_CMS_1        /*!< Center-aligned counting mode 2 */
   7 M* ^0 R* s0 M1 s, Z9 {( E
5. #define TIM_COUNTERMODE_CENTERALIGNED3     TIM_CR1_CMS          /*!< Center-aligned counting mode 3 */

复制代码

  成员Period
. d6 i1 @$ e0 s- ~/ c+ L用于设置定时器周期，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。
# N0 r: u, W1 x& r- M6 j
  成员ClockDivision
用于指示定时器时钟 (CK_INT) 频率与死区发生器以及数字滤波器（ETR、TIx）所使用的死区及采样时钟 (tDTS) 之间的分频比。
( B: H8 i; M7 F2 [  y" d
4 _: M0 R7 `2 `/ N& J5 b% H

1. #define TIM_CLOCKDIVISION_DIV1       ((uint32_t)0x0000U)        /*!< Clock Division DIV1 */
   ) z5 ]# R& c/ f" }1 v8 C4 T
2. #define TIM_CLOCKDIVISION_DIV2       (TIM_CR1_CKD_0)            /*!< Clock Division DIV2 */
   . P' W2 B( n7 ]: P1 ^3 y1 a
3. #define TIM_CLOCKDIVISION_DIV4       (TIM_CR1_CKD_1)             /*!< Clock Division DIV4 */

复制代码

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

+ r( ~: p- I$ A4 B3 P7 D) o  成员AutoReloadPreload
用于设置定时器的ARR自动重装寄存器是更新事件产生时写入有效还是立即写入有效。如果使能了表示更新事件产生时写入有效，否则反之。
# |  o6 R) N8 [1 F$ Y4 k* \2 N6 J+ S
. I* ]" n* U, \3 }" |. K6 J5 v$ w

1. #define TIM_AUTORELOAD_PRELOAD_DISABLE   ((uint32_t)0x0000U)   /*!< TIMx_ARR register is not buffered */
     c" l( P! m/ |2 d6 E& _9 x5 Q' M
2. #define TIM_AUTORELOAD_PRELOAD_ENABLE    (TIM_CR1_ARPE)        /*!< TIMx_ARR register is buffered */

复制代码

" h; r# D, ?. D' H$ M  HAL_TIM_ActiveChannel    Channel;
4 |* s: E* {* u6 g
用于设置定时器通道，比如TIM1和TIM8都是6个通道。
, z" q& L; s8 E8 l

1. typedef enum
   
2. {
   6 E- z3 N% i$ ~+ ]+ O0 |
3.   HAL_TIM_ACTIVE_CHANNEL_1        = 0x01U,    /*!< The active channel is 1     */
   
4.   HAL_TIM_ACTIVE_CHANNEL_2        = 0x02U,    /*!< The active channel is 2     */
   
5.   HAL_TIM_ACTIVE_CHANNEL_3        = 0x04U,    /*!< The active channel is 3     */   
   $ a. U& @! U& ]/ {6 W- l+ r
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     */
   ( _* J. X  z% w+ Z
9.   HAL_TIM_ACTIVE_CHANNEL_CLEARED  = 0x00U     /*!< All active channels cleared */   
   3 E% O9 e4 n  ^0 Z" [
10. }HAL_TIM_ActiveChannel;
    
11.   DMA_HandleTypeDef        *hdma[7];

复制代码

用于关联DMA。

配置定时器参数，其实就是配置结构体TIM_HandleTypeDef的成员。

1. TIM_HandleTypeDef   TimHandle = {0};
   
2. 
   
3. /*
   7 T4 v) s) v/ d7 s
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   9 y5 e5 S& ~' s: a
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;
    % \* x! u" o3 A, O
11. TimHandle.Init.RepetitionCounter = 0;
    
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    ( X3 o( N& S! K* V
14. {
    
15.         Error_Handler(__FILE__, __LINE__);
    ; {& U5 g0 [- u6 h5 u* _( b& Q: d
16. }

复制代码

32.3.3 定时器输出比较结构体TIM_OC_InitTypeDef
此结构体主要用于定时器的输出比较，定义如下：
( n; N( e, x7 y  k/ V

1. typedef struct
   
2. {                                 
   ! E$ U0 X5 J4 _
3.   uint32_t OCMode;      
   
4.   uint32_t Pulse;      
   # u7 f. y. N! s7 g/ O# t
5.   uint32_t OCPolarity;   
   
6.   uint32_t OCNPolarity;   
   
7.   uint32_t OCFastMode;  
   
8.   uint32_t OCIdleState;   
   
9.   uint32_t OCNIdleState;  
   $ o5 T/ c0 s( @# t# ?7 w% a0 R
10. } TIM_OC_InitTypeDef;  

复制代码

下面将这几个参数一 一做个说明。
' H" _# l! o! ?9 V8 X' m+ S, d
  OCMode
用于配置输出比较模式，支持的模式较多：

1. /*!< TIM Output timing mode */
   
2. #define TIM_OCMODE_TIMING                ((uint32_t)0x0000U)      
   . @! U# B% l% p4 [4 O
3. 
   ; Y3 B/ [( l: V5 Z7 n
4. /*!< TIM Output Active mode */                          
   / n1 i! s0 a) r5 n) ?9 F3 s
5. #define TIM_OCMODE_ACTIVE                ((uint32_t)TIM_CCMR1_OC1M_0)
   # r0 u" s% b$ |2 m, p3 t
6. 
   
7. /*!< TIM Output Inactive mode */                       
   ' f2 u, F' F- L+ _1 ?) y0 M
8. #define TIM_OCMODE_INACTIVE              ((uint32_t)TIM_CCMR1_OC1M_1)           
   
9. 
   $ A  Q/ h" y/ F0 q+ X8 e/ s
10. /*!< TIM Output Toggle mode */               
    5 K" e* D( b  q' K
11. #define TIM_OCMODE_TOGGLE                 ((uint32_t)TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)         
    * ~6 g; Y- `& S5 w5 P
12. 
    0 a# O8 p  ^* T: g4 F4 r0 X% ~
13. /*!< TIM PWM mode 1 */
    
14. #define TIM_OCMODE_PWM1                   ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1)
    1 r* Q2 Y/ y: n' \" C9 K! [
15. 
    
16. /*!< TIM PWM mode 2 */                    
    & O" w2 |1 Z2 g& m; D# o
17. #define TIM_OCMODE_PWM2                    ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)   
    
18. 
    7 e5 s" `; v# l
19. /*!< TIM Forced Active mode */   
    5 O6 X9 u* j! r% n! W; `
20. #define TIM_OCMODE_FORCED_ACTIVE           ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0)         
    ! W/ q6 F6 m  w. B5 d# b2 J9 M6 Y
21. 
    
22. /*!< TIM Forced Inactive mode */            
    
23. #define TIM_OCMODE_FORCED_INACTIVE         ((uint32_t)TIM_CCMR1_OC1M_2)                                       
    
24. 
    % W2 s2 C1 g6 Y: ~% a1 s
25. /*!< TIM Rettrigerrable OPM mode 1 */  
    . \+ M! h/ r# B- D$ V4 ?7 s
26. #define TIM_OCMODE_RETRIGERRABLE_OPM1      ((uint32_t)TIM_CCMR1_OC1M_3)   
    ( H; {& F1 o2 h  x' }
27. 
    9 N9 D0 m2 k* @  g: y$ ]- h
28. /*!< TIM Rettrigerrable OPM mode 2 */                                       
    ! B9 {9 P' y- E  |/ d3 [
29. #define TIM_OCMODE_RETRIGERRABLE_OPM2      ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0)   
    ( k' {6 M5 z! f- U
30. 
    
31. /*!< TIM Combined PWM mode 1 */                     
    6 r' s' |0 Z- S$ k) Q
32. #define TIM_OCMODE_COMBINED_PWM1           ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_2)     
    
33. 
    4 T. `: R, G2 a& N
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)   
    7 [2 b5 t0 S5 i) J# b
36. 
    & ?  t% L' f& f# _0 P  c+ B
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. 
    / M, v) c+ \6 S- }
40. /*!< TIM Asymetruc PWM mode 2 */   
    
41. #define TIM_OCMODE_ASSYMETRIC_PWM2         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M)  

复制代码

/ k& w5 k9 X2 Z2 Q  
/ {6 L! l. l, k7 V  Pulse
可用于设置占空比，对应定时器的CCR寄存器，32位的TIM2和TIM5范围是0到0xFFFFFFFF。
+ J' a/ A$ e: I: u
  OCPolarity
) i6 G9 j1 B$ l6 I9 y设置输出极性，可选高电平或低电平有效。
/ q; O. ]- k8 v  v: Y

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

复制代码

  OCNPolarity
0 |' `, Y% T/ V  b, _% q. J互补输出极性设置，可选高电平或者低电平有效。

, ?2 Z. ?  V* p9 h& ~5 }

1. #define TIM_OCNPOLARITY_HIGH               ((uint32_t)0x0000U)
   # a( u- z) Q$ X; A5 u) f
2. #define TIM_OCNPOLARITY_LOW                (TIM_CCER_CC1NP)

复制代码

- z4 ?+ ^2 m. e0 n8 l6 e  OCFastMode
快速输出模式使能，仅OCMode配置为PWM1或者PWM2模式时才有意义。

( f) f2 f) p6 l( C! T) K$ B  d" [

1. #define TIM_OCFAST_DISABLE                ((uint32_t)0x0000U)
   ; A. }7 a) Y" m4 X2 @; ^9 Z
2. #define TIM_OCFAST_ENABLE                 (TIM_CCMR1_OC1FE)

复制代码

  OCIdleState
空闲状态时，设置输出比较引脚的电平状态。
3 G/ }9 b& o  z  G- |7 N
& Z2 O7 }& F( Q. \

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

复制代码

  OCNIdleState
( _% A; ^  P% X2 Q+ o$ i$ d空闲状态时，设置互补输出引脚的电平状态。

, a0 i1 x* D+ [6 o% M

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

复制代码

5 |# ?: D4 T  N& k6 `32.3.4 定时器输入捕获结构体TIM_IC_InitTypeDef
+ n& B; z% E$ J) ]此结构体主要用于定时器的输入捕获，定义如下：

1. typedef struct
   7 ^3 C0 h, c9 t! S, T
2. {                                 
   7 ?7 C9 a( s9 W5 U/ z; ?
3.   uint32_t ICPolarity;   
   
4.   uint32_t ICSelection;
   " F- D  X8 a- b
5.   uint32_t ICPrescaler;
   # `4 H9 n& p6 S8 E; h6 O
6.   uint32_t ICFilter;   
   ' o1 R5 C& d( L7 }. E
7. } TIM_IC_InitTypeDef;

复制代码

) O  b7 r6 |' E, ~下面将这几个参数一 一做个说明。
4 h/ Z0 C, E* E1 D
% o. h8 W# T$ k$ c" ^  ICPolarity
1 V6 F0 E; z$ Z输入触发极性，可以选择上升沿，下降沿或者双沿触发。
6 a7 t( d/ ?' E- u
# X% J, Z8 B& S$ t

1. #define  TIM_ICPOLARITY_RISING             TIM_INPUTCHANNELPOLARITY_RISING
   
2. #define  TIM_ICPOLARITY_FALLING            TIM_INPUTCHANNELPOLARITY_FALLING
   ; R, w1 Y7 n- {8 \1 k2 o5 v
3. #define  TIM_ICPOLARITY_BOTHEDGE           TIM_INPUTCHANNELPOLARITY_BOTHEDGE

复制代码

% H2 ^3 N/ g6 {. q  ICSelection
输入捕获通道选择，可以选择直接输入（即CC1选择TI1，CC2选择TI2等），间接输入（CC1选择TI2，CC3选择TI4等）或者TRC。

  s0 a8 v0 |0 a2 k% l

1. #define TIM_ICSELECTION_DIRECTTI       (TIM_CCMR1_CC1S_0)   
   
2. #define TIM_ICSELECTION_INDIRECTTI     (TIM_CCMR1_CC1S_1)  
   & w! J  {+ m- e
3. #define TIM_ICSELECTION_TRC            (TIM_CCMR1_CC1S)   

复制代码

  ICPrescaler
输入捕获分频，表示每捕获1，2，4或8个事件后表示一次捕获。

5 Y6 i0 f' e3 O* i

1. #define TIM_ICPSC_DIV1       ((uint32_t)0x0000U)                 
   
2. #define TIM_ICPSC_DIV2       (TIM_CCMR1_IC1PSC_0)   
   
3. #define TIM_ICPSC_DIV4       (TIM_CCMR1_IC1PSC_1)   
   
4. #define TIM_ICPSC_DIV8       (TIM_CCMR1_IC1PSC)

复制代码

  ICFilter
5 \# v- v+ _$ h+ d+ X& g2 G: _输入捕获滤波器，可以定义采样频率和多少个连续事件才视为有效的触发，参数范围0到15。具体定义如下，其中fCK_INT表示定时器时钟，fDTS表示死区时间采样率，N表示这么多个事件代表一次有效边沿。

1. 0000：无滤波器，按 fDTS 频率进行采样
   
2. 0001： fSAMPLING=fCK_INT， N=2
   6 H" \: a+ ^7 R9 ]
3. 0010： fSAMPLING=fCK_INT， N=4
   
4. 0011： fSAMPLING=fCK_INT， N=8
   + Z4 O5 G+ i7 ^) C0 ?
5. 0100： fSAMPLING=fDTS/2， N=6
   7 g! Q6 C- o. a3 S. t% |
6. 0101： fSAMPLING=fDTS/2， N=8
   
7. 0110： fSAMPLING=fDTS/4， N=6
   
8. 0111： fSAMPLING=fDTS/4， N=8
   : l  k, B; K! i$ k
9. 1000： fSAMPLING=fDTS/8， N=6
   
10. 1001： fSAMPLING=fDTS/8， N=8
    2 A& s' @6 V  ]+ V, x# U( z' u
11. 1010： fSAMPLING=fDTS/16， N=5
    5 k0 k/ M+ [) o
12. 1011： fSAMPLING=fDTS/16， N=6
    ' y7 @9 w/ _) D# s# y
13. 1100： fSAMPLING=fDTS/16， N=8
    
14. 1101： fSAMPLING=fDTS/32， N=5
    - i0 f) f+ c# y0 Q* S
15. 1110： fSAMPLING=fDTS/32， N=6

复制代码

; ^( q- R# A/ n32.3.5 定时器的底层配置（GPIO，时钟，中断等）
- n4 [) m% P2 ]2 Z7 a" y5 N3 }HAL库有个自己的底层初始化回调函数，比如调用函数HAL_TIM_Base_Init就会调用HAL_TIM_Base_MspInit，此函数是弱定义的。
& ]' y- V7 A- q9 q$ t' {

1. __weak void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
   
2. {
   
3.   /* Prevent unused argument(s) compilation warning */
   
4.   UNUSED(htim);
   
5.   /* NOTE : This function Should not be modified, when the callback is needed,
   $ ]1 x3 I& m1 A
6.             the HAL_TIM_Base_MspDeInit could be implemented in the user file
   
7.    */
   
8. }

复制代码

用户可以在其它的C文件重定向，并将相对的底层初始化在里面实现。对应的底层复位函数HAL_TIM_Base_DeInit是在函数HAL_TIM_Base_MspDeInit里面被调用的，也是弱定义的。

+ q$ l* P- i' Z7 V+ m7 Y( U: Y当然，用户也可以自己初始化，不限制必须在两个函数里面实现。

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

1. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
   ( J& `- s* I# R' ~* ?
2. {
   
3.   GPIO_InitTypeDef   GPIO_InitStruct;
   
4. 
     x6 w0 t  ^8 e7 M6 h2 n
5.   /* 使能TIM1时钟 */
   ( B+ V0 [2 y5 \; d
6.   __HAL_RCC_TIM1_CLK_ENABLE ();
   # K) v+ K" M5 f  U( ~
7. 
   : o) f- u* R7 e, c+ N+ c: W1 x! k
8.   /* 使能GPIOA时钟 */
   9 r0 c& y: T6 b1 s- Q
9.   __HAL_RCC_GPIOA_CLK_ENABLE ();
   7 S1 g$ \3 Z/ I0 n
10. 
    
11.   /* 设置TIM1使用PA8做PWM输出引脚，将其配置为输出，推挽，复用模式 */
    ) v# _1 a& S; E. v! \9 n$ C$ }# h
12.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
13.   GPIO_InitStruct.Pull = GPIO_PULLUP;
    , ~2 }: T9 Z. n4 W. w( s2 |
14.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    " ^/ T: C' E: s1 p0 H
15. 
    
16.   GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
    
17.   GPIO_InitStruct.Pin = GPIO_PIN_8;
    . F* h% H0 {% J. [3 Q
18.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
19. 
    
20. }

复制代码

总结下来就是以下几点：

2 a; d2 [- d( k" E- Y' x, ?  配置TIM时钟。
5 w) {4 y" H" H3 G( e6 a1 n  配置TIM所用到引脚和对应的GPIO时钟。
, j6 `1 V8 W1 S  l# B6 J( w  如果用到定时器中断，还需要通过NVIC配置中断。
  W4 A4 @1 M1 c  如果用到DMA，还要配置DMA。
& z' R3 d, X. y4 p, s! K关于这个底层配置有以下几点要着重说明下：
- K2 f' c, a; N9 T: N- d: i
  定时器所使用引脚的复用模式选择已经被HAL库定义好，放在了stm32h7xx_hal_gpio_ex.h文件里面。比如TIM1有一个复用，

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

复制代码

1 F* _$ @; G: D( L1 f$ Y5 K* A! K但是却有4个输出通道，每个通道都有几个支持的输出引脚：

1. TIM1_CH1,  PA8   PE9    PK1
   
2. TIM1_CH2,  PA9   PE11
   , C- ?) u6 G0 Y4 Q
3. TIM1_CH3,  PA10  PE13   PJ9
   
4. TIM1_CH4,  PA11  PE14   PJ11

复制代码

( @- W  u3 U) N1 T具体使用哪个，配置对应引脚的复用即可：
' n+ G3 B6 K2 {* K/ }: {- v
5 U" E* ?* }8 ]  ?$ [# V6 {

32.3.6 定时器的状态标志清除问题
& U  Z4 S% U) V3 r8 Q5 s3 e7 u下面我们介绍__HAL_TIM_GET_FLAG函数。这个函数用来检查定时器标志位是否被设置。
% R; s, \! {$ x. C6 ^4 h: _

1. 
   
2. /** @brief  Check whether the specified TIM interrupt flag is set or not.
   ) K2 N- U5 \  g6 [
3.   * @param  __HANDLE__: specifies the TIM Handle.
   7 A7 I0 Q% ^  N/ [. C( `, Z
4.   * @param  __FLAG__: specifies the TIM interrupt flag to check.
   
5.   *        This parameter can be one of the following values:
   
6.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag
   1 T! w/ U8 h( L' z
7.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
   , F1 F" s1 l' e1 h3 ?
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
    " V1 K- Q- J  N6 v0 j
11.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag
    9 P$ ^4 X7 h6 T0 A0 o
12.   *            @arg TIM_FLAG_CC6: Compare 6 interrupt flag
    ( d; E$ ?" _7 [# Z) r0 T: K) O
13.   *            @arg TIM_FLAG_COM:  Commutation interrupt flag
    
14.   *            @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
    ; O4 N  q8 m; s7 ]* X+ @: k$ y
15.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   
    ( P' l% O1 j/ Y; j1 p
16.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    0 p) ~3 e* o6 s' K, B  V' x
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
    
20.   *            @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
    
21.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    ( f! j9 w$ @4 S3 z: C7 m; Z
22.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    
23.   */
    4 u1 E! R' C3 X- e: g9 O
24. #define __HAL_TIM_GET_FLAG(__HANDLE__, __FLAG__)   (((__HANDLE__)->Instance->SR &(__FLAG__)) == (__FLAG__))

复制代码

( Q% h+ V' A$ V$ V( J: R0 O8 |前5个是比较常用的中断标志。

9 y8 A5 {" L5 J+ ]$ y  TIM_FLAG_UPDATE
定时器更新标准，配置一个周期性的定时器中断要用到。
/ ^7 a) o1 M, L0 l, O
     TIM_FLAG_CC1
6 G# Q* O% p- e' T- E1 ZTIM_FLAG_CC2
/ }2 P- \; T% y4 Q9 h) l3 _* }
TIM_FLAG_CC3
2 T4 X# k+ S' V# S9 T- k
TIM_FLAG_CC4

; Y0 L/ c/ R0 `3 @7 f/ Q. w捕获/比较标志，配置了捕获/比较中断要用到。

- Q5 M$ ?) H% S与标志获取函数__HAL_TIM_GET_FLAG对应的清除函数是__HAL_TIM_CLEAR_FLAG：

1. /** @brief  Clear the specified TIM interrupt flag.
   $ L; `( p; t5 S1 r2 S
2.   * @param  __HANDLE__: specifies the TIM Handle.
   7 z6 v  A0 Y1 i. {/ p  T
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
   
6.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
   # z9 g; ~$ p: j* \: r+ [2 C
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
   7 {* |: b3 U& c6 v0 a
10.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag
    
11.   *            @arg TIM_FLAG_CC6: Compare 6 interrupt flag
    ) t) |* }( V! {! P  f
12.   *            @arg TIM_FLAG_COM:  Commutation interrupt flag
    " |9 z0 I" v! Q2 I1 U5 X
13.   *            @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
    4 y, \- T0 @6 l2 f6 X6 }
14.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   
    : C+ f( [' X, i
15.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     
    + U# S" W2 b& t' J/ U1 V/ @5 g- S
16.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
    ' ?; c' z6 M# c# B& U0 i
17.   *            @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
    % O# ]; h% u; g2 \. ~
18.   *            @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
    . }& |& G  e3 i# E
19.   *            @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
    
20.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    ( W, u0 o0 [$ N
21.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    
22.   */
    4 ?; `" ?) L- P7 d
23. #define __HAL_TIM_CLEAR_FLAG(__HANDLE__, __FLAG__)       ((__HANDLE__)->Instance->SR = ~(__FLAG__))

复制代码

5 ?# K7 w( ?7 P- M4 w% f2 S, y清除标志函数所支持的参数跟获取函数是一 一对应的。除了这两个函数，还是定时器的中断开启和中断关闭函数用的也比较多。

% d' p! s& \/ v+ j; K, V

1. /** @brief  Enable the specified TIM interrupt.
   : q' }) H! V! O+ I& e
2. * @param  __HANDLE__: specifies the TIM Handle.
   : U+ G* h' m9 ?+ D
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 {5 y* w  }
7. *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt
   
8. *            @arg TIM_IT_CC3:  Capture/Compare 3 interrupt
   
9. *            @arg TIM_IT_CC4:  Capture/Compare 4 interrupt
   
10. *            @arg TIM_IT_COM:   Commutation interrupt
    ' i6 j+ {8 b, U# H8 u  O
11. *            @arg TIM_IT_TRIGGER: Trigger interrupt
    ! R7 C; A3 z! |$ y
12. *            @arg TIM_IT_BREAK: Break interrupt
    ! W; R  i# J' g4 X) r! N4 V
13. * @retval None
    & B; t9 Y! Q# W
14. */
    / G0 f" S' E/ d" v
15. #define __HAL_TIM_ENABLE_IT(__HANDLE__, __INTERRUPT__)  ((__HANDLE__)->Instance->DIER |= (__INTERRUPT__))
    1 A0 U0 l" }- I5 S7 f" {
16. 
    
17.   /** @brief  Disable the specified TIM interrupt.
    
18.   * @param  __HANDLE__: specifies the TIM Handle.
    6 C- h( a# `# _( X& m
19.   * @param  __INTERRUPT__: specifies the TIM interrupt source to disable.
    8 r- x2 w! O: v+ X/ Y( m
20.   *          This parameter can be one of the following values:
    3 _; h8 U1 V( T
21.   *            @arg TIM_IT_UPDATE: Update interrupt
    
22.   *            @arg TIM_IT_CC1:   Capture/Compare 1 interrupt
    - e3 Z8 t$ u# c$ g/ X
23.   *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt
    
24.   *            @arg TIM_IT_CC3:  Capture/Compare 3 interrupt
    6 R. q. s- }+ t# r) X9 T2 }
25.   *            @arg TIM_IT_CC4:  Capture/Compare 4 interrupt
    
26.   *            @arg TIM_IT_COM:   Commutation interrupt
    
27.   *            @arg TIM_IT_TRIGGER: Trigger interrupt
    
28.   *            @arg TIM_IT_BREAK: Break interrupt
    
29.   * @retval None
    , X& H* V) N2 Y' w
30.   */
    
31. #define __HAL_TIM_DISABLE_IT(__HANDLE__, __INTERRUPT__)   ((__HANDLE__)->Instance->DIER &= ~(__INTERRUPT__))

复制代码

8 Y( V" C( T* A7 p9 u常用的也是前五个参数，1个定时器更新中断以及4个CC中断 。
7 P2 s* K. w9 g) R  ?2 Y
$ @. Y9 Q9 U9 x  c* ]注意：操作定时器的寄存器不限制必须要用HAL库提供的API，比如要操作寄存器CR1，直接调用TIM1->CR1操作即可。

32.3.7 定时器初始化流程总结
使用方法由HAL库提供：
2 Y, k$ D" O' z  L
0 K9 ~3 \: u5 X' n  第1步：通过下面几个函数配置定时器工作在相应的模式

  HAL_TIM_Base_Init
简单的定时器时基础功能

6 T/ G( j9 E  ~  HAL_TIM_OC_Init 和 HAL_TIM_OC_ConfigChannel
7 N' H' \( z5 j5 i# E- h  Q" K配置定时器产生输出比较信号
. _% @+ e  n  a
  HAL_TIM_PWM_Init 和 HAL_TIM_PWM_ConfigChannel
配置定时器产生PWM信号
  R& T. W/ c% B" B1 }& P5 q
  HAL_TIM_IC_Init 和 HAL_TIM_IC_ConfigChannel
$ d. r) ], u; V6 T配置定时器测量外部信号

5 O6 w0 o' `8 g3 s; o8 v: A  HAL_TIM_OnePulse_Init 和 HAL_TIM_OnePulse_ConfigChannel
配置定时器工作在单脉冲模式

  HAL_TIM_Encoder_Init
配置定时器使用编码器接口

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

第1步里面的几个函数会调用下面的API。

1 R" ?& R$ q$ ?3 F  定时器基本功能 : HAL_TIM_Base_MspInit()
  输入捕获 : HAL_TIM_IC_MspInit()
  输出比较 : HAL_TIM_OC_MspInit()
5 ~# g! B$ X1 S% y; o5 H( w6 c  PWM输出 : HAL_TIM_PWM_MspInit()
7 G" _& b& f1 ~  单脉冲输出模式: HAL_TIM_OnePulse_MspInit()
2 T" ?+ K; P% T. }4 L  编码器模式 : HAL_TIM_Encoder_MspInit()
# v8 m; b4 {3 U& }* l- Q  第3步：底层初始化具体实现

第2步中函数的具体实现。
4 `1 a4 `3 D6 t9 }, |( y6 M
# c2 ^2 a, p$ \+ L  使用函数__HAL_RCC_TIMx_CLK_ENABLE()使能定时器时钟。
  使用函数__HAL_RCC_GPIOx_CLK_ENABLE()使能定时器使用到的引脚时钟。
  使用函数HAL_GPIO_Init()配置GPIO的复用功能。
  如果使能了定时器中断，调用函数HAL_NVIC_SetPriority和HAL_NVIC_EnableIRQ配置。
5 Y, E; H0 f+ p  ?  如果使能了DMA，还需要做DMA的配置。
# q1 }: D* ]3 Q/ |- M  定时器默认使用APB时钟，如果使用外部时钟，调用函数HAL_TIM_ConfigClockSource可以配置。
  第4步：启动定时器外设

4 V* O; `4 r4 w( }) }9 z, G  定时器基础功能:
5 `! c( m' [0 E7 J/ x; ~6 zHAL_TIM_Base_Start()

HAL_TIM_Base_Start_DMA()
% ^' F1 r1 @1 K. B
$ L% \2 W( R* e. m' q4 p+ v) QHAL_TIM_Base_Start_IT()
9 L. ^" h  w) `% p
! H$ _$ e5 X7 Z+ D$ b# d) Q0 x  输入捕获 :
HAL_TIM_IC_Start()

HAL_TIM_IC_Start_DMA()

  L4 B* d  ^+ y8 O  i/ z8 DHAL_TIM_IC_Start_IT()

  输出比较 :
: k: g/ ?) V8 r8 @3 \+ P) n7 Z4 cHAL_TIM_OC_Start()
1 z- |0 M: m  @( u; ^2 _
HAL_TIM_OC_Start_DMA()

: F' E" G6 V/ Y0 B6 ~8 B# y9 iHAL_TIM_OC_Start_IT()

  PWM输出：
7 q( ?% U4 n* S+ y- B: S4 \/ f  iHAL_TIM_PWM_Start()

8 U, n. L1 {3 UHAL_TIM_PWM_Start_DMA()

' @) x: k+ \  Y4 _4 S  \! PHAL_TIM_PWM_Start_IT()
( `2 i" t+ N# o* j! R, I. v
  单脉冲模式：
1 I& g* ]1 j3 w/ O9 LHAL_TIM_OnePulse_Start()
7 U) [! \3 t* d3 v
HAL_TIM_OnePulse_Start_IT().

6 R7 b6 O  k% n  编码器模式：
HAL_TIM_Encoder_Start()
$ x& T# u; U) Q3 @6 T2 O
* Y; c, }% ?8 iHAL_TIM_Encoder_Start_DMA()

9 F% M: |  e1 k' RHAL_TIM_Encoder_Start_IT().
" v/ V5 ^  B# d5 t
& R, N! z& j) ?$ _" G9 c$ [  第5步：定时器的DMA突发使用下面两个函数
  C! V* u4 g5 }) }3 U* J
( h  }  x' |9 A3 Z7 }, m2 E  HAL_TIM_DMABurst_WriteStart()
  HAL_TIM_DMABurst_ReadStart()
+ R9 E- B, V( V0 ^" G定时器常用的功能，通过上面这几步即可实现。

) A6 m/ J" `" W* |32.4 源文件stm32h7xx_hal_tim.c
此文件涉及到的函数非常多，这里把几个常用的函数做个说明：
4 q' l- z" c' O9 D# K# I
  HAL_TIM_Base_Init
' K, o* `( ^2 ~8 A+ L8 t" W# X  HAL_TIM_Base_Start
  HAL_TIM_PWM_Init
  HAL_TIM_PWM_ConfigChannel
4 j. J6 m/ _$ b7 L  HAL_TIM_PWM_Start
3 ^# ^2 }# O$ F0 C' D  HAL_TIM_IC_Init
' J8 M& B8 [& K1 M, Y) v2 }  HAL_TIM_IC_ConfigChannel
  HAL_TIM_IC_Start_IT
- k8 H% y  H% A/ L  HAL_TIM_OC_Init
, @% d9 ?; W1 D  HAL_TIM_OC_ConfigChannel
0 g( @9 M# @+ r( x  HAL_TIM_OC_Start
# q8 @8 Z% }7 n) a. v3 A32.4.1 函数HAL_TIM_Base_Init
8 |/ c0 a7 {( N/ D* n, H函数原型：
' H2 p3 I' ~" D4 q
9 N* W* X- o# d* ~6 H/ h

1. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   
2. {
   # [% v: t- M. V, i3 e( c" E
3.   /* 检测是否是有效句柄 */
   * B- M( l. s2 B- o9 n( S# s
4.   if(htim == NULL)
   
5.   {
   
6.     return HAL_ERROR;
   
7.   }
   
8. 
   2 V5 @- }' d$ _/ K- G) z
9.   /* 检测参数 */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    . @" `+ _2 \$ ]
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    1 ]. E$ K+ A0 Z, o
13. 
    3 s4 D: w5 d" Z/ R7 b
14.   if(htim->State == HAL_TIM_STATE_RESET)
    
15.   {
    7 D% C( j/ H  Q' a! ]& O) E$ `
16.     /* 默认取消锁 */
    
17.     htim->Lock = HAL_UNLOCKED;
    * {" U. m, c6 \7 H4 W9 O; H
18.     /* 初始化底层硬件 : GPIO, CLOCK, NVIC */
    
19.     HAL_TIM_Base_MspInit(htim);
    
20.   }
    * N' |9 |* U* N# l
21. 
    
22.   /* 设置TIM状态 */
    ! l: \( |; g2 ~" g5 E* [
23.   htim->State= HAL_TIM_STATE_BUSY;
    
24. 
    
25.   /* 基本参数配置 */
    
26.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    # i, e& {( x" Y) r5 c2 i# i2 k1 ]$ t
27. 
    - s) s/ r. O( i; a6 M$ u
28.   /* 设置TIM就绪 */
    
29.   htim->State= HAL_TIM_STATE_READY;
    
30. 
    " Q. L0 I* _/ S) }0 ^$ r
31.   return HAL_OK;
    ' w6 A0 g* p7 v4 t2 Z! T: Y
32. }

复制代码

函数描述：

此函数用于初始化定时器用于PWM。

+ G  q# Z6 f, ~9 h+ [; I- h函数参数：
- ], T7 u! z. ^4 P! M
$ b9 y. L$ n; P  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：

函数HAL_TIM_Base_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
& c5 G( l# }( g6 I8 x+ w, a/ d9 D5 H如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
! F' d3 {* u( F2 `2 a5 C- V& B对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_TIM_STATE_RESET  = 0x00U。
  p/ L" N2 ]) s- g& O. _
1 U" |$ G, x3 }7 e8 C解决办法有三：

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

; V* o" T* L! D5 g0 b方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

方法3：下面的方法
5 a. H( x7 z1 W/ C
! i! Z6 s3 j: Z- Y# a! l

1. if(HAL_TIM_Base_DeInit(&TimHandle) != HAL_OK)
   , ?2 a# k% b# p+ V4 i2 l' E+ f
2. {
   
3.     Error_Handler();
   4 r. p& H: N8 g( x  i, Z% a2 T
4. }  
   " ?+ r( s) [8 I0 b! s
5. if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
   ' ]: V/ B& a% ?3 {; \- X
6. {
   
7.     Error_Handler();
   
8. }

复制代码

使用举例：
; }  m! h( {4 [* _, [

1. TIM_HandleTypeDef   TimHandle = {0};
   
2. 
   ) Y3 p4 E0 z  e+ x3 M
3. /*
   
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   0 N5 g1 E5 d) r8 `& `. p, \
5. */
   
6. TimHandle.Instance = TIMx;
   
7. TimHandle.Init.Prescaler         = usPrescaler;
   3 ?7 Y- {/ B6 O( W: ~: M& I# |
8. TimHandle.Init.Period            = usPeriod;        
   6 h4 t6 l* }3 D9 L/ R) [' J
9. TimHandle.Init.ClockDivision     = 0;
   
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    1 V+ ~. @; ~2 v6 Y9 \" O
11. TimHandle.Init.RepetitionCounter = 0;
    
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    ) X5 r/ N7 V1 ^8 D/ B
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    7 B, V0 l9 N: E/ w9 Z: K
14. {
    
15.         Error_Handler(__FILE__, __LINE__);
    
16. }

复制代码

7 k5 @, l# }) D% i5 [, X32.4.2 函数HAL_TIM_Base_Start
函数原型：

  v# a" v( |. q: i% C1 [/ h' M3 a

1. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   
2. {
   ( }+ |! w1 @1 h5 m6 g2 q; }
3.   /* 检测参数状态 */
   
4.   assert_param(IS_TIM_INSTANCE(htim->Instance));
   
5. 
   
6.   /* 设置定时器状态 */
   
7.   htim->State= HAL_TIM_STATE_BUSY;
   " S2 [" H+ v, h/ B0 X; b
8. 
   ) o! e& K/ y" Q' @* ~/ e' z8 u& k& p
9.   /* 使能定时器 */
   
10.   __HAL_TIM_ENABLE(htim);
    
11. 
    
12.   /* 设置定时器状态 */
    
13.   htim->State= HAL_TIM_STATE_READY;
    
14. 
    
15.   /* 返回HAL_OK */
    
16.   return HAL_OK;
    ) U1 x9 t) U) N1 J' ~
17. }

复制代码

' C' u) ?) }1 S! W函数描述：
1 G5 a5 f4 w5 Y
2 r' i) G  n* W: H; h% j此函数比较简单，调用函数HAL_TIM_Base_Init配置了基础功能后，启动定时器。
! R' n* W  l: K
' N, {4 G- a4 {! J函数参数：

! J4 s. k, H# f& Z" i& z( X  第1个参数是TIM_HandleTypeDef类型结构体指针变量。
  返回值，固定返回HAL_OK，表示初始化成功。
. V/ u* H8 I  O/ x* k使用举例：

# S! l# P" Z" u% G

1. TIM_HandleTypeDef   TimHandle = {0};
     ~" z/ T! F  J9 p3 x1 j* _/ Z
2. 
   , y+ s( `# C! e  U+ k# ~
3. /*
   * A7 M: w, H2 p% ~3 i( |1 d
4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
   
5. */
   
6. TimHandle.Instance = TIMx;
   " v5 I; I/ x2 F: m+ H
7. TimHandle.Init.Prescaler         = usPrescaler;
   * @# [& _$ k! O. `- W- Q  ^" ~/ z
8. TimHandle.Init.Period            = usPeriod;        
   : S: u6 i2 b& x
9. TimHandle.Init.ClockDivision     = 0;
   
10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    ! H: [8 J7 J7 L+ C2 q  p
11. TimHandle.Init.RepetitionCounter = 0;
    
12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    ' s0 p: [; ^$ `7 S: J0 ]
13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    
14. {
    9 F' ?" n7 W2 N8 E9 Q- P
15.         Error_Handler(__FILE__, __LINE__);
    
16. }
      a4 h0 o* g1 M/ Z0 z
17. 
    ' t* d- E9 A+ p; t/ i
18. /* 启动定时器 */
    
19. if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
    
20. {
    + _9 U4 b# @% u2 M
21. Error_Handler(__FILE__, __LINE__);
    ! H3 \( R: ?3 v$ `  j) b) M! o! T
22. }

复制代码

32.4.3 函数HAL_TIM_PWM_Init
函数原型：
5 [% Z2 m0 B- D: @% j

1. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
   
2. {
   
3.   /* 检查句柄是否有效 */
   
4.   if(htim == NULL)
   
5.   {
   
6.     return HAL_ERROR;
   ) M7 m; [1 W4 m
7.   }
   5 [9 i& l1 |" ]9 k( {
8. 
   
9.   /* 检测参数 */
   8 R# F; X  m- S5 d6 Q6 L2 \
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    0 G4 A. _5 {0 v7 [" m* r5 z/ A
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
13. 
    0 ]: p3 u" A* |% b  |1 p  ]3 c1 e
14.   if(htim->State == HAL_TIM_STATE_RESET)
    
15.   {
    1 H' a) k+ X6 c$ S
16.     /* 默认取消锁 */
    
17.     htim->Lock = HAL_UNLOCKED;
    
18. 
    
19.     /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_PWM_MspInit(htim);
    3 w! j3 H- \' n5 L* c0 i0 d9 f* s5 k
21.   }
    
22. 
    9 z' `5 J! k; B9 J
23.   /* 设置定时状态 */
    ' P, X6 g; s7 i# P/ [
24.   htim->State= HAL_TIM_STATE_BUSY;
    
25. 
    $ q' H6 E2 O* [8 p6 O( |2 b
26.   /* 配置定时器用于PWM */  
    
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    ) B+ ?" }$ @# l
28. 
    8 O/ P! O' C* N7 L* t
29.   /* 设置定时器状态 */
    
30.   htim->State= HAL_TIM_STATE_READY;
    3 v0 u$ _' E- ~2 L
31. 
    
32.   return HAL_OK;
    ; n( j3 y6 H, ]4 s8 _% U, D) {
33. }

复制代码

9 E0 z1 D7 ?$ p7 a函数描述：

# x) l8 a) Q, a8 n7 C; |; w8 n此函数用于初始化定时为PWM方式。

0 @0 K& S* S/ g" S) y函数参数：
* U& H; G3 N4 G8 m0 S2 ?# B, l
+ d, a6 u9 W- i9 K$ A% y* I1 _  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
3 |- z# N+ }. `  ^! b) [0 V  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
3 u3 z4 k1 E. F$ C  E/ q! {" ^  z注意事项：

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

解决办法有三：

/ G/ L- F3 K: H+ y方法1：用户自己初始定时器和涉及到的GPIO等。
4 H$ h% ?+ V6 w0 Q0 a( [0 `. H
4 c# x9 S9 x5 g* b% x方法2：定义TIM_HandleTypeDef TimHandle为全局变量。

方法3：下面的方法
& i" ~% v" @8 W# r0 X4 _' j
. ^* r- h" e% A/ ]5 M5 B+ i

1. if(HAL_TIM_PWM_DeInit(&TimHandle) != HAL_OK)
   8 P8 P9 L0 Z3 `4 r  o: O, q2 m
2. {
   
3.     Error_Handler();
   
4. }  
   : d! _& j/ G3 v+ ^0 }3 r
5. if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
   8 A: Y  B$ k1 \& j  X) B
6. {
   6 S7 |% |: A; F& f# C% _# P2 |
7.     Error_Handler();
   
8. }

复制代码

使用举例：
$ [( ?& W6 l3 h: D" P

1. TIM_HandleTypeDef  TimHandle = {0};
   ( J; x) E0 }; z5 L9 p- T
2. 
   
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   6 o) p' B2 x. @9 ]3 @, `
4. TimHandle.Instance = TIM1;
   
5. TimHandle.Init.Prescaler         = usPrescaler;
   # j0 U  X9 Z7 n$ F0 ?
6. TimHandle.Init.Period            = usPeriod;
   
7. TimHandle.Init.ClockDivision     = 0;
   
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   
9. TimHandle.Init.RepetitionCounter = 0;
   
10. TimHandle.Init.AutoReloadPreload = 0;
    " Q/ [' w5 v! t0 p, P
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    ' O$ x9 V6 w& T- a& o% k1 h0 ], ^9 w
12. {
      F/ I- W. H' \
13.     Error_Handler(__FILE__, __LINE__);
    ( S# x- a* n7 q5 I+ W) M7 U
14. }

复制代码

0 j$ m+ ~' j/ `32.4.4 函数HAL_TIM_PWM_ConfigChannel
函数原型：

$ M( ~& r) \4 H( l) k( [2 ~

1. HAL_StatusTypeDef HAL_TIM_PWM_ConfigChannel(TIM_HandleTypeDef *htim,
   7 R: W1 N& U: o) A4 n
2.                                             TIM_OC_InitTypeDef* sConfig,
   * W! p9 D/ s" O6 B0 \0 G
3.                                             uint32_t Channel)
   6 j2 b. D1 a5 E5 {+ v5 W
4. {
   ; N* k5 {: ]9 }' \5 ?) `, U+ e
5.    /* 省略 */
   
6. 
   . P& ^6 [: {- `1 N5 v3 Z  ?$ q
7.   /* 开锁 */
   
8.   __HAL_LOCK(htim);
   , N0 m. `7 Q& k+ D( v8 w; J
9. 
   
10.   htim->State = HAL_TIM_STATE_BUSY;
    
11. 
    2 q1 F) {) R( L4 X4 s* ]& J
12.   switch (Channel)
    ; t3 s8 A- q4 m  i+ ]+ L
13.   {
    
14.     case TIM_CHANNEL_1:
    9 n, T. H8 D2 c$ o# U" T2 l6 u
15.     {
    " a0 v5 T4 F7 A$ \
16.       /* 检查参数 */
    
17.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    
18. 
    
19.       /* 配置通道1的PWM模式 */
    
20.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    
21. 
    
22.       /*预装载使能，更新事件产生时写入有效 */
    / J( E* l0 m% w2 y7 Z# b. J
23.       htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;
    
24. 
    
25.       /* 配置是快速输出模式 */
    % c3 U' H# p+ j6 W/ J0 X# K: x: K9 i
26.       htim->Instance->CCMR1 &= ~TIM_CCMR1_OC1FE;
    ) W* J: f2 P& p& k) f7 r- U4 ~
27.       htim->Instance->CCMR1 |= sConfig->OCFastMode;
    
28.     }
    
29.     break;
    ) A% n4 K% |" {/ j1 w
30. 
    6 m& G# ?3 s+ `" {" ?3 S; @' s
31.     case TIM_CHANNEL_2:
    
32.     {
    
33.        /* 省略 */
    ! u8 p9 m6 p  u* g" p: R$ l
34.     }
    ! I4 U: k4 ]( ]7 e4 h% s( s; R0 _& c
35.     break;
    - D5 q7 T; b5 q, R3 o: D  C
36. 
    % v# {. N/ K4 L! g% }
37.     case TIM_CHANNEL_3:
    
38.     {
    7 K# Z6 h) U0 V8 w7 @
39.        /* 省略 */
    * O; g0 }' D0 u2 ~1 {# \
40.     }
    
41.     break;
    
42. 
    
43.     case TIM_CHANNEL_4:
    6 C' {9 h& V( l) A+ [
44.     {
    
45.       /* 省略 */
    
46.     }
    ' m) o% G1 U; ~& N4 k
47.     break;
    : o( L6 |3 f  o! T4 V7 H5 U" {
48. 
    
49.     case TIM_CHANNEL_5:
    0 H' q" b, V5 r$ E7 k
50.     {
    
51.        /* 省略 */
    
52.     }
    
53.     break;
    
54. 
    / [, B: z" Z; }( ?) ~; D
55.     case TIM_CHANNEL_6:
    3 i' s7 _, @* {7 A
56.     {
    $ l7 e5 a' Q( W4 O7 v! l. c# u
57.         /* 省略 */
    0 U+ }/ S0 k0 I' N( U4 x* B
58.     }
      a% o" T- ^  Y/ h# ?
59.     break;
    
60. 
    
61.     default:
    4 n2 G% N8 T7 T& ^  x
62.     break;
    3 K, D: C9 _2 {) n2 l
63.   }
    
64. 
    6 J/ `7 y0 l  |
65.   htim->State = HAL_TIM_STATE_READY;
    
66. 
    
67.   /* 关锁 */
    , e* L3 i# o/ N) B" e8 k# I" ?
68.   __HAL_UNLOCK(htim);
    $ B3 Z) @" f5 O1 N' N! K+ |+ ?0 ~
69. 
    
70.   return HAL_OK;
    : Z* t+ j: X2 K) `1 _" h4 C( j
71. }

复制代码

函数描述：

此函数用于配置定时器的PWM通道。
3 j! S2 b  W- z# Y; T1 H
6 F/ h! g7 T  e$ y4 X* q# B, Y. n函数参数：
; w3 ^. p* d7 S4 b6 Q5 S
  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
3 q  e. v, A  O( x( _  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
* f) V! q8 h- L. W/ ZTIM_CHANNEL_1
! e7 F4 W2 I9 `. J/ M$ g; Q) W3 S
0 r1 v7 p  Y$ l6 ZTIM_CHANNEL_2
6 z0 m8 j/ {! y1 L& g6 {" l
2 P- j2 N. C4 n% l" ^TIM_CHANNEL_3
4 W& l: e$ [8 Z! t- Y' X
& K0 p  o( k: z. T2 G2 ^TIM_CHANNEL_4
% U3 ^* ~/ d' a
TIM_CHANNEL_5

TIM_CHANNEL_6

  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
) M; g# i. p( @5 L9 Q使用举例：

+ K( w2 b2 [6 e+ ], X# P+ M; C

1. TIM_HandleTypeDef  TimHandle = {0};
   
2. 
   - Q( e9 |( t5 u
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   
4. TimHandle.Instance = TIM1;
   6 r" s$ S* B2 g+ ^( ?+ k. D
5. TimHandle.Init.Prescaler         = usPrescaler;
   
6. TimHandle.Init.Period            = usPeriod;
   3 n* O0 D& o( \/ Z& C% k
7. TimHandle.Init.ClockDivision     = 0;
   
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   
9. TimHandle.Init.RepetitionCounter = 0;
   " _6 m9 V) L1 J& o1 M! Y# x
10. TimHandle.Init.AutoReloadPreload = 0;
    . d. j% F2 c2 O0 `, [9 V9 g
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    6 z8 P( O# t$ i$ s  F
12. {
    " B: Z- L  Z% ^1 Y
13.     Error_Handler(__FILE__, __LINE__);
    
14. }
    
15. 
    
16. /* 配置定时器PWM输出通道 */
    
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
      ]6 i, P2 l( D$ u
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    , D) P; _' q- U0 w: T4 z
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
    
23. 
    : H2 p( }7 @$ ]4 V+ n0 j7 T8 D
24. /* 占空比 */
    
25. sConfig.Pulse = pulse;
    
26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    / Y- a6 \2 u+ k, p9 K3 a
27. {
    
28.     Error_Handler(__FILE__, __LINE__);
    
29. }

复制代码

32.4.5 函数HAL_TIM_PWM_Start
/ K2 z5 Z$ ]% {, \- y* [3 T函数原型：

1. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
   / H1 M  X2 T$ F
2. {
   
3.   /* 检测参数 */
   
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
     U$ \8 U1 V+ h7 p" f% ?. N' X
5. 
   % {" ~4 g( e* K2 p. k
6.   /* 使能捕获比较通道 */
   2 e) [, o( c, p" H3 \* W5 x
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
8. 
   ; j8 o* K& s; ~
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
   
10.   {
    
11.     /* 使能主输出 */
    
12.     __HAL_TIM_MOE_ENABLE(htim);
    & m+ [" |6 u+ r2 x
13.   }
      d, W0 h  d% o2 b  R9 j5 Q
14. 
    % o  g" v: d0 ?. @
15.   /* 使能定时器 */
    ( v5 o8 ^. c" R9 N) T
16.   __HAL_TIM_ENABLE(htim);
    0 ~. M& h+ h0 A& p9 V
17. 
    ( M6 R9 H, j6 ^% d* T' f* H1 M
18.   /* 返回状态*/
    
19.   return HAL_OK;
    & I* p. U4 e5 J; e' q, Z' ?
20. }

复制代码

3 M0 W/ L# c% P) q函数描述：

. `4 z+ Q% ]1 o7 ]$ R+ h此函数用于启动PWM。
7 l$ C) u: T( a$ S
函数参数：
+ o6 y6 J. z( c/ m0 A
% G. B) b1 G8 Z" B, b& A2 Q2 T  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  第2个参数是通道设置，支持以下参数：
TIM_CHANNEL_1
4 b) q, |! M8 }! C. m
TIM_CHANNEL_2

TIM_CHANNEL_3
$ x. Q, @, }/ v/ |" U1 }
TIM_CHANNEL_4
. L& m' f' [. t: F1 W7 ?; y+ ], B
. C* \# t$ [+ L6 K+ K- Z  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
! ]0 v1 B0 e- M/ k8 `8 w1 B1 j! r使用举例：

1. TIM_HandleTypeDef  TimHandle = {0};
   2 i8 W; g4 x( a# Z
2. 
   
3. /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
   
4. TimHandle.Instance = TIM1;
   " t, q/ g" }) f, I
5. TimHandle.Init.Prescaler         = usPrescaler;
   
6. TimHandle.Init.Period            = usPeriod;
     f  J) a4 A! |% x( A: Q% f0 V9 R5 n
7. TimHandle.Init.ClockDivision     = 0;
   9 P' z) g) I4 U4 w: p8 x
8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
   6 e+ r% p. O, k4 M; s
9. TimHandle.Init.RepetitionCounter = 0;
   8 B! _% w3 a) Q
10. TimHandle.Init.AutoReloadPreload = 0;
    9 h2 |% m0 S  D. p! d
11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    8 q' p' s" |# k+ s0 }8 W1 ?  Y0 Z
12. {
    8 X7 S$ y0 X' U: X: s8 q
13.     Error_Handler(__FILE__, __LINE__);
    , q2 ?. I% W1 |
14. }
    $ |5 ~- a& c! T, a0 O0 @
15. 
    % V  _! j& a' @3 P7 Z# T2 [
16. /* 配置定时器PWM输出通道 */
    
17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    7 _/ A' q  j+ \+ D- ?9 e2 l& l/ L4 b; x. b
18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    / q8 z1 k# c2 s7 [' O8 Y: g
19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    
20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    
21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    2 n! E  @* @- O2 V
22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
    
23. 
    
24. /* 占空比 */
    2 M% `1 ?: x# [$ C
25. sConfig.Pulse = pulse;
    0 @. ]# f) ^& U; D" f7 Y. v# k9 Y
26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    
27. {
    , a# v' m9 Q' ^' D$ a
28.     Error_Handler(__FILE__, __LINE__);
    
29. }
    
30. 
    
31. /* 启动PWM输出 */
    % @0 u6 b) N3 L0 M
32. if (HAL_TIM_PWM_Start(&TimHandle, TimChannel[_ucChannel]) != HAL_OK)
    
33. {
    " D! Z) x9 s5 F  k8 X. w
34.         Error_Handler(__FILE__, __LINE__);
    1 g/ N5 ]. W6 b' z, E% G6 N
35. }

复制代码

32.4.6 函数HAL_TIM_IC_Init
函数原型：
+ u) G% \, s) m5 T
! S. L9 c, v: n+ }- U

1. HAL_StatusTypeDef HAL_TIM_IC_Init(TIM_HandleTypeDef *htim)
   + `6 p1 n. W$ ]% C
2. {
   ; R3 l. V- @3 e5 m' g
3.   /* 检测形参是否有效 */
   
4.   if(htim == NULL)
   3 Q* a  T9 A" {* C) ^& B2 k  q" x
5.   {
   
6.     return HAL_ERROR;
   4 r. M. \9 ]7 F# G0 O5 z
7.   }
   
8. 
   
9.   /* 检测参数 */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    2 _9 y  {7 i% S; k( e- d- l& R0 r
12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
13. 
    0 u0 a" z/ n  I$ f
14.   if(htim->State == HAL_TIM_STATE_RESET)
    
15.   {
    0 o) _# Z1 h) Y/ Q) i
16. /* 默认取消锁 */
    2 I5 Z- g3 ^$ K$ _) u: T
17.     htim->Lock = HAL_UNLOCKED;
    
18. 
    4 n4 @8 e5 x: H. S; s' A8 \8 s/ Y
19.      /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    
20.     HAL_TIM_IC_MspInit(htim);
    ( C* ^5 |% j& n
21.   }
    
22. 
    
23.   /* 设置定时器状态 */
    ) v0 B' I- s2 ^9 u
24.   htim->State= HAL_TIM_STATE_BUSY;
    ; P+ w& `# Q2 [; D" v- G
25. 
    
26.   /* 配置定时器为输入捕获模式 */  
    $ m8 h; ^& @! W' ~1 L% ^' [+ D9 I
27.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    ! [. P- R: ]. o, b! |* }
28. 
    
29.   /* 设置定时器状态 */
    
30.   htim->State= HAL_TIM_STATE_READY;
    $ t/ I* ]$ e) y4 ?
31. 
    
32.   return HAL_OK;
    8 C+ u) P) Q/ ~9 a- }0 G
33. }

复制代码

函数描述：

; n4 D9 W! ]# e1 e# r此函数用于定时器输入捕获初始化。
9 o9 n  F3 W( ^- F
函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：
1 y4 [: a3 x9 Q! F) ?
函数HAL_TIM_IC_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
2 z* k! ~: Z1 v' A. Z8 M如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
; C# N! q, J8 m; B2 z$ v+ F9 }对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个HAL_TIM_STATE_RESET  = 0x00U。
3 B6 ]& c% h1 `, s
解决办法有三：
3 t5 ^6 Q7 N) H# E! x0 y, {
' q2 g3 v) H# n方法1：用户自己初始定时器和涉及到的GPIO等。

9 f5 I! Q8 N: \$ G+ }! T' Y方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
( d8 X, l2 b% W* f
& A7 Q- ]/ E& G/ h% c0 l; f方法3；下面的方法
& f  I! V: E: u$ m- F
# |1 T# `# d- b: w) L6 F: o/ d- x

1. if(HAL_TIM_IC_DeInit(&UartHandle) != HAL_OK)
   ; w# G. k) u1 h6 N$ _
2. {
   % Y+ X" X0 Z; o6 K$ x/ \/ L
3.     Error_Handler();
   , y2 m4 g, c8 l0 r7 j
4. }  
   
5. if(HAL_TIM_IC_Init(&UartHandle) != HAL_OK)
   . ~! O! [$ s5 ~) h+ o: Y# t
6. {
   
7.     Error_Handler();
   
8. }

复制代码

32.4.7 函数HAL_TIM_IC_ConfigChannel
函数原型：
- e& H, H. W, t" H% i/ ^

1. HAL_StatusTypeDef HAL_TIM_IC_ConfigChannel(TIM_HandleTypeDef *htim, TIM_IC_InitTypeDef* sConfig, uint32_t Channel)
   8 _% H# L! j- }' o. W# N
2. {
   
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
   
5.   assert_param(IS_TIM_IC_POLARITY(sConfig->ICPolarity));
   / I( o& B( a( I/ P  B1 M& U* J
6.   assert_param(IS_TIM_IC_SELECTION(sConfig->ICSelection));
   
7.   assert_param(IS_TIM_IC_PRESCALER(sConfig->ICPrescaler));
   
8.   assert_param(IS_TIM_IC_FILTER(sConfig->ICFilter));
   
9. 
   
10.   /* 开锁 */  
    2 v4 C! q  Y( g: i8 T/ U
11.   __HAL_LOCK(htim);
    
12. 
    3 U% i0 }% _3 u; R# k5 n
13.   htim->State = HAL_TIM_STATE_BUSY;
    
14. 
    $ M2 r# Y1 x; \, f, t9 |
15.   if (Channel == TIM_CHANNEL_1)
    
16.   {
    . D  R# X& ^" H
17.     /* 配置输入通道1 */
    : _  f1 q) n2 v
18.     TIM_TI1_SetConfig(htim->Instance,
    
19.                sConfig->ICPolarity,
    # l7 Q4 z! K& r9 O9 x* c5 z8 b
20.                sConfig->ICSelection,
    1 Q0 [8 c% g# A3 ~
21.                sConfig->ICFilter);
    - o+ s( }% ?' m$ e
22. 
    
23.     /* 清零IC1PSC位 */
    0 N& D& e* P+ ~' |8 s+ l( g
24.     htim->Instance->CCMR1 &= ~TIM_CCMR1_IC1PSC;
    & q2 Q- E( G4 J( X4 B
25. 
    9 U5 e/ P+ T) _7 I
26.     /* 根据用户配置，设置分频 */
    ! Z( i$ y% H4 H' b7 n
27.     htim->Instance->CCMR1 |= sConfig->ICPrescaler;
    : G! ~( p& _8 l. D
28.   }
    
29.   else if (Channel == TIM_CHANNEL_2)
    1 W/ R5 Z: t( H* e, ]. X
30.   {
    ' O: K3 u3 b- X6 A6 O. o* N4 G5 D
31. /* 省略 */
    
32.   }
    6 ~6 _, h7 @7 [0 s6 ?8 X" ?) F
33.   else if (Channel == TIM_CHANNEL_3)
    
34.   {
    # [4 c* [) a, Z0 ]$ \
35.      /* 省略 */
    
36.   }
    0 {/ J2 `2 b$ F, Y. ?
37.   else
    
38.   {
    ) I' ?/ N% u: `4 H/ m! m; K  j
39.      /* 省略 */
    0 G( [$ v" Y: }% L6 z! T( J
40.   }
    ' r$ s1 j1 x& j# ^
41. 
    6 C  d- |" p7 K7 v. l# ^
42.   htim->State = HAL_TIM_STATE_READY;
    / h- g& \# I1 p' R
43. 
    " g3 L4 B  v- r) P8 i
44.   __HAL_UNLOCK(htim);
    . _3 f* F3 f1 L8 f; x. l/ p; @0 N8 j
45. 
    0 C# r* E) b! |- W" d' B
46.   return HAL_OK;
    
47. }

复制代码

函数描述：
& ^5 |8 B" x- Q2 u
" e. w; Q% l4 A! _此函数用于配置定时器的输入捕获通道。
6 V- n7 n  |, T& J* @
函数参数：

3 U6 B3 g/ z3 B. [  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置
  第2个参数是TIM_IC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
! z& C3 q. T5 e! G; e" n8 k  第3个参数是通道设置，支持以下参数：
TIM_CHANNEL_1
8 T* F, n. d. X* s( a
* d( V' ]' P+ p# }TIM_CHANNEL_2

TIM_CHANNEL_3

TIM_CHANNEL_4

% @/ ^8 d( e& i1 ~  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
3 x# G* {# B7 q# X& {4 P0 ~
. J$ O  K; u  _! b8 S3 e32.4.8 函数HAL_TIM_IC_Start_IT
8 g3 K& Z$ i8 Z' U& u4 S; I函数原型：
0 n9 `1 d4 h) `) z1 |: p  r2 D

1. HAL_StatusTypeDef HAL_TIM_IC_Start_IT (TIM_HandleTypeDef *htim, uint32_t Channel)
   ' S' ?+ ], d* j
2. {
   . f" {- E  ]+ a5 J3 {! P0 J
3.   /* 检查参数 */
   
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   : W5 Z5 v. p- G5 g) T) Z: }  o
5. 
   & f# |' g% V. R/ @8 b
6.   switch (Channel)
   ; S) I  b# w* H
7.   {
   3 o* |& {0 N, A3 Z: @( c
8.     case TIM_CHANNEL_1:
   
9.     {      
   ; _" v$ P' w4 _& g
10.       /* 使能CC1（Capture/Compare 1）中断 */
    
11.       __HAL_TIM_ENABLE_IT(htim, TIM_IT_CC1);
    0 G+ L$ l9 h0 a/ Y9 w- N  i
12.     }
    
13.     break;
    
14. 
    7 C! D2 F. I# m0 Q
15.     case TIM_CHANNEL_2:
    2 C/ W4 [/ ?" ?2 N4 ~6 K* c
16.     {
    % ^# A9 Z+ O7 G: s% G, t
17.    /* 省略 */
    - P) k- X7 V+ {- ]. y- J2 `3 |& E1 S7 y/ F
18.     }
    
19.     break;
    2 @2 M# T& N9 }
20. 
    4 [1 ^- `1 C$ S4 `8 s
21.     case TIM_CHANNEL_3:
    " m* I9 B9 u/ M
22.     {
    
23.   /* 省略 */
    
24.     }
    
25.     break;
    
26. 
    
27.     case TIM_CHANNEL_4:
    * y: b( [9 r* A5 C6 N% a! I
28.     {
    . w" c9 a" g; [( y2 S  G* R+ t% W. z
29.   /* 省略 */
    
30.     }
    
31.     break;
    8 O/ U- x( v7 l( s" |. |
32. 
    
33.     default:
    
34.     break;
    
35.   }  
    
36.   /* 使能输入捕获通道 */
    
37.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
38. 
    ) x/ h  F# E4 X7 j2 U- l2 ]
39.   /* 使能定时器 */
    ) q' j3 c1 W  `) {3 m% M% m/ p
40.   __HAL_TIM_ENABLE(htim);  
    + S. P0 Z6 Q; O5 m  Y
41. 
    + H7 y7 x' m* P) j
42.   /* 返回状态 */
    
43.   return HAL_OK;  
    , Y' d" C; l( g' y. Y
44. }

复制代码

函数描述：

此函数用于启动定时器输入捕获模式，采用定时器方式。

函数参数：
3 \/ Q" K" V7 P# w% c
8 z7 y& ~# p8 s5 c8 n! z6 Y  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
* g# ]  z2 x2 t/ d! L, q/ S  第2个参数是通道设置，支持以下参数：
TIM_CHANNEL_1

( r. D/ }, g- D- xTIM_CHANNEL_2
4 O) n& Z8 `0 F- [
TIM_CHANNEL_3

TIM_CHANNEL_4

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

32.4.9 函数HAL_TIM_OC_Init
" r: q0 E1 U0 a2 K2 B函数原型：

: _2 l/ W' {& z8 h4 Z4 U4 N

1. HAL_StatusTypeDef HAL_TIM_OC_Init(TIM_HandleTypeDef* htim)
   
2. {
   * I5 H0 b4 U4 h
3.   /* 检测形参是否有效 Check */
   
4.   if(htim == NULL)
   ; w6 x" u/ [+ d4 o, G' k  S
5.   {
   : R4 E$ G7 z: L- m. f0 f5 {
6.     return HAL_ERROR;
   - h* _+ G0 I+ M( f, p+ X
7.   }
   
8. 
   . T( r4 L) d  [1 Y
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));
    # q& P4 ~0 G$ J; J
13. 
    
14.   if(htim->State == HAL_TIM_STATE_RESET)
    
15.   {
    
16. /* 默认取消锁 */
    2 N  _/ ~: c! z. M* S
17.     htim->Lock = HAL_UNLOCKED;
    9 \6 C& @6 s. Q8 L2 |' m
18. 
    & D; V9 F8 _+ O  W8 j
19. /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    3 D: K5 Q$ u9 h  m1 P
20.     HAL_TIM_OC_MspInit(htim);
    
21.   }
    3 m- p+ n" ^  [/ u4 S" i; n8 c  I
22. 
    8 y3 d' R/ N9 d$ k$ D/ H
23.   /* 设置定时器状态Set the TIM state */
    
24.   htim->State= HAL_TIM_STATE_BUSY;
    ) q  V+ h: ?( G
25. 
    # }+ J. A1 ]% K% G
26.   /* 配置定时器为输出比较模式Init the base time for the Output Compare */  
    $ C! \6 h+ N% V" Y
27.   TIM_Base_SetConfig(htim->Instance,  &htim->Init);
    
28. 
    . t2 W4 @+ A- m
29.   /* 设置定时器状态 */
    
30.   htim->State= HAL_TIM_STATE_READY;
    
31. 
    
32.   return HAL_OK;
    
33. }

复制代码

: i9 B8 H4 o! I函数描述：
* q  n) @4 V  V# V- C: ?) |! S
+ F1 T9 y7 R% a0 C: g8 j! l; b此函数用于定时器输出比较初始化。

函数参数：

' w6 J( M7 y, K0 I! k2 M! s, Q  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
% p7 S$ z4 I# M1 k& `3 y  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：

/ C% s; u2 ]: K, E函数HAL_TIM_OC_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
* J# q( Y/ k* t+ A7 n) [如果形参htim的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
- A4 ~( W" ^8 B0 T对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个HAL_TIM_STATE_RESET  = 0x00U。

解决办法有三：

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

& f( k" M* k/ v: c% z' t2 b& u: Q方法2：定义TIM_HandleTypeDef TimHandle为全局变量。
0 s! S) f* a8 h$ @2 a5 i
方法3；下面的方法
& x0 o1 z3 t$ I. _1 ?# @/ X
4 N# x  D, g; p7 Q1 J3 q3 Z

1. if(HAL_TIM_OC_DeInit(&UartHandle) != HAL_OK)
   3 P2 ~! X  _% Z) K) l' K
2. {
   - M% s) j/ B9 x$ E3 L+ ^
3.     Error_Handler();
   
4. }  
   
5. if(HAL_TIM_OC_Init(&UartHandle) != HAL_OK)
   " M' |/ m$ L, e% b2 t" U4 ]
6. {
   
7.     Error_Handler();
   9 G/ A! W9 Q4 m( |1 C! S
8. }

复制代码

: }2 c- A' q! f$ h3 t; w* i0 [7 v& @32.4.10   函数HAL_TIM_OC_ConfigChannel
) p" E& P5 f. q9 ]函数原型：
+ K1 D2 v1 b9 K' g

1. HAL_StatusTypeDef HAL_TIM_OC_ConfigChannel(TIM_HandleTypeDef *htim,
   & z  m9 G6 w/ S/ @6 o' p
2.                                            TIM_OC_InitTypeDef* sConfig,
   
3.                                            uint32_t Channel)
   
4. {  
   
5.   /* Check the parameters */
   
6.   assert_param(IS_TIM_CHANNELS(Channel));
   
7.   assert_param(IS_TIM_OC_MODE(sConfig->OCMode));
   - \2 v4 O$ v& v! Y* S/ R
8.   assert_param(IS_TIM_OC_POLARITY(sConfig->OCPolarity));
   
9. 
   # |9 F4 {! A; C4 ~5 k, P* X
10.   /* Process Locked */
    . S7 m' a- `  R8 Y
11.   __HAL_LOCK(htim);
    
12. 
    
13.   htim->State = HAL_TIM_STATE_BUSY;
    ) J4 q( @5 E! J( ]* ?6 Y
14. 
    
15.   switch (Channel)
    
16.   {
    
17.     case TIM_CHANNEL_1:
    
18.     {
    
19.       /* 检测参数Check the parameters */
    
20.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    " O  k% j& [4 Z9 ^2 n
21. 
    9 T9 v& s/ f8 e* |0 W; `
22.      /* 配置定时器输出比较通道1 */
    6 @% i8 S" g/ z6 ^9 n9 s' g5 a: Z2 S
23.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    
24.     }
    3 J. ]! Q' d' u* q
25.     break;
    
26. 
    7 ~' _' Y' j8 ^  t- u) o' l
27.     case TIM_CHANNEL_2:
    ) Q+ l& o( i0 @, j/ [3 W( z
28.     {
    
29.       /* 省略 */
    
30.     }
    & i% J, _4 A' o! i  O( F
31.     break;
    
32. 
    ' F! m6 H9 I. R8 |
33.     case TIM_CHANNEL_3:
    
34.     {
      E# D- R( _# r- a( _: d3 e
35.       /* 省略 */
    $ v  M' |, @$ o& [, A
36.     }
    / W) ^$ L" @8 L4 M2 {- K
37.     break;
    
38. 
    
39.     case TIM_CHANNEL_4:
    * n0 _" D0 H7 T. L" d. U1 }
40.     {
    1 a4 c9 B; x# X% c9 @: \
41.       /* 省略 */
    
42.     }
    5 [. r1 l, o  x6 H2 W/ o2 e
43.     break;
    1 i) @% u( y! P/ i+ c0 [& |/ ?) L! K
44. 
    
45.     case TIM_CHANNEL_5:
    
46.     {
    ; U  Q& e5 D5 L8 [5 X3 Y) s
47.       /* 省略 */
    
48.     }
    # U6 W4 ~) D/ b8 e: l; c2 n2 B
49.     break;
    + Q" z6 z( W8 T6 T6 M
50. 
    
51.     case TIM_CHANNEL_6:
    
52.     {
    
53.       /* 省略 */
    ( A" W$ K( c6 E/ T
54.     }
    * o6 k% Z7 T! U! d& s
55.     break;
    ; u4 m. x6 [* d9 L, S4 c
56. 
    - d) j- N1 ~1 a4 I
57.     default:
    + Y; ]8 j/ X2 Z
58.     break;   
    " p2 Q# D) r8 s; t& C* m
59.   }
    
60. 
    
61.   htim->State = HAL_TIM_STATE_READY;
    
62. 
    ) J. e- T9 K' _4 U# O7 }2 {2 x
63.   __HAL_UNLOCK(htim);
    
64. 
    ( Q* ?& T, o2 G4 k- F/ l0 j
65.   return HAL_OK;
    . v+ B; A) W, J3 @% Q
66. }

复制代码

: a* B/ D% |- ?' e" \函数描述：
0 r( n( g" k) f( [
+ [2 E  O# z4 r9 h此函数用于初始化串口的基础特性和高级特性。
/ ~9 |  |  c. y
函数参数：

( k3 {) L  q$ `9 A5 c3 b6 z& @0 b  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
( ~; |% y: M1 cTIM_CHANNEL_1
' [1 O% O( ~* j2 X0 b
- R: s5 o0 I' O5 c8 Y! U2 NTIM_CHANNEL_2
/ }# [" _& {8 q3 B$ _
TIM_CHANNEL_3

TIM_CHANNEL_4
( I( k( E( i! q# O* V/ S
TIM_CHANNEL_5

3 B0 f6 n5 w( v% mTIM_CHANNEL_6
) o" r% K0 X, v& U/ k) b" {
$ a: M. r& M7 a" V% @4 N  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
3 j& A7 W% P* L: T7 {( G
32.4.11   函数HAL_TIM_OC_Start
函数原型：

1. HAL_StatusTypeDef HAL_TIM_OC_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
   
2. {
   
3.   /* 检查参数 */
   ; r4 Z* b6 x, k9 }5 Z
4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
   
5. 
   ; q; _- P: g4 X0 s
6.   /* 使能输出比较通道 */
   6 t; K  w+ \$ h% p) h( T  a
7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
8. 
   - a3 J- I2 W! i
9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
   
10.   {
    ' S8 i$ s) n' K1 m, C4 g5 k
11.     /* 使能主输出 */
    
12.     __HAL_TIM_MOE_ENABLE(htim);
    
13.   }
    # K5 n% o7 b8 n4 Y! c, U
14. 
    
15.   /* 使能定时器 */
    1 h* q2 [0 C7 G) B% w7 x$ D: t
16.   __HAL_TIM_ENABLE(htim);
    
17. 
    
18.   /* 返回状态 */
    
19.   return HAL_OK;
    
20. }

复制代码

% y+ e. T% u, B函数描述：
4 H1 ]& t  b' _
此函数用于启动定时器输出比较模式。

# p% |" B/ ^0 @$ E0 }) t% \* `! ~函数参数：
! u% O! P! b; `
4 m, ~% w! G2 R5 J  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  第2个参数是通道设置，支持以下参数：
3 k8 t% m1 e/ a% p: g% rTIM_CHANNEL_1
: K- S3 ]+ @( }# ^/ \2 G1 q% U
TIM_CHANNEL_2

TIM_CHANNEL_3
6 A3 @9 U' ?* I8 [
7 g; J" S% k5 t) g; |) o. {- eTIM_CHANNEL_4
' b1 _% ^0 t0 p0 \% `* R! P
1 z& ?0 n9 R+ o  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
# W* g! \  A+ b. M8 `" p
32.5 总结
本章节就为大家讲解这么多，建议大家将GPIO的驱动源码结合参考手册中的寄存器通读一遍，对于我们后面章节的学习大有裨益。
5 @7 C. m0 N3 D5 {8 Y) l+ J

2 V& _1 o! a4 l( }' S6 V, z