【经验分享】STM32H7的TIM定时器基础知识和HAL库API

[复制链接]

STMCU小助手发布时间：2021-12-21 23:00

文章
文章封面:
文章简介:	STM32H7的TIM定时器基础知识和HAL库API

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

TIM1_BRK_IRQHandler
" N9 Y, y0 b' g& ]/ H
TIM1_UP_IRQHandler
/ K0 q- t6 @) O- i$ v
TIM1_TRG_COM_IRQHandler
. v& P% u' z) Z1 w* H
TIM1_CC_IRQHandler
7 V9 w* {! Y1 l$ Z; H) q: W
TIM2_IRQHandler
TIM3_IRQHandler - C+ ^; o% \, \. O
TIM4_IRQHandler : a. V7 B$ s" x, B7 d7 c9 f; E
TIM5_IRQHandler " Y' Z5 N7 I: e
TIM6_DAC_IRQHandler <------------------要注意
3 d+ ?7 K( C2 z% u6 v! } }
TIM7_IRQHandler & W% N1 f% ]! J% N5 x! p/ R, f
TIM8_BRK_TIM12_IRQHandler <------------------要注意，定时器12也是用的这个1 p% U1 W7 P. L' Y- X: k9 B# y# r' X
TIM8_UP_TIM13_IRQHandler <------------------要注意，定时器13也是用的这个
' Y& d* V8 M6 p- F! m' P7 g3 _
TIM8_TRG_COM_TIM14_IRQHandler <------------------要注意，定时器14也是用的这个$ f9 D9 D2 q5 G# ^' J
TIM8_CC_IRQHandler 3 \1 U/ s$ p0 W0 I) l
TIM15_IRQHandler & V a$ ^+ h5 V+ ]% }9 ]8 r
TIM16_IRQHandler ) ?4 }, {- y I# y* Q. W3 s
TIM17_IRQHandler

复制代码

32.2 定时器基础知识
注，不同定时支持的功能略有区别，基础定时器功能较少，TIM1和TIM8高级定时器功能多些。

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

– 输出比较。

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

– 单脉冲模式输出。

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

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

– 输入捕获

– 输出比较

  支持增量式编码器和霍尔传感器。
32.2.1 定时器TIM1-TIM17的区别
STM32H7支持的定时器有点多，要简单的区分下。STM32H7支持TIM1-TIM8，TIM12-TIM17共14个定时器，而中间的TIM9，TIM10，TIM11是不存在的，这点要注意。

粗略的比较如下：

aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png

通过上面的表格，至少要了解到以下两点：

STM32H7的定时器主要分为高级定时器，通用定时器，基础定时器和低功耗定时器。
TIM2和TIM5是32位定时器，其它都是16位定时器。

32.2.2 定时器的硬件框图
认识一个外设，最好的方式就是看他的框图，方便我们快速的了解定时器的基本功能，然后再看手册了解细节。

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

通过这个框图，我们可以得到如下信息：

TIMx_ETR接口
外部触发输入接口。ETR支持多种输入源：输入引脚（默认配置）、比较器输出和模拟看门狗。

  截图左侧的TIMx_CH1，TIMx_CH2，TIMx_CH3和TIMx_CH4接口
这四个通道主要用于输入捕获，可以计算波形频率和脉宽。

  TIMx_BKIN和TIMx_BKIN2接口
断路功能，主要用于保护由 TIM1 和 TIM8 定时器产生的 PWM 信号所驱动的功率开关

  TRGO内部输出通道
主要用于定时器级联，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没有互补输出。

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

32.2.3 定时器的时基单元
定时器要工作就需要一个基本时基单元，而基本的时基单元是由下面几个寄存器组成的：

  预分频器寄存器 (TIMx_PSC)
用于设置定时器的分频，比如定时器的主频是200MHz，通过此寄存器可以将其设置为100MHz，50MHz，25MHz等分频值。

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

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

  自动重载寄存器 (TIMx_ARR)
自动重装寄存器是CNT计数寄存器能达到的最大计数值，以递增计数模式为例，就是CNT计数器达到ARR寄存器数值时，重新从0开始计数。

注，自动重载寄存器是预装载的。对自动重载寄存器执行写入或读取操作时会访问预装载寄存器。预装载寄存器的内容既可以立即传送到影子寄存器（让设置立即起到效果的寄存器），也可以在每次发生更新事件时传送到影子寄存器。简单的说就是让ARR寄存器的数值立即更新还是更新事件发送的时候更新。

  重复计数器寄存器 (TIMx_RCR)
以递增计数模式为例，当CNT计数器数值达到ARR自动重载数值时，重复计数器的数值加1，重复次数达到TIMx_RCR+ 1后就，将生成更新事件。

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

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

32.2.4 定时器输出比较（PWM）
使用定时器时基单元的那几个寄存器仅仅能设置周期，还不能设置占空比。针对这个问题，还需要比较捕获寄存CCR的参与，这样就可以设置占空比了。

为了方便大家理解，以PWM 边沿对齐模式，递增计数配置为例：

  当计数器TIMx_CNT < 比较捕获寄存器TIMx_CCRx期间，PWM参考信号OCxREF输出高电平。
  当计数器TIMx_CNT >= 比较捕获寄存器TIMx_CCRx期间， PWM参考信号OCxREF输出低电平。
  当比较捕获寄存器TIMx_CCRx > 自动重载寄存器TIMx_ARR，OCxREF保持为1。
  当比较捕获寄存器TIMx_CCRx = 0，则OCxRef保持为0。
下面是TIMx_ARR=8的波形效果：

32.2.5 定时器输入捕获
与PWM一样，使用定时器实现输入捕获，仅靠时基单元的那几个寄存器是不行的，我们需要一个寄存器来记录发生捕获时的具体时间，这个寄存器依然由比较捕获寄存器TIMx_CCRx来实现。

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

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

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

32.3.1 定时器寄存器结构体TIM_TypeDef
定时器相关的寄存器是通过HAL库中的结构体TIM_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：

typedef struct
6 K; k9 Z& k8 |$ u/ F
{3 o: Y n0 V" h* t
__IO uint16_t CR1; /*!< TIM control register 1, Address offset: 0x00 */
4 Z+ I/ k' o/ U# K, {4 P1 G
uint16_t RESERVED0; /*!< Reserved, 0x02 */ M9 D' ?0 x5 X$ a
__IO uint32_t CR2; /*!< TIM control register 2, Address offset: 0x04 */
+ P) @9 [+ [8 G: K! }, g2 Q4 t" M
__IO uint32_t SMCR; /*!< TIM slave mode control register, Address offset: 0x08 */
# z1 l1 s- `0 P" u
__IO uint32_t DIER; /*!< TIM DMA/interrupt enable register, Address offset: 0x0C */5 w4 h4 s' _- A1 O% K+ _9 I- }
__IO uint32_t SR; /*!< TIM status register, Address offset: 0x10 */
8 O+ B% o5 B) f0 a2 |/ a
__IO uint32_t EGR; /*!< TIM event generation register, Address offset: 0x14 */
9 ?+ b. A; B5 `- |- X
__IO uint32_t CCMR1; /*!< TIM capture/compare mode register 1, Address offset: 0x18 */0 x% W. s$ z! s1 k9 S8 @3 T
__IO uint32_t CCMR2; /*!< TIM capture/compare mode register 2, Address offset: 0x1C */( E) k6 ^8 d2 H0 s7 {1 S
__IO uint32_t CCER; /*!< TIM capture/compare enable register, Address offset: 0x20 */
8 t K: t; R6 t0 V2 w# c: [3 _% N
__IO uint32_t CNT; /*!< TIM counter register, Address offset: 0x24 */# s: a ?- n- I1 m" _8 S
__IO uint16_t PSC; /*!< TIM prescaler, Address offset: 0x28 *// z$ f& H2 _# N1 b" q
uint16_t RESERVED9; /*!< Reserved, 0x2A */
! d: G2 P& i2 S( z0 P
__IO uint32_t ARR; /*!< TIM auto-reload register, Address offset: 0x2C */
/ s# }/ k$ S# [, t
__IO uint16_t RCR; /*!< TIM repetition counter register, Address offset: 0x30 */* L- p8 D& R/ S5 J) E$ I! q& {9 z& S
uint16_t RESERVED10; /*!< Reserved, 0x32 */9 g* x/ H$ `6 f# s. E- _0 b
__IO uint32_t CCR1; /*!< TIM capture/compare register 1, Address offset: 0x34 */3 K, f" h8 I3 U+ Q
__IO uint32_t CCR2; /*!< TIM capture/compare register 2, Address offset: 0x38 */
7 l) f" s9 K3 R# v! n8 r: g+ z
__IO uint32_t CCR3; /*!< TIM capture/compare register 3, Address offset: 0x3C */2 i4 Q% K6 @3 M. I& _* L9 A1 t
__IO uint32_t CCR4; /*!< TIM capture/compare register 4, Address offset: 0x40 */
0 l* b4 k9 j6 f/ U! G: l' W# ~% M
__IO uint32_t BDTR; /*!< TIM break and dead-time register, Address offset: 0x44 */
$ O; U/ C2 g6 m
__IO uint16_t DCR; /*!< TIM DMA control register, Address offset: 0x48 */ l. Y* O- F! _- t4 ~( {
uint16_t RESERVED12; /*!< Reserved, 0x4A */- U9 }5 {8 b+ G0 j) n9 r" f
__IO uint16_t DMAR; /*!< TIM DMA address for full transfer, Address offset: 0x4C */
0 u' r$ @7 H, u# l1 j
uint16_t RESERVED13; /*!< Reserved, 0x4E */4 y! _" @/ O; }3 q
uint16_t RESERVED14; /*!< Reserved, 0x50 */
2 m5 v. l% @0 C; n2 i. x
__IO uint32_t CCMR3; /*!< TIM capture/compare mode register 3, Address offset: 0x54 */' c, E3 }4 e% z3 @8 |4 d5 `
__IO uint32_t CCR5; /*!< TIM capture/compare register5, Address offset: 0x58 */
2 N# H- r! @" s" W/ j
__IO uint32_t CCR6; /*!< TIM capture/compare register6, Address offset: 0x5C */ y6 i0 g9 Q) b, k& c% s
__IO uint32_t AF1; /*!< TIM alternate function option register 1, Address offset: 0x60 */
4 q; S8 p/ H' T+ V
__IO uint32_t AF2; /*!< TIM alternate function option register 2, Address offset: 0x64 */
% y" k1 Y, t' X
__IO uint32_t TISEL; /*!< TIM Input Selection register, Address offset: 0x68 */6 ?# r: c/ E+ [5 b! r2 E- B+ T
} TIM_TypeDef;

复制代码

这个结构体的成员名称和排列次序和CPU的定时器寄存器是一一对应的。

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

#define __O volatile /*!< Defines 'write only' permissions */
1 [# @( {" t3 W
#define __IO volatile /*!< Defines 'read / write' permissions */

复制代码

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

#define PERIPH_BASE ((uint32_t)0x40000000)$ y: R* R, a: T9 o4 G
#define D2_APB1PERIPH_BASE PERIPH_BASE5 Q9 Z- ]4 N( h& a4 ?' ^6 K/ d
#define D2_APB2PERIPH_BASE (PERIPH_BASE + 0x00010000)- Q% p& c; I9 @1 ]9 A6 e/ y" ]. A
* ~! {% W y4 Z: m& e& ?
/*!< D2_APB1PERIPH 外设 */$ k" N- C4 D1 V
#define TIM2_BASE (D2_APB1PERIPH_BASE + 0x0000) <----- 展开这个宏，(TIM_TypeDef *) 0x40000000
8 ^) }% M! U7 u2 B8 N
#define TIM3_BASE (D2_APB1PERIPH_BASE + 0x0400)
* n) x; }' y& d6 M
#define TIM4_BASE (D2_APB1PERIPH_BASE + 0x0800)
8 s/ g& H! N" {2 P3 z w
#define TIM5_BASE (D2_APB1PERIPH_BASE + 0x0C00)& w5 G: N; l1 X
#define TIM6_BASE (D2_APB1PERIPH_BASE + 0x1000)
& x) ]' N' t9 j, a6 X
#define TIM7_BASE (D2_APB1PERIPH_BASE + 0x1400)
" V+ X* l$ S! f: d
#define TIM12_BASE (D2_APB1PERIPH_BASE + 0x1800)
; ~% L, A8 A v
#define TIM13_BASE (D2_APB1PERIPH_BASE + 0x1C00)
$ Z8 M$ r9 |7 o# v1 E
#define TIM14_BASE (D2_APB1PERIPH_BASE + 0x2000)
9 }9 Q1 `+ C" i9 q7 P2 j
2 N! x5 o3 r5 Z" |6 B2 t8 W5 C
/*!< D2_APB1PERIPH 外设 */
: N( N c+ S; y l' Z+ }8 f
#define TIM1_BASE (D2_APB2PERIPH_BASE + 0x0000)! g' v- I; c" u5 a
#define TIM8_BASE (D2_APB2PERIPH_BASE + 0x0400)
$ E# ~) S, m% |
#define TIM15_BASE (D2_APB2PERIPH_BASE + 0x4000)
1 [. @3 Y7 y( t3 }8 B. w+ p8 Y
#define TIM16_BASE (D2_APB2PERIPH_BASE + 0x4400)
- g% ?% B' ?8 C' H4 `. j6 G
#define TIM17_BASE (D2_APB2PERIPH_BASE + 0x4800)" g" N; F8 X/ D% b& i6 b( }" W
6 o4 F, b% x& z2 @& `5 n* `
#define TIM1 ((TIM_TypeDef *) TIM1_BASE)) _3 \5 s R1 X V O* x
#define TIM2 ((TIM_TypeDef *) TIM2_BASE)
& `1 i \2 ~7 Q2 {8 c6 l' X
#define TIM3 ((TIM_TypeDef *) TIM3_BASE)
7 C: s9 y, ?( s! S( ~
#define TIM4 ((TIM_TypeDef *) TIM4_BASE); l2 ?' M8 T8 V8 O# d% U D* q
#define TIM5 ((TIM_TypeDef *) TIM5_BASE)
+ m9 K3 g) l; |; @+ G) t7 ^. e
#define TIM6 ((TIM_TypeDef *) TIM6_BASE)- G. Y3 v( |0 ?1 C5 t+ o
#define TIM7 ((TIM_TypeDef *) TIM7_BASE)
3 l/ }5 q$ k8 h8 q; }# j0 a
#define TIM8 ((TIM_TypeDef *) TIM8_BASE)
% j/ c( l9 S, r1 m; o5 b: `
#define TIM12 ((TIM_TypeDef *) TIM12_BASE)
' Y: l5 b+ x! t" l5 `) f4 j
#define TIM13 ((TIM_TypeDef *) TIM13_BASE)
- P; p3 _( T3 I# w, x) w- J
#define TIM14 ((TIM_TypeDef *) TIM14_BASE)
" o; ]9 ]! W" V* ?3 z2 E+ R
#define TIM15 ((TIM_TypeDef *) TIM15_BASE)
+ S8 S% c! }9 @ I, K( I* y
#define TIM16 ((TIM_TypeDef *) TIM16_BASE)8 X; k" F( C% A7 A! ^
#define TIM17 ((TIM_TypeDef *) TIM17_BASE)

复制代码

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

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

typedef struct3 D/ q' d( b( d/ r5 q3 Y
{
5 G$ m# T+ c; X8 v0 b0 B i5 \3 W
TIM_TypeDef *Instance; /*!< Register base address */
1 x+ k5 [# J/ S: E: w9 ?
TIM_Base_InitTypeDef Init; /*!< TIM Time Base required parameters */
2 h7 ]- O- p9 H* u$ h
HAL_TIM_ActiveChannel Channel; /*!< Active channel */ 6 F- T; f: ]7 N6 u
! c9 ]& S5 i: ], d2 ]
/*!< DMA Handlers array This array is accessed by a @ref DMA_Handle_index */" o) t; p! B Y5 n7 p" W8 g
DMA_HandleTypeDef *hdma[7];
5 _# }9 d, Y8 G* b
HAL_LockTypeDef Lock; /*!< Locking object */( h' v& p" c9 T: y
__IO HAL_TIM_StateTypeDef State; /*!< TIM operation state */
: T2 e/ f$ Y) U: P& f6 W: N$ @
}TIM_HandleTypeDef;

复制代码

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

  TIM_TypeDef  *Instance

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

SET_BIT(huart->Instance->CR1,  TIM_CR1_CEN)。

  TIM_Base_InitTypeDef  Init

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

TIM_Base_InitTypeDef结构体的定义如下：

typedef struct# k0 n6 a: `' I
{4 d6 _- Z1 l; G3 Z8 D
uint32_t Prescaler; 7 }9 N/ U4 ?, w9 |
uint32_t CounterMode;
5 ? \0 {. I( n- y8 X& H
uint32_t Period; # A2 O5 r$ p3 I. J9 [
uint32_t ClockDivision; 4 A2 E* W4 o4 k: d5 [ U7 H
uint32_t RepetitionCounter; + o3 c3 v, R# I- O, S9 R8 v
uint32_t AutoReloadPreload; # t' c7 i/ h R* t, n
} TIM_Base_InitTypeDef;

复制代码

成员Prescaler
用于设置定时器分频，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。

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

#define TIM_COUNTERMODE_UP ((uint32_t)0x0000U) /*!< Up counting mode */3 G8 u; H0 V& t2 A, P
#define TIM_COUNTERMODE_DOWN TIM_CR1_DIR /*!< Down counting mode */) M& D3 ?, V6 f) \
#define TIM_COUNTERMODE_CENTERALIGNED1 TIM_CR1_CMS_0 /*!< Center-aligned counting mode 1 */0 t9 \) b; l. a$ J$ ?. j
#define TIM_COUNTERMODE_CENTERALIGNED2 TIM_CR1_CMS_1 /*!< Center-aligned counting mode 2 */
3 `6 ~0 D& ]0 F( u: o4 {
#define TIM_COUNTERMODE_CENTERALIGNED3 TIM_CR1_CMS /*!< Center-aligned counting mode 3 */

复制代码

成员Period
用于设置定时器周期，对于32位的TIM2和TIM5范围是0到0xFFFFFFFF，其它定时器是0到0xFFFF。

成员ClockDivision
用于指示定时器时钟 (CK_INT) 频率与死区发生器以及数字滤波器（ETR、TIx）所使用的死区及采样时钟 (tDTS) 之间的分频比。

#define TIM_CLOCKDIVISION_DIV1 ((uint32_t)0x0000U) /*!< Clock Division DIV1 */$ t& P: }0 x1 _" y+ L
#define TIM_CLOCKDIVISION_DIV2 (TIM_CR1_CKD_0) /*!< Clock Division DIV2 */% M+ o* E3 H- \1 R2 Y( F3 e. b/ t
#define TIM_CLOCKDIVISION_DIV4 (TIM_CR1_CKD_1) /*!< Clock Division DIV4 */

复制代码

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

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

#define TIM_AUTORELOAD_PRELOAD_DISABLE ((uint32_t)0x0000U) /*!< TIMx_ARR register is not buffered */5 @! V# R% x$ t+ [4 Z0 \9 b
#define TIM_AUTORELOAD_PRELOAD_ENABLE (TIM_CR1_ARPE) /*!< TIMx_ARR register is buffered */

复制代码

HAL_TIM_ActiveChannel Channel;

用于设置定时器通道，比如TIM1和TIM8都是6个通道。

typedef enum6 r# u+ G& `7 n: J
{( r% w$ K" W- [+ L+ C. O
HAL_TIM_ACTIVE_CHANNEL_1 = 0x01U, /*!< The active channel is 1 */
/ K3 ^6 I( Z& W/ Z! W
HAL_TIM_ACTIVE_CHANNEL_2 = 0x02U, /*!< The active channel is 2 */
# `$ E( U$ K4 K. F
HAL_TIM_ACTIVE_CHANNEL_3 = 0x04U, /*!< The active channel is 3 */ # O4 F7 Y9 O4 l) v
HAL_TIM_ACTIVE_CHANNEL_4 = 0x08U, /*!< The active channel is 4 */
) X) ^5 v* p: m
HAL_TIM_ACTIVE_CHANNEL_5 = 0x10U, /*!< The active channel is 5 */
2 e' G6 d# V5 H$ M& P$ V
HAL_TIM_ACTIVE_CHANNEL_6 = 0x20U, /*!< The active channel is 6 */
^ @9 D) _( E9 L
HAL_TIM_ACTIVE_CHANNEL_CLEARED = 0x00U /*!< All active channels cleared */ . v( H! G& u0 Q# \, ?& q; Z% A0 c
}HAL_TIM_ActiveChannel;
1 v l0 D4 S; X' ?
DMA_HandleTypeDef *hdma[7];

复制代码

用于关联DMA。

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

TIM_HandleTypeDef TimHandle = {0};7 h* d& Y. o, n
) _8 W0 W8 F, X: y; {- L) F$ i0 f2 q
/* 2 l9 u8 i$ T8 D% B$ p% m2 V- {
定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）) d1 V4 X% N, Z$ q3 L) m+ F
*/' Z) |$ S6 \* Y3 S! d& a
TimHandle.Instance = TIMx;; h$ u9 [1 {. S8 w* f$ _+ T
TimHandle.Init.Prescaler = usPrescaler;
; m) Y2 }0 a( N, R- s0 @% ?
TimHandle.Init.Period = usPeriod;
0 f9 W4 h& g, b
TimHandle.Init.ClockDivision = 0;
0 @' I4 o5 v3 a* `
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;3 ~) G9 W8 _) P& T' Q" ]
TimHandle.Init.RepetitionCounter = 0;. }! R& V. V2 B: u2 A" }$ k' Q
TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
1 b$ x8 w d8 @8 A9 X! }
if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)+ @ Q# G; i! `. W
{7 E2 i0 Q: P* [
Error_Handler(__FILE__, __LINE__);
& Y$ o: `6 J/ |) R+ a7 G. d" T
}

复制代码

, t. }5 X2 t* U) A" e1 K! g: x32.3.3 定时器输出比较结构体TIM_OC_InitTypeDef
此结构体主要用于定时器的输出比较，定义如下：

typedef struct* ]8 q( Y7 I Y; H; k7 Q0 w6 n) z# A
{ * Q2 i3 E7 u# | a! c0 ~% G
uint32_t OCMode; ) M5 X( B7 {5 t% ~4 f8 C
uint32_t Pulse;
, R K9 _& l4 u4 a1 J& Y
uint32_t OCPolarity;
' Z" e$ E: O( r" R2 M
uint32_t OCNPolarity; " f' R) ? n. H5 z; i8 A3 |
uint32_t OCFastMode; 1 Q, @$ F) I, {. h" x& _/ w4 Q9 o
uint32_t OCIdleState; ) f( X5 l6 @) C. [1 N5 k
uint32_t OCNIdleState;
4 R# t% y( m& f) N7 z o
} TIM_OC_InitTypeDef;

复制代码

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

OCMode
用于配置输出比较模式，支持的模式较多：

/*!< TIM Output timing mode */% y7 `" R5 v, }: a
#define TIM_OCMODE_TIMING ((uint32_t)0x0000U)
5 d; K. v+ o" H3 m
4 G7 M1 n( T' ~, Q
/*!< TIM Output Active mode */
0 t3 L1 Q7 S+ K7 g
#define TIM_OCMODE_ACTIVE ((uint32_t)TIM_CCMR1_OC1M_0)
5 b V S& w$ d7 g" C, \
! I9 C- r' E2 x% Y3 B% j @+ D4 V
/*!< TIM Output Inactive mode */ 4 \( J( N7 I5 L0 K' P, V. s
#define TIM_OCMODE_INACTIVE ((uint32_t)TIM_CCMR1_OC1M_1) # N2 H# b0 P" Y0 W' u" s2 `& S$ d& s- }
, v! g3 ^/ R9 D; P4 g" Y. m
/*!< TIM Output Toggle mode */
: x8 f- Q9 ?5 Z4 G# a8 ?" _) C) Y$ M
#define TIM_OCMODE_TOGGLE ((uint32_t)TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0) , T |3 Z9 V+ _5 ^! ^ M
5 w1 I8 U0 w, l$ T" a4 S2 g3 {
/*!< TIM PWM mode 1 */
# |# K; B8 |+ ]5 ^ [
#define TIM_OCMODE_PWM1 ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1) 5 R" j b- V# C6 u
# V1 P7 v! l r
/*!< TIM PWM mode 2 */
4 e- [9 }0 L7 a, K2 F
#define TIM_OCMODE_PWM2 ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)
+ p! V9 W: O, h6 N% {! P
, b' _6 r, d9 D8 e2 x
/*!< TIM Forced Active mode */
) Z( P; } P0 w' f% P
#define TIM_OCMODE_FORCED_ACTIVE ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0)
* `. [ o: h* [8 U5 l
* B( Q. m& Q3 x2 t. D
/*!< TIM Forced Inactive mode */
8 Y/ c2 C8 u! \
#define TIM_OCMODE_FORCED_INACTIVE ((uint32_t)TIM_CCMR1_OC1M_2)
# h1 J5 b2 J$ |
* e: v( p; ]0 ?
/*!< TIM Rettrigerrable OPM mode 1 */ 8 `) h% r1 r, h
#define TIM_OCMODE_RETRIGERRABLE_OPM1 ((uint32_t)TIM_CCMR1_OC1M_3)
$ p _% Q* |1 u2 \3 G
, h: V8 V% q5 b, X) U$ z5 q
/*!< TIM Rettrigerrable OPM mode 2 */ 1 k: [4 b( Q9 T! x; H; ?7 v2 M/ C
#define TIM_OCMODE_RETRIGERRABLE_OPM2 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0) . e H. g" V; b4 q
; ?5 b+ ^2 _& q- D! y y
/*!< TIM Combined PWM mode 1 */
+ e: K0 w+ a" p0 C9 m% b; g$ i
#define TIM_OCMODE_COMBINED_PWM1 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_2)
0 N9 R! x& G7 K; {; J
/ M; X5 `' i- Q& d# j5 U* j
/*!< TIM Combined PWM mode 2 */
0 Q! ~! i* {+ b- a2 O+ N# ]; ~8 L
#define TIM_OCMODE_COMBINED_PWM2 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0 | TIM_CCMR1_OC1M_2) 3 n- O5 V1 o* ~- X5 g
# _6 k" V ^, E$ d" ^( g. c; g
/*!< TIM Asymetruc PWM mode 1 */
0 O; s0 l. ?( F; l
#define TIM_OCMODE_ASSYMETRIC_PWM1 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2) ) l8 ^ ?# T7 E8 w( T# {& q1 U
; M2 E/ K0 S- B) _9 c. ]& o4 R
/*!< TIM Asymetruc PWM mode 2 */
5 v4 j. A5 X4 F7 y' h) ^) }7 Y( k
#define TIM_OCMODE_ASSYMETRIC_PWM2 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M)

复制代码

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

  OCPolarity
设置输出极性，可选高电平或低电平有效。

#define TIM_OCPOLARITY_HIGH ((uint32_t)0x0000U)
1 I2 }8 Z4 n) ]; e" t3 B8 j
#define TIM_OCPOLARITY_LOW (TIM_CCER_CC1P)

复制代码

OCNPolarity
互补输出极性设置，可选高电平或者低电平有效。

#define TIM_OCNPOLARITY_HIGH ((uint32_t)0x0000U)7 ?$ O6 u9 V( c5 E4 m) O
#define TIM_OCNPOLARITY_LOW (TIM_CCER_CC1NP)

复制代码

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

#define TIM_OCFAST_DISABLE ((uint32_t)0x0000U)
8 B. y/ x, W T, s1 ^# q6 o
#define TIM_OCFAST_ENABLE (TIM_CCMR1_OC1FE)

复制代码

OCIdleState
空闲状态时，设置输出比较引脚的电平状态。

#define TIM_OCIDLESTATE_SET (TIM_CR2_OIS1)$ B: C: }9 F' e) g; z
#define TIM_OCIDLESTATE_RESET ((uint32_t)0x0000U)

复制代码

OCNIdleState
空闲状态时，设置互补输出引脚的电平状态。

#define TIM_OCNIDLESTATE_SET (TIM_CR2_OIS1N)
# c3 e8 o2 E& e0 N( F( {/ @
#define TIM_OCNIDLESTATE_RESET ((uint32_t)0x0000U)

复制代码

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

typedef struct7 K8 q: }( M. U5 i3 o: {
{
$ v2 b. P3 v D+ `
uint32_t ICPolarity; : |; `( e9 W6 D; n3 C8 U, |
uint32_t ICSelection; ; F5 d8 B5 l! d+ c
uint32_t ICPrescaler;
$ ?/ w- j* ^ I, v9 p* b8 N
uint32_t ICFilter;
6 y0 A9 E$ ^9 ] `
} TIM_IC_InitTypeDef;

复制代码

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

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

#define TIM_ICPOLARITY_RISING TIM_INPUTCHANNELPOLARITY_RISING; l9 ~9 N) A0 w! W) ]
#define TIM_ICPOLARITY_FALLING TIM_INPUTCHANNELPOLARITY_FALLING
# x# ]1 R& ?' s9 u2 P8 `
#define TIM_ICPOLARITY_BOTHEDGE TIM_INPUTCHANNELPOLARITY_BOTHEDGE

复制代码

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

#define TIM_ICSELECTION_DIRECTTI (TIM_CCMR1_CC1S_0) + t9 J) M( g' s3 y# c
#define TIM_ICSELECTION_INDIRECTTI (TIM_CCMR1_CC1S_1) ; Z8 ?4 [$ X0 _+ Q; c
#define TIM_ICSELECTION_TRC (TIM_CCMR1_CC1S)

复制代码

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

#define TIM_ICPSC_DIV1 ((uint32_t)0x0000U)
" `6 G0 H: C6 V4 f& j: N1 Z
#define TIM_ICPSC_DIV2 (TIM_CCMR1_IC1PSC_0) 1 c4 J5 h+ r" G7 ^
#define TIM_ICPSC_DIV4 (TIM_CCMR1_IC1PSC_1)
+ J- V6 m/ ]9 ?; k: L- N
#define TIM_ICPSC_DIV8 (TIM_CCMR1_IC1PSC)

复制代码

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

0000：无滤波器，按 fDTS 频率进行采样
3 X7 |' B0 P0 x: `1 ~7 G
0001： fSAMPLING=fCK_INT， N=2
6 [" D" N& b) E* p7 a
0010： fSAMPLING=fCK_INT， N=4
6 g7 w% }# j' }1 G9 y9 O- _
0011： fSAMPLING=fCK_INT， N=8
: Y/ i/ q: Y; F7 z# O! D8 k# Z1 b
0100： fSAMPLING=fDTS/2， N=6+ u5 T0 q1 q! \+ t
0101： fSAMPLING=fDTS/2， N=86 u: x, ^* {% J5 ]/ m0 y. I6 E
0110： fSAMPLING=fDTS/4， N=6' Q2 h4 n2 S$ K! m* r% `7 ~ F3 E
0111： fSAMPLING=fDTS/4， N=8
$ }% x& u; `" |9 P: a: h
1000： fSAMPLING=fDTS/8， N=6" q5 M; D' R5 l0 o; X) N
1001： fSAMPLING=fDTS/8， N=8
~6 k) H L: b; S
1010： fSAMPLING=fDTS/16， N=5
" ?. y1 P0 t ]2 W2 V
1011： fSAMPLING=fDTS/16， N=6
3 J0 i( f/ |, ]$ w1 C
1100： fSAMPLING=fDTS/16， N=8
" ?- {. E; U r/ l' Z
1101： fSAMPLING=fDTS/32， N=5
8 R0 m/ S; @$ |5 T: }' E: {, f
1110： fSAMPLING=fDTS/32， N=6

复制代码

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

__weak void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
# M4 x2 y1 Z4 F
{
) m4 z; X: w% V
/* Prevent unused argument(s) compilation warning */* ?0 E% F, M- O; V/ y2 O J
UNUSED(htim);7 H! F" F' K% [! q I
/* NOTE : This function Should not be modified, when the callback is needed,
- M. \( }- i. |/ R6 a, l
the HAL_TIM_Base_MspDeInit could be implemented in the user file
: o$ Q5 ?. l1 ?* s) u8 B
*/
) c) u. s1 v2 q7 `' f+ p
}

复制代码

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

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

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

void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)5 z2 `# ?. C9 y" H- I0 X' b
{5 _# B2 {1 f9 B8 ~
GPIO_InitTypeDef GPIO_InitStruct;
" q# I8 E! z* \
" i' ^: u0 C6 [: u
/* 使能TIM1时钟 */
- s8 }8 D7 q. h0 a% u
__HAL_RCC_TIM1_CLK_ENABLE ();
+ ^( K% Q# \* j- i ?. N
' l$ V+ @- X# `
/* 使能GPIOA时钟 */+ M4 M$ H# S5 \* e- |6 [
__HAL_RCC_GPIOA_CLK_ENABLE ();5 l; U7 X8 Y: J' D0 B! L, D
' M) Y5 o; A4 o6 M! Z) u: v/ X
/* 设置TIM1使用PA8做PWM输出引脚，将其配置为输出，推挽，复用模式 */
7 s f8 q' c8 |3 _3 a Z
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;& c& s" U: G' q" p7 U2 p [
GPIO_InitStruct.Pull = GPIO_PULLUP;
( D' W' V8 B* R4 L7 i8 X9 a
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;' t2 g5 P( G1 Q6 X
7 M. R* A7 F) R2 V& q* w
GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
' o1 v% p; }% l: I& R, r" t) Y$ t
GPIO_InitStruct.Pin = GPIO_PIN_8;
+ `5 ]! X& V5 M2 @" @" Q# U
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);" x+ k0 |3 e% w0 [9 d( W- S3 }
4 m9 i2 D x' N% ?+ O0 d
}

复制代码

总结下来就是以下几点：

  配置TIM时钟。
  配置TIM所用到引脚和对应的GPIO时钟。
  如果用到定时器中断，还需要通过NVIC配置中断。
  如果用到DMA，还要配置DMA。
关于这个底层配置有以下几点要着重说明下：

  定时器所使用引脚的复用模式选择已经被HAL库定义好，放在了stm32h7xx_hal_gpio_ex.h文件里面。比如TIM1有一个复用，

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

复制代码

但是却有4个输出通道，每个通道都有几个支持的输出引脚：

TIM1_CH1, PA8 PE9 PK18 Q+ }) M& D9 i/ h( q i* ]- S
TIM1_CH2, PA9 PE11
' {# G! H% ]/ q, F# }2 O0 f
TIM1_CH3, PA10 PE13 PJ94 ?9 a' t% z" c
TIM1_CH4, PA11 PE14 PJ11

复制代码

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

32.3.6 定时器的状态标志清除问题
下面我们介绍__HAL_TIM_GET_FLAG函数。这个函数用来检查定时器标志位是否被设置。

0 d. t8 S( i/ O
/** @brief Check whether the specified TIM interrupt flag is set or not.
& H) _6 P# X1 z. F5 |; \/ U: z: t
* @param __HANDLE__: specifies the TIM Handle.! _( ]; @$ K, r2 X
* @param __FLAG__: specifies the TIM interrupt flag to check.% X9 S% @% f. U7 o9 f& ?
* This parameter can be one of the following values:/ @7 Y2 S: R$ O8 z* M# W5 |/ Z
* @arg TIM_FLAG_UPDATE: Update interrupt flag6 v) H/ d% A/ |1 o
* @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag+ M8 T" r% S) D7 m4 Y3 E
* @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
4 N/ I) k7 m+ ~) t
* @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag5 n% h% B3 [) @4 b( s# f
* @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag/ @3 K+ `8 M$ [' R
* @arg TIM_FLAG_CC5: Compare 5 interrupt flag
7 I' s+ h* \1 a5 G; z: g
* @arg TIM_FLAG_CC6: Compare 6 interrupt flag
) c7 O4 l& q- |
* @arg TIM_FLAG_COM: Commutation interrupt flag
* [/ T! E1 w$ E' S
* @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
( j6 \# l8 r* }3 J
* @arg TIM_FLAG_BREAK: Break interrupt flag # d: L0 Z. B, r6 H' }
* @arg TIM_FLAG_BREAK2: Break 2 interrupt flag ! b% z) k% N7 t& h: l& A' B
* @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
, t3 {' l1 L7 g+ [' B4 ]/ c2 h/ t, F
* @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
0 R: t8 t8 U" Q; G
* @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
4 X: ?0 t; q8 {0 K: U v- W( ~% Y
* @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag# H& j- o0 @" \2 K- q7 W5 m
* @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
+ L. r! q1 Q$ p& _
* @retval The new state of __FLAG__ (TRUE or FALSE).
' T; T# Y* M5 F& E# s. b
*/ M* {# `" W. S$ P$ V
#define __HAL_TIM_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->SR &(__FLAG__)) == (__FLAG__))

复制代码

前5个是比较常用的中断标志。

TIM_FLAG_UPDATE
定时器更新标准，配置一个周期性的定时器中断要用到。

TIM_FLAG_CC1
TIM_FLAG_CC2

TIM_FLAG_CC3

TIM_FLAG_CC4

捕获/比较标志，配置了捕获/比较中断要用到。

与标志获取函数__HAL_TIM_GET_FLAG对应的清除函数是__HAL_TIM_CLEAR_FLAG：

/** @brief Clear the specified TIM interrupt flag.
! b [* [9 k5 z
* @param __HANDLE__: specifies the TIM Handle.( w+ C, `; l) O* f8 O
* @param __FLAG__: specifies the TIM interrupt flag to clear.# B) r# _2 O# V9 R$ B
* This parameter can be one of the following values:/ f' B# i3 ]! }( f
* @arg TIM_FLAG_UPDATE: Update interrupt flag* u7 F( m# g8 m& d
* @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag9 O6 b) d; m0 \. Z% A
* @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag& H7 ^/ W% a9 H) _% I
* @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
7 ?5 x. G u' }) j3 ]
* @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
" k4 f9 F8 _; M4 F, P9 S( y
* @arg TIM_FLAG_CC5: Compare 5 interrupt flag
. u; i. V+ c4 I7 s# m. u) x4 n
* @arg TIM_FLAG_CC6: Compare 6 interrupt flag; N6 J& W& E, @1 A7 V2 ^' E
* @arg TIM_FLAG_COM: Commutation interrupt flag y* k( r8 }) U" h* E
* @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
6 ^* z8 R' U7 x+ q
* @arg TIM_FLAG_BREAK: Break interrupt flag
; q4 q# v7 g& C+ `! O
* @arg TIM_FLAG_BREAK2: Break 2 interrupt flag
8 T8 g" {4 Y4 a: f
* @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag! U. ^ j2 g9 G" `+ u
* @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
3 h+ L p0 W2 g( c4 ?
* @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
/ e; z( y2 Q( B2 ?) w
* @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
8 Q W. N7 @5 t/ M& ]1 I* ]/ [
* @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag: ^( J2 \6 G" g
* @retval The new state of __FLAG__ (TRUE or FALSE).
9 j2 z' Z5 U5 O( I: j
*/3 |. h6 _2 V( `. D+ g( I
#define __HAL_TIM_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->SR = ~(__FLAG__))

复制代码

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

/** @brief Enable the specified TIM interrupt.' i7 n7 Q8 F* b9 D6 U2 ?4 u
* @param __HANDLE__: specifies the TIM Handle.
9 n4 I: t1 M: a& @ b h
* @param __INTERRUPT__: specifies the TIM interrupt source to enable.
/ B4 A: L! ]1 e7 t5 ~
* This parameter can be one of the following values:8 Z) C& ~# A9 b* U U+ n
* @arg TIM_IT_UPDATE: Update interrupt
: ?, p6 _" M: b' R2 i& e! v3 H0 K* y
* @arg TIM_IT_CC1: Capture/Compare 1 interrupt
2 N1 x& \ q3 y8 A! p
* @arg TIM_IT_CC2: Capture/Compare 2 interrupt, D: Q1 y2 n8 @! E: o
* @arg TIM_IT_CC3: Capture/Compare 3 interrupt; `2 F3 c3 a$ i2 U
* @arg TIM_IT_CC4: Capture/Compare 4 interrupt
# B: w4 H. @- _& K, e1 U3 h
* @arg TIM_IT_COM: Commutation interrupt
4 [) o% K H5 m3 g) T
* @arg TIM_IT_TRIGGER: Trigger interrupt! N0 i5 d3 u& e# D1 y$ K
* @arg TIM_IT_BREAK: Break interrupt
2 C/ ~' g; ^4 e8 [- e
* @retval None( C) i: G3 L% n0 e
*/
) v0 |! t0 x/ L- b
#define __HAL_TIM_ENABLE_IT(__HANDLE__, __INTERRUPT__) ((__HANDLE__)->Instance->DIER |= (__INTERRUPT__))% R8 W0 i# W4 @7 O
3 T1 s1 y7 p5 T8 C. B5 z2 m
/** @brief Disable the specified TIM interrupt.( ?/ N# \0 k' n1 T+ ^
* @param __HANDLE__: specifies the TIM Handle.
3 V$ Z* Z5 R$ A7 B+ [) j
* @param __INTERRUPT__: specifies the TIM interrupt source to disable.- }3 z z. ~. N: ]+ W Y8 I
* This parameter can be one of the following values:
* i: [' I8 V" v F, y
* @arg TIM_IT_UPDATE: Update interrupt7 T6 M# ]% p) ?- n' `4 ]
* @arg TIM_IT_CC1: Capture/Compare 1 interrupt
. F& H0 m8 u) |! R. h4 ^
* @arg TIM_IT_CC2: Capture/Compare 2 interrupt) C* w- r/ M- F: \
* @arg TIM_IT_CC3: Capture/Compare 3 interrupt$ c9 J% _5 y9 ~4 Q5 P" w: x
* @arg TIM_IT_CC4: Capture/Compare 4 interrupt
6 V/ t. m2 z. W7 n: V: _
* @arg TIM_IT_COM: Commutation interrupt
- C9 u: K. e$ a9 A+ v( J
* @arg TIM_IT_TRIGGER: Trigger interrupt
3 f# ~$ I2 h: K0 O3 M( |
* @arg TIM_IT_BREAK: Break interrupt
. d) D7 n# U, p0 O( M
* @retval None
- D7 i: ~) S5 |' m: n6 q
*/
2 N& l5 Z/ G7 {8 o" K) J3 i
#define __HAL_TIM_DISABLE_IT(__HANDLE__, __INTERRUPT__) ((__HANDLE__)->Instance->DIER &= ~(__INTERRUPT__))

复制代码

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

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

32.3.7 定时器初始化流程总结
使用方法由HAL库提供：

  第1步：通过下面几个函数配置定时器工作在相应的模式

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

  HAL_TIM_OC_Init 和 HAL_TIM_OC_ConfigChannel
配置定时器产生输出比较信号

  HAL_TIM_PWM_Init 和 HAL_TIM_PWM_ConfigChannel
配置定时器产生PWM信号

  HAL_TIM_IC_Init 和 HAL_TIM_IC_ConfigChannel
配置定时器测量外部信号

  HAL_TIM_OnePulse_Init 和 HAL_TIM_OnePulse_ConfigChannel
配置定时器工作在单脉冲模式

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

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

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

  定时器基本功能 : HAL_TIM_Base_MspInit()
  输入捕获 : HAL_TIM_IC_MspInit()
  输出比较 : HAL_TIM_OC_MspInit()
  PWM输出 : HAL_TIM_PWM_MspInit()
  单脉冲输出模式: HAL_TIM_OnePulse_MspInit()
  编码器模式 : HAL_TIM_Encoder_MspInit()
  第3步：底层初始化具体实现

第2步中函数的具体实现。

  使用函数__HAL_RCC_TIMx_CLK_ENABLE()使能定时器时钟。
  使用函数__HAL_RCC_GPIOx_CLK_ENABLE()使能定时器使用到的引脚时钟。
  使用函数HAL_GPIO_Init()配置GPIO的复用功能。
  如果使能了定时器中断，调用函数HAL_NVIC_SetPriority和HAL_NVIC_EnableIRQ配置。
  如果使能了DMA，还需要做DMA的配置。
  定时器默认使用APB时钟，如果使用外部时钟，调用函数HAL_TIM_ConfigClockSource可以配置。
  第4步：启动定时器外设

  定时器基础功能:
HAL_TIM_Base_Start()

HAL_TIM_Base_Start_DMA()

HAL_TIM_Base_Start_IT()

  输入捕获 :
HAL_TIM_IC_Start()

HAL_TIM_IC_Start_DMA()

HAL_TIM_IC_Start_IT()

  输出比较 :
HAL_TIM_OC_Start()

HAL_TIM_OC_Start_DMA()

HAL_TIM_OC_Start_IT()

  PWM输出：
HAL_TIM_PWM_Start()

HAL_TIM_PWM_Start_DMA()

HAL_TIM_PWM_Start_IT()

  单脉冲模式：
HAL_TIM_OnePulse_Start()

HAL_TIM_OnePulse_Start_IT().

  编码器模式：
HAL_TIM_Encoder_Start()

HAL_TIM_Encoder_Start_DMA()

HAL_TIM_Encoder_Start_IT().

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

  HAL_TIM_DMABurst_WriteStart()
  HAL_TIM_DMABurst_ReadStart()
定时器常用的功能，通过上面这几步即可实现。

32.4 源文件stm32h7xx_hal_tim.c
此文件涉及到的函数非常多，这里把几个常用的函数做个说明：

  HAL_TIM_Base_Init
  HAL_TIM_Base_Start
  HAL_TIM_PWM_Init
  HAL_TIM_PWM_ConfigChannel
  HAL_TIM_PWM_Start
  HAL_TIM_IC_Init
  HAL_TIM_IC_ConfigChannel
  HAL_TIM_IC_Start_IT
  HAL_TIM_OC_Init
  HAL_TIM_OC_ConfigChannel
  HAL_TIM_OC_Start
32.4.1 函数HAL_TIM_Base_Init
函数原型：

HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
" O4 C1 m% x2 ~0 _1 P, d
{ % e! I6 d- Q8 D/ P/ {% S) W
/* 检测是否是有效句柄 */
9 w; P1 ?' i1 T V3 t$ a
if(htim == NULL)
/ [ r: l3 O7 @" Z
{( v. y4 y" A3 n9 b
return HAL_ERROR;+ E3 E- W8 B7 u* ?9 W9 ]2 I
}2 Y- C8 l( k4 b9 j
) q& {$ t6 m- n7 r7 B
/* 检测参数 */' c" q6 ^8 N2 U9 \; W4 R2 j
assert_param(IS_TIM_INSTANCE(htim->Instance));
2 D# t2 O; `* U3 c
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
" Y; C. X# L6 ~1 M3 }. S3 x( B
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
& Q" R4 r( l. g, ~6 f' P
2 J5 E5 I3 \8 l# W2 ^
if(htim->State == HAL_TIM_STATE_RESET)
0 W1 W. p0 o- Y8 J
{ 8 i- o+ Z; ^. D' W8 M7 h3 @* A
/* 默认取消锁 */& ` Y; `9 x1 m2 j( q/ t
htim->Lock = HAL_UNLOCKED;
% ?8 o* q- l g# Q9 y& q; {
/* 初始化底层硬件 : GPIO, CLOCK, NVIC */) @4 T4 D1 P, @! r! x
HAL_TIM_Base_MspInit(htim);5 u/ H/ y) j0 Y- O( x3 s! a
}
3 a( {% s, ^, c/ y5 R/ Q- n' c0 L8 N# L
3 l% M ~+ ^# b& Z+ J' d
/* 设置TIM状态 */5 \: Y0 n# ?2 H+ Z
htim->State= HAL_TIM_STATE_BUSY;
$ I) \! C" [ c5 i, h4 \) Y
/ ` F9 S3 G$ U. e' B7 F3 H
/* 基本参数配置 */7 E( w" n, x, x
TIM_Base_SetConfig(htim->Instance, &htim->Init); + X( D1 ^$ v. ~: i) h: a9 W
9 y% t, s9 b8 V" P
/* 设置TIM就绪 */
$ e6 O6 S6 `6 Q5 Y# A
htim->State= HAL_TIM_STATE_READY;
* Y. }2 \0 l' H2 K
, a. }: N9 e6 A) y1 N
return HAL_OK;
4 A& }$ i/ A8 M2 X& |
}

复制代码

函数描述：

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

函数参数：

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

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

解决办法有三：

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

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

方法3：下面的方法

if(HAL_TIM_Base_DeInit(&TimHandle) != HAL_OK), r4 _0 X( W, U
{2 k1 ~6 X2 c- V: i6 E2 N" `. \
Error_Handler();/ w9 Q5 F' u* G: I/ T
}
& g6 J, O9 b( X* u
if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
/ D, I4 Q+ z3 H/ h5 k
{ ?6 X8 t4 o B9 e
Error_Handler();* `) s* M2 h B, \' d1 x; d w/ E8 \
}

复制代码

使用举例：

TIM_HandleTypeDef TimHandle = {0};
! w; U) K( Z% V7 y( K
3 w0 K9 L/ x8 K7 f1 J
/* # O' o4 g+ J3 p. b) u
定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
*/
) T1 _/ g: ?# G
TimHandle.Instance = TIMx;7 U! h3 k; r* C6 y
TimHandle.Init.Prescaler = usPrescaler;
i1 O* X" | w% m0 h0 c
TimHandle.Init.Period = usPeriod;
! x9 Q' t+ F, \2 M2 r% Y
TimHandle.Init.ClockDivision = 0;
+ A. p( X9 N) ^6 q
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
4 ]8 V3 M2 q9 H' {
TimHandle.Init.RepetitionCounter = 0;: M" L! ^) d7 n B
TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;0 c6 Q3 I& Z1 Y! n1 c
if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
1 ?' C1 e) p! l7 W, A: S4 m, w; l( a
{
. S% O, j( e& f1 B: U; C+ [
Error_Handler(__FILE__, __LINE__);" S' L2 ?; Z4 e7 F, o( @- A
}

复制代码

32.4.2 函数HAL_TIM_Base_Start
函数原型：

HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)4 T+ B' Z }- |6 O5 [+ k
{
# t0 U! l% X- [: a( C/ U! _
/* 检测参数状态 */! S( ?8 N; Z t* c" r' U- M
assert_param(IS_TIM_INSTANCE(htim->Instance));
, U, v) M4 P+ J$ r4 {. o
+ s; n7 X0 g# H* D5 ^5 r
/* 设置定时器状态 */
8 W" \! t1 z$ F# U8 u
htim->State= HAL_TIM_STATE_BUSY;
/ q7 k# k h# e$ _9 i9 q2 Y: R/ c, r
2 m3 H, @3 h% J1 {. M r
/* 使能定时器 *// k7 t/ J' H" `1 @2 o7 |7 i
__HAL_TIM_ENABLE(htim);. j& W+ M: B4 ^0 U7 K
K* o' h- f; }4 m+ m4 e B% ]
/* 设置定时器状态 */- T+ k( N+ d& z! T8 m# s
htim->State= HAL_TIM_STATE_READY;: W. I0 d- c5 A+ h
* S' w2 l1 M* u9 K- E' p
/* 返回HAL_OK */
4 i) E7 Y& P) c4 V4 Q
return HAL_OK;+ v! G: h% P. G- Z5 M5 {
}

复制代码

函数描述：

此函数比较简单，调用函数HAL_TIM_Base_Init配置了基础功能后，启动定时器。

函数参数：

第1个参数是TIM_HandleTypeDef类型结构体指针变量。
返回值，固定返回HAL_OK，表示初始化成功。
使用举例：

TIM_HandleTypeDef TimHandle = {0};
7 F" ^; ?3 `* \' M3 F/ x
7 P' H, G8 T3 k/ M: x+ e
/*
% f& {% p, p6 a7 Q2 e$ E
定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）( i& r2 Y: Z' H4 X0 `
*/
. Q" {" ?5 r2 m+ X
TimHandle.Instance = TIMx;
6 z+ H( Z, d0 G* { P1 I
TimHandle.Init.Prescaler = usPrescaler;
' p; z# o0 p. s0 f' z: ]+ B
TimHandle.Init.Period = usPeriod;
$ F2 }. v! d7 ^; r& l
TimHandle.Init.ClockDivision = 0;, O( c8 ^4 r+ F* A
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;# |& x0 L* r1 e; ?
TimHandle.Init.RepetitionCounter = 0;% Q" b9 [1 n- y5 ^9 x
TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;; B! r5 f( Y- p: F5 {$ _
if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
5 J& u8 S$ n& J1 J
{
' f" k# V4 l! f8 E' R9 Z+ u
Error_Handler(__FILE__, __LINE__);+ ]' l- n* n' u6 o* p
}0 B, ^0 i0 e' h1 j. Y- `9 v# z
f2 m+ H# `* C% n
/* 启动定时器 */
3 X4 D) Y# P! r- x- H
if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)0 |. i( Z! t4 R( T" s) k
{
' L7 E0 o5 V6 p- T
Error_Handler(__FILE__, __LINE__);
& M* N$ K/ O% l! |7 u8 ]8 D. d
}

复制代码

32.4.3 函数HAL_TIM_PWM_Init
函数原型：

HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
. D* P$ d- ?' v* P* i* @6 |3 n. h+ `
{* b" m$ [+ w. E) g) g1 ?$ P
/* 检查句柄是否有效 */
" B/ [8 n0 s4 _4 r
if(htim == NULL)
! w6 }1 E! ~; L# K
{9 w0 E q4 v+ F. o! X
return HAL_ERROR;
o( |, O# O+ @7 _) b9 L+ W
}8 V7 Y& P# q$ `/ |
G+ i) D0 [/ C- ^8 T" `: A
/* 检测参数 */$ D$ }2 p# i0 J# y# P# E: B
assert_param(IS_TIM_INSTANCE(htim->Instance));
i0 W! y1 ~5 y# S
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));$ v& Y4 `1 R8 X& d
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision)); \* X$ V9 N1 K; W! x. u
2 t; a" q4 I3 a3 W1 G
if(htim->State == HAL_TIM_STATE_RESET)
- g& _3 i" A4 y# s- I( \+ w. z) }
{6 n" b A( J5 e& D4 E* Q7 J
/* 默认取消锁 */$ t6 o- O$ t% k. A' N
htim->Lock = HAL_UNLOCKED;) Z% P' Z- ^% p4 ^
6 ?/ v' c/ I. `
/* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
8 T% W+ j# Q$ v$ ^
HAL_TIM_PWM_MspInit(htim);% n. X X0 I. ]* ?' G
}) `$ F _) V7 [4 t& V
: ]* Y6 s* s/ X( w
/* 设置定时状态 */
0 o: \; U2 o l3 v o1 ~9 e% ]% u
htim->State= HAL_TIM_STATE_BUSY;
# \6 N! B8 H% ~0 {# j: e+ D. Z
6 O& U" Y% n# W$ R5 q* T7 h3 K, T
/* 配置定时器用于PWM */
& r2 D+ t1 z' J3 ]; l9 d+ a
TIM_Base_SetConfig(htim->Instance, &htim->Init);
! S! ?& c% y- H/ }$ L
" t- O; b$ w# h( n9 k2 A1 }
/* 设置定时器状态 */
' t. h' H5 G$ G4 q
htim->State= HAL_TIM_STATE_READY;
& M% W) t2 c$ c. |5 L
/ K/ [! Q7 T- W6 a, R
return HAL_OK;
9 Y+ G( C7 t' k6 j0 Q- Q7 t
}

复制代码

函数描述：

此函数用于初始化定时为PWM方式。

函数参数：

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

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

解决办法有三：

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

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

方法3：下面的方法

if(HAL_TIM_PWM_DeInit(&TimHandle) != HAL_OK)
) J) t V+ g2 ^/ c G1 y
{
) B; e+ U6 [/ o, I2 S( N
Error_Handler();0 [- [- q% S1 l
}
/ ]2 G) p" u5 O. l) J0 |- z3 }- y
if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)$ ?- C/ l- L3 ^
{" k$ s1 U. X5 }" l- S. J7 ^
Error_Handler();
}

复制代码

使用举例：

TIM_HandleTypeDef TimHandle = {0};
4 O1 `) f9 B" D) D. @, x* L( ]
8 {8 Z9 n1 ]% _/ c; a- n; Z( d% z
/* PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/5 @3 h3 i1 U3 K
TimHandle.Instance = TIM1;, r# u G+ k; m$ V( Y: {- a2 i
TimHandle.Init.Prescaler = usPrescaler;, Z1 A6 b {# k8 Q# ]5 ~$ M6 }) T% {
TimHandle.Init.Period = usPeriod;
! n+ ]4 H8 ]. h4 q8 O0 w
TimHandle.Init.ClockDivision = 0;' ~8 L- u2 j4 P& j) d9 {) r6 X
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;5 K$ f" r; f' c3 S; ^- P( X* U7 f; ?
TimHandle.Init.RepetitionCounter = 0;; \/ J6 ], ]1 }9 `0 P
TimHandle.Init.AutoReloadPreload = 0;
/ w2 a! H' n+ n) c1 f0 f5 ~- P
if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK) s# }4 G' M" I6 M( p" j4 k
{
9 v6 S0 n" g. x3 ]
Error_Handler(__FILE__, __LINE__);4 o9 F; A! V, W2 Z" N
}

复制代码

32.4.4 函数HAL_TIM_PWM_ConfigChannel
函数原型：

HAL_StatusTypeDef HAL_TIM_PWM_ConfigChannel(TIM_HandleTypeDef *htim,& @3 ]+ u4 b. H2 j+ K: x
TIM_OC_InitTypeDef* sConfig,
# o" |, T% y2 D, W" p( W5 }
uint32_t Channel)7 b/ m7 z7 z2 C. i7 I7 K: D) h
{
" i/ s' T+ n: p: Q: a8 |
/* 省略 */
( @9 j: [5 J0 d1 p/ E7 F. j I
& B" h$ \5 B/ N k
/* 开锁 */
9 `3 Z' e7 P+ s
__HAL_LOCK(htim);7 x& {6 s3 c6 W1 m
6 U) j2 M+ u9 n3 N, Q
htim->State = HAL_TIM_STATE_BUSY;/ v$ ~5 S" l7 f, g
9 k8 M6 P4 a4 [" s+ Z! `: e7 }1 \
switch (Channel)
* P2 T$ y7 G6 I; d4 |" Z
{- R$ p. i. h9 Q
case TIM_CHANNEL_1:! ^' M( {$ j8 k6 K1 P! ]; x
{; `' i5 M' I3 H A1 o4 a8 s
/* 检查参数 */
3 r' d( l7 D4 u5 S
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
/ D4 Q+ |' v4 L% Q9 I
( }9 ^5 s1 Y; E" s# h" M" h8 B1 n
/* 配置通道1的PWM模式 */- O8 V. z8 N: b
TIM_OC1_SetConfig(htim->Instance, sConfig);& y/ o& E1 S* Q6 J. V
. W; p7 a1 y8 ~ u$ o' Y0 l
/*预装载使能，更新事件产生时写入有效 */) O* |) c( Z: W8 v5 t
htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;
/ p3 [6 e; u# Z! I9 i
+ F5 w4 L* N9 h$ q9 f
/* 配置是快速输出模式 */' ?* W& p: I, d; x6 c$ r. [
htim->Instance->CCMR1 &= ~TIM_CCMR1_OC1FE;
. U s; H9 X$ p7 S
htim->Instance->CCMR1 |= sConfig->OCFastMode;
4 k5 g8 n9 r3 c7 h: h h
}) n d3 W& S. t) ]" I1 r
break;! n% f$ A2 ~# T" j% E
' s6 I7 ~. o& {% f- W: m8 Q
case TIM_CHANNEL_2:
+ T' C; ?2 y0 X: R& y6 t$ P9 N! `
{. A" i. {' D+ L: x$ h
/* 省略 */4 U" |2 X, e' k. t/ W# R9 J
}
9 O5 b6 C" v- W+ F8 m
break;+ w2 q5 x c! c: h* D
. m9 P6 l/ y O( Q# l0 N% E
case TIM_CHANNEL_3:9 ]- ?/ g3 \% I, A
{
) A/ T. ~: U1 e8 E( L
/* 省略 */
" _% X( W2 K- k% k. v' O
}
. ]% }' i' Y7 }0 L/ o+ m0 @
break;
4 z: ?6 D/ C( i3 q
$ ^8 c5 c4 C( z& v* n' U2 _4 u0 k$ x
case TIM_CHANNEL_4:
3 w2 ]$ y, f# Q" }2 r
{
9 T4 d0 Z* @1 N1 j% I! X. y: { z
/* 省略 */
|+ E' |" y, N7 u3 O7 d
}. |9 @' |5 Z& g1 E8 h# b- E
break;3 n" C u. e9 A9 J( o6 W2 I6 j/ v" X
: K/ m0 [# @. ^6 c
case TIM_CHANNEL_5:
# e/ Q% I* l& r7 x; _
{
* J' c* `/ n: ~; R
/* 省略 */
7 R& x# u- F9 D' P; y
}" }# V1 B& p Z2 g0 ]
break;
. } I1 O: f& U/ s7 l# M3 f" R
8 t7 B0 f5 M* ^* D: Y
case TIM_CHANNEL_6:
2 t+ K7 n, ~! P6 w2 _
{
3 D4 E2 Z& q1 n
/* 省略 */" z8 s; z6 p" b4 |2 l
}- y5 b- `. d, ] [
break;
2 b1 E5 d+ w7 y: j
default:
4 e$ b; \1 A0 i) b
break;
3 j2 L6 s2 j5 V U7 C0 u' \
}' ~+ ]4 f- Y* o. }) c5 [. ^$ I
7 v7 H4 d8 {( U9 {8 ~
htim->State = HAL_TIM_STATE_READY; {& [; [" u ]$ U
7 h$ \9 j, i* Z9 U! t
/* 关锁 */
0 l' y$ p" ~5 j& R
__HAL_UNLOCK(htim);4 U) c G* O. Q" Z' `2 Y
# h. {3 b. p; T3 A6 @
return HAL_OK;0 v5 s0 k4 A- p- _7 \0 `" W' J6 Z
}

复制代码

函数描述：

此函数用于配置定时器的PWM通道。

函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
TIM_CHANNEL_1

TIM_CHANNEL_2

TIM_CHANNEL_3

TIM_CHANNEL_4

TIM_CHANNEL_5

TIM_CHANNEL_6

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

TIM_HandleTypeDef TimHandle = {0};/ A- V2 u+ I4 ]. I% ?: p% ?6 @
/ k6 n2 @. E, {' [ \; r: @
/* PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
% b3 s1 A: ~, I5 @3 R1 J+ e& T" X
TimHandle.Instance = TIM1;3 h( d. v, e0 T# l9 U# G' z! y& U
TimHandle.Init.Prescaler = usPrescaler;
6 ]( n. f6 f! V d& H6 H
TimHandle.Init.Period = usPeriod;
+ O/ u: A- [( c
TimHandle.Init.ClockDivision = 0;$ K* P( p; T4 r
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
- M: U7 i. }" l$ d1 A
TimHandle.Init.RepetitionCounter = 0;/ X( R9 z2 |' w B8 U
TimHandle.Init.AutoReloadPreload = 0;
) _7 c- X' Q8 f6 U" M s( O. ?+ q
if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
: c5 [+ O. `0 j/ n
{6 X+ \0 U' V7 x0 M% r0 K
Error_Handler(__FILE__, __LINE__);( O- g! O, b5 Q& H& u
}
5 Q1 f' C- J7 [4 C
* t, w3 ?. }+ e( ~5 i. F
/* 配置定时器PWM输出通道 */
+ J2 |! x3 @2 l) O/ v9 e' a
sConfig.OCMode = TIM_OCMODE_PWM1;
# I3 V [5 u5 A, O# a. J* p
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;. ~$ O/ n5 t! w/ n
sConfig.OCFastMode = TIM_OCFAST_DISABLE;
- I1 [9 M$ ?+ _ q6 J6 o9 ~' t
sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;" Y4 q+ o; f \+ Y+ o5 p
sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;0 K1 K$ `# o% `2 u8 e8 x
sConfig.OCIdleState = TIM_OCIDLESTATE_RESET;0 \0 D G0 B9 D. W3 u
2 w1 R2 l1 `5 J5 _. |' m9 Q2 j
/* 占空比 */" Z$ Q* d+ R! B& U/ m
sConfig.Pulse = pulse;3 a. D7 t9 {$ j- i$ T9 y( W
if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)+ ]" i2 |' p" j7 [ i
{
2 V3 T7 z# q& W1 ?1 l" O
Error_Handler(__FILE__, __LINE__);
# N0 X( |8 S1 |$ ~
}

复制代码

32.4.5 函数HAL_TIM_PWM_Start
函数原型：

HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
3 e+ l3 `7 y0 X* V' V' g' s
{' u+ h" p3 k# S
/* 检测参数 */
& E3 t) z/ `- S" x' B% P9 K5 t7 H
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));5 q& Q1 B8 u% P( R
7 U4 e; s6 v, a; C$ Y6 A6 @- T
/* 使能捕获比较通道 */
8 d l5 @0 N. e
TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
$ H z' t) g7 _% n
4 k v: L. O {4 n3 b! l2 M: H
if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)
9 J" Z) b4 }' Q
{0 b7 }2 G/ M) G0 y: a- B, ~: z1 X
/* 使能主输出 */
' O% L+ R7 r% X+ H, Q3 ]2 L
__HAL_TIM_MOE_ENABLE(htim);' ]- N r2 u6 V4 ]
}
# k Y7 p. E6 o
7 v7 e' d& F1 D& v/ V' e- Y
/* 使能定时器 */4 ^( l$ I9 Z+ B
__HAL_TIM_ENABLE(htim);; _* [2 F! p: ~
1 A9 K+ Q& b+ ?/ ]) O, w; b
/* 返回状态*/& d8 O. q u' y9 e4 Z3 x" i: t
return HAL_OK;2 ^8 ~9 h% R+ F
}

复制代码

函数描述：

此函数用于启动PWM。

函数参数：

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

TIM_CHANNEL_2

TIM_CHANNEL_3

TIM_CHANNEL_4

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

TIM_HandleTypeDef TimHandle = {0}; \6 {" u; U, z% a0 n( m7 U; y
% G2 _1 t0 U' {$ a4 x7 H8 q
/* PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
/ I" \. Y/ d! ?9 _; J
TimHandle.Instance = TIM1;
& s, p$ P$ d& x9 {& P/ m
TimHandle.Init.Prescaler = usPrescaler;
5 b! W8 X% ]) n8 Q Q: H
TimHandle.Init.Period = usPeriod;
6 o$ C/ _4 x. w- w2 G( t: n
TimHandle.Init.ClockDivision = 0;
* o& ]6 l: J) b4 m! h
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;" C, f4 d% Q# R; n2 n- H
TimHandle.Init.RepetitionCounter = 0;+ }. b" p7 w: K0 I7 }/ q9 {
TimHandle.Init.AutoReloadPreload = 0;
# z! W) C3 n [
if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)1 E$ [# N! `! U; I2 ?) C
{: Y! d+ s b, ^. _( [- h
Error_Handler(__FILE__, __LINE__);
! e* F7 Z' F/ m# s% D R. V
}4 X) X9 c4 @$ O a+ |( r5 U c
4 V6 F' }3 h, y0 V
/* 配置定时器PWM输出通道 */, r# Q, I6 }5 E2 ^; j: I$ t4 C* d
sConfig.OCMode = TIM_OCMODE_PWM1;( G: Z J6 M' k
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;5 ^$ x! ~& \" C! a: c
sConfig.OCFastMode = TIM_OCFAST_DISABLE;" N3 |( K9 B* @$ A
sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;% W7 }8 V' [9 [3 }
sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
4 I: W3 q$ D- _% l G9 C
sConfig.OCIdleState = TIM_OCIDLESTATE_RESET;* x/ O; e0 \5 t+ W4 Z: j
% z, u% i% B7 T o o4 W
/* 占空比 */! ]/ N0 I% Q: h, M8 j
sConfig.Pulse = pulse;3 {# \- U5 {" K7 y8 c
if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)+ M& W$ ~2 s+ c E! s
{
% W7 Q @* c. z, O. ^
Error_Handler(__FILE__, __LINE__);2 N) i/ ?( @: J
}
% G3 `) \! J4 S0 D( U
1 q7 z9 m2 k3 j0 D Y7 H5 O' T
/* 启动PWM输出 */
O8 N. L6 {; [7 `
if (HAL_TIM_PWM_Start(&TimHandle, TimChannel[_ucChannel]) != HAL_OK)1 x* b0 U- H# x* w( O6 `
{# g0 W. R) ^1 }. j. N& X6 y
Error_Handler(__FILE__, __LINE__);" d/ x5 v4 c' c+ ]. @
}

复制代码

32.4.6 函数HAL_TIM_IC_Init
函数原型：

HAL_StatusTypeDef HAL_TIM_IC_Init(TIM_HandleTypeDef *htim)0 T: {* G. q9 [7 m2 b; Q
{: i0 N' @! t+ B
/* 检测形参是否有效 */
+ C: A6 J, _5 Y5 ]4 H
if(htim == NULL)
( }4 N& n0 j5 y7 G' I* p4 }
{
+ K; k) X4 D( ]2 q8 q
return HAL_ERROR;
, L i6 V, h( L: H- I ]0 F2 N
}
# a& k) F' Y. o7 `
' [( I m! [: Y- i7 w3 B
/* 检测参数 */" W5 A% }' `" E8 G. Y$ e' M
assert_param(IS_TIM_INSTANCE(htim->Instance));
" Q; o( z9 D( U# }4 m6 y
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));7 H. v8 q" m6 T4 k2 m
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
, ^7 m! o) w. u& Y. j
2 M5 ~) D I; X% Y' r/ g$ I
if(htim->State == HAL_TIM_STATE_RESET)3 b* ^2 X% V# N% K/ h1 G
{
1 e2 o" r5 }0 d
/* 默认取消锁 */" f! s" S) t5 S# {' j, m
htim->Lock = HAL_UNLOCKED;
/ W/ s, c2 I" j
3 f& ^' |& o, ]
/* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
& V4 R! | O/ D! x% Q
HAL_TIM_IC_MspInit(htim);
" N4 M! p( z. A4 U" z
}- p9 C+ ?: X5 P( k9 a( A
/ C3 M6 h* E% O: [, X5 l o
/* 设置定时器状态 */7 P! S* T+ w; y/ B7 i2 S
htim->State= HAL_TIM_STATE_BUSY; & C% k% w7 j! W, t
) A# i& W- |% x3 U
/* 配置定时器为输入捕获模式 */
. |1 r+ @. Z s
TIM_Base_SetConfig(htim->Instance, &htim->Init); 9 s, Z$ B: Q9 Q6 ?/ r( L( |/ s5 f
# x( w! g( W( j
/* 设置定时器状态 */+ P: r7 N9 ` M; {8 J
htim->State= HAL_TIM_STATE_READY;
' v& r" [2 N. B+ [8 h7 y# i
6 t2 T- u6 S; z! k0 a& A
return HAL_OK;
5 k. p: K7 Q! J9 I1 p
}

复制代码

函数描述：

此函数用于定时器输入捕获初始化。

函数参数：

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

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

解决办法有三：

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

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

方法3；下面的方法

if(HAL_TIM_IC_DeInit(&UartHandle) != HAL_OK)1 |- n* ?- K n4 F& v. u
{8 [5 `9 C+ x% V) Z9 F- R. v
Error_Handler();4 A. `9 Z. u; x! k; b; |7 Q
}
' h. J; C- x. Z. q
if(HAL_TIM_IC_Init(&UartHandle) != HAL_OK)) V7 G, Q% y+ ^" w: J3 ]5 o
{
% k2 M* N1 c1 |4 ^8 r; {0 W5 l
Error_Handler();& L7 }, Y/ G1 ]8 j4 ` y
}

复制代码

32.4.7 函数HAL_TIM_IC_ConfigChannel
函数原型：

HAL_StatusTypeDef HAL_TIM_IC_ConfigChannel(TIM_HandleTypeDef *htim, TIM_IC_InitTypeDef* sConfig, uint32_t Channel)4 }/ [2 g# |* B- {6 B$ y) k) U
{# Q) f" u) _. U' ?* k0 p9 L
/* 检查参数 */
) c0 S& E8 s1 m( O; j4 |1 k! b
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));9 X' z9 f% t+ L3 M
assert_param(IS_TIM_IC_POLARITY(sConfig->ICPolarity));
6 C+ r) _3 S% p% Z' m- n% m
assert_param(IS_TIM_IC_SELECTION(sConfig->ICSelection));
; r, }3 r0 b; m. W* ?$ L2 Y5 R
assert_param(IS_TIM_IC_PRESCALER(sConfig->ICPrescaler));# z3 I; f) M& Q% @' @- [6 h) l
assert_param(IS_TIM_IC_FILTER(sConfig->ICFilter));
& P- B% @+ b. k5 p* m+ ?" i
0 a/ w2 n% C) Y3 ^; r/ T
/* 开锁 */
0 Y* q) m4 r& ^. g m* i
__HAL_LOCK(htim);
$ c, u. M; X" ^2 i& O4 ^; f
% _7 \, R% G* g( g. _, a- r
htim->State = HAL_TIM_STATE_BUSY;
: {; q! J4 {& s% Y6 H$ g3 N! r
/ p% a! _ w R
if (Channel == TIM_CHANNEL_1)
5 r& d' o& m; r7 I) i/ z2 Z, {
{; T D& d3 N& @! E! V: W2 \
/* 配置输入通道1 */
+ x; s2 T8 P2 q. c9 F+ x0 q
TIM_TI1_SetConfig(htim->Instance,8 k$ U' v; l/ Q2 N2 ~( v, m8 o6 d7 N& E: b. K
sConfig->ICPolarity,4 J, [( W# R/ j
sConfig->ICSelection,
$ ^2 h' X: C% K- H0 {
sConfig->ICFilter);
' W: Z) G4 P7 v4 k9 C9 A
; _0 [" Q* Y! X4 {4 n% Y5 e
/* 清零IC1PSC位 */
( r$ k) r1 `! @" ?; Y, I7 k8 V! i
htim->Instance->CCMR1 &= ~TIM_CCMR1_IC1PSC;7 |% {( |+ F( q
( M; {6 R6 R$ {6 X' j L
/* 根据用户配置，设置分频 */! @5 ]/ _0 T: e9 A! O4 y5 y* ?) |0 v
htim->Instance->CCMR1 |= sConfig->ICPrescaler;
4 Y/ N8 @) |- L/ \: r+ l
}
' B$ t0 R' K5 x8 H3 ?' q* ]
else if (Channel == TIM_CHANNEL_2), H6 Z D4 {# i1 l( C
{
9 ~7 m4 P, v7 s4 b6 U
/* 省略 */
) J, C8 B/ \* ^. @/ w o/ I
}
, a) n: c+ I2 p' I! O) P$ Z
else if (Channel == TIM_CHANNEL_3): q6 _! a- X4 Z
{
6 b8 o( y) c5 n+ H7 g% i
/* 省略 */
4 s0 \: _3 o- X
}9 P( i2 m/ M% X
else
* K* ]- d/ p" v4 L
{1 ~3 H5 v3 s1 [! d
/* 省略 */
0 N" I5 l- i; n* q9 d) H
}
# s& |- k! z2 x: I0 ~% a: B
- a( Q0 h( y6 z1 p# B7 i
htim->State = HAL_TIM_STATE_READY;
# x) u/ ~- }; z2 t2 d
" O* P) t# h8 F$ p
__HAL_UNLOCK(htim);: ?, K+ U+ ^6 b' J
( m" C6 M: \7 {( u' ~+ C2 j
return HAL_OK; ! C9 y* m* c3 P! J l
}

复制代码

函数描述：

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

函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置
  第2个参数是TIM_IC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
TIM_CHANNEL_1

TIM_CHANNEL_2

TIM_CHANNEL_3

TIM_CHANNEL_4

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

32.4.8 函数HAL_TIM_IC_Start_IT
函数原型：

HAL_StatusTypeDef HAL_TIM_IC_Start_IT (TIM_HandleTypeDef *htim, uint32_t Channel)& z: ?- `6 l4 p! G5 c" m% g$ N( ], g+ e
{
# K3 F% {; {- e
/* 检查参数 */ P' e% _8 s# M" ~4 z6 T
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));* M. { ^( B4 w
6 @" q" y$ n' ?5 `; H4 |2 k
switch (Channel)
4 n; o. A. {5 X; _
{$ N& m% P: k5 z: h# V
case TIM_CHANNEL_1:
a8 ]+ r. u' L1 D
{ . B% `! \1 V# w0 u: f
/* 使能CC1（Capture/Compare 1）中断 */- A6 a0 j. f [) o0 @# c
__HAL_TIM_ENABLE_IT(htim, TIM_IT_CC1);
/ h, `; p7 r# }2 b2 e5 [
}& l4 `8 d9 _% o0 h) @5 t& w
break;
" p) i8 Y0 x2 E3 o; Y' p5 a
y% j Z( L. I, |
case TIM_CHANNEL_2:
% l- Q7 w1 g" p7 p" k& ]3 B
{ R: w' F& b `2 _
/* 省略 */3 Z7 N7 K& S# r0 g; s
}* Z7 n+ j' t% d, K! M
break;, N0 x! o/ j2 [5 T) V m) Q
- A( q2 k" Y+ i; Y+ I
case TIM_CHANNEL_3:: D# b+ ^, Y: r* P) h
{6 m1 G4 d+ `* w: k( d2 L) [+ }' |
/* 省略 *// R; l/ t+ ]# l0 B+ z& e5 ?; ]
}
" g/ Y& e# }1 I0 I- n% s
break;
& d0 m. f1 x8 n, h" D
9 H0 v' C* {! V/ g
case TIM_CHANNEL_4:
1 D7 {) Y- _/ `9 B* N) Q# ]3 L
{& U9 x4 r6 ~! g- ^) P
/* 省略 */
2 y' d5 G. t' V9 f
} F2 W9 G) O6 k% o8 {) K I
break; J4 O/ _% J9 l" x" Q. n* @; r
% H6 j6 o' b* [$ s& C
default:
: v9 u7 I7 j0 W5 }6 M
break;, V; O8 s6 Z. Z
}
9 G# L/ l$ G6 f+ G. J
/* 使能输入捕获通道 */
# j( e6 ]# j3 Y) i- }8 Z* F
TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
$ [# |( m2 p9 Z/ E' J1 }
+ d/ I6 d2 n( V$ z/ J
/* 使能定时器 */
& A8 ^" [7 Y6 S' ?( b G4 v
__HAL_TIM_ENABLE(htim); + i0 T4 f4 s& O. C5 d( j8 I
% i1 q% ^4 }( z( z) C4 {8 b! A
/* 返回状态 */# d' i9 @- \) s- k2 A- J
return HAL_OK;
, h9 p3 n$ l( Q z# ?
}

复制代码

函数描述：

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

函数参数：

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

TIM_CHANNEL_2

TIM_CHANNEL_3

TIM_CHANNEL_4

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

32.4.9 函数HAL_TIM_OC_Init
函数原型：

HAL_StatusTypeDef HAL_TIM_OC_Init(TIM_HandleTypeDef* htim)
5 e1 w5 ^' z+ r" ~( T
{) t1 }9 {2 A! q T' A2 B
/* 检测形参是否有效 Check */
# y* l0 c' ?! ?* x. r1 L# ^
if(htim == NULL)+ |' A' S4 T$ ^. `, X, M" d
{
( J, V) S6 P% L" t2 w8 L' ]! P( C
return HAL_ERROR;
0 D1 l2 V* d7 J b2 n2 Q
}
+ U" T0 Q- h" _1 y* C3 N5 I5 G
- T. T0 O& F" }9 F D
/* 检查参数 */: u3 [9 s5 d! H& F! k- \* P6 }: Y
assert_param(IS_TIM_INSTANCE(htim->Instance));" X" c' {7 K, U* |8 I
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));$ ~) O0 x" R0 i- b* c" h4 M
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));& D3 z e1 F D1 e2 v
6 \5 n8 p9 U8 ?. U) r$ x
if(htim->State == HAL_TIM_STATE_RESET)
; t% y7 u0 x" V0 j C7 p3 c
{+ s- b: O1 e) [
/* 默认取消锁 */0 g ~2 n/ s, c4 R( U: N0 E' `
htim->Lock = HAL_UNLOCKED;7 p/ f# z0 W; g& X* Y
+ I/ O7 P! P* Y+ @
/* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
T6 g3 n% G/ x- V7 e2 H' j! b; _
HAL_TIM_OC_MspInit(htim);
% m0 P5 j, c* Y+ c- q
}
_8 J3 C& d9 ^+ d
. \+ r d7 e9 ]$ F6 O
/* 设置定时器状态Set the TIM state */1 _% g @* {! u. ]2 u7 Q. G m
htim->State= HAL_TIM_STATE_BUSY;
& l. c% ]/ Z/ Q& ?8 Y$ E
/ ~3 U. M- P/ U, K
/* 配置定时器为输出比较模式Init the base time for the Output Compare */ $ u% Q; ~4 p2 _
TIM_Base_SetConfig(htim->Instance, &htim->Init); & f; b% g$ r/ w. w) D$ U
) X- T/ q% E6 k/ l1 S0 ^9 Z% r
/* 设置定时器状态 */
" |) [9 t3 N( Q, p5 E' b$ ?+ u
htim->State= HAL_TIM_STATE_READY;- Y6 k$ e1 [- X7 D' Z; Y
8 T; h5 M& b7 u. c: A, |
return HAL_OK;9 m( {& i& e3 o" C8 H% |
}

复制代码

函数描述：

此函数用于定时器输出比较初始化。

函数参数：

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

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

解决办法有三：

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

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

方法3；下面的方法

if(HAL_TIM_OC_DeInit(&UartHandle) != HAL_OK)
+ y3 z/ f! S' a% p+ e" Y
{
1 R# v4 j- R0 t* T
Error_Handler();0 K7 v0 g( e! L, W5 J
} / D8 j# [5 O1 s; c" j# X
if(HAL_TIM_OC_Init(&UartHandle) != HAL_OK)4 p& [4 D; x& G( S; W8 c4 z1 @
{, o4 b6 o; e% R" b
Error_Handler();' Z. O; t3 D9 N
}

复制代码

32.4.10 函数HAL_TIM_OC_ConfigChannel
函数原型：

HAL_StatusTypeDef HAL_TIM_OC_ConfigChannel(TIM_HandleTypeDef *htim,
/ v1 k/ a9 ^9 x6 y
TIM_OC_InitTypeDef* sConfig,+ S; F2 b8 R" f2 @" A* P' y0 I
uint32_t Channel)
/ i2 K8 m" y: T8 r9 N d7 {7 S
{
* o" o5 b& }& O' _8 l1 ^. l) ^# i$ g
/* Check the parameters */ i8 ^& G- f# r5 ~0 a2 H
assert_param(IS_TIM_CHANNELS(Channel));
" r ^" T4 |7 I
assert_param(IS_TIM_OC_MODE(sConfig->OCMode));2 m/ A5 |/ U6 x) D4 ?
assert_param(IS_TIM_OC_POLARITY(sConfig->OCPolarity));
5 k7 B3 y+ [: X) k7 w% ^1 D! F5 }
' {( A% [; h" g
/* Process Locked */
) g' s1 I/ p/ p' t7 C8 f: d
__HAL_LOCK(htim);
* ^7 s0 k& q" x- {! f d: f
. R# l" O' r+ p$ T( l
htim->State = HAL_TIM_STATE_BUSY;
4 q4 g% \5 h: Q6 G$ P" M
; U* b( q0 i& H( J5 Y# ]
switch (Channel)$ C2 q; |# j' l9 v
{; H$ k$ s F u3 K5 L
case TIM_CHANNEL_1:7 i( u" |2 j2 y
{
5 J/ ^, H+ F" n) r- o5 w# N9 x6 p7 O
/* 检测参数Check the parameters */7 ]0 D& w9 S6 L0 o8 ]
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance)); 2 s. f, H, W7 T; o! D4 S$ H1 P1 y
?/ ]; ]# ^$ v2 z6 V0 z1 b; K
/* 配置定时器输出比较通道1 */: m. |6 a, T9 Y
TIM_OC1_SetConfig(htim->Instance, sConfig);
y! m% i# _% f1 S6 t
}
0 c/ T3 M! A3 b$ Q: D7 v
break;4 s! I; z, U6 L8 F. q
6 Y) o/ c3 d4 t v/ Q
case TIM_CHANNEL_2:
& B5 i9 W: S6 Z: B
{
& @, g0 C# r* p+ J% t0 { T
/* 省略 */
) k# d( o8 e7 u# l2 S9 E! v4 I
}5 k {. G) s) R% Y9 |! K; b! C
break;5 r; C3 R! n/ }+ k! @
3 @# }2 w" t7 w A
case TIM_CHANNEL_3:( |, G2 V1 f, p7 s
{+ z6 _+ D Z, I$ }
/* 省略 */% X: n8 l) B0 ]. s3 S) m- O; u
}
1 ^6 Z4 B# C0 J7 v4 y# R; ^7 g
break;/ e; b) _" e6 L; X7 D
1 F* J6 K" u' l, [9 z/ D/ D
case TIM_CHANNEL_4:
3 k! Q9 o' j2 G+ ?/ H3 w J
{
5 d0 `8 Q) ]6 X! [0 {
/* 省略 */
0 ~8 c- W# A* F1 _3 D4 E
}
8 l2 v! d- P% O6 ~/ C- R1 r# `6 F
break;5 W& u6 E- |5 d; a
case TIM_CHANNEL_5:! ~, u# V: d. l- _% H0 ^
{
6 q. ~, e. J% a) e& {) W
/* 省略 */6 ^. ~* B* I; n+ |
}) c+ P; y( l# k2 g
break;
' e- K; `1 N1 `! k4 E9 o
; l. Y" w5 q; M/ a5 s1 O! \/ Q
case TIM_CHANNEL_6:
9 g$ G/ e* e6 ^
{
" O- R! F! ^# j" m( h1 `, b. E
/* 省略 */9 e& F* H( S4 K9 C5 e' j
}- \, [* b! c2 ^# K2 l- f
break;$ |" N) @; y7 P+ s+ s5 `3 t+ U
. d; n2 _! F& Q
default:/ {& s% i' x) e! z) I. [9 g" p
break;
H: c) M) Y& s. F' f6 ?
}! N- C+ k* u) v" b. U# P; \0 Z @" T% ]
4 a# g1 F7 y+ Z7 ?9 m) \
htim->State = HAL_TIM_STATE_READY;
9 [+ G9 s2 @7 e0 D7 g
__HAL_UNLOCK(htim); 7 h7 U4 Z: N) }8 r- M
5 N5 l) ? f% P8 P9 V3 ?) `
return HAL_OK;
& P- O/ R) f% C$ t
}

复制代码

函数描述：

此函数用于初始化串口的基础特性和高级特性。

函数参数：

  第1个参数是TIM_HandleTypeDef类型结构体指针变量，用于定时器基本参数配置。
  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量，用于定时器输出比较参数配置。
  第3个参数是通道设置，支持以下参数：
TIM_CHANNEL_1

TIM_CHANNEL_2

TIM_CHANNEL_3

TIM_CHANNEL_4

TIM_CHANNEL_5

TIM_CHANNEL_6

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

32.4.11 函数HAL_TIM_OC_Start
函数原型：

HAL_StatusTypeDef HAL_TIM_OC_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
- T, U" A$ A+ D( X$ v7 O
{# H2 S, L4 G) L5 s
/* 检查参数 */
# C# {1 e# o' p! Z, K
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
. m) h$ e# a& o8 \
; r6 J' m7 L- ^) Q
/* 使能输出比较通道 */
; W# W8 v6 |: B4 v* k1 }3 a
TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
, O& e3 W# F% P& c
+ s* W; i) w+ G7 k6 Y% V t9 {
if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)
F9 z& h9 n) k5 A
{" d9 ]- e' T; A# {
/* 使能主输出 */
0 y7 ?: L. J- C3 Y8 l$ t
__HAL_TIM_MOE_ENABLE(htim);/ u% u9 n' p, \1 U
}
; s/ h3 c2 Y$ x. c. w
! ]8 l+ j) S& |& R
/* 使能定时器 */
& R: O6 e6 ?4 W" P% p! s
__HAL_TIM_ENABLE(htim); 2 r6 i! t# a5 U! R7 G" Z
' y5 Z) W/ m6 C5 }* E- B* z5 X$ g
/* 返回状态 */
$ y5 o' a$ O0 s1 a6 ]$ N
return HAL_OK;1 u3 d0 p+ t0 y
}

复制代码

函数描述：

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

函数参数：

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

TIM_CHANNEL_2

TIM_CHANNEL_3

TIM_CHANNEL_4

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

32.5 总结
本章节就为大家讲解这么多，建议大家将GPIO的驱动源码结合参考手册中的寄存器通读一遍，对于我们后面章节的学习大有裨益。