【经验分享】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
9 N% p7 Y1 d( D, O' ^1 x3 M
TIM1_UP_IRQHandler e2 _$ v- Y6 O# ~- K" \: \+ [
TIM1_TRG_COM_IRQHandler
: X% @( ~+ v9 z0 {# r
TIM1_CC_IRQHandler 2 Q3 o- M& M6 e! l5 U' l. S
TIM2_IRQHandler 4 q5 W) ]* m) @7 j7 U7 N1 e7 a/ \: i
TIM3_IRQHandler " x, y+ U9 x( P2 y; ]" m; f
TIM4_IRQHandler
: h U( e) t2 r D7 R @+ w0 E
TIM5_IRQHandler
TIM6_DAC_IRQHandler <------------------要注意
' W* A& w% i* {4 K
TIM7_IRQHandler
& l$ n2 K* Y8 V+ N) S$ X: v
TIM8_BRK_TIM12_IRQHandler <------------------要注意，定时器12也是用的这个; ]9 d* K3 L' }8 L0 A
TIM8_UP_TIM13_IRQHandler <------------------要注意，定时器13也是用的这个
$ L1 D, D" I+ }. |- d/ o7 B: G& p
TIM8_TRG_COM_TIM14_IRQHandler <------------------要注意，定时器14也是用的这个/ s( B9 s9 z) @2 _8 }+ z
TIM8_CC_IRQHandler
7 T8 n! O( I. Y' u' A' Q" ]2 ~
TIM15_IRQHandler
4 l# H( G# V, {$ o
TIM16_IRQHandler ' b' {+ x" g/ o; T
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
& j& @3 x% p0 |1 V; U7 D1 x5 s
{
: C( C* ^8 f& G$ a2 t# B$ S
__IO uint16_t CR1; /*!< TIM control register 1, Address offset: 0x00 */
5 k/ }3 j2 C# ^6 x* V1 _
uint16_t RESERVED0; /*!< Reserved, 0x02 */ `4 f) Z/ F3 ^" X
__IO uint32_t CR2; /*!< TIM control register 2, Address offset: 0x04 */* d* G- N* s G# l1 z$ b
__IO uint32_t SMCR; /*!< TIM slave mode control register, Address offset: 0x08 */& w7 p- U8 H% M- s/ i
__IO uint32_t DIER; /*!< TIM DMA/interrupt enable register, Address offset: 0x0C */
' z. F; |/ ]2 z
__IO uint32_t SR; /*!< TIM status register, Address offset: 0x10 */
2 A b" M# x5 r' K% o. b* ~
__IO uint32_t EGR; /*!< TIM event generation register, Address offset: 0x14 */
% g9 f0 i G! L9 ^5 `
__IO uint32_t CCMR1; /*!< TIM capture/compare mode register 1, Address offset: 0x18 */
. W" F% p$ S7 X- S5 v7 S
__IO uint32_t CCMR2; /*!< TIM capture/compare mode register 2, Address offset: 0x1C */
1 i% I( Y4 F3 W9 ]4 f$ t
__IO uint32_t CCER; /*!< TIM capture/compare enable register, Address offset: 0x20 */
2 g4 z( y Z" I
__IO uint32_t CNT; /*!< TIM counter register, Address offset: 0x24 */
4 U8 s8 j: X# B7 u2 Z M9 S9 @
__IO uint16_t PSC; /*!< TIM prescaler, Address offset: 0x28 */
6 C) W& \: O+ d
uint16_t RESERVED9; /*!< Reserved, 0x2A */- O% G9 X e. X _$ b
__IO uint32_t ARR; /*!< TIM auto-reload register, Address offset: 0x2C */
, v) r& X; Y. `: {6 b
__IO uint16_t RCR; /*!< TIM repetition counter register, Address offset: 0x30 */) z' [6 @" u" Z( R5 z
uint16_t RESERVED10; /*!< Reserved, 0x32 */ ?3 ^# ~5 K2 m5 v, B* `, M
__IO uint32_t CCR1; /*!< TIM capture/compare register 1, Address offset: 0x34 */
* d+ k( i* h& _% ?, Y+ { C- n
__IO uint32_t CCR2; /*!< TIM capture/compare register 2, Address offset: 0x38 */$ R: p% K! ]5 [0 }) \$ Y
__IO uint32_t CCR3; /*!< TIM capture/compare register 3, Address offset: 0x3C *// v) r# d; k; d. j: q. w/ R7 V
__IO uint32_t CCR4; /*!< TIM capture/compare register 4, Address offset: 0x40 */
' N3 M. J9 V* v2 [
__IO uint32_t BDTR; /*!< TIM break and dead-time register, Address offset: 0x44 */
; F/ X0 m. j5 x7 T
__IO uint16_t DCR; /*!< TIM DMA control register, Address offset: 0x48 */
, v! s. i5 |- X( g( B% h, V( r. l- g' U
uint16_t RESERVED12; /*!< Reserved, 0x4A */
8 M& R4 l3 `- W* Z
__IO uint16_t DMAR; /*!< TIM DMA address for full transfer, Address offset: 0x4C */8 G9 G/ M( K$ j4 B# d* }, C) _
uint16_t RESERVED13; /*!< Reserved, 0x4E */% g5 ~6 r D6 e( c) B! A- |
uint16_t RESERVED14; /*!< Reserved, 0x50 */
/ ^/ Q! D7 X( E {; n1 H s9 b
__IO uint32_t CCMR3; /*!< TIM capture/compare mode register 3, Address offset: 0x54 */& j( D4 `- m2 n7 d* d6 m
__IO uint32_t CCR5; /*!< TIM capture/compare register5, Address offset: 0x58 */0 _( y2 U2 L) _. K
__IO uint32_t CCR6; /*!< TIM capture/compare register6, Address offset: 0x5C */
* {% z0 {' v, o- _2 X9 q3 }6 s' ^
__IO uint32_t AF1; /*!< TIM alternate function option register 1, Address offset: 0x60 *// E- H& `1 f% p
__IO uint32_t AF2; /*!< TIM alternate function option register 2, Address offset: 0x64 */5 y9 T9 V8 u, J( e6 x2 y
__IO uint32_t TISEL; /*!< TIM Input Selection register, Address offset: 0x68 */. ^( H) B F& i+ y) ~% Q
} TIM_TypeDef;

复制代码

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

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

#define __O volatile /*!< Defines 'write only' permissions */7 `! `0 r4 R+ z2 l% a
#define __IO volatile /*!< Defines 'read / write' permissions */

复制代码

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

#define PERIPH_BASE ((uint32_t)0x40000000)* ]- G5 [) x$ s; q
#define D2_APB1PERIPH_BASE PERIPH_BASE
0 H6 ]0 h( P: ]5 Q0 ^' H
#define D2_APB2PERIPH_BASE (PERIPH_BASE + 0x00010000), _. _% F; o' s" y
9 m1 f* k0 l7 S5 b
/*!< D2_APB1PERIPH 外设 */* i% \/ i) }5 B7 z0 Z2 z% Z
#define TIM2_BASE (D2_APB1PERIPH_BASE + 0x0000) <----- 展开这个宏，(TIM_TypeDef *) 0x40000000
- F; |) d8 P5 }# ]- A& I
#define TIM3_BASE (D2_APB1PERIPH_BASE + 0x0400)+ p6 ]+ b- F6 I8 ~' Z: V
#define TIM4_BASE (D2_APB1PERIPH_BASE + 0x0800)2 L0 x9 t ?* A8 E2 t
#define TIM5_BASE (D2_APB1PERIPH_BASE + 0x0C00)7 t+ T/ J: K" J$ E0 y0 |
#define TIM6_BASE (D2_APB1PERIPH_BASE + 0x1000)
7 B! E1 f F5 B X* c
#define TIM7_BASE (D2_APB1PERIPH_BASE + 0x1400)
# E! n j( s4 ~! t9 U# g% r0 S5 {
#define TIM12_BASE (D2_APB1PERIPH_BASE + 0x1800)' b4 k4 a$ _& s
#define TIM13_BASE (D2_APB1PERIPH_BASE + 0x1C00)
* I( h/ L7 a# J" N2 i4 B
#define TIM14_BASE (D2_APB1PERIPH_BASE + 0x2000)* K/ I( J4 H7 i w4 Y5 V a& o
. d8 k8 c* g. h- ^2 g% ]
/*!< D2_APB1PERIPH 外设 */% b3 }9 _4 s% F; W' q
#define TIM1_BASE (D2_APB2PERIPH_BASE + 0x0000)9 @2 ?; z3 D5 [9 q. d4 c
#define TIM8_BASE (D2_APB2PERIPH_BASE + 0x0400)
$ Z, S4 U0 I' C* E, B+ w: V
#define TIM15_BASE (D2_APB2PERIPH_BASE + 0x4000)
4 R6 n' c6 M8 K
#define TIM16_BASE (D2_APB2PERIPH_BASE + 0x4400)# x; m4 ^6 k, Z
#define TIM17_BASE (D2_APB2PERIPH_BASE + 0x4800)- @" A2 p1 y2 ], x: t4 \
( e3 _ z/ W# t* ?7 C
#define TIM1 ((TIM_TypeDef *) TIM1_BASE)
1 P# V6 S m+ G8 b! S
#define TIM2 ((TIM_TypeDef *) TIM2_BASE)
& }( i* t; c; c. d0 k
#define TIM3 ((TIM_TypeDef *) TIM3_BASE)
! Z: Z% ]7 {. O$ z
#define TIM4 ((TIM_TypeDef *) TIM4_BASE)
4 `7 K* Q1 S# G" C
#define TIM5 ((TIM_TypeDef *) TIM5_BASE)( g, g( K/ y* X+ B9 c
#define TIM6 ((TIM_TypeDef *) TIM6_BASE)7 X% z P9 e5 h
#define TIM7 ((TIM_TypeDef *) TIM7_BASE), R5 ?2 I1 @0 R k) Z% q9 Q' S
#define TIM8 ((TIM_TypeDef *) TIM8_BASE)3 C9 N# ]) Q/ x7 e
#define TIM12 ((TIM_TypeDef *) TIM12_BASE)
# r& U) y# y8 W) c
#define TIM13 ((TIM_TypeDef *) TIM13_BASE)) X( Y2 K, [3 X: K
#define TIM14 ((TIM_TypeDef *) TIM14_BASE)
7 q- g5 H8 H5 X# k3 O4 D* N
#define TIM15 ((TIM_TypeDef *) TIM15_BASE)- H |# y) O! z8 r u# K
#define TIM16 ((TIM_TypeDef *) TIM16_BASE)
. C8 N/ y7 A1 t/ V& B
#define TIM17 ((TIM_TypeDef *) TIM17_BASE)

复制代码

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

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

typedef struct
1 U: [, |! t( w- r! P
{( |- J+ B! v) p5 i# X" N5 y+ ^
TIM_TypeDef *Instance; /*!< Register base address */ ' G5 F% o0 W5 A
TIM_Base_InitTypeDef Init; /*!< TIM Time Base required parameters */
' I( i5 B7 W* D4 Q0 P$ Z |* g
HAL_TIM_ActiveChannel Channel; /*!< Active channel */ 2 d) @' {' Q2 |0 s/ M3 H6 r: N
' L5 Z6 L! [; n6 o$ B: i8 n
/*!< DMA Handlers array This array is accessed by a @ref DMA_Handle_index */
o/ O8 D; v: o }5 `
DMA_HandleTypeDef *hdma[7];
6 R/ q" T6 O0 h7 M$ X4 K* H
HAL_LockTypeDef Lock; /*!< Locking object */6 `! ?7 I } w5 Y, N
__IO HAL_TIM_StateTypeDef State; /*!< TIM operation state */
( Q5 @8 F) w- { E
}TIM_HandleTypeDef;

复制代码

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

  TIM_TypeDef  *Instance

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

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

  TIM_Base_InitTypeDef  Init

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

TIM_Base_InitTypeDef结构体的定义如下：

typedef struct
+ B/ v+ T0 k! g% u+ _& I7 S. @! J1 H
{: j, N) W6 g% u9 u; Q% q" H: U* \1 k
uint32_t Prescaler; x' s) d$ M8 u
uint32_t CounterMode; 5 a: Y+ |6 I0 i7 w( q
uint32_t Period; - C4 `; `1 x# p6 h" j4 g7 A6 e4 j
uint32_t ClockDivision;
; @9 U/ n( P! s7 }: m9 k/ b
uint32_t RepetitionCounter;
\ r/ x1 Q4 g) z
uint32_t AutoReloadPreload; ' M' y: _) |: i' E' p' {' S$ s
} TIM_Base_InitTypeDef;

复制代码

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

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

#define TIM_COUNTERMODE_UP ((uint32_t)0x0000U) /*!< Up counting mode */
4 l1 j0 ]8 q# n, {" U0 Q) J
#define TIM_COUNTERMODE_DOWN TIM_CR1_DIR /*!< Down counting mode */
% Q1 U( f: c9 `. W) c' | { U
#define TIM_COUNTERMODE_CENTERALIGNED1 TIM_CR1_CMS_0 /*!< Center-aligned counting mode 1 */7 j% t* q' e& J1 E
#define TIM_COUNTERMODE_CENTERALIGNED2 TIM_CR1_CMS_1 /*!< Center-aligned counting mode 2 */& G( x% x! a3 z/ Y& f" o& I# q
#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 */0 S# v% w; ^. K5 t5 \: o1 I# S1 Y
#define TIM_CLOCKDIVISION_DIV2 (TIM_CR1_CKD_0) /*!< Clock Division DIV2 */5 T& E+ O# H) q1 M
#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 */
: S2 K. j: Q; R# C! f" n
#define TIM_AUTORELOAD_PRELOAD_ENABLE (TIM_CR1_ARPE) /*!< TIMx_ARR register is buffered */

复制代码

HAL_TIM_ActiveChannel Channel;

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

typedef enum" o1 O3 [/ S0 K. V4 g. ]
{* J1 k8 y; S: X9 ]
HAL_TIM_ACTIVE_CHANNEL_1 = 0x01U, /*!< The active channel is 1 */" J6 B* _: I, Z- P# @7 }
HAL_TIM_ACTIVE_CHANNEL_2 = 0x02U, /*!< The active channel is 2 */
) Y( T# A, O, k$ B% ^8 {
HAL_TIM_ACTIVE_CHANNEL_3 = 0x04U, /*!< The active channel is 3 */
2 F' s; Y" u) l* |3 V R
HAL_TIM_ACTIVE_CHANNEL_4 = 0x08U, /*!< The active channel is 4 */
$ T& P- M0 q2 S) v$ ?* R% u9 r) d
HAL_TIM_ACTIVE_CHANNEL_5 = 0x10U, /*!< The active channel is 5 */! E3 {; A3 Q# E4 L: U- ?
HAL_TIM_ACTIVE_CHANNEL_6 = 0x20U, /*!< The active channel is 6 */ }8 X0 L, N# F% S. @( C. l/ n
HAL_TIM_ACTIVE_CHANNEL_CLEARED = 0x00U /*!< All active channels cleared */ ( \+ i2 G% z) G4 `# q& C
}HAL_TIM_ActiveChannel;
+ ^/ w+ r2 ^! H# m1 `3 m' c
DMA_HandleTypeDef *hdma[7];

复制代码

用于关联DMA。

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

TIM_HandleTypeDef TimHandle = {0}; {+ y' ]" b6 k. c( p* i9 X6 |" {
' n5 W$ k: X6 A: a- P* W
/* 0 v/ b3 w9 r" z
定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
5 s8 z. r" q9 D
*/$ x( s- F7 X9 h" k3 E" ` P8 L; `
TimHandle.Instance = TIMx;7 i! Y9 j9 D( u/ F2 G
TimHandle.Init.Prescaler = usPrescaler;: a5 D! _# Y4 T! Z5 H6 y$ Z
TimHandle.Init.Period = usPeriod; ' p0 P+ j) N$ f$ Z! v( d1 w
TimHandle.Init.ClockDivision = 0;0 K! L6 P8 I2 W
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
8 l1 S2 k. C3 y
TimHandle.Init.RepetitionCounter = 0;- z8 ~; S* c7 V9 ?
TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;; j: i- o" u2 I9 p6 r6 i' ?
if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
8 w! v3 Z- ` }2 U }
{" j. Q1 A0 K* F8 C$ |
Error_Handler(__FILE__, __LINE__);
, D- D3 v E7 N8 B E+ k# M0 F
}

复制代码

! F9 F, |; e$ l1 d, i& ]. Z32.3.3 定时器输出比较结构体TIM_OC_InitTypeDef
此结构体主要用于定时器的输出比较，定义如下：

typedef struct
7 J. ?4 x1 q6 `0 @# U: @
{
/ }. t" n9 J" Q+ h! a
uint32_t OCMode; + W) G7 U. l. O" ?# ^2 {* G0 y! y
uint32_t Pulse;
8 J7 ]; m! _1 L& h1 r, \/ h" _
uint32_t OCPolarity; % G5 D' |5 ~7 k* V$ q2 e
uint32_t OCNPolarity;
/ t" A2 Z1 z O6 v
uint32_t OCFastMode;
. k6 `2 U. D1 E: H0 c
uint32_t OCIdleState; 5 D/ z' R' P* x, H a. s
uint32_t OCNIdleState; 4 v' O, I; C8 D" ~3 x" t% L
} TIM_OC_InitTypeDef;

复制代码

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

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

/*!< TIM Output timing mode */) a2 V4 G s* {
#define TIM_OCMODE_TIMING ((uint32_t)0x0000U)
5 z: G* B/ W+ i) ^7 p
9 O3 M2 h+ G. a4 n7 ]2 n
/*!< TIM Output Active mode */
O, d$ H# m" {
#define TIM_OCMODE_ACTIVE ((uint32_t)TIM_CCMR1_OC1M_0) # V0 K- Q F( V% @* `
/*!< TIM Output Inactive mode */ ' N; O/ d0 V& D5 Y4 C' Z5 _
#define TIM_OCMODE_INACTIVE ((uint32_t)TIM_CCMR1_OC1M_1) w. Z' K& A0 u5 U D1 P! i u
2 a4 B @. G5 a0 R0 b
/*!< TIM Output Toggle mode */ ( Q: H- k$ q& h) R9 \
#define TIM_OCMODE_TOGGLE ((uint32_t)TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)
% R ^* k. w6 `) `' \' g/ A
9 d' h( u; w9 U4 a- T0 C/ v
/*!< TIM PWM mode 1 */, _4 @1 \# T( c' W8 |
#define TIM_OCMODE_PWM1 ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1) k5 W7 R) R7 O. H) J8 i5 x, C
! Y0 y" b5 U' |% P5 X# G, V* ^. e
/*!< TIM PWM mode 2 */
6 ]% X- k, d }, G# `9 M
#define TIM_OCMODE_PWM2 ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)
8 t9 S2 p; V2 X6 K+ f
3 i0 ~; I5 w/ N6 D) I% K
/*!< TIM Forced Active mode */ - D- |9 k1 ^, o P
#define TIM_OCMODE_FORCED_ACTIVE ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0)
% U! C/ h/ _: s2 j- [2 W& K
& T& t+ E: J3 m# `1 ~
/*!< TIM Forced Inactive mode */
- ~3 w6 s# a: h7 V+ i
#define TIM_OCMODE_FORCED_INACTIVE ((uint32_t)TIM_CCMR1_OC1M_2) 8 X( Q: ?6 [, Y1 \" k
9 R$ P8 \* U$ d- M- |
/*!< TIM Rettrigerrable OPM mode 1 */ 9 V5 A/ x' R3 f+ s) u! I
#define TIM_OCMODE_RETRIGERRABLE_OPM1 ((uint32_t)TIM_CCMR1_OC1M_3) + [7 Q: A' J S4 g% u& u: Q$ z
' ~. r! F" r* T: b8 e7 U+ `
/*!< TIM Rettrigerrable OPM mode 2 */ 0 @. V( W C9 e: ]( X" U5 B
#define TIM_OCMODE_RETRIGERRABLE_OPM2 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0) 7 t# d3 _2 W+ _) B( |) n1 d1 Q& H
5 q) {0 k, B4 T) ?* ]" n0 @+ n& Q
/*!< TIM Combined PWM mode 1 */ ' N4 k) U& X& L; f/ r4 ~* g
#define TIM_OCMODE_COMBINED_PWM1 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_2)
' v- N0 \+ [' z
8 x5 } f! K+ z* `$ D
/*!< TIM Combined PWM mode 2 */ : u% V$ g l( T" G7 {* j( X! K
#define TIM_OCMODE_COMBINED_PWM2 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0 | TIM_CCMR1_OC1M_2) 0 t3 _% T' C5 E4 V
( o N2 g3 S) M
/*!< TIM Asymetruc PWM mode 1 */
% R: E) ~ }- ]" N# c$ I' b- E c
#define TIM_OCMODE_ASSYMETRIC_PWM1 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2)
$ n6 _5 a* A# n7 e( c
7 o b& s" T2 B( o* {
/*!< TIM Asymetruc PWM mode 2 */
* w9 P/ K, Y( B% d* m: r
#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)
& n/ w+ R9 r2 [7 R, D, V
#define TIM_OCPOLARITY_LOW (TIM_CCER_CC1P)

复制代码

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

#define TIM_OCNPOLARITY_HIGH ((uint32_t)0x0000U)
1 S( Z7 v# R0 L/ I3 n. l
#define TIM_OCNPOLARITY_LOW (TIM_CCER_CC1NP)

复制代码

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

#define TIM_OCFAST_DISABLE ((uint32_t)0x0000U)4 u# M. @; V# t1 _
#define TIM_OCFAST_ENABLE (TIM_CCMR1_OC1FE)

复制代码

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

#define TIM_OCIDLESTATE_SET (TIM_CR2_OIS1)) ~9 ]( r) ]+ u9 ~
#define TIM_OCIDLESTATE_RESET ((uint32_t)0x0000U)

复制代码

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

#define TIM_OCNIDLESTATE_SET (TIM_CR2_OIS1N)
! k) n' u$ V' R
#define TIM_OCNIDLESTATE_RESET ((uint32_t)0x0000U)

复制代码

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

typedef struct
) o1 x: C% z q/ c9 c: M
{
7 \+ ^; B8 E& p l
uint32_t ICPolarity; ) j3 v) Q! q( B- E; j
uint32_t ICSelection;
; v: n, ^) [, K% A' F$ s; J
uint32_t ICPrescaler;
& n5 Z1 m0 W! v6 n0 N
uint32_t ICFilter; 9 ]$ p8 R( C7 X; D8 h5 q
} TIM_IC_InitTypeDef;

复制代码

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

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

#define TIM_ICPOLARITY_RISING TIM_INPUTCHANNELPOLARITY_RISING
6 R1 e) \% R: n( @! m
#define TIM_ICPOLARITY_FALLING TIM_INPUTCHANNELPOLARITY_FALLING; n) [! E1 a& F% D- B& y
#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) ( W2 I* L) t; x6 C) f% A
#define TIM_ICSELECTION_INDIRECTTI (TIM_CCMR1_CC1S_1) " ~& s3 a* Q1 _( s" O* Q
#define TIM_ICSELECTION_TRC (TIM_CCMR1_CC1S)

复制代码

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

#define TIM_ICPSC_DIV1 ((uint32_t)0x0000U) + Q( }( l; g7 u" g j% t
#define TIM_ICPSC_DIV2 (TIM_CCMR1_IC1PSC_0) 8 c9 E e5 y8 o# e
#define TIM_ICPSC_DIV4 (TIM_CCMR1_IC1PSC_1) ; S- J; ?2 y+ _$ S! p, H0 q
#define TIM_ICPSC_DIV8 (TIM_CCMR1_IC1PSC)

复制代码

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

0000：无滤波器，按 fDTS 频率进行采样
+ N1 [% I8 i; V4 i+ a- a. I
0001： fSAMPLING=fCK_INT， N=26 p& a8 k6 v* [
0010： fSAMPLING=fCK_INT， N=4
" \1 \0 b+ H% q5 m! k4 o/ o2 g% B* A
0011： fSAMPLING=fCK_INT， N=8
B/ k% [+ \$ h2 e
0100： fSAMPLING=fDTS/2， N=6
- H" n& w: f0 s8 c& f# ?
0101： fSAMPLING=fDTS/2， N=8/ e5 h5 ~$ J1 ~% p4 H4 r4 H
0110： fSAMPLING=fDTS/4， N=60 i: o. d) S9 K" ]" T
0111： fSAMPLING=fDTS/4， N=87 ]8 x: v: y, }1 h3 Y1 ]' f
1000： fSAMPLING=fDTS/8， N=6
! H1 t. S! b2 k6 P" V* H
1001： fSAMPLING=fDTS/8， N=8* s3 S$ I2 s8 A0 S' J
1010： fSAMPLING=fDTS/16， N=5
' Y; H2 \ ]6 ?% W; F
1011： fSAMPLING=fDTS/16， N=6
1 ~' m2 c. b D# q% G. T
1100： fSAMPLING=fDTS/16， N=8
1 a8 w# a; ?! [/ ?
1101： fSAMPLING=fDTS/32， N=5
! e7 x" ~8 K( A5 m) b5 Z
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)
7 ^8 M' H7 e: P' B6 ?: b: U, N
{
1 F- n: y3 r8 A8 M( M# X
/* Prevent unused argument(s) compilation warning */
7 J. l4 Z5 D) ?6 ^( g
UNUSED(htim);- j+ m0 D5 e6 N8 R. p
/* NOTE : This function Should not be modified, when the callback is needed,% ~# P# l8 u/ t* H- f8 O
the HAL_TIM_Base_MspDeInit could be implemented in the user file% B3 P; v% q3 v* Y* W
*/
2 W% C& n" k3 x7 k( C
}

复制代码

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

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

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

void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)3 ]/ ~. D: V7 Z J: }
{
3 J) g l1 J% z/ n) e
GPIO_InitTypeDef GPIO_InitStruct;' c1 ]# H2 v! z2 y8 u: y
) I' z, t3 v" y
/* 使能TIM1时钟 *// f9 O2 R- Y: |. H% j
__HAL_RCC_TIM1_CLK_ENABLE ();
& |3 a9 Y( k, E3 ?; P4 g/ I9 y
; N4 P& h) K; `1 n Q7 ?
/* 使能GPIOA时钟 */
! i9 v( u Y. X* d1 l+ n
__HAL_RCC_GPIOA_CLK_ENABLE ();* ^* N9 c: Z/ \; G
3 S9 [) A, O. I& Q. M( a
/* 设置TIM1使用PA8做PWM输出引脚，将其配置为输出，推挽，复用模式 */* K8 }9 z; v& R$ v8 H
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;( [8 [! { i: O
GPIO_InitStruct.Pull = GPIO_PULLUP;3 G7 B; e# Q. O
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
9 }/ N b! d& {' l U k" E2 D
2 y2 X: _# W7 A
GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;5 R1 J2 W8 E3 f( m; q; @% o
GPIO_InitStruct.Pin = GPIO_PIN_8;) s2 v. ]% L( P0 Q! n
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
, B" b1 u+ X8 X' {$ u9 \2 q
1 k/ q- N9 p+ F6 w$ r' I
}

复制代码

总结下来就是以下几点：

  配置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 PK1% j6 r. U0 }: ^0 Y& D
TIM1_CH2, PA9 PE11
/ K. N7 f. H) G, W6 f- X4 T0 N1 s
TIM1_CH3, PA10 PE13 PJ9
. q8 M% X, c4 u/ Q2 P( R5 k A5 m5 e
TIM1_CH4, PA11 PE14 PJ11

复制代码

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

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

~- V" C- ]9 k+ a' Z
/** @brief Check whether the specified TIM interrupt flag is set or not.
: k# C4 @, e1 U
* @param __HANDLE__: specifies the TIM Handle.' I8 `$ x9 K- U8 s
* @param __FLAG__: specifies the TIM interrupt flag to check.$ z! G4 a* Q4 E W. |9 N1 ?1 ?
* This parameter can be one of the following values:
9 a/ p; b, P" ?/ `1 f0 d! p
* @arg TIM_FLAG_UPDATE: Update interrupt flag
: N4 ~+ M6 Q$ u( C7 }
* @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
) Q. Q" I& v* W' m: {/ u
* @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag( l% \) ? C G( D2 e l& l
* @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
9 _ B! u* H; U- n S' |/ {: c; Z
* @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
" p6 c4 p1 T1 d3 F% h* s
* @arg TIM_FLAG_CC5: Compare 5 interrupt flag/ W+ K7 K% K4 P% i5 e
* @arg TIM_FLAG_CC6: Compare 6 interrupt flag! K& s# Y, g$ [" N
* @arg TIM_FLAG_COM: Commutation interrupt flag6 {' T6 n! U0 [: r# `' t
* @arg TIM_FLAG_TRIGGER: Trigger interrupt flag" o" V$ l1 b) t! A
* @arg TIM_FLAG_BREAK: Break interrupt flag % U# t! [. B" b
* @arg TIM_FLAG_BREAK2: Break 2 interrupt flag
) a% n9 H# G) l) I0 [8 ~. A
* @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag$ N$ {! t0 z" _" G9 X
* @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
2 ~* L$ ^: {! W9 S
* @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag9 _3 H/ K$ {2 D
* @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag; a- `7 ~( z9 K
* @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag, O. l. i0 d) w) }7 \: r
* @retval The new state of __FLAG__ (TRUE or FALSE).
4 T: G7 j g- `; j+ @" x
*/5 I. D- }2 d6 w
#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.. U+ H: M+ ^' r# h+ d# \
* @param __HANDLE__: specifies the TIM Handle.3 u j2 N3 r0 j/ H4 c
* @param __FLAG__: specifies the TIM interrupt flag to clear.$ g" _+ ?8 @9 |/ z% K( R. C, g, x
* This parameter can be one of the following values:, A& y# Q3 p. o* H+ _
* @arg TIM_FLAG_UPDATE: Update interrupt flag4 H% Z7 S) K; H. C% ?& y
* @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
3 F& B8 [5 o# d: r3 F) \' G2 j0 r# Z
* @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag% v$ C+ Y2 V% c# j& u8 S
* @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
0 j- V" v9 |# Q# d: J$ V6 I5 L
* @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag: R6 ^9 l$ {. @* [; j* s: S
* @arg TIM_FLAG_CC5: Compare 5 interrupt flag2 a2 f, p, |4 V' c, G
* @arg TIM_FLAG_CC6: Compare 6 interrupt flag
4 `) q; z% }) i* `8 g% X( L/ T
* @arg TIM_FLAG_COM: Commutation interrupt flag
% L1 P4 T/ i( |. h
* @arg TIM_FLAG_TRIGGER: Trigger interrupt flag4 Q% ] Q. {" X8 f+ b
* @arg TIM_FLAG_BREAK: Break interrupt flag . R9 U2 e/ [6 P4 M5 W" A
* @arg TIM_FLAG_BREAK2: Break 2 interrupt flag
* a4 O+ }0 v+ b- q- \
* @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag2 X: J( |5 u+ c y& [) p
* @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag2 x2 O* e, x, q9 \+ }6 A
* @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
5 ?, @% {4 R+ Q3 J: `( c; S
* @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
/ E8 I) s5 m- U
* @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
- Z3 r+ X7 M# w2 U$ I" ]) S, i+ i: x
* @retval The new state of __FLAG__ (TRUE or FALSE).
" Z+ p- R! p6 O, I+ x
*/5 ]4 a, k& C9 C2 h( f% ?9 g
#define __HAL_TIM_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->SR = ~(__FLAG__))

复制代码

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

/** @brief Enable the specified TIM interrupt.
# z7 }4 @9 e5 Z, B( p
* @param __HANDLE__: specifies the TIM Handle.
+ e. T1 G) Q |3 J7 A& |
* @param __INTERRUPT__: specifies the TIM interrupt source to enable.
! Q( ~! K: [ h1 }+ h0 f
* This parameter can be one of the following values:
% \+ Z) B- D- A5 q1 p
* @arg TIM_IT_UPDATE: Update interrupt
$ o/ I* b9 T& g! s9 l
* @arg TIM_IT_CC1: Capture/Compare 1 interrupt
t% a5 ~) j5 n5 k3 y! M& u
* @arg TIM_IT_CC2: Capture/Compare 2 interrupt) z8 x4 G, L4 i& Y# B
* @arg TIM_IT_CC3: Capture/Compare 3 interrupt% K- h" R7 C9 t4 Q# t8 m/ j* |. E
* @arg TIM_IT_CC4: Capture/Compare 4 interrupt7 z& Y5 g, N* z: l% j
* @arg TIM_IT_COM: Commutation interrupt
. P# E! x F% Y+ F+ g g& I
* @arg TIM_IT_TRIGGER: Trigger interrupt
9 ], D2 p- e3 E7 _/ W" H
* @arg TIM_IT_BREAK: Break interrupt, l' a! X0 L& j+ b
* @retval None
# I7 r. I- o( u, f
*/. ~( P8 K. W2 r& z* G: P9 p* C
#define __HAL_TIM_ENABLE_IT(__HANDLE__, __INTERRUPT__) ((__HANDLE__)->Instance->DIER |= (__INTERRUPT__))
3 J6 n$ e2 X2 f
- r) R: v, p" _) d% |( V
/** @brief Disable the specified TIM interrupt.0 Y5 X6 M' }4 P- g6 ]
* @param __HANDLE__: specifies the TIM Handle.- ]8 l( O& j( W0 O1 Z
* @param __INTERRUPT__: specifies the TIM interrupt source to disable.
; a3 h6 x- S) r, v
* This parameter can be one of the following values:- t4 \2 t1 d) @0 b
* @arg TIM_IT_UPDATE: Update interrupt
" ^- Q6 ]7 @+ f4 `' p7 H* K4 w
* @arg TIM_IT_CC1: Capture/Compare 1 interrupt
# q" D! J& n& }/ f G3 d* m6 S
* @arg TIM_IT_CC2: Capture/Compare 2 interrupt6 \% l7 ?" Z7 y
* @arg TIM_IT_CC3: Capture/Compare 3 interrupt
9 B+ U# P. r) D0 m6 o+ K
* @arg TIM_IT_CC4: Capture/Compare 4 interrupt
2 u* @9 |/ \: M" @3 m: `
* @arg TIM_IT_COM: Commutation interrupt3 r1 H/ ^" \/ L, {
* @arg TIM_IT_TRIGGER: Trigger interrupt1 ]$ a- t; }+ }0 a" \( |+ S) V5 R
* @arg TIM_IT_BREAK: Break interrupt) s5 ?# g4 I- `( e
* @retval None
. H) o* I5 y0 _0 W( m; q) y
*/
" w% q v' W3 x# q1 i8 @3 O
#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)+ r4 n6 N% U) j8 }/ [
{ 2 l( h* [) j* k$ E$ {4 A
/* 检测是否是有效句柄 */! ~% t# m( H9 L3 S p q
if(htim == NULL)
/ d' C5 @5 o# R5 u3 r
{
8 L+ i" s# I7 `; g* i3 j- g' k
return HAL_ERROR;+ x( t- `1 u% i+ e* Z
}( F* Z% _) D: l3 O
- J, i0 }6 Z. p2 B7 R
/* 检测参数 */
4 e1 l* ~4 h5 j: |
assert_param(IS_TIM_INSTANCE(htim->Instance));
$ X- ~5 e: m; H& b( O
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));; V; v! }* [4 s* u+ c+ O! H
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));0 [0 R9 q8 N% y9 T4 S
1 F0 R1 t+ A% {3 B7 R
if(htim->State == HAL_TIM_STATE_RESET)
S) Z# S/ |+ u. a! ^* D, W- G: |) n
{ ' h9 H1 M- K8 h' u0 r
/* 默认取消锁 */
& T! T% L C8 W0 C" `2 z
htim->Lock = HAL_UNLOCKED;
- R3 l5 ]2 W9 t) c. |) Q- @
/* 初始化底层硬件 : GPIO, CLOCK, NVIC */
& Y& T4 \9 s) m( v2 O9 g
HAL_TIM_Base_MspInit(htim);& M) Q7 \) }! e3 B. u5 B
}
: N# [$ S" }4 R
8 J; [9 Y, C% A7 j3 J* M
/* 设置TIM状态 */
7 ^* X3 {" x A* i7 F0 ^
htim->State= HAL_TIM_STATE_BUSY;
4 L2 p; f! @# x! U4 g
6 g K# r V9 U" n; ]3 I( G
/* 基本参数配置 */
! `# Q3 [: u+ e1 x# m- n9 ^9 e
TIM_Base_SetConfig(htim->Instance, &htim->Init); 3 _9 R8 w n: L4 V) D
* t* n) c; [$ o: m/ }
/* 设置TIM就绪 */
+ F( [, e$ Q% C) a
htim->State= HAL_TIM_STATE_READY;
! ^8 L! m3 o" Y, h
. T$ N! w2 V" D0 |7 O- m
return HAL_OK;
' C" ]8 [! v8 Z7 Q
}

复制代码

函数描述：

此函数用于初始化定时器用于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)% C0 H3 B4 e# M3 c7 e( n
{
9 q3 ~# S2 w; A" w5 z! e% _8 y! t
Error_Handler();
- N1 _) r: d# q
} : H6 V: g% c. H+ v3 s3 o$ C- h
if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
) Z! o: A3 C( q- U. }/ w0 T
{2 n. C5 I. H: u: ]0 X0 n
Error_Handler(); _9 g9 a$ o. B) p) e4 W3 M$ }
}

复制代码

使用举例：

TIM_HandleTypeDef TimHandle = {0};
?% w% `% [8 q/ R
' E) M! Z' Y# k4 v' Q9 f2 G
/* B ~8 L, Y- Y+ a% R' ^8 q' s
定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
' a* h T) l$ y
*/7 _' [5 F K) U: ?6 M
TimHandle.Instance = TIMx;
: Z. h: }& t, a6 z( w+ v
TimHandle.Init.Prescaler = usPrescaler;' v3 e5 E- S9 d& q. i# \: k' F0 [
TimHandle.Init.Period = usPeriod; , r3 m( F) s/ h9 y' r
TimHandle.Init.ClockDivision = 0;
' Z3 O# I+ B8 |- v! g. }
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;$ I1 @9 `9 P5 V8 S7 e
TimHandle.Init.RepetitionCounter = 0;
2 O) C Z% ^3 G/ d D( K
TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;0 n. ]) d# g2 W/ U7 Z* P! c
if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK), c3 c: Q C* U5 }' p
{
4 ^. T( ^5 T6 S+ o
Error_Handler(__FILE__, __LINE__);& ^0 Z) D5 ~1 c0 v8 J2 o
}

复制代码

32.4.2 函数HAL_TIM_Base_Start
函数原型：

HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim), h" B8 E: f& l* U' m# M
{
2 v0 X; ?6 P% H" Y4 G
/* 检测参数状态 */
/ _: W9 h! H. p* W+ H/ c# a* O
assert_param(IS_TIM_INSTANCE(htim->Instance));8 t1 b: \# A! y7 B1 a. ]
2 h7 H) r7 T l; i" D- b
/* 设置定时器状态 */
; {+ G$ y) B/ b* _
htim->State= HAL_TIM_STATE_BUSY;5 @1 U2 P4 g5 s* j+ t0 j- L) |
7 I) C0 L5 Z# U; d
/* 使能定时器 */
# @) R$ n) |. W
__HAL_TIM_ENABLE(htim);
% O6 g" M! F2 ~ v: Q& P
+ D" l" F* i+ Q, c& a3 I+ G
/* 设置定时器状态 */2 E# }5 @& Z, H$ `7 e
htim->State= HAL_TIM_STATE_READY;
9 I7 P. f) f7 c' n9 J
8 T" b1 Q% A) P/ C' q
/* 返回HAL_OK */
, s/ C5 y8 I* b; L6 f2 V
return HAL_OK;6 n/ j% S! x5 r1 a
}

复制代码

函数描述：

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

函数参数：

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

TIM_HandleTypeDef TimHandle = {0};
, N- c# w8 O0 i9 E: C8 G
) u" a6 O: |/ W
/* 7 q* ~+ E; c# d1 G* R
定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
2 w# H* g& I5 o& N
*/
6 t/ f& q" k' n1 E" q8 s. o4 Z% f7 M
TimHandle.Instance = TIMx;8 m" L0 a9 g' M1 \% X: o
TimHandle.Init.Prescaler = usPrescaler;
: l5 q. n2 B' J3 w. n
TimHandle.Init.Period = usPeriod; D4 C5 {( A6 w+ \/ E
TimHandle.Init.ClockDivision = 0;
# @ u1 B+ }8 i1 U
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;1 c4 N% a" l3 ^2 Y$ _- r- K1 ?4 r
TimHandle.Init.RepetitionCounter = 0;
8 h7 m; R5 m& c& t
TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
# d; t3 b: D& V' [% F
if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
% k2 |! g2 I0 A' `% J- U3 J
{
$ A+ g) t; b7 [; Q; m8 F
Error_Handler(__FILE__, __LINE__);% [# N# K9 @" t2 f; i& s
}0 J# |( h( G2 K( F9 E$ {& ~
& O# C9 h4 i# n& E5 T* H( j5 F4 R
/* 启动定时器 */
$ x6 ^ k) a" l0 X- V0 D2 ]) o: o$ ?
if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)( G! i6 a# M" V
{% L) h* N" B q
Error_Handler(__FILE__, __LINE__);- L+ t% i9 _8 [
}

复制代码

32.4.3 函数HAL_TIM_PWM_Init
函数原型：

HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)! e+ T4 m* J# Y% J4 ~
{
4 c/ c9 O8 C+ ^: w
/* 检查句柄是否有效 */
" D5 K/ A7 m+ ~. u1 ]3 a
if(htim == NULL)7 H, B1 w5 v5 x7 w
{4 K, p& b$ ^) Q0 N3 c# R: |+ z+ ~
return HAL_ERROR;
9 h/ e6 w5 |& d0 u# D
}+ F4 p7 r( n! l; ^
& Z6 U4 `( H3 [0 y0 i6 D+ n
/* 检测参数 */' i. F# z- {+ l9 {/ z
assert_param(IS_TIM_INSTANCE(htim->Instance));, q$ U; [" f- I
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));6 i' }% s8 {5 F6 K/ K7 t. U
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision)); e& @5 I8 E S$ ?* C6 [+ h
8 O: b2 Q- ]2 n$ l9 o. K- ~
if(htim->State == HAL_TIM_STATE_RESET)7 X) ~# F7 V7 u- U1 G$ T/ w
{" m* y. q5 H5 @3 l0 l
/* 默认取消锁 */
+ z2 m0 }- G+ h4 e7 v' K+ j/ e
htim->Lock = HAL_UNLOCKED;
: V9 C* j _/ A2 L. Z# L
) O5 S. p& s5 ~# T# C
/* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
6 @1 i) @2 `% v# k
HAL_TIM_PWM_MspInit(htim);
o8 C, Q) P5 Z" e4 A; L
}
& c+ I( H: C1 e8 I4 _$ u$ v6 f! U. s
1 {! P6 O. r: Y
/* 设置定时状态 */
& |4 v: s) `, ~, ?' w# y9 w
htim->State= HAL_TIM_STATE_BUSY;
& I- b7 B+ Y" o- C# w
, c3 {/ q. ] a& J3 j
/* 配置定时器用于PWM */
: c/ Y% A% U P+ N
TIM_Base_SetConfig(htim->Instance, &htim->Init); , J2 U7 _6 N* P& `
6 t+ Q! ^1 w+ ~1 N' w
/* 设置定时器状态 */
6 h# y" P: }# I/ t9 k8 f
htim->State= HAL_TIM_STATE_READY;
; @1 |) ~+ O% n/ p8 X# z
$ ]2 j' E8 }1 a t: J7 R
return HAL_OK;
) e( ` F! W3 t; \% j2 \
}

复制代码

函数描述：

此函数用于初始化定时为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)
. U4 Z" P7 u; A1 M* \
{
2 [( s0 ^- R6 _1 h
Error_Handler();
' U3 {( p5 _ y
} - i% Z. }) N! |4 }/ W. p
if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
4 t+ `+ i6 m* l9 {3 A# j
{8 A' _7 C- {4 o6 J8 B. ?0 {
Error_Handler();
# P" Q5 d- [) d2 p" b7 i
}

复制代码

使用举例：

TIM_HandleTypeDef TimHandle = {0};
+ e- _( z7 x( T4 Q( k, L0 M* Z
2 j7 |5 ^1 i) P: f. _
/* PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/1 `6 g2 K8 y# |) E/ }
TimHandle.Instance = TIM1;
& Z4 w8 `0 d# ^ S6 R# D3 Z" H
TimHandle.Init.Prescaler = usPrescaler;9 j- Y0 Q7 C6 |; Z
TimHandle.Init.Period = usPeriod;1 O) @( x, U: I# B
TimHandle.Init.ClockDivision = 0;$ O+ C. i' {2 c
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
% @& P- }0 \* }+ d3 I
TimHandle.Init.RepetitionCounter = 0;
8 m' m* U( x0 M: j
TimHandle.Init.AutoReloadPreload = 0;
/ u9 x* C! u( \
if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)- r9 |) l6 R* s2 R: V9 z
{8 D1 ~' \" p8 {; N' C, R
Error_Handler(__FILE__, __LINE__);7 D p5 _/ N, t; R( X' ~
}

复制代码

32.4.4 函数HAL_TIM_PWM_ConfigChannel
函数原型：

HAL_StatusTypeDef HAL_TIM_PWM_ConfigChannel(TIM_HandleTypeDef *htim,
( R4 ~7 I* V' I& d8 R e
TIM_OC_InitTypeDef* sConfig,! j. Z! ` v* b3 |/ g
uint32_t Channel)
$ Q! n$ ^% B/ B
{
# P: H' f' y" z& @) B8 [
/* 省略 */( r$ t$ f% M6 F9 W" P7 {
Y& b: }8 Y% }5 C
/* 开锁 */
5 V& _. v& j$ c8 A4 s+ b- f
__HAL_LOCK(htim);
0 N3 W$ z4 t+ K6 J: J7 ?- h3 ^
9 n. S) w0 N) n3 H+ n" K: D2 g
htim->State = HAL_TIM_STATE_BUSY;
. ~% k* E3 U; o7 O7 P6 U
0 R% v$ m0 P3 U8 u2 ]7 ~1 |% b
switch (Channel)
8 Z! E, t. W& D* n/ P; R5 q
{
" p: H8 J9 u( ~% t
case TIM_CHANNEL_1:
& ], a0 g) e- T o
{
/ w- }" u V) m+ Z, C
/* 检查参数 */( u$ y' h* N! ], R
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));: s( O1 c$ E6 ^4 ?. L
9 j, f1 Q |+ o
/* 配置通道1的PWM模式 */
, I0 F5 |: S# y
TIM_OC1_SetConfig(htim->Instance, sConfig);- j( e* w) ?/ m* L( W+ _
& k0 a7 H' J& v4 c. w5 {
/*预装载使能，更新事件产生时写入有效 */
! b* ]/ E, _- Y6 b) B9 A0 k4 X
htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;$ P. k# a7 A8 @+ l, H1 K6 w/ b
; h( ~% I, |* {5 D5 T4 W' g& C: x
/* 配置是快速输出模式 */
: I4 p/ Z7 e# J0 c a+ _( V
htim->Instance->CCMR1 &= ~TIM_CCMR1_OC1FE;1 d& P Y }. y& k
htim->Instance->CCMR1 |= sConfig->OCFastMode;( o1 x. e! j9 B9 N$ c! G5 b; x
}
1 a* f+ D1 B8 t9 Z, a# t
break;. |, R/ ~4 Y) B7 z
: s3 ~$ B# \# S& B" o W
case TIM_CHANNEL_2:
3 l' p1 x" |5 ^
{6 Q, T+ k% j! c( R& Z6 |
/* 省略 */- H& t& n# `2 u: Q8 \3 P8 w# O% D
}
- c9 P8 \ P, O- d
break;
6 M4 e! ?, w4 z0 {
& P! i4 z5 [: @0 `7 H' D
case TIM_CHANNEL_3:
( v: x2 a9 g* c* i, r: I# E
{
& {& i* a/ {" J# M( s/ s* A* ?% Y
/* 省略 */
, l2 ^9 l5 @6 r
}) u. G( ~3 h5 z! ~1 v1 |
break;) {. ]0 v! b |2 B, z
6 Z# O& y5 d5 y" s0 D
case TIM_CHANNEL_4:3 X1 j% A* b* q1 C
{) n- @" B7 I4 l. Y
/* 省略 */
$ n1 l7 E9 g; f0 y0 M9 l
}
& m: w( }* s/ r! P6 O8 x" S
break;* G% N b5 N" a1 }1 t, V- A; h/ o
' K& W0 b* O; v$ K, Z
case TIM_CHANNEL_5:4 A2 Y6 {0 P6 U5 F, J- h
{
9 {8 q/ k$ K& g7 Y1 z
/* 省略 */9 X6 U6 K0 N; _, ~
}
% V7 w9 A. q% K; |
break;% u0 N. U6 P0 N J, S% r
! `- B, |4 v$ n& L' e( t
case TIM_CHANNEL_6:3 i2 A/ J m7 ~; g! v
{
' [0 g1 p/ Y" z5 F# O6 Q- l$ r$ _7 D
/* 省略 */
1 r& r" h" [; l7 m
}& i: A+ [, h. d' {* e! ^5 {
break;. S1 q7 X% w4 ?6 Y3 m7 @1 @1 ~* A
0 p. X, }! q( ?! l' L1 l7 y+ ^
default:
( s v0 I: G2 `. k" T; K" d$ a' C
break;* ?; A, P* P) M
}; j" \! l/ W" |
- ~0 Z& K* P8 g2 a! l+ V6 d
htim->State = HAL_TIM_STATE_READY;
6 a2 c2 r+ ?: W' J. J( O5 m. ]% V
$ t- D1 s) P1 _: g3 c
/* 关锁 */
0 }( s# z/ r: T w" G
__HAL_UNLOCK(htim);$ B0 y) z) P: z' V( R) f
) ?; n* i5 g$ _5 q4 s; q" I
return HAL_OK;7 f, v. O. ^3 |4 U' y
}

复制代码

函数描述：

此函数用于配置定时器的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};
+ h6 y' P& z, H, I* R
. ^/ A6 m) B8 w3 J* H
/* PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
6 m# U% F4 w) T, f* y
TimHandle.Instance = TIM1;1 ?- z- e3 d. a
TimHandle.Init.Prescaler = usPrescaler;
m& G5 Q' m! K7 L7 _6 P
TimHandle.Init.Period = usPeriod;- {9 C; D Y {/ ?! i2 L! p
TimHandle.Init.ClockDivision = 0;8 b h( S! o! K8 {; ~
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
; e) x8 j0 C; F0 g+ N# z
TimHandle.Init.RepetitionCounter = 0;- R) k. Y; [3 s6 ]1 g; ]0 d: V* }
TimHandle.Init.AutoReloadPreload = 0;- `2 a$ |+ Z$ o: o4 F$ e: x
if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
0 G8 h! o d; S) m# z
{
: J5 o( {: E6 d3 y/ n$ T# X4 n
Error_Handler(__FILE__, __LINE__);" w6 t4 U1 o; y# c
}
7 @8 M" p; z `
' z( E# ?8 H1 e' y
/* 配置定时器PWM输出通道 */% [+ |7 O% L' {) D$ Z# k/ k
sConfig.OCMode = TIM_OCMODE_PWM1;
# e9 @8 W) q4 z% ^* i( [$ c
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
$ M! Y0 F1 \# ^1 q' y) E- n/ U& d
sConfig.OCFastMode = TIM_OCFAST_DISABLE;
3 @3 w: `! g) G( [; ^( B/ y# K }
sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;
& @% O! X h$ m9 T$ x( u4 }3 t
sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;- }6 ^1 i x: y* P
sConfig.OCIdleState = TIM_OCIDLESTATE_RESET;
! o- @/ t; Y9 H4 N. X" Z! S
+ V% N5 u5 a: m8 z8 G! U
/* 占空比 */$ h: R, \0 Q4 y1 \& v
sConfig.Pulse = pulse;
0 _. b7 V1 |( z2 {$ M% f( l
if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)) W6 T6 }* @% I
{ Z- ^3 n* E7 c& `5 f- i* q. H
Error_Handler(__FILE__, __LINE__);, k) Y" v. Y; d: h
}

复制代码

32.4.5 函数HAL_TIM_PWM_Start
函数原型：

HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
* C5 @! l1 [. c" m/ d/ ]1 ?
{
% T2 D1 @. _- @. t% L" Q, y
/* 检测参数 */1 F4 q* }$ {4 O3 |! R5 ~* q) N( r
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));% w" N/ I: r! _9 T1 d
$ j. k9 l- n+ t0 d7 j
/* 使能捕获比较通道 */
" } U; M1 t1 A
TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
" G- \3 Q8 A7 M! Z4 c) n
0 {1 j {, {9 T, M
if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET) # q9 d* l) V- R& Q, E
{
$ g" ?# P5 A$ |3 h7 I& q8 Q
/* 使能主输出 */
# ~& q: E, U/ h5 S2 }
__HAL_TIM_MOE_ENABLE(htim);
. S7 H3 @, C0 U5 C8 @# i
}/ g: K7 y( {9 R6 S9 C
. D$ `$ G) m/ `& R* b/ W' F2 q
/* 使能定时器 */, N! Y: T6 l/ V5 ~, F' r
__HAL_TIM_ENABLE(htim);
1 F ]& T8 c" q2 u) p: d" `. K' _
8 F5 a& O7 _7 @ V/ c; j
/* 返回状态*/6 ]" ~! V- L& n) D
return HAL_OK;; r: H M* {4 t' Z% H. `( x
}

复制代码

函数描述：

此函数用于启动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};
$ T! a4 s2 q7 K E) e: u
4 H' w' F' q: z4 w1 i
/* PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
% \' ^' a, n' S1 G5 R8 K) l
TimHandle.Instance = TIM1;
- h2 N- l. d0 W
TimHandle.Init.Prescaler = usPrescaler;
1 L1 f( _/ D7 v5 l- a
TimHandle.Init.Period = usPeriod;
u4 o! s& ]; R$ O* F
TimHandle.Init.ClockDivision = 0;
$ b; b5 p2 ~# E( Q& F5 }$ _: r/ i
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;$ e5 |. K+ E7 k% F/ v+ n& G, C
TimHandle.Init.RepetitionCounter = 0;
/ g0 j; Z. j- _% h ^1 l
TimHandle.Init.AutoReloadPreload = 0;
) x- r6 Q( d6 c- }
if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
8 I7 u; p7 J5 H: m3 _
{( ?, ]( I& F1 M
Error_Handler(__FILE__, __LINE__);
7 Q" w d; w7 F
}
& ?" }( @! t# x) [
: F" l5 b2 p, q1 K+ K6 J' N2 H1 ~
/* 配置定时器PWM输出通道 */0 X+ r. t8 B) E$ T& n1 c1 u
sConfig.OCMode = TIM_OCMODE_PWM1;
2 W$ R, W1 Z9 ~3 ?% w4 Q
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;: Z" O. o- ]- s
sConfig.OCFastMode = TIM_OCFAST_DISABLE;% Y1 X5 g, B9 m% S* @6 s- g
sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;9 i! ]% {8 z; v( x R7 b; W8 N4 c
sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
6 T1 O( Z9 y& |/ o
sConfig.OCIdleState = TIM_OCIDLESTATE_RESET;) ~+ o3 o3 U& U% R# @$ ~. H
2 h- Y$ |( z5 Q6 A7 }" S Z
/* 占空比 */
! L& @2 Z. k a' D9 c
sConfig.Pulse = pulse;
, x- Y2 s0 P0 i6 C9 W3 Q% u' M
if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
- `* \' t# {: b
{
: e; y& G' S/ \% r: }
Error_Handler(__FILE__, __LINE__);
$ @* a8 f* k& ~ D& n
}0 C F. Q/ V& y+ Y5 \4 @% h% O" z
1 O. M$ a" S7 Q7 H% H$ Y: ?
/* 启动PWM输出 */' C7 W' j! A. r/ H
if (HAL_TIM_PWM_Start(&TimHandle, TimChannel[_ucChannel]) != HAL_OK)
- k* @2 Z/ _0 H5 @' f
{
% R, h' U6 [: W M3 P- t4 v
Error_Handler(__FILE__, __LINE__);- {; o% f# A F- v
}

复制代码

32.4.6 函数HAL_TIM_IC_Init
函数原型：

HAL_StatusTypeDef HAL_TIM_IC_Init(TIM_HandleTypeDef *htim)& d6 n' N* G$ h; J2 J" S- Y
{
6 P- H. N4 C5 a5 r
/* 检测形参是否有效 */
5 C9 R% s/ T& R9 ^( p5 B
if(htim == NULL)! X5 U& L2 W5 n
{
" `5 f Y+ X1 @2 ]1 f( t" ]
return HAL_ERROR;. J$ F2 V% p1 |
}; e) C D* |' x- E
1 H7 o; Q% D1 O! z" T
/* 检测参数 */
* l+ @6 I: K6 ]( N/ {/ u7 \: _0 }$ A
assert_param(IS_TIM_INSTANCE(htim->Instance));6 X0 [1 k3 R$ Y
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));4 W% @" _, f* \ X
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
9 e) U( O/ c& y" L7 _$ ?
* V; Q- E3 n h5 D7 V# S
if(htim->State == HAL_TIM_STATE_RESET)& a5 G) v( o% e. Z: R
{
6 Q! l* t* P3 ]( c% N% I" i( ^
/* 默认取消锁 */$ f# [5 j; C9 A( h4 P1 P
htim->Lock = HAL_UNLOCKED;' Z1 ?/ q% B) t6 d4 ?
/ S5 p, G' d" C1 o, h
/* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */5 W |$ Q9 U5 c+ S: m' c3 S' Z
HAL_TIM_IC_MspInit(htim);
$ R5 [: U K& k8 ^, q
}
; ^/ ?# `; N9 v: O, |. s
- r) Z P( E4 {2 C
/* 设置定时器状态 */
7 }1 n" l) R) n6 L, x1 A* _1 U
htim->State= HAL_TIM_STATE_BUSY;
& q) |8 J! [' c# ^7 f6 O
, T' E( j; Z. G+ O
/* 配置定时器为输入捕获模式 */ 9 ~# p3 j. j9 ^" H$ }
TIM_Base_SetConfig(htim->Instance, &htim->Init); * q% F1 z; Z- {
, e j! G$ @- a: O1 ~: T9 Z
/* 设置定时器状态 */
, R6 ]# z; N4 h) |/ ~1 z' h w
htim->State= HAL_TIM_STATE_READY;
/ P: [8 y3 e: _7 f5 F
& ?" m& t! m0 R) k* G
return HAL_OK;4 C" n0 C, f8 I: l6 J* L, e: a
}

复制代码

函数描述：

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

函数参数：

  第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)
- }4 o. Z7 [; p' l B
{
/ S2 W9 d4 I, c: H
Error_Handler();1 z% S* i% z! Z7 m" {
}
1 v {; }; U0 t
if(HAL_TIM_IC_Init(&UartHandle) != HAL_OK); |& ~8 R* f6 a' y
{( q6 m$ n ^" U
Error_Handler();, Y/ d7 N3 u" \0 Y$ B1 X. A4 C
}

复制代码

32.4.7 函数HAL_TIM_IC_ConfigChannel
函数原型：

HAL_StatusTypeDef HAL_TIM_IC_ConfigChannel(TIM_HandleTypeDef *htim, TIM_IC_InitTypeDef* sConfig, uint32_t Channel)" o3 t" h$ d6 X: ~$ ~
{6 X! \, r, b& }, h4 s
/* 检查参数 */
8 i# |8 d7 @) W9 f" T
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));- F( e5 f8 w9 H, T
assert_param(IS_TIM_IC_POLARITY(sConfig->ICPolarity));- m% ^- U% N6 i
assert_param(IS_TIM_IC_SELECTION(sConfig->ICSelection));. Y# |6 c/ r$ `7 l7 G* t b
assert_param(IS_TIM_IC_PRESCALER(sConfig->ICPrescaler));; L: P+ q* u* u6 M8 e5 T
assert_param(IS_TIM_IC_FILTER(sConfig->ICFilter));
+ w/ I, V" Y! M! b# r. `$ w
+ R% `. i6 g% }1 p+ Q! t7 f
/* 开锁 */ " l. m' I( C2 R, I. Q
__HAL_LOCK(htim);( Y9 L/ A1 Y+ c3 K0 \4 A
! A' Y! {3 b5 }. H0 i+ O# z0 n% i
htim->State = HAL_TIM_STATE_BUSY;$ r5 ?/ O( `* b2 m( M
7 [4 F4 J) b% Q7 \" F8 Y4 ?. d
if (Channel == TIM_CHANNEL_1)% N, Q/ m, I1 B: b
{
( L/ A `) n A- y
/* 配置输入通道1 */
9 k6 G0 M* H, a% f6 h; Q
TIM_TI1_SetConfig(htim->Instance,
3 J% R, ]% _+ z2 \
sConfig->ICPolarity,4 j7 J2 ~. G; [ J3 A
sConfig->ICSelection,6 E8 \* o: G) {2 _% ]3 B
sConfig->ICFilter);- ^, P2 O' ?4 t7 A; i- X3 H
9 ^% V S, f9 M) u& u3 j; v8 \
/* 清零IC1PSC位 */
- ]1 F0 d# i! t, \2 q' z/ [% K: z
htim->Instance->CCMR1 &= ~TIM_CCMR1_IC1PSC;
4 K V2 z& ^& v6 S5 z2 `
6 y7 j* I7 k% t @4 N X1 w
/* 根据用户配置，设置分频 */
- l4 U0 _) r0 z% Y6 e
htim->Instance->CCMR1 |= sConfig->ICPrescaler;
! G9 M3 t" M2 `
}
+ ^; ^: [ {: a! {! ^
else if (Channel == TIM_CHANNEL_2)" o9 Y8 I. s, s; @# l% ]' d0 x
{
7 u1 ]' \: ]7 ]. j ~0 T
/* 省略 */' W6 k# f: B9 p5 {; m& @6 Z
}0 \2 A8 s) ^2 m& T% T$ L. i
else if (Channel == TIM_CHANNEL_3)% m! L" c# \6 C) V
{5 ]: h: \! g M2 ]0 ^, I5 h$ I
/* 省略 */
$ g6 g7 R% w5 D! v( }, }
}/ F8 k5 t9 ?+ e8 m
else+ g5 U& j* ^* A3 }4 J; L6 h% N$ L0 R
{ N- a- r9 w I
/* 省略 */+ A( X, P1 r9 r( p
}, L1 `' P1 b, v' y
0 J+ Z% k" D! I/ ~' M
htim->State = HAL_TIM_STATE_READY;4 ^6 _3 h' r7 E
; n$ _" z+ b( I( \
__HAL_UNLOCK(htim);( T. [$ ^* J K
# S/ Q# U- F) k) P( |( `
return HAL_OK; 0 d0 D; W0 X2 }& V7 O& j
}

复制代码

函数描述：

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

函数参数：

  第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)
8 x; B6 }6 g8 R$ y5 B
{
7 B; R! P3 R% {& i* z5 j6 ~
/* 检查参数 *// n2 }" M' I+ x5 A
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
: z5 O2 e5 A* G/ p+ ?
8 F0 ]- L' ?$ \9 E3 }
switch (Channel)5 t: Q% {# E c0 U" r; W5 h
{, h) F6 w6 ~6 X# @( j& ?: l7 j
case TIM_CHANNEL_1:2 }, x; m' J& B+ S# \, k
{
" j8 k, A$ i+ R* C3 T( j r! Q
/* 使能CC1（Capture/Compare 1）中断 */
" Q' B$ n: s$ h5 ]
__HAL_TIM_ENABLE_IT(htim, TIM_IT_CC1);
- P$ }) l" q8 v8 u' Y. E! i6 b% G1 m
}
- D6 O1 Y# L* C6 t) K1 w% {* d9 T. y
break;
" R4 t% F2 J" H" x% [
! f- L6 l0 K' K1 a! C& H o) e0 v
case TIM_CHANNEL_2:
r) } K1 s9 u' q( Y% H9 A
{
6 D& f. g$ U8 l1 @
/* 省略 */' _3 i" {! P3 C$ E9 O* [
}# _7 d5 b2 v! T# k+ ?! s
break;/ f9 t/ s. M3 j+ ^- [3 @
7 Z! q" }7 C |! ^6 W7 t
case TIM_CHANNEL_3:% F* c- v9 B7 M, M- P2 i
{: f. E% L8 _9 r# D7 b" n$ J- D
/* 省略 */
' A. _9 ]. X8 U e
}0 q7 P( V. C; i W
break;
. X( E9 U' `0 K! { i$ h
2 D3 _0 B% c$ n
case TIM_CHANNEL_4:
9 z3 Q9 h' T6 ^4 k* C. |( u Y! F
{& Z& _' Z5 d' @4 F6 l5 ]8 O
/* 省略 */. E+ @% @4 ~% b$ {: Z- B
}+ F7 L' Z9 g* T4 h( \3 u+ X
break;% ~. ]5 N* Z2 b5 J" t
6 ?( {5 E/ e4 F& k
default:
7 u' j/ O- G* _9 d, a
break;! I: p5 W4 M2 L
} " N7 o! P( o7 {1 [
/* 使能输入捕获通道 */6 n- J- [5 @+ `9 b. c4 t$ P
TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
9 M9 ^; l% i0 |' H
$ R0 @3 l3 m. x% T6 g; D
/* 使能定时器 */' f9 ~0 L/ \2 C" Z/ ^6 L
__HAL_TIM_ENABLE(htim); 6 i0 o4 t( s8 P7 D+ k/ w1 o
. J r6 v, V- [4 h+ g" [
/* 返回状态 */
) Q; \: @& b+ k/ Z+ F4 u
return HAL_OK;
% |' t' u( C, L5 [) U2 L5 M) h% q5 I
}

复制代码

函数描述：

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

函数参数：

  第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)
6 x0 ]/ \. J+ ^* ^; V; `
{/ Y( t8 l3 z7 `8 n7 N. o5 ^
/* 检测形参是否有效 Check */
: ]) _# z$ e/ i+ ^! F0 }- Y
if(htim == NULL)6 r6 I* V% `, j+ k4 D
{% u5 V9 I1 i4 e. J; @3 a# B
return HAL_ERROR;
% v! H/ M" }7 r( m1 N7 ~% i8 l
}
7 ]4 s; [2 v. m% @8 t1 @3 Q
6 R. n+ z. Y1 i, d; A
/* 检查参数 */
7 S6 O* f! h, t, P
assert_param(IS_TIM_INSTANCE(htim->Instance));
% g8 j/ m. n" `
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));3 y; M K1 K; ?4 h! I
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));2 g/ F5 ^) `) l& ` y2 u
. _- ]- Q. O) F8 ?
if(htim->State == HAL_TIM_STATE_RESET)& Z* h1 I+ c6 c# Y- c* K
{
3 j. s" z- o: v
/* 默认取消锁 */
! P/ O( ^, o- j8 J
htim->Lock = HAL_UNLOCKED;
& h! S; _! h, J8 i4 I7 H" @4 c5 g8 _: ~
/* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
9 D3 v2 Y! k) G7 K
HAL_TIM_OC_MspInit(htim);
% A, n/ [1 v2 C5 i( u% f
}
" P) y( N/ k3 x' v8 b" a
. S; i8 m3 v9 ]9 H3 l
/* 设置定时器状态Set the TIM state */) f% M7 j3 j' \/ C. G8 r/ h7 {
htim->State= HAL_TIM_STATE_BUSY;
; t8 z6 R. D) K i
9 {% {( T8 ^' {" ?
/* 配置定时器为输出比较模式Init the base time for the Output Compare */ ( R1 ?9 H4 S8 m
TIM_Base_SetConfig(htim->Instance, &htim->Init);
9 L5 T9 |( B) {
+ n8 p" q" q9 m7 N; h% H
/* 设置定时器状态 */
8 _5 S& c) _# I3 G# y7 v' \
htim->State= HAL_TIM_STATE_READY;
% K9 a& p7 t( d- Z' [; j, h; m
( P' Z7 J- h" ~- a) f
return HAL_OK;$ q+ a! L: | z K6 K
}

复制代码

函数描述：

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

函数参数：

  第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)
5 Y# F( l" ?' M! P" E: x7 F# a
{
4 }7 Z+ q7 I; W
Error_Handler();
+ ]& j5 N2 b: G4 E5 P" a( F Y
}
+ v* d1 t3 Q8 }! |% _9 ]( O
if(HAL_TIM_OC_Init(&UartHandle) != HAL_OK)9 B: a+ e1 T3 m! V& _5 @8 h ` |
{
* k# k2 _* S1 t7 R1 D
Error_Handler();
9 {/ P! M3 _0 y; O
}

复制代码

32.4.10 函数HAL_TIM_OC_ConfigChannel
函数原型：

HAL_StatusTypeDef HAL_TIM_OC_ConfigChannel(TIM_HandleTypeDef *htim,
$ T' ^& }8 }, o/ L3 |9 a
TIM_OC_InitTypeDef* sConfig,
% V. N% R6 O) V, j# `' G9 h3 i+ A
uint32_t Channel)
( f7 _$ t q9 X) ?& M8 a6 E9 q
{
% Y6 o$ F: R) V. ~# y( Z$ ?
/* Check the parameters */
3 T# Z& I5 \2 D8 `8 }: O
assert_param(IS_TIM_CHANNELS(Channel));
1 F h: X9 L( a! @
assert_param(IS_TIM_OC_MODE(sConfig->OCMode));: I3 G6 J2 ?$ u$ g
assert_param(IS_TIM_OC_POLARITY(sConfig->OCPolarity));+ E6 `7 u$ z8 l/ H: g0 J) k
/ D' P0 u0 u$ r4 a
/* Process Locked */$ m% J2 h: w4 D& X' K& ?/ x% U9 o
__HAL_LOCK(htim);
4 `2 N5 i) r8 ^. ], w6 O0 p: w
. P* @3 U& U# W1 ]; ~' R
htim->State = HAL_TIM_STATE_BUSY;
% A1 i3 z, x% g/ s- C9 d
7 Y- l, W# f* X/ o4 y& q0 t! u8 K! i
switch (Channel)0 u! S. Z0 e( L
{7 u h* I' I/ g; j/ F( H# P
case TIM_CHANNEL_1:2 j6 J3 c! k2 [8 |, P
{! d3 S7 m3 J. ]% B; ~
/* 检测参数Check the parameters */$ l; g# o5 \3 X* F3 O/ h1 y
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance)); " J+ q/ f0 m# P% a. p2 Z, M
8 G" G1 b& t% ?* Y* q
/* 配置定时器输出比较通道1 */0 H6 e0 @: b" g6 e o7 `7 L% l8 l! y
TIM_OC1_SetConfig(htim->Instance, sConfig);
# E [8 ]$ U! a, S
}
& R2 o. b1 |! G( X8 S1 S
break;
6 ^2 r$ z- w7 H6 Q# B
case TIM_CHANNEL_2:* U/ }3 ~" o# w# R; {" ~
{
/* 省略 */
( t3 J' O7 ^. f& o! k% ^# y) e
}, O3 f9 ?! n* I4 ^+ S
break;, s) @: `% \1 M9 T; F
8 X7 I% @" L; T
case TIM_CHANNEL_3:( D7 ^5 q$ w6 W$ V, P
{
, m- m7 T$ `. a% `' E1 `
/* 省略 */* Y9 Z7 d& d% k* J7 _; Y% W
}
) g f( s" N# t3 I8 N
break;' w* L' t# E: Q8 H1 R: |
+ t, H) \' T0 k" K/ B) R8 L
case TIM_CHANNEL_4:
9 Q. d! S5 K" ?1 J( z$ K
{$ V5 G! |; W) {0 B0 x+ ~
/* 省略 */
/ q/ r- C/ J* I/ R
}
* `$ W* f y: H6 T& ^! R
break;
8 J0 C7 X- w, E" ^1 g: ?
# z3 M4 o+ ?" C
case TIM_CHANNEL_5:$ c6 t6 R1 Y$ j. T2 S4 c* U+ l3 Q1 R/ G
{
/ Y, B h! Z" P1 }/ L: a$ ]
/* 省略 */5 l2 o+ ~! n5 H; a8 h% i: i( p4 r) S) i
}
! b& _; w F7 l0 I5 x
break;
5 j! {, s3 @3 `) j+ ?! h
1 f: c l, _+ C. H
case TIM_CHANNEL_6:% [5 u' m) [ F: ]# M
{
& d- ~- u: M& g5 d8 z$ J5 _
/* 省略 */
0 I/ J. u& v" o; T# S. U
}+ ^( g. ?8 R% M6 `6 y, G
break;
' v: w- f+ Q2 w* e* a% _. z$ d% ]
! Y6 p3 D& C6 |$ Z' W% b
default:8 j8 n# }; B U9 g& F
break;
+ F+ H! s& O7 O. l, U
}6 m" h& L/ b' W. n+ S( B2 B
0 n7 ~- D' Q1 C/ r- k) Y* K6 m
htim->State = HAL_TIM_STATE_READY;
/ t+ ?7 L& q* ^3 ^" _
6 ?- D9 U% Y" B
__HAL_UNLOCK(htim); ! w' w% T7 J' ]
" E$ y$ y* F& w3 n* }) `
return HAL_OK;+ N/ u0 Z" N3 e3 T* n) F6 v8 l+ v
}

复制代码

函数描述：

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

函数参数：

  第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)
7 L3 ~9 r! C# @. Z. a
{: z' v6 l/ t2 S0 I, P; {6 ^$ P
/* 检查参数 */4 d2 ~' ^/ c% H0 X3 r5 S( Z
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));# K, z7 p/ a8 p6 `* E8 z
$ x a7 G; J7 ]% Q& B
/* 使能输出比较通道 */1 d- q) X- t5 R! A' G1 o6 z
TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
/ J4 q$ c* j* O) l
7 L7 H9 B7 D( r
if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)
, z, B s' b* O- R& Y& l( S
{) i: B# o2 ?+ H! x' R1 v* W- |
/* 使能主输出 */7 b5 u! r, S) l% }
__HAL_TIM_MOE_ENABLE(htim);
4 c+ y3 T$ i2 E6 V0 z" X
}
2 a& Y, x5 q6 R: l
7 y9 j4 u0 ^! Z6 d
/* 使能定时器 */
5 w: J3 E) O; C5 `- U6 T% u/ d
__HAL_TIM_ENABLE(htim);
2 J0 z9 @$ m0 u: J
$ j. S+ h5 v0 _& o: h0 o
/* 返回状态 */
: o3 K8 `( B5 M1 I+ m
return HAL_OK;( \0 a/ U F, z# J* }: b
}

复制代码

函数描述：

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

函数参数：

  第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的驱动源码结合参考手册中的寄存器通读一遍，对于我们后面章节的学习大有裨益。