【经验分享】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 2 n& x F9 C9 j7 k8 ~2 P1 ]$ @- g
TIM1_UP_IRQHandler : t/ I F3 S( N3 q! a- S
TIM1_TRG_COM_IRQHandler - w0 z+ y @/ H7 k
TIM1_CC_IRQHandler ) c1 F6 B) b3 V5 m, [ A3 E
TIM2_IRQHandler
( \% H/ k6 X7 Y
TIM3_IRQHandler
3 a5 f9 a. B- n3 R
TIM4_IRQHandler
! F0 |& ]" Q* ~5 W9 Z
TIM5_IRQHandler # K# I3 T. n( X: W. d8 `0 S1 c
TIM6_DAC_IRQHandler <------------------要注意 & _( c! P' u9 P! S u2 ^7 y- E# m3 S
TIM7_IRQHandler ( |- N. A4 V5 v' `7 d. d
TIM8_BRK_TIM12_IRQHandler <------------------要注意，定时器12也是用的这个& G' P9 H0 k% P3 T% }; S$ Q: \
TIM8_UP_TIM13_IRQHandler <------------------要注意，定时器13也是用的这个
g5 F( |1 G/ y
TIM8_TRG_COM_TIM14_IRQHandler <------------------要注意，定时器14也是用的这个% t$ w W+ P; `& l" d; j8 l
TIM8_CC_IRQHandler / ?8 z+ N8 |0 j/ X, G/ s( s" {
TIM15_IRQHandler }: Z. i) S+ O$ g
TIM16_IRQHandler
1 q' ^! p8 H o! e. ?
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
1 N) |% T* j3 n
{
( f |% X6 l* y/ q) o# {! h- u
__IO uint16_t CR1; /*!< TIM control register 1, Address offset: 0x00 */
6 f5 d4 `& W9 h6 w! Z
uint16_t RESERVED0; /*!< Reserved, 0x02 */* p g. b/ I# a( s" {
__IO uint32_t CR2; /*!< TIM control register 2, Address offset: 0x04 */
8 C, [/ c* E+ t* e. a2 R( {
__IO uint32_t SMCR; /*!< TIM slave mode control register, Address offset: 0x08 */, }8 p+ x$ ~# U. c! Y6 X7 b
__IO uint32_t DIER; /*!< TIM DMA/interrupt enable register, Address offset: 0x0C */9 a) Q. O$ U7 a
__IO uint32_t SR; /*!< TIM status register, Address offset: 0x10 */
4 a/ k3 u& z1 a$ J& r
__IO uint32_t EGR; /*!< TIM event generation register, Address offset: 0x14 */
M: j- Q: ]. I) F% n- L h- i9 \
__IO uint32_t CCMR1; /*!< TIM capture/compare mode register 1, Address offset: 0x18 */' f+ R) W/ K {' m0 p
__IO uint32_t CCMR2; /*!< TIM capture/compare mode register 2, Address offset: 0x1C */
& t0 J" ~" ]: U e) {; X2 h
__IO uint32_t CCER; /*!< TIM capture/compare enable register, Address offset: 0x20 */# U* U" G7 P g! \ u( `* \6 h0 l
__IO uint32_t CNT; /*!< TIM counter register, Address offset: 0x24 */
q v: W: S: v
__IO uint16_t PSC; /*!< TIM prescaler, Address offset: 0x28 */& ?5 }* A5 {4 ?3 b: w% @6 h
uint16_t RESERVED9; /*!< Reserved, 0x2A */
& q- l' x9 {9 w
__IO uint32_t ARR; /*!< TIM auto-reload register, Address offset: 0x2C */
# y8 N F8 }6 z# e. I
__IO uint16_t RCR; /*!< TIM repetition counter register, Address offset: 0x30 */! V. @" v9 e2 K1 X4 Q; Z6 W0 u
uint16_t RESERVED10; /*!< Reserved, 0x32 */: b# p ?& N4 }7 G/ m
__IO uint32_t CCR1; /*!< TIM capture/compare register 1, Address offset: 0x34 */ L# l; T5 h. Z
__IO uint32_t CCR2; /*!< TIM capture/compare register 2, Address offset: 0x38 */9 u& v' @$ |- Q$ ^# y" n" M
__IO uint32_t CCR3; /*!< TIM capture/compare register 3, Address offset: 0x3C */
7 v5 S/ W; m2 j1 n+ V8 m
__IO uint32_t CCR4; /*!< TIM capture/compare register 4, Address offset: 0x40 */
- |! Z9 e/ k1 Y8 C! d
__IO uint32_t BDTR; /*!< TIM break and dead-time register, Address offset: 0x44 */ _3 W z- z6 ] {# D4 |5 p
__IO uint16_t DCR; /*!< TIM DMA control register, Address offset: 0x48 */, X8 C4 z( H, {
uint16_t RESERVED12; /*!< Reserved, 0x4A *// S( N, n% _7 X K' Q4 ?
__IO uint16_t DMAR; /*!< TIM DMA address for full transfer, Address offset: 0x4C */. i# A$ O6 o! S! C
uint16_t RESERVED13; /*!< Reserved, 0x4E */+ }4 H6 M8 o1 f% o6 m
uint16_t RESERVED14; /*!< Reserved, 0x50 */; T0 L6 E7 _3 t. h! @7 p6 |
__IO uint32_t CCMR3; /*!< TIM capture/compare mode register 3, Address offset: 0x54 */' o1 ~) f2 ]4 R1 K' ^
__IO uint32_t CCR5; /*!< TIM capture/compare register5, Address offset: 0x58 */' l e7 E' S& u) e5 Q3 a2 u: m
__IO uint32_t CCR6; /*!< TIM capture/compare register6, Address offset: 0x5C */
* e1 ?7 Y O y4 h$ f) w* x
__IO uint32_t AF1; /*!< TIM alternate function option register 1, Address offset: 0x60 */
; O5 c& c+ A3 |. ]' O* r1 ]
__IO uint32_t AF2; /*!< TIM alternate function option register 2, Address offset: 0x64 */7 _. i$ Q( f+ Y% Q
__IO uint32_t TISEL; /*!< TIM Input Selection register, Address offset: 0x68 */7 u9 u" @% Z" a' R5 g3 ]/ w
} TIM_TypeDef;

复制代码

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

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

#define __O volatile /*!< Defines 'write only' permissions */% v- q, [( ?' Z4 _: n
#define __IO volatile /*!< Defines 'read / write' permissions */

复制代码

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

#define PERIPH_BASE ((uint32_t)0x40000000)8 G) a& m2 Q* y. d4 A5 i
#define D2_APB1PERIPH_BASE PERIPH_BASE/ ?8 ? t9 H6 P
#define D2_APB2PERIPH_BASE (PERIPH_BASE + 0x00010000). ]+ d* A( P: p( R
; _; o( |9 a2 R$ m) d9 Y) S4 q# k
/*!< D2_APB1PERIPH 外设 */
! x* D5 e, _: c
#define TIM2_BASE (D2_APB1PERIPH_BASE + 0x0000) <----- 展开这个宏，(TIM_TypeDef *) 0x40000000
7 t1 W0 C+ b& t. ~* F) F! a' D
#define TIM3_BASE (D2_APB1PERIPH_BASE + 0x0400)
+ ?% t/ K3 N; T* E" v9 h
#define TIM4_BASE (D2_APB1PERIPH_BASE + 0x0800)1 F& L$ I4 f5 B9 P. Q. Z( q3 i
#define TIM5_BASE (D2_APB1PERIPH_BASE + 0x0C00)
/ t: }( Q7 F) N. k; A7 |( u
#define TIM6_BASE (D2_APB1PERIPH_BASE + 0x1000)) l6 s/ g" E$ y" t1 b
#define TIM7_BASE (D2_APB1PERIPH_BASE + 0x1400)9 M' N' G5 `( a' O5 L0 N0 J1 f
#define TIM12_BASE (D2_APB1PERIPH_BASE + 0x1800)( X7 j: W- U" F( ? _" d( W
#define TIM13_BASE (D2_APB1PERIPH_BASE + 0x1C00)
) b. Z: l3 h( ?, K! ]* O/ b3 Y$ L
#define TIM14_BASE (D2_APB1PERIPH_BASE + 0x2000)
& t5 V" j- [8 \" q$ H+ M% l
1 I8 Q& S5 M. U! h* ^' H. I
/*!< D2_APB1PERIPH 外设 */
! \! ~. p1 @3 C
#define TIM1_BASE (D2_APB2PERIPH_BASE + 0x0000)3 ]% H8 p1 R) G2 r. M7 z
#define TIM8_BASE (D2_APB2PERIPH_BASE + 0x0400)
/ T2 a& h& X% @
#define TIM15_BASE (D2_APB2PERIPH_BASE + 0x4000)+ o% o7 v* a' k+ C0 y
#define TIM16_BASE (D2_APB2PERIPH_BASE + 0x4400)% j3 y, I$ t; P& k
#define TIM17_BASE (D2_APB2PERIPH_BASE + 0x4800)
4 K: W% G; Z0 U4 i. b* @2 Z6 _
) M. I6 Q. k0 l+ c/ c- i- l9 f9 o4 r
#define TIM1 ((TIM_TypeDef *) TIM1_BASE)
3 b! a& ]5 Y p
#define TIM2 ((TIM_TypeDef *) TIM2_BASE)
" B% ?9 |& |' V# X
#define TIM3 ((TIM_TypeDef *) TIM3_BASE)
' i0 [3 y1 Z" D& c K: W j9 M6 Z
#define TIM4 ((TIM_TypeDef *) TIM4_BASE)( h! |8 a- G! r9 L4 N
#define TIM5 ((TIM_TypeDef *) TIM5_BASE)
* R# R9 z; l- \/ P& \* N
#define TIM6 ((TIM_TypeDef *) TIM6_BASE)
# p: R2 ?& {" b9 A; j9 Z
#define TIM7 ((TIM_TypeDef *) TIM7_BASE)
& L" k% H6 m, m, |0 J1 t7 Z2 N
#define TIM8 ((TIM_TypeDef *) TIM8_BASE)* S, T7 o }: r/ W# H* Y
#define TIM12 ((TIM_TypeDef *) TIM12_BASE)2 o3 e+ K1 n% U1 H& ~# O; i" [+ V) u! A
#define TIM13 ((TIM_TypeDef *) TIM13_BASE)
& ]" z* k. U- U& X; V% Q$ W) @
#define TIM14 ((TIM_TypeDef *) TIM14_BASE)' Z" b+ i8 E {( B6 P
#define TIM15 ((TIM_TypeDef *) TIM15_BASE)4 `) S. W2 _/ t$ X- T
#define TIM16 ((TIM_TypeDef *) TIM16_BASE)
4 n8 R# L- p7 w q& {$ O0 d
#define TIM17 ((TIM_TypeDef *) TIM17_BASE)

复制代码

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

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

typedef struct
- m. ~5 `( P; P% ^0 m
{
% U8 g! j8 F; ]: I$ u8 J( t3 ~
TIM_TypeDef *Instance; /*!< Register base address */
- S* J: s( Z; A" O7 @5 t; y# |% y1 v% ]
TIM_Base_InitTypeDef Init; /*!< TIM Time Base required parameters */
, x" c& x2 l$ v, c
HAL_TIM_ActiveChannel Channel; /*!< Active channel */
M' p! Q2 K! ~ T
/ O/ l2 X" a( ]$ V( B* F3 L
/*!< DMA Handlers array This array is accessed by a @ref DMA_Handle_index *// h4 `: M6 P4 E5 D8 H- Y
DMA_HandleTypeDef *hdma[7]; * }( G5 V U7 x& p- H; Z( S
HAL_LockTypeDef Lock; /*!< Locking object */4 X- s3 \8 }1 J/ c
__IO HAL_TIM_StateTypeDef State; /*!< TIM operation state */ 4 V0 W% f8 S! o
}TIM_HandleTypeDef;

复制代码

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

  TIM_TypeDef  *Instance

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

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

  TIM_Base_InitTypeDef  Init

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

TIM_Base_InitTypeDef结构体的定义如下：

typedef struct& Z, |5 C7 U8 v
{
uint32_t Prescaler;
1 c: ?& n& v1 z- T# J. `& T
uint32_t CounterMode; / O$ }8 n. s: o7 d, w5 o
uint32_t Period; 8 O. P# u1 y+ P8 `3 W j6 J2 D3 |; e
uint32_t ClockDivision; # t0 M& U I, O
uint32_t RepetitionCounter;
, ?2 j' e! n4 j1 q0 a% U- `* `/ [
uint32_t AutoReloadPreload;
) e. z9 H; x6 v6 Z
} TIM_Base_InitTypeDef;

复制代码

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

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

#define TIM_COUNTERMODE_UP ((uint32_t)0x0000U) /*!< Up counting mode */4 c# z+ ~( U6 e X1 l
#define TIM_COUNTERMODE_DOWN TIM_CR1_DIR /*!< Down counting mode */, O: }& c- W6 z4 }" a; O
#define TIM_COUNTERMODE_CENTERALIGNED1 TIM_CR1_CMS_0 /*!< Center-aligned counting mode 1 */
: u* v! x: l# a5 z: H8 d' F1 G) z
#define TIM_COUNTERMODE_CENTERALIGNED2 TIM_CR1_CMS_1 /*!< Center-aligned counting mode 2 */
" H5 G: W5 a7 f7 y! S: j6 s4 o0 R' C
#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 */
- {& v% _1 u" h- p8 v/ y2 X0 o
#define TIM_CLOCKDIVISION_DIV2 (TIM_CR1_CKD_0) /*!< Clock Division DIV2 */% S) K; |5 Y% S& c! P. o Y) Z
#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 *// ~/ u: D" ]; z/ ^+ |" O- K, A% ]
#define TIM_AUTORELOAD_PRELOAD_ENABLE (TIM_CR1_ARPE) /*!< TIMx_ARR register is buffered */

复制代码

HAL_TIM_ActiveChannel Channel;

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

typedef enum
) ?6 ^- i T* H5 j \
{" K5 c4 e$ ~8 ~7 x- t5 b P& [+ o
HAL_TIM_ACTIVE_CHANNEL_1 = 0x01U, /*!< The active channel is 1 */
Q( J/ q( x2 q, b9 X. h3 n; R0 g
HAL_TIM_ACTIVE_CHANNEL_2 = 0x02U, /*!< The active channel is 2 */ {! s5 Y% P# ~ N- X, V" P- ?
HAL_TIM_ACTIVE_CHANNEL_3 = 0x04U, /*!< The active channel is 3 */ ; F q. I- P* z
HAL_TIM_ACTIVE_CHANNEL_4 = 0x08U, /*!< The active channel is 4 */
& U9 v+ g. u# F8 X! _
HAL_TIM_ACTIVE_CHANNEL_5 = 0x10U, /*!< The active channel is 5 */' n4 V3 ]: m0 g9 J# {
HAL_TIM_ACTIVE_CHANNEL_6 = 0x20U, /*!< The active channel is 6 */2 s9 ] s5 |/ ~6 L7 k/ b
HAL_TIM_ACTIVE_CHANNEL_CLEARED = 0x00U /*!< All active channels cleared */ : k( T$ r: Y$ }6 p4 z
}HAL_TIM_ActiveChannel;
) M J0 w+ f% J, Y2 W4 f$ t
DMA_HandleTypeDef *hdma[7];

复制代码

用于关联DMA。

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

TIM_HandleTypeDef TimHandle = {0};% X9 x+ I1 ]% J1 U( @
3 X4 Z! S- Q) @2 J2 [
/* 8 X* r9 ^7 s1 w/ t' C
定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）7 [' ~4 e( h! B( f9 K
*/3 v2 |% G+ `, s; A( d1 ]' I& o
TimHandle.Instance = TIMx;7 m9 r1 Z1 e3 l$ J
TimHandle.Init.Prescaler = usPrescaler;) C4 s. t* B) q
TimHandle.Init.Period = usPeriod; 5 C+ x8 T, V, s
TimHandle.Init.ClockDivision = 0;! I! ~/ h+ ?& Q( }5 J6 E8 |2 {: x
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
) t# w. t& O" x' R$ e0 Q- ~+ |4 T: b
TimHandle.Init.RepetitionCounter = 0;4 k0 \, u6 z. m3 F' p5 e4 C h9 ~# ?
TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE; e4 D5 @% f0 r9 B# S
if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)6 s" r( c+ y( ?4 S3 @- B
{( @" r/ F9 k0 L# V. f
Error_Handler(__FILE__, __LINE__);
8 Z4 y$ B. E, z! m2 _
}

复制代码

5 V" j7 D- E9 y: ^/ O
32.3.3 定时器输出比较结构体TIM_OC_InitTypeDef
此结构体主要用于定时器的输出比较，定义如下：

typedef struct2 Q) P% p w) T1 c8 e% U0 _. \( k9 |. z
{ % f, J% j4 v' w# p6 e
uint32_t OCMode; # [& R6 D: [4 p
uint32_t Pulse; 3 q. o% ^6 ?% j+ Y1 ?' v( S
uint32_t OCPolarity; ) T' f% g- M# D) v/ U
uint32_t OCNPolarity;
9 E* {/ q+ A" z- s5 g
uint32_t OCFastMode; 2 ^7 l6 i* u* p) |( x x! N
uint32_t OCIdleState;
5 |6 `4 h$ k& P$ W$ v: ~
uint32_t OCNIdleState; ' C" E) |3 A! I3 r! D) z" x2 E
} TIM_OC_InitTypeDef;

复制代码

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

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

/*!< TIM Output timing mode */
[7 O: Z& u& d9 ^
#define TIM_OCMODE_TIMING ((uint32_t)0x0000U) ' I+ {# J: | P' p
' _- g$ u+ Y3 o1 H5 _7 u F* C) ?1 O
/*!< TIM Output Active mode */
& ~) K1 _) Y& [6 @; \; N
#define TIM_OCMODE_ACTIVE ((uint32_t)TIM_CCMR1_OC1M_0)
4 H% w, Q( B1 R) b
% ]5 ~2 l- P7 Q' w0 Y8 u
/*!< TIM Output Inactive mode */ 0 Q5 s7 [& n2 H- F: \1 I/ V+ H
#define TIM_OCMODE_INACTIVE ((uint32_t)TIM_CCMR1_OC1M_1)
' A3 A' j) t/ j" ^5 O4 O+ n) m0 z
9 }: Z- y2 ]8 h$ |- \
/*!< TIM Output Toggle mode */
% \2 K- P2 |# ? i
#define TIM_OCMODE_TOGGLE ((uint32_t)TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)
, j7 L/ ^+ v6 I: L( {
" c& r! X9 t+ {3 l( K, ]: [
/*!< TIM PWM mode 1 */# w, ~+ y: [. y' R* W* B: v
#define TIM_OCMODE_PWM1 ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1) . `8 l# t& Y( N9 @+ U, h2 R/ U
: a# B6 l9 K) q- g7 P8 j' Z, y' Y
/*!< TIM PWM mode 2 */ 2 [, `, i( E' L' f1 }& F h8 F1 Z
#define TIM_OCMODE_PWM2 ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)
# \/ y9 \& r' l% ~
" h# j9 ~/ \$ v g3 @
/*!< TIM Forced Active mode */ $ I8 `, s& f% N+ H" T
#define TIM_OCMODE_FORCED_ACTIVE ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0) + x+ e1 a, A, M# H8 P3 v
' ?# C- e5 N* Q& n+ s# }
/*!< TIM Forced Inactive mode */
1 l8 L: E n% u4 ^7 o" |$ T
#define TIM_OCMODE_FORCED_INACTIVE ((uint32_t)TIM_CCMR1_OC1M_2) ! \6 i8 a7 i3 ]! w1 x' P. y; M: R3 g
& ?( c/ m+ s0 w. ]# Z+ ?9 w
/*!< TIM Rettrigerrable OPM mode 1 */
4 d3 ~' d" m2 c! l. H4 Y+ L, B
#define TIM_OCMODE_RETRIGERRABLE_OPM1 ((uint32_t)TIM_CCMR1_OC1M_3) ) E% K5 E* l1 }8 v; M- c! L
" b" i4 T8 E# @: H# t! X
/*!< TIM Rettrigerrable OPM mode 2 */
1 e3 F8 m' x$ a. [2 E! a
#define TIM_OCMODE_RETRIGERRABLE_OPM2 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0) 7 Q( J& n$ N I0 E0 ?
3 n$ |3 E0 g1 w* w
/*!< TIM Combined PWM mode 1 */ # z$ p% z/ v* `4 K
#define TIM_OCMODE_COMBINED_PWM1 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_2)
& O% m% m1 Q! E% ^/ ?$ q
9 C* Z0 Z4 o3 y7 l0 W- @
/*!< TIM Combined PWM mode 2 */
3 l9 X" e0 i7 X2 u
#define TIM_OCMODE_COMBINED_PWM2 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0 | TIM_CCMR1_OC1M_2)
5 ~6 T! e+ I. O Y" M* T9 x
6 ?7 F1 M6 a v7 J. N
/*!< TIM Asymetruc PWM mode 1 */
( d- J4 F3 R/ q! x
#define TIM_OCMODE_ASSYMETRIC_PWM1 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2)
9 i) C9 H4 }* k, A' q, m: s
# {! D6 I8 Z5 H' F
/*!< TIM Asymetruc PWM mode 2 */ 0 b( h3 A8 ~! V+ h0 V) ^- _
#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)
4 O4 Q3 Y% ?1 F1 E0 D
#define TIM_OCPOLARITY_LOW (TIM_CCER_CC1P)

复制代码

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

#define TIM_OCNPOLARITY_HIGH ((uint32_t)0x0000U)4 u, C' G ~# C$ u* S% d9 D
#define TIM_OCNPOLARITY_LOW (TIM_CCER_CC1NP)

复制代码

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

#define TIM_OCFAST_DISABLE ((uint32_t)0x0000U)
/ B' g5 D5 x$ x( z0 J4 i
#define TIM_OCFAST_ENABLE (TIM_CCMR1_OC1FE)

复制代码

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

#define TIM_OCIDLESTATE_SET (TIM_CR2_OIS1)
. Q$ A, C5 E3 y; j7 w) A
#define TIM_OCIDLESTATE_RESET ((uint32_t)0x0000U)

复制代码

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

#define TIM_OCNIDLESTATE_SET (TIM_CR2_OIS1N)! O: O( Z7 b1 p* N# @
#define TIM_OCNIDLESTATE_RESET ((uint32_t)0x0000U)

复制代码

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

typedef struct' K+ b" T) U6 K6 w) e: R
{
1 R" m/ D( O: {; D5 P
uint32_t ICPolarity; , M3 a1 W* C4 N7 |
uint32_t ICSelection; 5 m% ?+ q% z% \+ }! x
uint32_t ICPrescaler; 1 O& ]* f0 M6 A8 f9 [6 s8 @* U9 A
uint32_t ICFilter; - l" K! H' j+ M9 _0 d
} TIM_IC_InitTypeDef;

复制代码

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

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

#define TIM_ICPOLARITY_RISING TIM_INPUTCHANNELPOLARITY_RISING
! p& x/ j( a2 B7 t# l
#define TIM_ICPOLARITY_FALLING TIM_INPUTCHANNELPOLARITY_FALLING
- Y1 w$ O& g6 {% }1 J
#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)
5 q: Q" U8 {; `. _. m* j2 d$ d
#define TIM_ICSELECTION_INDIRECTTI (TIM_CCMR1_CC1S_1)
3 @% m+ j* }9 Z0 A* G& d& b$ @
#define TIM_ICSELECTION_TRC (TIM_CCMR1_CC1S)

复制代码

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

#define TIM_ICPSC_DIV1 ((uint32_t)0x0000U) # l* W+ v# x' \ N! l# g5 ^
#define TIM_ICPSC_DIV2 (TIM_CCMR1_IC1PSC_0)
" I7 s! Y5 U% ^
#define TIM_ICPSC_DIV4 (TIM_CCMR1_IC1PSC_1) ) N( c; ]1 T4 s1 [# T" F3 T0 z
#define TIM_ICPSC_DIV8 (TIM_CCMR1_IC1PSC)

复制代码

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

0000：无滤波器，按 fDTS 频率进行采样
- {. E" N ]" S( f
0001： fSAMPLING=fCK_INT， N=2
& c2 [' B$ T# N7 }' d, M9 m* _
0010： fSAMPLING=fCK_INT， N=4
& q% h( z! q5 B6 O) T! G% {
0011： fSAMPLING=fCK_INT， N=89 @+ Y5 s* g' g. C) f2 g+ w
0100： fSAMPLING=fDTS/2， N=6/ i, _3 b' G$ P/ g- i4 y- n
0101： fSAMPLING=fDTS/2， N=8
) n. @' @8 p3 Y5 P9 {, O n
0110： fSAMPLING=fDTS/4， N=6+ |" L6 L3 r; ^/ k+ s1 C
0111： fSAMPLING=fDTS/4， N=8
{5 _& H- `' o/ Y6 B P
1000： fSAMPLING=fDTS/8， N=6' |, B+ b1 G. o3 x2 C# N
1001： fSAMPLING=fDTS/8， N=8% p/ c- |5 u/ U' O7 _& T& F& J
1010： fSAMPLING=fDTS/16， N=5
& s8 e% W2 g, P& \! x# ^0 a
1011： fSAMPLING=fDTS/16， N=6& x& J* S# ?' K' G3 H
1100： fSAMPLING=fDTS/16， N=8* [9 Q. x" u* j! R7 p
1101： fSAMPLING=fDTS/32， N=5! R, i3 f8 F7 p" ~% A, C
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)4 T7 D" Y, T" `0 y0 L+ D- X- W! z0 n
{0 G: z0 m/ v- g i- p
/* Prevent unused argument(s) compilation warning */4 U* }' x) q* q0 t1 ~0 P
UNUSED(htim);
( D" \' V5 E) _5 }4 p- S3 N2 `
/* NOTE : This function Should not be modified, when the callback is needed,/ e$ b+ t$ V8 W# I9 Q' s
the HAL_TIM_Base_MspDeInit could be implemented in the user file6 P; P" }+ {2 \ l% G3 u
*/% Q/ m5 o. e3 o v" H/ z2 }+ K
}

复制代码

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

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

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

void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
* W; u8 e% n+ g& F; N% T
{4 r8 l# A6 \+ L# W5 e
GPIO_InitTypeDef GPIO_InitStruct;+ a! e: ]6 ? U, o5 B
, u& X- R ^& R7 T/ @9 I8 _
/* 使能TIM1时钟 */
! Z: a3 Y4 \/ E4 G$ E" p7 B
__HAL_RCC_TIM1_CLK_ENABLE ();- K0 t3 \1 G0 [+ j2 `1 L: w
. j* C, A' c6 _ S3 _8 w
/* 使能GPIOA时钟 */8 V( _! x! m D: R# f; Q7 m
__HAL_RCC_GPIOA_CLK_ENABLE ();- l# K/ D' o$ ]
; q- Y. ]* j: }
/* 设置TIM1使用PA8做PWM输出引脚，将其配置为输出，推挽，复用模式 */& C/ t6 B2 i' Y
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;! p7 u6 m# W; a: p: y9 p' _, J5 G
GPIO_InitStruct.Pull = GPIO_PULLUP;5 z- k; E8 U/ H5 o+ e' E4 [ w
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;4 K6 A0 h( ^2 H$ \0 Z3 s {" K& J
7 R6 X1 f% N1 c( o+ U+ q6 v# k8 L
GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;+ z% D& d9 R8 x; T4 R& P3 {
GPIO_InitStruct.Pin = GPIO_PIN_8;
8 G/ e( ` [& j! v/ ~# u
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
( W& p2 H0 O" J- X
; }+ ~5 A+ d( b( ~$ H
}

复制代码

总结下来就是以下几点：

  配置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
$ G4 D3 o* O% ^1 \
TIM1_CH2, PA9 PE117 k/ I3 H: U$ ^' j- Q9 {+ D# e
TIM1_CH3, PA10 PE13 PJ9
" Y4 y/ [2 c) k4 J) [
TIM1_CH4, PA11 PE14 PJ11

复制代码

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

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

% n, D$ x# _2 L( Z* @1 G
/** @brief Check whether the specified TIM interrupt flag is set or not.
3 x2 Q a1 J. |+ R( {
* @param __HANDLE__: specifies the TIM Handle.
4 M* D! L8 U( R0 [
* @param __FLAG__: specifies the TIM interrupt flag to check.
$ m' W8 ^/ a2 Y' {! Y
* This parameter can be one of the following values:- D# Z4 n6 A, b% d8 T
* @arg TIM_FLAG_UPDATE: Update interrupt flag9 E9 o; ~$ T2 C4 L! ~
* @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag" g# t# ?2 g2 t1 C, Q4 r4 h* m6 s
* @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
4 Z3 G2 I; Z' c
* @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
B% F4 r) \3 R- a" y: I \& k5 j
* @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
1 S: Z0 }" Z$ k0 [8 X4 ?
* @arg TIM_FLAG_CC5: Compare 5 interrupt flag
0 [1 i) e& A* x; V7 V/ p
* @arg TIM_FLAG_CC6: Compare 6 interrupt flag- l- D t. D' l. E+ q
* @arg TIM_FLAG_COM: Commutation interrupt flag. X" C, z. F$ Q- a8 w& i+ e' S
* @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
0 l S+ |% V: e, W8 D
* @arg TIM_FLAG_BREAK: Break interrupt flag
4 {/ q& v" {& h
* @arg TIM_FLAG_BREAK2: Break 2 interrupt flag % Y1 C7 }) M/ j7 s3 \
* @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag1 X+ G/ w2 w; Y" H
* @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag8 S7 ~, o, m7 e, |3 E/ g
* @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
5 U# E: N3 j3 r9 @8 s- v
* @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
& A5 v" ^: J: Q! \
* @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
8 T1 v6 {& Z8 \, ~
* @retval The new state of __FLAG__ (TRUE or FALSE).- k5 b( K: E: @ r7 v6 t
*/
" p4 L4 U4 U( A1 @$ F1 t
#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.
* @param __HANDLE__: specifies the TIM Handle.6 t* s% ~3 \2 R0 A
* @param __FLAG__: specifies the TIM interrupt flag to clear., q7 t- n& @! }* @) M
* This parameter can be one of the following values:
$ u% |+ X8 P+ M
* @arg TIM_FLAG_UPDATE: Update interrupt flag
o( D1 [: @# M; J1 ~
* @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
0 p- l7 N7 k, F; I5 D
* @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag* o: ?) D& y# U9 q
* @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
, z% V4 A: F2 J. ^+ r5 v0 r
* @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag: w( }* Q) r, R9 L
* @arg TIM_FLAG_CC5: Compare 5 interrupt flag! {. ]* t4 d$ F) [6 R) j4 q N
* @arg TIM_FLAG_CC6: Compare 6 interrupt flag
J9 J+ x! X9 u; a$ [- @- ~
* @arg TIM_FLAG_COM: Commutation interrupt flag+ O6 A' ?& R- d0 K
* @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
6 P- s0 p* T% e$ A( H: \
* @arg TIM_FLAG_BREAK: Break interrupt flag ( O5 t# b+ }% _. b+ N0 R2 V$ R
* @arg TIM_FLAG_BREAK2: Break 2 interrupt flag 9 y* f- Q1 j' N/ C" M
* @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
9 n8 W4 ~2 x6 V2 T% }
* @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
( m& q+ O9 m- Q7 [
* @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
$ f1 `1 \; G- L
* @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
! G' g0 Y, @$ E0 ]) ]6 G, i X
* @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag. ~" b+ @8 T' ]3 Y% k; ~4 |
* @retval The new state of __FLAG__ (TRUE or FALSE)." \3 Y0 F0 R" l, J* t2 `8 t2 ^1 g0 u" m
*/8 J: s- G+ J# `* }" |) ]
#define __HAL_TIM_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->SR = ~(__FLAG__))

复制代码

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

/** @brief Enable the specified TIM interrupt.2 q* D Z7 T3 d# \. c: p
* @param __HANDLE__: specifies the TIM Handle.1 y* T* @. P2 [6 @& c2 v5 {7 y
* @param __INTERRUPT__: specifies the TIM interrupt source to enable.+ H% @( W" i! z/ Q, ^) }! x: j
* This parameter can be one of the following values:) f8 n) r: M' z6 N. k: x$ n5 o5 r
* @arg TIM_IT_UPDATE: Update interrupt
. s! ^: s# w3 x0 s$ \$ c; M* I
* @arg TIM_IT_CC1: Capture/Compare 1 interrupt, z; M8 v3 x# a5 ~5 O# j
* @arg TIM_IT_CC2: Capture/Compare 2 interrupt
" b& f5 z3 u5 U& L& V
* @arg TIM_IT_CC3: Capture/Compare 3 interrupt
c; v7 _7 r# x$ j2 x H7 D4 O
* @arg TIM_IT_CC4: Capture/Compare 4 interrupt: N. q/ n6 ?8 J
* @arg TIM_IT_COM: Commutation interrupt8 M4 Y) ?0 K+ O7 ?6 P
* @arg TIM_IT_TRIGGER: Trigger interrupt, c" z. C+ m/ g* j
* @arg TIM_IT_BREAK: Break interrupt
. I0 Q$ ~& ?& ~- d7 q$ S J* [
* @retval None
" J" v5 P8 l0 c( {6 k: S
*/" }& ]6 [: p4 T* \- S6 I
#define __HAL_TIM_ENABLE_IT(__HANDLE__, __INTERRUPT__) ((__HANDLE__)->Instance->DIER |= (__INTERRUPT__))
5 F5 B2 C, Q% n
6 E1 j4 B* k F/ i5 a4 J' K
/** @brief Disable the specified TIM interrupt.( r/ X/ e& D, x: g2 j
* @param __HANDLE__: specifies the TIM Handle.) F X j9 w, F& d+ o
* @param __INTERRUPT__: specifies the TIM interrupt source to disable.
% z' C1 K) H& I! X( {1 f
* This parameter can be one of the following values:
3 D' O& a! `! R& \+ J" O- h3 A
* @arg TIM_IT_UPDATE: Update interrupt# d$ D) M8 g. [
* @arg TIM_IT_CC1: Capture/Compare 1 interrupt2 X: R; O6 m3 k# g/ P; L
* @arg TIM_IT_CC2: Capture/Compare 2 interrupt
6 M2 |6 ] N% _: W6 {( s& G: f
* @arg TIM_IT_CC3: Capture/Compare 3 interrupt
9 @0 D, r9 H9 q
* @arg TIM_IT_CC4: Capture/Compare 4 interrupt8 `3 ^; g, l- o* T& Q0 Z
* @arg TIM_IT_COM: Commutation interrupt" Q+ U# L o4 }8 E, n) X9 H
* @arg TIM_IT_TRIGGER: Trigger interrupt9 D/ l! T3 A0 t: a. A
* @arg TIM_IT_BREAK: Break interrupt
; N, k# |/ h3 ]
* @retval None, w/ ^( f6 S9 Q$ Y+ ~: _5 v
*/+ s( n, [- @: s. ?" `- F
#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)9 V9 V1 D/ C) G* F" D& x
{ % }5 Q% ~1 \- n/ a, r
/* 检测是否是有效句柄 */2 o% b: G1 V5 r% h6 P# e! z
if(htim == NULL)7 S4 [( h+ o- R# O f; d
{1 m5 g" E$ h" t& X1 z$ F7 r
return HAL_ERROR;5 O8 W) p' Q/ f& U0 m$ K- m/ @2 Z
}! n( I- R7 H1 @3 q2 E P1 j" f
! ?* a' n% g9 u& u: b
/* 检测参数 */
; Q6 ], G/ K/ }
assert_param(IS_TIM_INSTANCE(htim->Instance)); 3 G- d5 ^ y! k. y1 @4 g8 }4 g
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
2 b4 M% t8 b+ D: l4 @
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));( {0 v( V3 @5 f# E' `3 O0 M1 M( m5 J
( F; Y) d E" l4 I; X
if(htim->State == HAL_TIM_STATE_RESET)1 t! N0 Z# d" c& [7 ?0 h
{ % l, v Z2 H3 I( H) z+ C8 m
/* 默认取消锁 */
8 Y6 Q& D Y$ e( h: v2 D
htim->Lock = HAL_UNLOCKED;
, H3 }. h* l9 P+ ~2 @. I
/* 初始化底层硬件 : GPIO, CLOCK, NVIC */" m. n/ R& M6 d5 ]3 V
HAL_TIM_Base_MspInit(htim);6 O; k* H; J2 b: i; D: j/ J+ t
}
8 E* C. f- E$ [# `1 Q
# T: O2 d6 D+ }! [
/* 设置TIM状态 */
6 T' M7 [* J6 F0 y1 R
htim->State= HAL_TIM_STATE_BUSY;
4 T* V; q7 y4 u. l
* g0 N$ w' L1 |/ J- E" b
/* 基本参数配置 */
. L) @" f( Z4 k) e
TIM_Base_SetConfig(htim->Instance, &htim->Init);
5 s% K0 `( E& z1 k0 N8 Z
& w" J9 A' |6 g: W8 F% D! @5 k, D
/* 设置TIM就绪 */' @+ d" o5 K6 }0 m, l+ [7 F" V
htim->State= HAL_TIM_STATE_READY;
1 y" L, P0 W2 A; X
# p: Q; t8 J( Z
return HAL_OK;
7 x& o; `$ S3 H' z: C9 U( w3 n9 r
}

复制代码

函数描述：

此函数用于初始化定时器用于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)4 D/ e" `' U8 d+ J: V. ~$ f' A
{5 z6 \. S) ]6 S K6 u
Error_Handler();8 {' [( X6 L3 H8 B7 ~, {
}
" h2 P; w N( b' E6 N% T9 E
if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)( U; l4 ^: X& c4 P2 e; j7 w( d
{
& E, O. O6 `, ~- V; U
Error_Handler();& w1 _3 @+ v. p/ p& m: M% M9 i. u
}

复制代码

使用举例：

TIM_HandleTypeDef TimHandle = {0};0 }3 r9 `& c3 b( _9 U" e- |# q
, ?3 L5 _! v7 _, e( s) j
/* - V' X+ P/ {+ h
定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）4 i/ M2 A: Y. \1 Z
*/
: n) a7 ]. \. Y# x$ O
TimHandle.Instance = TIMx;
2 Q$ i4 _7 f m3 H7 U2 Z
TimHandle.Init.Prescaler = usPrescaler;
0 P/ B9 Y$ c9 B# W7 ~1 d( \
TimHandle.Init.Period = usPeriod; ) E: j& g4 t$ X! y, M, E
TimHandle.Init.ClockDivision = 0;
3 ?$ k6 G% Q7 N( c' b
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
( j, t# E$ t$ }& P k$ O% J0 A9 c
TimHandle.Init.RepetitionCounter = 0;
6 e* s0 Y0 @. M8 W9 Y
TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
0 Q f) U1 s' u' I3 P6 w. C! N
if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
' s. {6 W# ?/ o. }3 R
{7 \4 F3 C, S% o8 j
Error_Handler(__FILE__, __LINE__);
0 v5 [' ~ Z7 G6 T/ ?* l* e0 t
}

复制代码

32.4.2 函数HAL_TIM_Base_Start
函数原型：

HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim). K3 c" U2 W/ F$ h+ N" m
{
: M/ M8 S q2 }' I1 a7 s* F5 ^
/* 检测参数状态 */; X$ c) k$ E) O6 k
assert_param(IS_TIM_INSTANCE(htim->Instance));% a2 D6 `! [5 k: u6 k
6 K7 q2 v7 C, |4 v5 `. {1 c
/* 设置定时器状态 */' c3 _9 d; @% p% n; @% U7 h
htim->State= HAL_TIM_STATE_BUSY;
' O! C8 [3 R. l
" k, B/ [# O& n+ n- c
/* 使能定时器 */
1 o* _. g9 G3 F9 ~2 d1 A
__HAL_TIM_ENABLE(htim);8 Q/ A. D! p# J, S& }
/ K! T$ m2 m# x7 t2 |( i
/* 设置定时器状态 */3 [% ?& t- _' `& ?: H
htim->State= HAL_TIM_STATE_READY;4 M6 D: E) j5 {3 {" z3 I
/ X7 x# D/ ], s8 I, j& W0 @
/* 返回HAL_OK */1 m# Y$ b* ?3 ]2 J& O( }: [
return HAL_OK;. v3 K6 m M% k
}

复制代码

函数描述：

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

函数参数：

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

TIM_HandleTypeDef TimHandle = {0};
+ Q8 p1 o! z8 i4 r+ a
/ h8 F( O* \- X3 L3 Y, u
/* $ |+ ^# a$ [0 n: V# }
定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
% ?( n# w: c3 H7 i7 l6 u, m0 y: i
*/% Y2 R& `6 w% \! m
TimHandle.Instance = TIMx;! l$ T( ?* H5 p* d" a2 V' J
TimHandle.Init.Prescaler = usPrescaler;$ T7 o0 J. L, K: B' d9 h$ v
TimHandle.Init.Period = usPeriod;
4 i0 X$ g8 E% A- {; `2 Y& j- a
TimHandle.Init.ClockDivision = 0;
! _; _- L4 s& [
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;% d! K/ @$ t5 E4 `
TimHandle.Init.RepetitionCounter = 0;
5 ~, w1 }' h9 W$ \' g
TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;5 P5 M2 G: |: X" s/ x+ q5 s1 a# Q
if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK). k. k! n0 d' k" ^2 K5 G
{
t( M3 [9 g; P0 y) [! _5 F
Error_Handler(__FILE__, __LINE__);
+ ^" t& c4 [2 C3 I2 |
}
' ~, ?1 V2 U4 s
& u6 x- o4 m1 n' }" ~9 h
/* 启动定时器 */
9 C* t; b4 U1 R/ ^
if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
* ~, t( S s) W
{
: Y/ d! d; Z( _) N6 D+ w9 J
Error_Handler(__FILE__, __LINE__);& |0 `* j, M* I( V5 g3 H! ]) w
}

复制代码

32.4.3 函数HAL_TIM_PWM_Init
函数原型：

HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)* T( }2 e# c1 Z
{
: ?& r* V1 D! T7 h
/* 检查句柄是否有效 */# |' Q1 n) }/ D$ U
if(htim == NULL)
: r2 t& l7 m" d9 p$ B. ]8 q
{# V# h1 k* |# u, M$ G( L- O
return HAL_ERROR;# L" K; S7 p7 G! m: W2 ~0 u% q
}
, i4 @. ]! K* }. t
# D$ K" Y: ~ D
/* 检测参数 */
. H \$ b& O5 {' `
assert_param(IS_TIM_INSTANCE(htim->Instance));8 ?& I9 p+ }% Y& l: m
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));0 w# p$ P! {, ~! o4 Q
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));7 Y8 ^7 d, D1 w3 c+ x9 a
" B0 f' r3 L/ c* C; q, ?
if(htim->State == HAL_TIM_STATE_RESET)
9 ?5 |2 X: W1 P" J: e8 B+ _& v
{
" u; g [3 R* C+ |8 | ~: n
/* 默认取消锁 */' K" m" j7 ?: \; h- D( X+ j2 H
htim->Lock = HAL_UNLOCKED;6 j4 V3 F8 H" J) [! s: C
5 g6 q: y. U! u( Q/ b
/* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
1 l+ C% R, }1 F6 p+ k% x' h
HAL_TIM_PWM_MspInit(htim);7 x! R4 r2 @- k5 d: R& V
}4 q* @. [2 F# [7 |) q* x8 j1 G
2 t" J+ D, ^- S9 F
/* 设置定时状态 */
. j# P2 [! O8 e1 p. r+ g+ N& V
htim->State= HAL_TIM_STATE_BUSY;; W5 C% g, A1 @4 k
/ W5 E/ ~! F/ s3 l5 I$ X; y( F
/* 配置定时器用于PWM */ 8 Y2 Z+ T! r6 O
TIM_Base_SetConfig(htim->Instance, &htim->Init);
1 J% x3 R4 _! i* g" i; |, h2 b
. a+ r0 d1 c9 ^* \9 I( p' z
/* 设置定时器状态 */
' _% r" P: w; m4 l
htim->State= HAL_TIM_STATE_READY;; x4 ^4 v5 u! h/ y; { d2 [3 m
0 G0 X g; a8 I1 _: A5 w9 |, t
return HAL_OK;) m3 G' c6 ^2 v* {* {6 e* I; C
}

复制代码

函数描述：

此函数用于初始化定时为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)
7 T+ f8 E2 {% M9 c% a% y) q
{
* N1 n6 G* U' ~ B& S. B3 q
Error_Handler();+ H; g; C9 I% h2 x# _
} ; M5 h# d. V5 K( k( }" [
if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
/ { |5 l5 o. f7 p# V3 }
{
7 q+ _! K. w; j) v4 _
Error_Handler();
- ]0 O2 ]; ^' b1 I( t( Q' H; @* v
}

复制代码

使用举例：

TIM_HandleTypeDef TimHandle = {0};
' W9 h4 ^" a( g: y9 J. N# T `
6 K v) O& h: o
/* PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/( Z; B* Z$ W: C: _4 l3 m
TimHandle.Instance = TIM1;
0 J0 F9 Z0 k m }
TimHandle.Init.Prescaler = usPrescaler;/ C- R/ Y0 h& `) P
TimHandle.Init.Period = usPeriod;
/ E$ _ _+ ]1 S
TimHandle.Init.ClockDivision = 0;: N2 M) G1 |' A, a* I- b
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
& N {+ p Y9 o" ~9 ~3 W
TimHandle.Init.RepetitionCounter = 0;
2 f, E: }0 t' v K+ v
TimHandle.Init.AutoReloadPreload = 0;
% q5 U C4 f% E0 A) H# B' t9 o$ D
if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)( a! @3 R m: i. ~6 x c& I
{
- q, K7 }0 {8 I3 I, a8 i0 ?
Error_Handler(__FILE__, __LINE__);
% O! A6 T; ~* R# c! B1 T f
}

复制代码

32.4.4 函数HAL_TIM_PWM_ConfigChannel
函数原型：

HAL_StatusTypeDef HAL_TIM_PWM_ConfigChannel(TIM_HandleTypeDef *htim,
; n) A& p' d% n& T+ h( ~9 E4 y' I
TIM_OC_InitTypeDef* sConfig,) S7 n+ B: @$ q! O3 ]! ~9 W, W( w2 J
uint32_t Channel)# q0 s7 k; x2 O4 e- g% L' Z& p
{1 D4 z! [# i6 m5 C- u$ f
/* 省略 */! D6 F( T/ c/ Z- @! L+ L* Z3 ^
* |. V2 M* v! u1 R2 m$ [! q6 I# p1 \
/* 开锁 */* F' q7 n4 w: X- a) i0 B- M
__HAL_LOCK(htim);" g! Y/ G$ l! ~6 k5 Q
, R: r% d! l6 d. s( o* D3 Z
htim->State = HAL_TIM_STATE_BUSY;* ?8 C: h& j2 R- D' l8 s% ~) h
9 {6 z# j. F8 z' \
switch (Channel)
% \" `' @* Y/ R* e3 A9 T3 I; S' e
{
' o6 Q, D+ A; i! f7 n9 q% K3 ^
case TIM_CHANNEL_1:* [6 [' B/ B! C
{+ P1 K- `6 \8 h6 p
/* 检查参数 */% x6 R3 C7 R8 d; Q2 B9 ^8 ]3 m2 _& {
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));/ Y: U2 E: w) v1 x; ~9 S( t0 N p
; I% @7 s i- c7 M3 P
/* 配置通道1的PWM模式 */
* j& {: P1 |- f
TIM_OC1_SetConfig(htim->Instance, sConfig);: b1 s$ ? a6 q7 R( q# \3 o
6 o9 p" r4 `/ R
/*预装载使能，更新事件产生时写入有效 */' V# _# S6 k7 j3 N) ]+ a
htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;5 k. h$ Y4 a' E" o7 Z( ?! r3 [
3 B0 k, @, ~ P
/* 配置是快速输出模式 */
* A, n& W' v0 X2 R, Y, C
htim->Instance->CCMR1 &= ~TIM_CCMR1_OC1FE;
. [, T/ _% |' ~* _) _9 r" l5 a
htim->Instance->CCMR1 |= sConfig->OCFastMode;9 T$ a6 X# q" C- B' x; X, {
}
$ |+ m% Z9 U' j/ t* n$ P" B
break;
; p$ K" x2 U, n( N; J: r: F
, H8 L6 D3 O9 J' D
case TIM_CHANNEL_2:
' P6 f$ \. d8 p/ v8 [
{
6 w% |- X* S5 k- u3 o) A
/* 省略 */4 w( t5 F% Y1 V) i' ]
}
* i* j; A3 B. ?3 L
break;9 k b7 ]% Z; h1 Q0 j& U% b7 [
$ V' d' f: i# ]
case TIM_CHANNEL_3:
' [; o' \9 d* S2 R) V4 \4 T
{ o: O4 g n5 T/ n [) z+ q
/* 省略 */. k! @0 e9 S' n8 i( V* e
}- Z7 d3 u' h6 A3 t: C* Y9 s
break;
( G; D) I5 H' y1 B u
: L% J5 H* @% w. S, t
case TIM_CHANNEL_4:& D& | ]' H% e* @! f/ J
{
9 v( v' s1 a* |- W
/* 省略 */; F1 J8 K7 |+ f/ C* }" a; S/ M' X
}! c y" E" ~2 X+ ~; I0 s1 `/ N
break;) f; k1 y# D" k- H8 D' U) F5 J* b/ I
1 i8 j: b; v! X* j. z& Q
case TIM_CHANNEL_5:. j9 T4 Y! O. m( m1 F
{
$ G. f9 ^7 W8 `, g/ D J8 t' A
/* 省略 */
! g4 g3 r2 J! Q9 ?
}
7 @3 ^- `. B. ^5 @, ?
break;6 \* |7 X% B- B7 s, H- k- W0 c
4 Z& j( ]& _5 L/ X' r2 Z
case TIM_CHANNEL_6:0 o r( P: A: V0 A' d3 `
{
/ y1 b' ?+ u& _2 U& V& b# R
/* 省略 *// m9 V. `4 N% Y
}: ]+ ~% b5 |. L9 q3 H5 D5 e
break;2 L( y3 x! U& b8 H
5 A# ` W- g! ^5 D% p
default:
9 }# t& t. ?' q _! z# i
break;: m; R; z. C. a# y! a
}; `' j+ I+ L% V+ B: ~
. E6 Q9 k% e- b; V0 L6 v
htim->State = HAL_TIM_STATE_READY;
! _ N' O' \3 W- M; q
. @" A+ J, N ]0 [/ n; N
/* 关锁 */
2 d+ N7 Y6 j0 k( }, L. M0 r* `
__HAL_UNLOCK(htim);, g! z+ e8 Z3 A0 A
, a+ W# `% ?/ Q8 C
return HAL_OK;+ h8 x! U& @3 H3 u) Q( v) H
}

复制代码

函数描述：

此函数用于配置定时器的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};
" h# C7 i" K f/ `) f2 _
) g; I2 ?3 _; M$ v
/* PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/+ T+ q/ C7 \5 @/ [: ?0 V* m2 s
TimHandle.Instance = TIM1;5 N2 v' i6 R6 K+ H( K% D. U
TimHandle.Init.Prescaler = usPrescaler;: m; i' P- k+ _, A) M: W
TimHandle.Init.Period = usPeriod;2 ~- f" x3 |) S5 B# O
TimHandle.Init.ClockDivision = 0;. {8 d; U& i0 W
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
* y" w2 x3 n4 k0 K) G, I: B
TimHandle.Init.RepetitionCounter = 0;
& ~* N6 A% J$ g [. K7 y- g) u
TimHandle.Init.AutoReloadPreload = 0; |, \( d5 T0 c/ d% J& V, w
if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)$ A# }" j, R- N$ z" I8 H( w
{; R% Q1 n( D/ u: |' @4 v6 C
Error_Handler(__FILE__, __LINE__);
" h; ?) |: n& P
}6 }5 s- d8 {. J3 \' B! x6 I
; l* P7 z! u3 ]1 _# R
/* 配置定时器PWM输出通道 */ S, f$ o( |3 v. T. q
sConfig.OCMode = TIM_OCMODE_PWM1;
. i6 \2 [' p$ D1 V" f- Q3 D
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;; z3 q& {6 V; t' e& V
sConfig.OCFastMode = TIM_OCFAST_DISABLE;" f' Y1 }3 E+ |( y
sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;
" _* l: H8 m# q( n3 |6 l' B) T
sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;' Y& C. s) p0 d: X( |' h: q( {. D
sConfig.OCIdleState = TIM_OCIDLESTATE_RESET;
8 ]9 c6 t7 W- [4 c7 b
, B& c6 C) [ E% G/ { j
/* 占空比 */
* t! M& v% y) m2 Q
sConfig.Pulse = pulse;& c. {" M& l5 ?* d2 O4 I
if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)) J# \0 T! V- q) I/ M& i8 J! a
{
% w3 C, a( v3 D# I& J
Error_Handler(__FILE__, __LINE__);1 Y3 k2 @; T/ M- v: v- k4 H4 k3 K
}

复制代码

32.4.5 函数HAL_TIM_PWM_Start
函数原型：

HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)& T, I o3 J8 f% U+ ?# D S
{
& U$ A @7 Y2 h! w1 V7 [; y
/* 检测参数 */
# P( G9 b% ^1 F6 e0 \3 n7 t
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
1 }7 z* F' F. E" n( R
2 d1 A9 P) d. r+ v2 ]# G0 [
/* 使能捕获比较通道 */9 O; \6 J, y. L# Q
TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
, j; h: E9 G, z' T- O4 o2 a4 K5 [, ^
) l( w0 \) q. e
if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET) 8 N! ]6 ?. z$ f5 \/ r6 S
{2 z$ ^$ X2 A& h2 I+ y3 A
/* 使能主输出 */
; g+ s6 W( q4 I
__HAL_TIM_MOE_ENABLE(htim);
4 j- J8 v# \3 ]) Q) W& L9 F; N
}7 X3 m$ F$ U: b" q% U7 q' o
$ D7 ^- i4 G0 M
/* 使能定时器 */
: _# j# o1 t; p/ v, X
__HAL_TIM_ENABLE(htim);
$ L# f+ B5 o1 H" z6 \& `
+ k8 ~* W, ^: P4 @* Z Y
/* 返回状态*/1 b$ U+ h, B- y0 n* r A4 u- x
return HAL_OK;
: ] j4 l# j( ~- z5 y7 g; \
}

复制代码

函数描述：

此函数用于启动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 `- D' g3 i3 ^9 G: f! t) Q
* Y, a( D" P5 o- R) p2 Q9 g. w
/* PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
( l% F" J) _& D: Q" l% U3 G. ^: X
TimHandle.Instance = TIM1;0 ?/ V& g6 [+ a
TimHandle.Init.Prescaler = usPrescaler;
a( y/ X: W# ^$ H: V, Z. }7 C' ]
TimHandle.Init.Period = usPeriod;
. |" q4 c: c5 @3 \) \* R: A
TimHandle.Init.ClockDivision = 0;
8 S9 c# Z. V; c0 |
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;1 p; I. k: ?) P' J" N/ Z- y3 B( ~
TimHandle.Init.RepetitionCounter = 0;
& \. f; t. ]0 x% y
TimHandle.Init.AutoReloadPreload = 0;
" ]2 F2 P* A4 l& `
if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)+ J8 O+ Z, f7 R5 n
{
3 l3 x8 ?) e4 A7 A
Error_Handler(__FILE__, __LINE__);
8 F2 D0 j4 z0 X) `
}) `' C) l5 U) C) I; d* J. Q
5 f, N( ?$ j2 ]3 [
/* 配置定时器PWM输出通道 */& r6 N/ |! k7 I7 }5 O! x: @5 ~
sConfig.OCMode = TIM_OCMODE_PWM1; v6 G& X! {: w) a Q2 X9 P
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
# i; e/ y* ]/ g ~+ O' h
sConfig.OCFastMode = TIM_OCFAST_DISABLE;" X% F: G, k% `( F; [, l0 G. K6 M$ O
sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;3 E/ T- ?0 l$ W* F# H/ ]
sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
9 t4 I8 k, X3 o; q; R. m
sConfig.OCIdleState = TIM_OCIDLESTATE_RESET;
; |9 }% p M7 Z# w% z! S
3 H/ ?+ U( M( r# e% c5 Z; H
/* 占空比 */
! g a8 l6 t, m- n6 x5 X
sConfig.Pulse = pulse;8 B8 T5 I; H3 O
if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)% p- }3 d$ t! `2 q4 |
{* V! f% {2 _* J" c! ^9 K; [' y8 c1 M
Error_Handler(__FILE__, __LINE__);; Z% q; t/ \7 G6 \
}0 i. G$ t! B) K5 l! |
& k1 `- Z) ]! E8 t( p5 e0 f; v
/* 启动PWM输出 */- P+ ~0 y% r1 J% J
if (HAL_TIM_PWM_Start(&TimHandle, TimChannel[_ucChannel]) != HAL_OK)5 u- Y* s: M, y# Y" E
{ P7 p, ~ c0 J0 ], b! \( B Z8 ^
Error_Handler(__FILE__, __LINE__);+ `0 p# L2 E( Y/ G$ g! _2 c
}

复制代码

32.4.6 函数HAL_TIM_IC_Init
函数原型：

HAL_StatusTypeDef HAL_TIM_IC_Init(TIM_HandleTypeDef *htim)
5 a+ g$ J5 B) _) I
{
( X1 X, k8 P* O4 I. U
/* 检测形参是否有效 */8 A# l! ], c4 v X: j
if(htim == NULL)# F% k- q! S- H' A
{9 S7 Z) s* p4 V3 ~& Y
return HAL_ERROR;
3 Z/ M( E: {' @* [2 F
}
$ Q5 z% Y( Z" l X) N
6 x' |' W, n* `1 R
/* 检测参数 */# N/ x! B- F4 H/ O- l
assert_param(IS_TIM_INSTANCE(htim->Instance));! j8 z6 B4 j4 _
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
) Z6 Y: x% O' \ N6 ?% s! @
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision)); ; {8 Z$ T" @! I8 C8 |
8 d% c i2 [6 m
if(htim->State == HAL_TIM_STATE_RESET)* l T0 V# o0 C7 B' d8 C9 r+ Z
{
& K& U! I+ I, d- B
/* 默认取消锁 */3 a- {6 D5 v! @) I
htim->Lock = HAL_UNLOCKED;9 O# p8 t1 ~5 ^# ?3 U9 i: d4 U) p# T
( {+ f! ~0 j) A( l" M, S
/* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */. j: T; S* ^. y
HAL_TIM_IC_MspInit(htim);
4 c6 e" J# o. G+ a ]
}
: z, T1 s4 T1 m% H
6 @* [) v) f1 Q2 e
/* 设置定时器状态 */
+ R4 T, o) ]2 y& T7 {
htim->State= HAL_TIM_STATE_BUSY; * H# c7 { x) q+ B( M0 T5 p
9 X/ A5 N8 k3 O) ^
/* 配置定时器为输入捕获模式 */
& R0 h, _: X% V1 j, C& @
TIM_Base_SetConfig(htim->Instance, &htim->Init); . D" ^& g& [& B% ?; a2 @& p+ Y
3 v' q' `: E# R7 N e/ g
/* 设置定时器状态 */
htim->State= HAL_TIM_STATE_READY;2 [; f, U7 L- w. Y8 q# s2 P
1 _# F% n' G7 X" z8 ?
return HAL_OK;# i% y( s" U$ |8 ?: |9 z2 j0 v% v
}

复制代码

函数描述：

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

函数参数：

  第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)
% v7 I# f4 |0 N( r, S0 G) F
{4 v! [* `: x( l
Error_Handler();
" W" X! B5 V7 q0 a
}
% }6 K8 d7 e- E. S
if(HAL_TIM_IC_Init(&UartHandle) != HAL_OK)# J# o; e# Z! D9 }0 r5 q3 ?
{
$ S; C9 k6 z( p N7 P
Error_Handler();
3 H# n) `9 z3 ^
}

复制代码

32.4.7 函数HAL_TIM_IC_ConfigChannel
函数原型：

HAL_StatusTypeDef HAL_TIM_IC_ConfigChannel(TIM_HandleTypeDef *htim, TIM_IC_InitTypeDef* sConfig, uint32_t Channel)% i. t+ P& i+ x- E+ p0 D$ l* ~
{5 C7 M* { d$ t# M4 u. g
/* 检查参数 */6 x0 U! O6 y$ ^: p0 `
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
3 H3 q) A! b8 u, V) b
assert_param(IS_TIM_IC_POLARITY(sConfig->ICPolarity));
! [* [1 a3 Q4 S' \* b6 h9 `7 L
assert_param(IS_TIM_IC_SELECTION(sConfig->ICSelection));
q$ |; \! F0 Z3 i) w
assert_param(IS_TIM_IC_PRESCALER(sConfig->ICPrescaler));. K* b& c: I% V7 H
assert_param(IS_TIM_IC_FILTER(sConfig->ICFilter));
& V/ [. \0 y3 Y: _/ j5 P
f* J! x! q4 ^/ J% c) {
/* 开锁 */ + F' e8 N6 q. x8 f" } J' Z
__HAL_LOCK(htim);" G9 d3 }$ A/ f
3 H. g. M8 ]0 y$ o' f2 g4 z; P c
htim->State = HAL_TIM_STATE_BUSY;
8 N [5 u0 I" }* F$ l
) W+ |% L" R9 g) ~( I" k
if (Channel == TIM_CHANNEL_1)
0 m: \* ]( I- u z% Y
{
/ M" G% r9 o, X4 G8 f1 x
/* 配置输入通道1 */' v5 L" K0 o3 I3 ^7 _# {
TIM_TI1_SetConfig(htim->Instance,, O3 F1 {0 x8 ?
sConfig->ICPolarity,# |2 f+ d" `0 C3 |- @3 O3 ]
sConfig->ICSelection,# j) s# ?2 Z% V4 K# ?- N
sConfig->ICFilter);
% }- _3 }9 d* l! ?8 p
% n! t! Q( ] B" Q+ |: h2 O
/* 清零IC1PSC位 */9 d+ v3 W! Z0 U' D1 B6 V
htim->Instance->CCMR1 &= ~TIM_CCMR1_IC1PSC; S0 G- F( q, z
7 R% ]; q$ G8 T/ [/ D
/* 根据用户配置，设置分频 */- z/ _. i# L( P# U6 Z
htim->Instance->CCMR1 |= sConfig->ICPrescaler;& A# _/ o7 ~' l9 f5 a
}
% H0 q; V5 u J Z% P: `
else if (Channel == TIM_CHANNEL_2)0 n- P$ ~% q* e) V5 r
{. P5 T* S& T$ a! J5 O4 m; i; }
/* 省略 */
2 [0 O7 O0 y2 b9 Q8 p
}9 E7 e; E y2 k
else if (Channel == TIM_CHANNEL_3)
0 s4 L1 M4 x+ Y- T/ e9 x9 ?
{* ]+ h8 `! ^' |8 R5 I7 U
/* 省略 */7 y( U6 g: D D; }3 s' W k k$ W6 U
}1 n! n' B8 h ?$ I" \$ k
else* Q3 L/ Z; e8 t. Q( S* G' A- F& p# o
{& Y8 x- i- I& {$ R _4 t6 B" F3 X
/* 省略 */5 t/ E0 ?1 J5 K5 R0 d
}
1 p4 t6 ^3 B! S$ F
4 G0 F1 G6 h2 P: M) g
htim->State = HAL_TIM_STATE_READY;& w" g% ]: K/ Z( Z. m3 o5 W
6 `- B! p. h9 _2 a, Q$ ?
__HAL_UNLOCK(htim);
, n' ~: @4 x& l8 G3 p5 I
+ \ x6 z/ X4 Z
return HAL_OK;
0 t/ o" z& G7 n2 [$ [
}

复制代码

函数描述：

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

函数参数：

  第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)" I' L" t- D0 g. O0 k5 W+ y
{
" W9 a6 k; \) J3 ^+ e# v/ n6 I
/* 检查参数 */
/ @2 y, f2 c v, \ A5 s
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));! [6 ?; n8 ]! O) @
$ D* A& s) R* n4 q4 @0 H
switch (Channel)
" O6 g" D" F1 n, S6 v
{' ?$ p5 X$ ~/ ?: a; [; I
case TIM_CHANNEL_1:
, ~1 N2 w6 w+ W% d& _* j5 @3 r- ]4 p
{ 9 a% t ?1 v9 J8 Z& L g7 l- H
/* 使能CC1（Capture/Compare 1）中断 */: @. A% ~4 ?( D) F; ~
__HAL_TIM_ENABLE_IT(htim, TIM_IT_CC1);4 H# [ N. p- M
}
: M6 R9 W q1 n6 b/ p; Q. E
break;
. c2 j, G. T6 d4 m* ?- ~
* Q" l+ g, A, u; |+ G
case TIM_CHANNEL_2:
( A" L7 _8 @4 C& ~% c$ H( |
{- A, J {, S+ m2 W; g
/* 省略 */
, p. k n3 [; g. H0 i) W# O
}
; r" j7 F+ n5 J+ ?9 p7 E+ D: }
break;4 n9 }. n7 n1 K
9 o8 k/ D/ \* T( h* q) s
case TIM_CHANNEL_3:
; d# m6 F. K6 l/ h8 ]" Y) d0 n
{
! a! Z1 q8 u5 [8 N( {3 C% O9 F" k
/* 省略 */9 Q5 P/ J4 R& Z( K. q- f5 H
}
+ } _: c0 ?5 }, _4 q0 J
break;
- H! e$ u, v/ D4 F* R
- M X* ?! c3 F2 v$ G' C6 k' ?
case TIM_CHANNEL_4:2 q$ ?# d5 ]) H' J: x
{
2 r9 e0 N+ {$ e1 s, p0 k! E& B
/* 省略 */
% d A: V( M8 O) j
}
; o' o6 R' W) j* ^/ P
break;: O: o ~- q0 g. ^. m* E' h
( O4 l) X, d/ a
default:3 J- z% y' b: r/ g# L
break;
} - p5 h5 V4 Q$ L
/* 使能输入捕获通道 */
{) o- q) p; G8 y* o7 L
TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
7 V5 x' m0 X# L5 A" F
! Z. j* e9 C% r4 V3 s
/* 使能定时器 */
: ?$ i- a; `! v+ H2 \% i! g0 [5 T6 Z' y
__HAL_TIM_ENABLE(htim);
0 ~3 Q7 K2 M n$ d' K
. z/ E: e7 a. C8 r" C% x/ C
/* 返回状态 */- Z5 e. K( x9 P
return HAL_OK; % h+ R0 v/ ?% @6 A
}

复制代码

函数描述：

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

函数参数：

  第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)
* ~) v d( P4 n( v( n- F" ~. c$ O
{
( `' Q$ J L' N* t! ^
/* 检测形参是否有效 Check */1 z, s+ M }' @- Z- V3 ]/ s- L
if(htim == NULL)
$ y) ]6 j$ a; p) T0 i! g
{
% B" P; M* m1 ?( u8 i
return HAL_ERROR;
3 P5 @" G6 `8 A; Y$ \0 t- n
}
2 }( G% t3 l( C0 j/ }
8 O1 f) t) M% T, E/ d1 S ~: r
/* 检查参数 */
8 u# {' m$ Y" D+ a5 {- f" ?- p9 M: h$ A
assert_param(IS_TIM_INSTANCE(htim->Instance));
6 ^7 R0 A$ z4 g9 ^' u
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
1 t' i1 f8 b6 d! C$ T( I! h
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));& I& ^/ \- F! S8 f2 R0 o: i3 w
1 V' ~# I" o$ m6 A- K8 F$ W" C
if(htim->State == HAL_TIM_STATE_RESET)
" d% r. V9 q$ |" g& ?$ C) y! i
{
6 |+ x. z! e: ]; x7 v/ ~- T$ u6 q
/* 默认取消锁 */
! n* Z6 D p( E! \ @% f- j [
htim->Lock = HAL_UNLOCKED;
% q1 B* E1 `) e* `- l0 S
1 N7 a! O6 b( ~$ l1 a3 Z
/* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
( f5 K8 k' V. X: `+ X
HAL_TIM_OC_MspInit(htim);& \& J0 P4 t- L+ q( c& u( _
}! f% C9 U* E: h6 S
8 s( n1 t# A# O5 d. d; a* y
/* 设置定时器状态Set the TIM state */* |" _' D& u& f3 i ]4 H0 a
htim->State= HAL_TIM_STATE_BUSY;% C2 W1 |6 c% ?) {- x$ v2 Q
' S$ w4 ~: F8 N S
/* 配置定时器为输出比较模式Init the base time for the Output Compare */ 0 V: O0 O* t, A7 U+ v' s
TIM_Base_SetConfig(htim->Instance, &htim->Init); " p, J) G0 @! D- [/ K( g6 I
, t1 h( r* e9 `; N8 G, S; t
/* 设置定时器状态 */5 v* f+ w2 n8 @% K
htim->State= HAL_TIM_STATE_READY;; Y6 M8 q+ q7 y7 a( n
+ x# x. ?8 b+ u4 M1 M8 ~6 S; Z
return HAL_OK;
4 d/ Q" ^1 F% w0 M- Q( Q
}

复制代码

函数描述：

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

函数参数：

  第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), L, h6 ~# t" Z" U# A& v( \9 I
{
3 w8 e* r' c" s+ O; ^. J4 S
Error_Handler();. X+ e0 ~% U8 f7 N9 |5 c3 o
} / c+ G6 L+ l: ]; E. ^2 j1 [* E% z
if(HAL_TIM_OC_Init(&UartHandle) != HAL_OK)( y# c5 Q' h- _ E
{5 Z" ^0 H5 L( }) a3 p0 R) \5 ]
Error_Handler();' M' l3 n- Q% c7 R
}

复制代码

32.4.10 函数HAL_TIM_OC_ConfigChannel
函数原型：

HAL_StatusTypeDef HAL_TIM_OC_ConfigChannel(TIM_HandleTypeDef *htim,
1 _# Q% H4 @( t8 K; y
TIM_OC_InitTypeDef* sConfig,
" V/ O* k' c7 n" v( b
uint32_t Channel)% q- O, R/ o2 N5 i2 f3 \! u, L
{ 8 V% `+ j- ?+ ~- a5 X( p+ t) N; V! E
/* Check the parameters */6 o- B- g7 ~: Q1 u4 t
assert_param(IS_TIM_CHANNELS(Channel)); / K, B7 z( S5 w9 f3 V
assert_param(IS_TIM_OC_MODE(sConfig->OCMode));
7 x5 S3 h( f m% l/ t
assert_param(IS_TIM_OC_POLARITY(sConfig->OCPolarity));" K. o# I6 F& E9 m8 ^& U- |
! l8 b x2 T# K' T; w
/* Process Locked */) L. g/ ^4 N- L [
__HAL_LOCK(htim);
( P9 T% o/ u/ c3 I- S
* @7 o/ s3 L# A) R$ g
htim->State = HAL_TIM_STATE_BUSY;
3 |3 O( r, p& x6 ?
0 o a. ^$ ?" x7 s: B! {
switch (Channel)& _' A3 p9 f2 A& \
{
7 j+ }1 v5 L3 J$ d2 Y" p
case TIM_CHANNEL_1:
! T' w; e$ A+ |1 F) k: T% I4 D& b
{
4 T1 B8 j! U5 W+ [5 ]
/* 检测参数Check the parameters */
7 H1 k$ o: p$ M4 O+ U8 l
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
& K$ b# H W t) [, ]" t
! N1 D5 V; I& G
/* 配置定时器输出比较通道1 */
7 W0 U- V1 c! _( j9 `
TIM_OC1_SetConfig(htim->Instance, sConfig);) l, m H: D/ R: w% ^# X7 b
}: p4 [6 a U/ l" K- R
break;5 h& S; Q0 F s$ Z* O
& U+ S2 ~/ H" J- ~4 B6 `
case TIM_CHANNEL_2:6 G/ w* v U; z! M Z. k: r
{+ T: Y' X4 s# f. h, W
/* 省略 */6 k. V, ~) Y7 ?
}
3 S. ~, o( N+ n8 `4 H
break;
# A; f) a" h( D7 J5 V+ ?: \
1 w, \9 w5 Y$ u2 E
case TIM_CHANNEL_3:! g, D2 b" d/ ~8 N% ^- B
{$ ?' i& c! L# `* n% e
/* 省略 */
. e# R: c! K1 m; X5 |
}
6 W( b+ m) p) b/ Q" i4 L
break;
8 s7 U7 Z* L$ C+ b) ]
. m3 k" b; r- g0 Y/ z
case TIM_CHANNEL_4:
2 j3 ~. ~5 R/ F( v
{
2 X0 [/ t# Y4 d: k, r' E; a
/* 省略 */) D! e- t( q2 M. c( j( |! }4 v
}( C7 ^0 J+ p1 [ d- {/ G6 j
break;. S$ F5 Q4 g7 x
# C, r8 N: O/ D! w; x: F
case TIM_CHANNEL_5:
4 Y# F7 A Z, t
{
1 [* O; m9 u, D
/* 省略 */0 P3 D' X$ g" o0 @/ A5 O7 T
}7 x7 @) h0 e2 X: m
break;
# F8 I$ F) ~7 q1 [! ^
* A% [0 z1 n7 E6 P+ a9 B+ J2 ^; S8 O
case TIM_CHANNEL_6:" Y1 f- H9 f# K a9 w
{
+ E7 H5 \' j0 |5 D( u0 M) I
/* 省略 */: V2 E E- l1 K+ ?( W
}1 c+ A* G7 B5 b0 G( ?4 i# Z
break;
! j: m9 @0 L; ?! Z# ~
1 C7 v' R+ \6 s- I! `
default:
1 B8 J! J6 a+ D9 g2 x* L: `5 C
break; 0 Q+ G2 P- R' ]$ a1 m( z
}7 j+ @* z3 o0 d/ c9 g# |: `
( [9 F; w2 K+ N/ e, K, t( X/ N% U
htim->State = HAL_TIM_STATE_READY;
) N$ z9 R7 c4 v/ F' h
3 v1 i( k1 `9 r6 C# S
__HAL_UNLOCK(htim); ; u: o' `; ?7 R$ a- B+ W
' y8 S k( r, C7 r) c
return HAL_OK;+ F( v2 r2 X# `* H
}

复制代码

函数描述：

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

函数参数：

  第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)
: ?1 f- c# M* @2 r. O
{/ Z* j( H" U3 a6 v! e) n3 d! }
/* 检查参数 */
6 Q# [2 Y2 q$ p! M2 }8 r+ [0 q+ B
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
7 n) x+ V' G7 ?/ f4 t
8 _$ G |7 ]+ N7 T, Z$ q
/* 使能输出比较通道 */
3 B8 [0 c# x, M0 ?' w q* i1 n
TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);) Y8 g* r& H: E7 w% W' z8 _2 J4 D
# w0 x# O/ @1 m& U1 l# j
if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)
1 L7 h4 B1 m! Z* X8 ? {0 ?7 }1 g
{
8 {: z) v$ f9 J$ A
/* 使能主输出 */
' ]& m: G9 A7 G
__HAL_TIM_MOE_ENABLE(htim);
" q, b( P R! [: t5 @2 v, i
}" E3 |$ @! Q P9 F# h2 a
8 r# F1 J/ W& U( Y: E0 i
/* 使能定时器 */8 u% i- M( Q" O& i8 T
__HAL_TIM_ENABLE(htim); + M" w. i: @" o# Q
3 V$ Z7 Z: p Z; x& v* H6 w: Y% J
/* 返回状态 */* w. z* w" I4 v
return HAL_OK;
; W {) m( N# u' v7 ~: U& ~
}

复制代码

函数描述：

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

函数参数：

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