【经验分享】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 I5 s* e- `, N' d$ O
TIM1_UP_IRQHandler
, D- d2 P* T+ G2 h+ H. q& v! ^* \
TIM1_TRG_COM_IRQHandler % ^, D1 o3 O h3 c8 o
TIM1_CC_IRQHandler
2 t, i' D8 J2 R1 p) n/ B
TIM2_IRQHandler
( X$ r7 r( J7 b$ m' }
TIM3_IRQHandler : V6 E1 S/ M# z2 }
TIM4_IRQHandler 3 K( s( O: M6 f0 L* P
TIM5_IRQHandler $ l& X1 @0 O. d6 z
TIM6_DAC_IRQHandler <------------------要注意 8 r m6 v1 e# W. u. B3 k! {2 e
TIM7_IRQHandler . w0 |" }( o' |+ @+ @" I. ]
TIM8_BRK_TIM12_IRQHandler <------------------要注意，定时器12也是用的这个. x; p& |. z% `8 V1 [
TIM8_UP_TIM13_IRQHandler <------------------要注意，定时器13也是用的这个
8 W- ]6 y) p! j! Y* g
TIM8_TRG_COM_TIM14_IRQHandler <------------------要注意，定时器14也是用的这个
' u3 {' {) T' `0 p) |* b
TIM8_CC_IRQHandler 8 J, B1 s( r+ k" k' N
TIM15_IRQHandler
% N. a3 L( Z- X
TIM16_IRQHandler
4 B7 g8 L" {, T5 m3 k% @
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 struct0 v i1 R6 u8 i% \
{# {* f! y6 g1 n2 F" @7 m% D
__IO uint16_t CR1; /*!< TIM control register 1, Address offset: 0x00 */
+ ~4 ]# N8 g0 P3 `8 K
uint16_t RESERVED0; /*!< Reserved, 0x02 */
2 W) m! j; F* t( P
__IO uint32_t CR2; /*!< TIM control register 2, Address offset: 0x04 */
+ t2 v: y) ~7 t* C% M) ^
__IO uint32_t SMCR; /*!< TIM slave mode control register, Address offset: 0x08 */( ]8 m8 [" I! a6 w- {6 ?3 ^
__IO uint32_t DIER; /*!< TIM DMA/interrupt enable register, Address offset: 0x0C */1 L1 O5 y% s7 M' s& } Q
__IO uint32_t SR; /*!< TIM status register, Address offset: 0x10 */
. `/ v# z E* b. G
__IO uint32_t EGR; /*!< TIM event generation register, Address offset: 0x14 */" ~5 L$ K. h+ Q( d0 _
__IO uint32_t CCMR1; /*!< TIM capture/compare mode register 1, Address offset: 0x18 */
* K' n7 e) }7 R/ n, ~
__IO uint32_t CCMR2; /*!< TIM capture/compare mode register 2, Address offset: 0x1C */
2 Z4 N0 H: ?' V1 b! J4 H) b+ {
__IO uint32_t CCER; /*!< TIM capture/compare enable register, Address offset: 0x20 */
2 b/ C, j2 k: }
__IO uint32_t CNT; /*!< TIM counter register, Address offset: 0x24 */$ O) p+ w' D) I# R d+ C& P8 b
__IO uint16_t PSC; /*!< TIM prescaler, Address offset: 0x28 */
) m; @3 [' ~- f
uint16_t RESERVED9; /*!< Reserved, 0x2A */
! Z$ @4 Q2 Z6 Z( T1 F! k
__IO uint32_t ARR; /*!< TIM auto-reload register, Address offset: 0x2C */
8 }9 y. Q7 y/ @% e: D4 _% v% j$ H
__IO uint16_t RCR; /*!< TIM repetition counter register, Address offset: 0x30 */* |2 u; O" y3 J- u5 d8 j
uint16_t RESERVED10; /*!< Reserved, 0x32 */ z' X% ^8 Q1 ? J
__IO uint32_t CCR1; /*!< TIM capture/compare register 1, Address offset: 0x34 */
d' z1 q# o# ^
__IO uint32_t CCR2; /*!< TIM capture/compare register 2, Address offset: 0x38 */0 V; x, l- C5 U! k5 c& N
__IO uint32_t CCR3; /*!< TIM capture/compare register 3, Address offset: 0x3C */
7 z/ U3 B! Z) z }0 g) P5 O! v
__IO uint32_t CCR4; /*!< TIM capture/compare register 4, Address offset: 0x40 */# C7 V8 K% p. X! g- K! w
__IO uint32_t BDTR; /*!< TIM break and dead-time register, Address offset: 0x44 */
) p& I6 f0 E- h8 H
__IO uint16_t DCR; /*!< TIM DMA control register, Address offset: 0x48 */6 U$ a+ G x6 v+ F w
uint16_t RESERVED12; /*!< Reserved, 0x4A */
1 q3 r# r) R t* T: |( y
__IO uint16_t DMAR; /*!< TIM DMA address for full transfer, Address offset: 0x4C */% c, X8 ~$ A8 \, A7 Q' B
uint16_t RESERVED13; /*!< Reserved, 0x4E */
; {: k E0 c& @+ v
uint16_t RESERVED14; /*!< Reserved, 0x50 */7 Y5 T5 }) ^, \, D/ d2 t- F! }
__IO uint32_t CCMR3; /*!< TIM capture/compare mode register 3, Address offset: 0x54 */. \4 t" M: {1 H& H, H) V3 J5 ^
__IO uint32_t CCR5; /*!< TIM capture/compare register5, Address offset: 0x58 */5 H- S P- b5 Z; t
__IO uint32_t CCR6; /*!< TIM capture/compare register6, Address offset: 0x5C */
7 M2 C3 o, A( z% v3 X3 `
__IO uint32_t AF1; /*!< TIM alternate function option register 1, Address offset: 0x60 */1 g4 `# n' y7 h0 }9 _$ m
__IO uint32_t AF2; /*!< TIM alternate function option register 2, Address offset: 0x64 */7 R0 F! o. ?" M5 P
__IO uint32_t TISEL; /*!< TIM Input Selection register, Address offset: 0x68 */8 H8 _0 p$ g1 Q4 R" U! \
} TIM_TypeDef;

复制代码

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

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

#define __O volatile /*!< Defines 'write only' permissions */0 E Y$ J: b: O' f/ z% m
#define __IO volatile /*!< Defines 'read / write' permissions */

复制代码

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

#define PERIPH_BASE ((uint32_t)0x40000000)
, y) @; X% M' ^, ], C( `
#define D2_APB1PERIPH_BASE PERIPH_BASE
1 Q1 x& V+ ~7 O+ h5 k) z- {8 B
#define D2_APB2PERIPH_BASE (PERIPH_BASE + 0x00010000)- j) o9 U3 p, J3 w# P: V) A
: }' h! Q. q" P( U: R* [$ d
/*!< D2_APB1PERIPH 外设 */
' y5 j& n' J, {( M \
#define TIM2_BASE (D2_APB1PERIPH_BASE + 0x0000) <----- 展开这个宏，(TIM_TypeDef *) 0x40000000* r' X. I/ Z2 u/ L9 C8 D" ?
#define TIM3_BASE (D2_APB1PERIPH_BASE + 0x0400)$ s4 x1 s- @' T' t i0 D6 G
#define TIM4_BASE (D2_APB1PERIPH_BASE + 0x0800)
+ A1 j; V# _, V$ Q2 {
#define TIM5_BASE (D2_APB1PERIPH_BASE + 0x0C00)9 R5 W4 g, y+ f" a: E6 p& @4 \
#define TIM6_BASE (D2_APB1PERIPH_BASE + 0x1000)0 V% N5 u. P2 S. @; l
#define TIM7_BASE (D2_APB1PERIPH_BASE + 0x1400), S, C& I) Q9 ^$ D. `5 r
#define TIM12_BASE (D2_APB1PERIPH_BASE + 0x1800)3 F1 z/ l, a) M& y4 h
#define TIM13_BASE (D2_APB1PERIPH_BASE + 0x1C00)
2 x5 K2 Z; p1 F2 b
#define TIM14_BASE (D2_APB1PERIPH_BASE + 0x2000)% a7 I6 [. \5 |* a/ ]1 J( O* `
V f( f* ?" ?: N
/*!< D2_APB1PERIPH 外设 */
+ \! \: }+ `2 s1 r
#define TIM1_BASE (D2_APB2PERIPH_BASE + 0x0000)8 H8 {- }( J8 G( v
#define TIM8_BASE (D2_APB2PERIPH_BASE + 0x0400)
4 k2 ^8 [9 |3 i* z' ?# W
#define TIM15_BASE (D2_APB2PERIPH_BASE + 0x4000)
4 X5 _) \" x& S
#define TIM16_BASE (D2_APB2PERIPH_BASE + 0x4400) n% S I- q1 T* l6 b; H) g; D" j
#define TIM17_BASE (D2_APB2PERIPH_BASE + 0x4800)" m! V% O$ O, a H0 {% A9 ]7 P
0 H) Z% V5 ?& v& }" n" y7 B
#define TIM1 ((TIM_TypeDef *) TIM1_BASE)
2 k( i( s' \/ k Z
#define TIM2 ((TIM_TypeDef *) TIM2_BASE)/ g4 t6 f0 t4 L6 C. g
#define TIM3 ((TIM_TypeDef *) TIM3_BASE)
, S" ?7 l7 r! V' R1 P) b+ ]9 B
#define TIM4 ((TIM_TypeDef *) TIM4_BASE), u1 J- a+ K) ^+ [
#define TIM5 ((TIM_TypeDef *) TIM5_BASE)
t/ H, n0 Y( J3 p3 i
#define TIM6 ((TIM_TypeDef *) TIM6_BASE)/ T% r9 [8 `7 Z1 x. }, u! I: j
#define TIM7 ((TIM_TypeDef *) TIM7_BASE)6 N3 @; w# H7 o. L# H$ H5 n
#define TIM8 ((TIM_TypeDef *) TIM8_BASE)
5 J) K0 [! }( l8 w- I* y( s
#define TIM12 ((TIM_TypeDef *) TIM12_BASE)
I T4 r. k8 _+ c V \# _) D
#define TIM13 ((TIM_TypeDef *) TIM13_BASE)- V/ e, O) Z4 ~$ h6 Y l
#define TIM14 ((TIM_TypeDef *) TIM14_BASE)" q6 p/ R6 K1 Q: `# H
#define TIM15 ((TIM_TypeDef *) TIM15_BASE)9 l+ I. u: `( ~/ q, z" t& y
#define TIM16 ((TIM_TypeDef *) TIM16_BASE)
3 ]3 S# G) @. o- d* p
#define TIM17 ((TIM_TypeDef *) TIM17_BASE)

复制代码

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

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

typedef struct
9 q. V. D9 X& Y& ~0 e9 U2 C9 B
{% z6 h& X+ _* o2 B; p
TIM_TypeDef *Instance; /*!< Register base address */ ( Q1 L! T. }. V. T
TIM_Base_InitTypeDef Init; /*!< TIM Time Base required parameters */
! p+ M: F8 e/ ]9 t
HAL_TIM_ActiveChannel Channel; /*!< Active channel */
' m/ G/ x) x2 x' ]8 S, @, ]) X- z
& r: J3 t& E2 E% S. R- c
/*!< DMA Handlers array This array is accessed by a @ref DMA_Handle_index */1 Z0 A$ c5 b2 j
DMA_HandleTypeDef *hdma[7]; ) |- ~; v/ V( e* s
HAL_LockTypeDef Lock; /*!< Locking object */' N; R% Z$ D# O2 q, W
__IO HAL_TIM_StateTypeDef State; /*!< TIM operation state */
}TIM_HandleTypeDef;

复制代码

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

  TIM_TypeDef  *Instance

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

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

  TIM_Base_InitTypeDef  Init

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

TIM_Base_InitTypeDef结构体的定义如下：

typedef struct V) i& s y. z3 ^
{
$ S e1 V* w2 O% d2 O
uint32_t Prescaler; 0 H+ W8 \; L+ m' G7 G! b6 {
uint32_t CounterMode;
, |" V# D3 H$ b1 l* E3 ?( M
uint32_t Period; ! x7 V+ h; v' D
uint32_t ClockDivision; 6 l* x# ?/ h" ]5 j W) ?, P
uint32_t RepetitionCounter;
+ n: @. i B' C. y$ _8 P8 z
uint32_t AutoReloadPreload;
! M: \- D# ~8 x! @
} TIM_Base_InitTypeDef;

复制代码

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

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

#define TIM_COUNTERMODE_UP ((uint32_t)0x0000U) /*!< Up counting mode */
6 e9 u' J2 }4 Z% M
#define TIM_COUNTERMODE_DOWN TIM_CR1_DIR /*!< Down counting mode */6 @7 Q% h: Z% F `1 \% H, z) z
#define TIM_COUNTERMODE_CENTERALIGNED1 TIM_CR1_CMS_0 /*!< Center-aligned counting mode 1 */; M4 V7 d" J9 W8 B
#define TIM_COUNTERMODE_CENTERALIGNED2 TIM_CR1_CMS_1 /*!< Center-aligned counting mode 2 */
) H* Z* _) _# \$ \( ^8 M! W
#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 */
- O( t) w: I* s$ S! k) E# e- U
#define TIM_CLOCKDIVISION_DIV2 (TIM_CR1_CKD_0) /*!< Clock Division DIV2 */
& ~1 f$ W9 o4 ^2 e6 [
#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 */
* u2 i) K# a5 H1 r
#define TIM_AUTORELOAD_PRELOAD_ENABLE (TIM_CR1_ARPE) /*!< TIMx_ARR register is buffered */

复制代码

HAL_TIM_ActiveChannel Channel;

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

typedef enum& W2 |+ e# Y* ~' ^. E
{( ~4 D2 Z+ i- G3 V9 i d
HAL_TIM_ACTIVE_CHANNEL_1 = 0x01U, /*!< The active channel is 1 */2 u! o" J* [- _% `1 y
HAL_TIM_ACTIVE_CHANNEL_2 = 0x02U, /*!< The active channel is 2 */7 _5 j3 H! v$ `* f. M' ^
HAL_TIM_ACTIVE_CHANNEL_3 = 0x04U, /*!< The active channel is 3 */ 9 c8 ?+ O7 N/ {6 m7 ?# ]
HAL_TIM_ACTIVE_CHANNEL_4 = 0x08U, /*!< The active channel is 4 */* {/ g4 D% m- Q. M
HAL_TIM_ACTIVE_CHANNEL_5 = 0x10U, /*!< The active channel is 5 */1 `3 k# @2 T5 O: M+ s9 g9 j
HAL_TIM_ACTIVE_CHANNEL_6 = 0x20U, /*!< The active channel is 6 */
6 S: L! J* Q' G
HAL_TIM_ACTIVE_CHANNEL_CLEARED = 0x00U /*!< All active channels cleared */
1 d. S' l. L _$ G$ `8 c
}HAL_TIM_ActiveChannel;
! Z& H# c5 i8 O+ f" G, U# J
DMA_HandleTypeDef *hdma[7];

复制代码

用于关联DMA。

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

TIM_HandleTypeDef TimHandle = {0};6 H; j1 [4 ~3 V: R
( ]; l! _/ x1 u7 R
/* 5 u8 N: u9 {' u* N9 Q/ }
定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
1 v# Y* T) J. L
*/
; ^+ P( @2 Z; k3 k/ @8 Y" r
TimHandle.Instance = TIMx;
: ]9 r2 Q" L) N; W7 n1 t! B: J5 y7 i
TimHandle.Init.Prescaler = usPrescaler;
! G% L8 J8 i8 n
TimHandle.Init.Period = usPeriod;
' b8 C2 c q9 f; K% d) k
TimHandle.Init.ClockDivision = 0;5 c6 _0 z( N# A a$ C! W1 g+ ~
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;0 J# z& i R* v
TimHandle.Init.RepetitionCounter = 0;
! u! B% X4 d( E
TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;: p1 H) Q0 r9 x! \
if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)$ t' d* i3 U( t7 K1 R
{
' s+ p3 R( n ]5 z/ f0 a1 d1 R
Error_Handler(__FILE__, __LINE__);2 E( N# ~, R' v% ]# A5 B
}

复制代码

& K, B y8 ^1 y, r32.3.3 定时器输出比较结构体TIM_OC_InitTypeDef
此结构体主要用于定时器的输出比较，定义如下：

typedef struct: O; D7 G8 y& ~6 ^. k: N6 p+ F
{
0 |& T6 r. N6 O* l& C
uint32_t OCMode; $ n( l; b0 P6 A4 g$ g' S { d
uint32_t Pulse;
8 ], U( I' x( }+ _( ^0 j
uint32_t OCPolarity;
! O" V: g. w8 B! u: |( k
uint32_t OCNPolarity; : R: `, v# N6 s$ \1 I( i9 D8 Y. U
uint32_t OCFastMode;
uint32_t OCIdleState; ! q# B. e" s# L- e$ \' y
uint32_t OCNIdleState;
2 ?- d1 g" y9 j$ A
} TIM_OC_InitTypeDef;

复制代码

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

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

/*!< TIM Output timing mode */+ g ~, k/ c9 k# z4 V; [
#define TIM_OCMODE_TIMING ((uint32_t)0x0000U) 5 f, G7 \1 E2 ~& B6 k- M3 l" Q% y
3 D: `+ U. s$ O" a* i' H$ `, ?
/*!< TIM Output Active mode */ 2 u6 `# I3 W' z1 d9 r
#define TIM_OCMODE_ACTIVE ((uint32_t)TIM_CCMR1_OC1M_0)
% x5 U" C& R0 l9 M# @1 s& e
& L' T% o, l9 F$ S; ]6 f
/*!< TIM Output Inactive mode */
) ]$ M& _) ~6 m, w
#define TIM_OCMODE_INACTIVE ((uint32_t)TIM_CCMR1_OC1M_1) 0 ]. l4 d) @* N$ T8 ]
6 P( V( w9 k4 z" p7 a
/*!< TIM Output Toggle mode */
, \; D; E5 \" q4 |/ T" F) h
#define TIM_OCMODE_TOGGLE ((uint32_t)TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0) , w5 Q- h3 y6 U: M8 C
7 _3 |. j# o) w, e z1 t
/*!< TIM PWM mode 1 */
# o5 T+ n5 N( r: q8 g; \4 |- P) R
#define TIM_OCMODE_PWM1 ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1) 7 i5 D8 W" Y+ ]" V8 c! B
* v( a" z" [0 e! @3 U3 R$ V
/*!< TIM PWM mode 2 */ / @" q" Y1 X$ y" \/ @
#define TIM_OCMODE_PWM2 ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0) " a' L, Z; r0 X( G1 C
. C; q! g. F& R/ x- ]
/*!< TIM Forced Active mode */
# U$ Q' u# B3 h( `1 I
#define TIM_OCMODE_FORCED_ACTIVE ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0) * M( t& a5 B# A& K" C
, v) E# |" u- r
/*!< TIM Forced Inactive mode */
3 }! u( B3 p. h$ m2 X
#define TIM_OCMODE_FORCED_INACTIVE ((uint32_t)TIM_CCMR1_OC1M_2) . n( W6 r; R' o* Y+ o) }+ W
7 f$ W' B0 ?3 k g9 E3 o5 q/ u* N: v
/*!< TIM Rettrigerrable OPM mode 1 */
. q0 L4 m, C& C/ q) P
#define TIM_OCMODE_RETRIGERRABLE_OPM1 ((uint32_t)TIM_CCMR1_OC1M_3) * g- l& a0 e! U0 }3 [& U0 m, U- C2 c
9 Q/ X4 x ^% Y' A$ j% r
/*!< TIM Rettrigerrable OPM mode 2 */
4 P, f* o$ G: ^, s
#define TIM_OCMODE_RETRIGERRABLE_OPM2 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0) 4 S5 h; n {7 a' F: ~; ]
! X2 G$ O6 i" h9 g2 m
/*!< TIM Combined PWM mode 1 */ 9 U" Q% K$ ~/ t% S
#define TIM_OCMODE_COMBINED_PWM1 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_2)
9 M3 i. [4 i T
0 J4 Y/ z0 K% J2 ?8 D% [! F. G
/*!< TIM Combined PWM mode 2 */
, i4 O1 Z6 a7 B4 l( `* p: h1 Y8 I/ Q3 @
#define TIM_OCMODE_COMBINED_PWM2 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0 | TIM_CCMR1_OC1M_2) $ ?% u' s( K, W
+ C+ e% j: J' H' b% g
/*!< TIM Asymetruc PWM mode 1 */
1 u6 H; g( |4 W& q' e) k
#define TIM_OCMODE_ASSYMETRIC_PWM1 ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2)
3 n5 K! F% v$ h0 k! U6 j( w# Q
# P& ?( V$ }. R9 {" C; z: s( \
/*!< TIM Asymetruc PWM mode 2 */ & w4 a5 j5 \: ` E- ?! U8 o
#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)
7 A9 h' J! y& E+ X# G
#define TIM_OCPOLARITY_LOW (TIM_CCER_CC1P)

复制代码

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

#define TIM_OCNPOLARITY_HIGH ((uint32_t)0x0000U)
" Y+ f3 D' E L2 I2 J3 |* Y
#define TIM_OCNPOLARITY_LOW (TIM_CCER_CC1NP)

复制代码

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

#define TIM_OCFAST_DISABLE ((uint32_t)0x0000U)! f# G& n3 u3 T' G, G
#define TIM_OCFAST_ENABLE (TIM_CCMR1_OC1FE)

复制代码

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

#define TIM_OCIDLESTATE_SET (TIM_CR2_OIS1)
! D/ n0 U; k4 A7 ~3 X9 x
#define TIM_OCIDLESTATE_RESET ((uint32_t)0x0000U)

复制代码

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

#define TIM_OCNIDLESTATE_SET (TIM_CR2_OIS1N)* K8 G" K: C6 n, U3 p6 P* C9 k
#define TIM_OCNIDLESTATE_RESET ((uint32_t)0x0000U)

复制代码

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

typedef struct
& n% o; I3 }! E9 W
{
+ i4 I! N: \) ^
uint32_t ICPolarity;
* X" ?- n6 ^' o0 c
uint32_t ICSelection; ; i( C- z& R% l6 l- r
uint32_t ICPrescaler; & [% E8 u+ t7 z8 v4 e N4 V9 j
uint32_t ICFilter;
2 s/ }4 d. B4 O$ h
} TIM_IC_InitTypeDef;

复制代码

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

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

#define TIM_ICPOLARITY_RISING TIM_INPUTCHANNELPOLARITY_RISING
% N# Q/ n7 h- ~( q2 n
#define TIM_ICPOLARITY_FALLING TIM_INPUTCHANNELPOLARITY_FALLING
8 C) f0 a4 s9 Q% 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) . y* I# f" o( H' {9 {
#define TIM_ICSELECTION_INDIRECTTI (TIM_CCMR1_CC1S_1) + [3 H- H1 j6 V) N! b. t9 w
#define TIM_ICSELECTION_TRC (TIM_CCMR1_CC1S)

复制代码

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

#define TIM_ICPSC_DIV1 ((uint32_t)0x0000U) , l3 z- {( E; ]) j, r
#define TIM_ICPSC_DIV2 (TIM_CCMR1_IC1PSC_0) ( c+ X6 X/ |- {& B; ]
#define TIM_ICPSC_DIV4 (TIM_CCMR1_IC1PSC_1)
* O% n( G% R& ^+ j
#define TIM_ICPSC_DIV8 (TIM_CCMR1_IC1PSC)

复制代码

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

0000：无滤波器，按 fDTS 频率进行采样
. s1 a2 k M8 s& g
0001： fSAMPLING=fCK_INT， N=2* u5 v' }" h/ ?# A
0010： fSAMPLING=fCK_INT， N=4
( `& W/ Z6 l+ @0 b" ~
0011： fSAMPLING=fCK_INT， N=8* V8 Y U6 s, {' C
0100： fSAMPLING=fDTS/2， N=66 P) \5 d- V# x: x4 o
0101： fSAMPLING=fDTS/2， N=8
3 w7 o1 F7 C1 b' z$ E( k
0110： fSAMPLING=fDTS/4， N=62 @$ V% u& t1 o
0111： fSAMPLING=fDTS/4， N=8
9 h4 j. P# K! a# |8 w$ P% f
1000： fSAMPLING=fDTS/8， N=6
* C! Q9 v# ^) o' p4 \
1001： fSAMPLING=fDTS/8， N=8
9 z0 x! |. o& t( I V
1010： fSAMPLING=fDTS/16， N=5
/ M2 b3 Q( b1 y3 F
1011： fSAMPLING=fDTS/16， N=6
, _4 e" M( T; i
1100： fSAMPLING=fDTS/16， N=8
5 [' _; W) a, F( n; r4 m8 P
1101： fSAMPLING=fDTS/32， N=5
4 h" @7 n* q; a$ J
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)
0 d1 U, M8 K) ]9 ~# Z
{$ V# u& z* I' M3 S: `: p
/* Prevent unused argument(s) compilation warning */
9 {8 m8 F$ e. Z3 z! e
UNUSED(htim);
, U N; B* K# L2 l3 c( { l
/* NOTE : This function Should not be modified, when the callback is needed,
" F/ h5 C/ V/ F
the HAL_TIM_Base_MspDeInit could be implemented in the user file' \* r! K; m( L9 W9 U7 l
*/- K1 N3 S K7 d4 M9 r k8 a
}

复制代码

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

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

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

void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)8 I9 h+ K' h3 n- N; m8 w }# s9 G
{$ L4 n% X0 E8 h3 T
GPIO_InitTypeDef GPIO_InitStruct;
3 o# P; G- w3 ~
8 m/ Y" J' g! e
/* 使能TIM1时钟 */
7 h7 C9 Z# T; e
__HAL_RCC_TIM1_CLK_ENABLE ();
7 T( z. c) t" Z; p* N$ x; A
2 m2 X- p Q1 c7 ~- ]. `! z
/* 使能GPIOA时钟 */( c# x' n3 n5 |9 Z
__HAL_RCC_GPIOA_CLK_ENABLE ();3 Y3 _4 N: B$ f+ _9 W9 @# V4 R
# ?, c; B7 j/ T3 D+ w9 p* F' @
/* 设置TIM1使用PA8做PWM输出引脚，将其配置为输出，推挽，复用模式 */
- [7 v: t' U3 r7 g( u( S
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
& ]& H; ^2 g ~
GPIO_InitStruct.Pull = GPIO_PULLUP;: @' P+ K& q0 {6 f
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;4 o3 q# p) V. S$ g2 P
0 h2 W/ O- n3 E( e* _' ~$ g
GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
3 j# M# E G$ ?2 ^( K
GPIO_InitStruct.Pin = GPIO_PIN_8;
- Y% U: A% d$ H
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
& `/ U, G" X& b5 e Z
8 h% _" k- y1 S' l, N2 J4 A
}

复制代码

总结下来就是以下几点：

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

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

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

复制代码

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

TIM1_CH1, PA8 PE9 PK18 W( r4 i2 |) c) W( Q* k
TIM1_CH2, PA9 PE11% B6 M) ]% J9 y. k- K' i. q- G
TIM1_CH3, PA10 PE13 PJ9
# Z& Q1 p0 `/ X. a+ B5 v! t
TIM1_CH4, PA11 PE14 PJ11

复制代码

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

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

4 Y0 m+ M0 ?; X% I1 I
/** @brief Check whether the specified TIM interrupt flag is set or not.6 J2 H; K( Q" {6 [, I* n _: Y
* @param __HANDLE__: specifies the TIM Handle., ?. S0 X/ \/ q( T3 D1 ]
* @param __FLAG__: specifies the TIM interrupt flag to check.5 Q1 R! R8 S2 e( s0 j& c5 p/ [6 N
* This parameter can be one of the following values:
8 f' \2 u9 G% p0 p" d
* @arg TIM_FLAG_UPDATE: Update interrupt flag! W$ `# ]! m4 F: K
* @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag" C& _* W* R4 P* T- c- n" a
* @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
# f$ S5 R" S) Z
* @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag+ M' R8 }7 a2 q5 l! M
* @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
6 @" ~# `& T7 V/ S( Q4 x
* @arg TIM_FLAG_CC5: Compare 5 interrupt flag( O1 m. g, W* B3 Z
* @arg TIM_FLAG_CC6: Compare 6 interrupt flag4 Q) t- N/ X/ j5 u6 {4 F
* @arg TIM_FLAG_COM: Commutation interrupt flag
2 s$ c; J- ?* @! Z8 d& A1 o
* @arg TIM_FLAG_TRIGGER: Trigger interrupt flag, z' D: Q& `. b8 |
* @arg TIM_FLAG_BREAK: Break interrupt flag
; T/ K6 A# ~3 q. J2 B4 W
* @arg TIM_FLAG_BREAK2: Break 2 interrupt flag
- L; o: H# g) J- U' Z
* @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag! C8 Z, r, i+ n1 \- `8 B
* @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag( h6 n" t6 v3 C/ I8 ?
* @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
* @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
) U" R, z0 Y- t
* @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag# ]& S9 _$ z* ^+ Z# s) m
* @retval The new state of __FLAG__ (TRUE or FALSE).. I) E7 G+ i6 R/ h8 q7 ?
*/
+ {& m) r' w, t1 J$ b
#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.
8 W' I* J5 u) W( P
* @param __HANDLE__: specifies the TIM Handle.
u9 F0 Z, n! G2 d
* @param __FLAG__: specifies the TIM interrupt flag to clear.
$ N4 d; d4 i* `0 X- q
* This parameter can be one of the following values:, O% }9 e2 x" [) N L. n, j
* @arg TIM_FLAG_UPDATE: Update interrupt flag# A' _( v3 V: Y0 a$ s# Y
* @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag
0 _: u* W9 y! k( r
* @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag5 u6 [1 Q7 b) I: a5 A* E0 w* z
* @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
3 ^6 `! m8 o: ~( V
* @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
5 v# q+ x5 ]+ s& r5 v2 z
* @arg TIM_FLAG_CC5: Compare 5 interrupt flag
+ C# Q w/ Z3 C3 Q4 [$ F
* @arg TIM_FLAG_CC6: Compare 6 interrupt flag! c* U+ w* c }; i1 R; O$ i
* @arg TIM_FLAG_COM: Commutation interrupt flag. m+ O* `0 O: O1 X' H- R
* @arg TIM_FLAG_TRIGGER: Trigger interrupt flag
9 R3 W2 S0 L, @
* @arg TIM_FLAG_BREAK: Break interrupt flag : Y0 `! l' Q" A
* @arg TIM_FLAG_BREAK2: Break 2 interrupt flag % ~! H7 O" z# Q- Z7 {3 y( B
* @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
- ?8 ?: y; J9 v+ x8 q
* @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag
4 ~% C5 z! n# K% V* C
* @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag* [6 n! `7 [. h" I
* @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
8 ^ e' ?4 @& Z' @' f1 o/ `" S
* @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag+ ~8 I; e! q! G% L* A
* @retval The new state of __FLAG__ (TRUE or FALSE).% U, G3 b. G8 [4 _
*/
) Z2 [3 v, I* K
#define __HAL_TIM_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->SR = ~(__FLAG__))

复制代码

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

/** @brief Enable the specified TIM interrupt.% o: j4 m" {4 v5 x6 V, ^
* @param __HANDLE__: specifies the TIM Handle.
8 j$ o, H8 L' r8 n) f) n: C
* @param __INTERRUPT__: specifies the TIM interrupt source to enable.
. V- T4 [/ M$ U3 } D' ], e
* This parameter can be one of the following values:3 h' G8 a& I' t- B* @6 Z+ p5 r+ U8 n
* @arg TIM_IT_UPDATE: Update interrupt, r: C$ L5 u! j9 u8 P9 P" K9 d
* @arg TIM_IT_CC1: Capture/Compare 1 interrupt( d2 Z) j) a H& a
* @arg TIM_IT_CC2: Capture/Compare 2 interrupt
7 f0 K6 n3 Q9 @- C. e O( l7 ^
* @arg TIM_IT_CC3: Capture/Compare 3 interrupt
4 I& N; o _0 T8 @2 n1 w5 H
* @arg TIM_IT_CC4: Capture/Compare 4 interrupt" }9 S$ a& Z" z2 r
* @arg TIM_IT_COM: Commutation interrupt
* @arg TIM_IT_TRIGGER: Trigger interrupt
7 F, [+ @3 w, w* Q8 Y7 |
* @arg TIM_IT_BREAK: Break interrupt
4 ]9 p/ [1 g8 ]
* @retval None
- m& `" _6 j) I" w
*/ { t& c5 p1 b/ A P {. o% A
#define __HAL_TIM_ENABLE_IT(__HANDLE__, __INTERRUPT__) ((__HANDLE__)->Instance->DIER |= (__INTERRUPT__))
; U( V. ?: [& C
0 ?5 ~& y0 L5 S- k. G) y1 D: d
/** @brief Disable the specified TIM interrupt.
. M! Y: |7 d% K( H
* @param __HANDLE__: specifies the TIM Handle.
/ E' H( }0 f3 o* C% Z* g* I$ H! p+ j
* @param __INTERRUPT__: specifies the TIM interrupt source to disable.& \( F- [$ ~) O0 U
* This parameter can be one of the following values:
5 ]( ?0 T( q3 m
* @arg TIM_IT_UPDATE: Update interrupt
) e: K7 K c- E, _6 o
* @arg TIM_IT_CC1: Capture/Compare 1 interrupt
% {$ R7 f5 X. n+ L9 M7 q
* @arg TIM_IT_CC2: Capture/Compare 2 interrupt
+ x) D& [6 l8 n
* @arg TIM_IT_CC3: Capture/Compare 3 interrupt/ A7 a' S& Y4 H' q# u; S( O. f
* @arg TIM_IT_CC4: Capture/Compare 4 interrupt
3 i- p* f- B: D' ^3 _
* @arg TIM_IT_COM: Commutation interrupt3 z, h) e* t. Y
* @arg TIM_IT_TRIGGER: Trigger interrupt z) D; E5 i5 Q" k3 |& w
* @arg TIM_IT_BREAK: Break interrupt
/ X& V. Q/ U7 q" E {
* @retval None5 }2 k9 L. S) W
*/ b4 z1 O- Y7 }7 ?% j
#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) u9 Q& E, ~! E2 G
{
8 w7 \! {/ @& R7 s5 j
/* 检测是否是有效句柄 */0 K; K, y! Z5 `/ G3 _/ Z/ f
if(htim == NULL). @5 {& e( q, c$ P3 Q/ `
{
# h( z5 x! s3 X9 Z, V' `8 |
return HAL_ERROR;1 M; l8 v3 Q9 [6 T
}
7 a+ S& ~: R) L9 Y* m5 s
; J" k/ ^/ n) Y' B9 P
/* 检测参数 */+ b1 I: y( r; ^1 E
assert_param(IS_TIM_INSTANCE(htim->Instance));
* O5 z7 J% [3 B/ K: l, M; l
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
+ F3 P* U/ J) e$ P+ a9 F) l
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
7 V; q3 x1 T# f. S4 H% I; p
6 ^5 b1 w3 B& D+ \ [
if(htim->State == HAL_TIM_STATE_RESET)
' S3 c& m: j3 |) b1 b2 w
{ 4 w% w @; m+ ^1 h3 L G
/* 默认取消锁 */
" w6 R1 y+ p" W' @: x
htim->Lock = HAL_UNLOCKED;
% C4 Z9 {' S% n) T' G' J% T# K3 S
/* 初始化底层硬件 : GPIO, CLOCK, NVIC */ v; Q% C4 k# K( H# k$ v0 w
HAL_TIM_Base_MspInit(htim);! E1 o1 P) |! Y& \/ S1 D. n! M
}/ r6 N# @/ [: z6 L3 Y& ]$ ~
& I+ a+ }; \7 [9 q3 O, _4 J9 r
/* 设置TIM状态 *// H6 i: r0 a l0 ^/ U
htim->State= HAL_TIM_STATE_BUSY;
( b" n* p2 g/ [% h e: b6 l
O$ o2 o3 p/ p Y" }
/* 基本参数配置 */
0 V, C+ L/ W! m9 t
TIM_Base_SetConfig(htim->Instance, &htim->Init); ) v) w' ]& ~5 R
5 m; a' O2 J+ K$ L
/* 设置TIM就绪 */+ Z( X) k9 j( I: ^$ \/ h9 J, y
htim->State= HAL_TIM_STATE_READY;
/ I# Y( A# K: V
! ]% c0 y4 q. J* Y6 K( ?5 x
return HAL_OK;
. X# Q+ a! S7 w) A5 q9 t
}

复制代码

函数描述：

此函数用于初始化定时器用于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 S3 w; F$ Q/ G% H' c
{. ^, P0 u( `' w1 n4 ?0 g
Error_Handler();
8 g+ w) A0 O6 V8 P. O/ s1 a
} Z- j8 L7 O$ a" V+ ], s9 u
if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
2 X( Y+ u/ w7 s) F/ a7 K
{
" ]. i6 I4 U- @) ^! o9 Q u2 R
Error_Handler();
! X4 i- X1 v; e! ?& X
}

复制代码

使用举例：

TIM_HandleTypeDef TimHandle = {0};$ l6 @4 {* X/ ~
" B$ o2 L4 Z+ Z* l$ T2 d
/*
- M1 g" B: R8 o1 s& V3 O) G
定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
- b: N( V" t* ^& u/ L
*/
' K: o' b/ m' W5 `5 X
TimHandle.Instance = TIMx;
) X7 b6 I. Y+ u7 d3 ~
TimHandle.Init.Prescaler = usPrescaler;
& g# v8 X% K- d
TimHandle.Init.Period = usPeriod; 6 c2 ^2 k2 _5 q8 ` N
TimHandle.Init.ClockDivision = 0;5 O: w" E$ ^, h
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
0 i: w+ x+ Q) S( W7 D
TimHandle.Init.RepetitionCounter = 0;
5 K% m. W7 `& [( i; o) _
TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
2 z8 b3 b$ R5 y' z& }' ~
if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
) w" n( }% }+ Z0 m9 u3 |# k4 I7 Q8 o
{" ? l2 m) o: V4 H
Error_Handler(__FILE__, __LINE__);
0 o! r% D3 }: ^) D7 U
}

复制代码

32.4.2 函数HAL_TIM_Base_Start
函数原型：

HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)4 m6 c% N# q* l* {, N0 w5 }5 K
{
: ~( s/ j, j# E) O7 v [% N6 Q% P
/* 检测参数状态 */# f, } g& a C% t5 [
assert_param(IS_TIM_INSTANCE(htim->Instance));
5 k( X# n" o3 w, z! X. H
" D5 c y5 J% c ?& |9 F. n
/* 设置定时器状态 */$ H1 `9 K7 J8 d
htim->State= HAL_TIM_STATE_BUSY;
' H* L- J! D* O
7 j& W: z. s$ ^
/* 使能定时器 */3 J' B! v: G" I) i& J1 U
__HAL_TIM_ENABLE(htim);. a0 }: ?+ F! E
: N! B" t) q4 l7 R0 {, c+ C( o" o
/* 设置定时器状态 */
- c. W) v! G: Q
htim->State= HAL_TIM_STATE_READY;" y% ]" z# F3 ]7 J* X5 b5 P
6 i9 S v/ p1 Y8 q7 c; T
/* 返回HAL_OK */
+ I& r& B- G) D8 D0 j
return HAL_OK;: R" J/ |& ?4 S/ ?
}

复制代码

函数描述：

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

函数参数：

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

TIM_HandleTypeDef TimHandle = {0};
" H A x1 Z( T: [- g& t
: P0 ]& X# f- P7 g' Y$ C3 d
/*
. S! R0 E7 c& L' B1 }
定时器中断更新周期 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）
: [3 M s( i$ j" F) w, i( { p( y
*/. d' ?3 O- U! s0 o
TimHandle.Instance = TIMx;8 [) \8 {' D7 _& g$ w" k1 s+ N* Z
TimHandle.Init.Prescaler = usPrescaler;
* E) `3 g) K, B4 m8 [
TimHandle.Init.Period = usPeriod; # C) |4 t5 c1 Q; U0 Y1 g3 F, W* G
TimHandle.Init.ClockDivision = 0;" R5 c$ b+ S! L4 ^, c
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
0 p) D3 p0 h& J% D. ]
TimHandle.Init.RepetitionCounter = 0;7 {% k" V0 A5 ]+ l `
TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
7 w# Q. y5 y$ g; Z
if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
5 v5 j% I& p3 t$ g; m
{
% G5 m0 n6 \/ a0 l
Error_Handler(__FILE__, __LINE__);
" F9 A5 T q& E n e8 a5 p3 C
}0 z% V# u9 U3 Y( ?
# T$ _3 T; @ X
/* 启动定时器 */' M7 g: }* l3 [, c8 a/ t6 q* O2 d
if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
7 Z- ?, I" u4 \, Z
{
r+ B! e6 Y6 w6 V; h6 o
Error_Handler(__FILE__, __LINE__);8 X/ O1 |$ [6 U& R0 r( B
}

复制代码

32.4.3 函数HAL_TIM_PWM_Init
函数原型：

HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)' b( x' ^* c2 n; f7 X
{
- u- s, D3 {9 Q3 i3 q( r8 d
/* 检查句柄是否有效 */
/ `& J$ W- S, j1 g* U& V/ f
if(htim == NULL)
) R1 L6 n. @% E( Z/ z5 i
{0 C9 `- @1 s1 b% y9 N x! Q
return HAL_ERROR;
! r/ }; L# d5 ^! t. v
}
" e3 {8 {. C7 u! U$ A k
/ T- v8 H! v% F
/* 检测参数 */
9 |( K; P& _/ B% Z7 O) q6 H
assert_param(IS_TIM_INSTANCE(htim->Instance));
3 l X4 N6 D; b* e
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));) U6 T1 p% p/ t! l0 S3 j9 ?
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
6 r2 F, O; D: j+ C1 d
6 N9 S% R/ Y% x2 n
if(htim->State == HAL_TIM_STATE_RESET)
# }, s: X- w. r: b4 [# U
{: c! I% a# b3 `9 d( Y0 `! L
/* 默认取消锁 */$ V7 [, F3 I- r2 O
htim->Lock = HAL_UNLOCKED;
+ P: T! M6 R# Y2 t6 O
& F; ]. s) }' t- `$ s- j# m9 `0 K
/* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
9 U t x. O9 e# X
HAL_TIM_PWM_MspInit(htim);
2 w% J- \0 r( Y; U
}$ W( A3 k' g6 u+ l4 U: x' k
4 z- U+ L2 d; M6 o" O
/* 设置定时状态 */
8 n+ G# c+ n. m8 x9 d
htim->State= HAL_TIM_STATE_BUSY;
/ \; ]5 U& N! R
, [4 x, G( u+ T) n. Q
/* 配置定时器用于PWM */
% h* S! Y2 D( J$ m- H: }
TIM_Base_SetConfig(htim->Instance, &htim->Init); ( R) W) E2 M) @3 d$ n6 e
/ u& G- {; N v) ^* a# e7 @
/* 设置定时器状态 */* A) t) o3 r. D; v8 i& W9 l+ u d) v
htim->State= HAL_TIM_STATE_READY;9 p ?' P* S; y5 u# d
% G0 I* D+ U P) u/ j2 t5 R0 @
return HAL_OK;; S& L' T/ h: s; w
}

复制代码

函数描述：

此函数用于初始化定时为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)9 M& m' l; i- z; Y3 @$ g [7 B4 s
{
) S) ?6 f9 |- l5 I
Error_Handler();* | u6 q7 q1 M2 U7 S% y2 q
}
; v0 D2 _# M4 p4 I% ?4 c! g& ~2 ~
if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
0 H' O. u1 P. E7 n4 V$ `# F
{0 z$ I) n4 x; Z1 p8 g
Error_Handler();
& o+ e/ R) N3 a) k
}

复制代码

使用举例：

TIM_HandleTypeDef TimHandle = {0}; C# {' v! b+ V$ e4 h
2 ]2 S; F3 J' s5 s: Z
/* PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
. u/ s6 x* E- ~1 L# C8 ]3 e! u
TimHandle.Instance = TIM1;
; `9 [: N6 g& ^, l' ~
TimHandle.Init.Prescaler = usPrescaler;: q" A) J5 s: S" r0 L% n
TimHandle.Init.Period = usPeriod;
% @0 h/ |- l5 n+ H
TimHandle.Init.ClockDivision = 0;- q- U J) D8 k l s F: ^
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;$ v. T0 F; [, F( ?
TimHandle.Init.RepetitionCounter = 0;! I7 r3 m: j" O) ` k ?
TimHandle.Init.AutoReloadPreload = 0;7 U2 V; ?8 Z. ]0 J; M+ e6 E8 a) B- X
if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK). }* M4 R% U- G' U$ H. e; b! T8 y
{. O5 l$ F7 d/ C y2 u$ c
Error_Handler(__FILE__, __LINE__);/ E0 R# d+ y4 L) R
}

复制代码

32.4.4 函数HAL_TIM_PWM_ConfigChannel
函数原型：

HAL_StatusTypeDef HAL_TIM_PWM_ConfigChannel(TIM_HandleTypeDef *htim,. ~1 _6 t1 U# c% A; A
TIM_OC_InitTypeDef* sConfig,
5 V; s# C0 ~6 V# e5 d5 E
uint32_t Channel): [- a* `& f9 ~5 L# W Z3 O
{
$ h' i! q/ s2 l2 l$ n8 M5 q
/* 省略 */. p+ G. k. ]( N) |
( g [& t% Q2 p1 l! C
/* 开锁 */
4 @9 z/ | ?. C2 p* u' i8 g" p7 c( T
__HAL_LOCK(htim);1 J% N; a G2 z" E
8 F5 |+ t7 J9 i0 }
htim->State = HAL_TIM_STATE_BUSY;5 N( l) [# w, j w' W! {$ E1 w4 a; ]
+ u% }# s0 S- q/ F
switch (Channel)
' e! U3 R6 b7 Q0 E. V5 K
{
, {6 L* T7 U6 {; o/ J% G
case TIM_CHANNEL_1:& N% \$ g4 O" D4 K8 n/ @/ K
{5 b: A3 x0 Q: |) i1 P* Y5 U6 E% Q
/* 检查参数 */
7 o" F. Z# z3 @; q2 L& u
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));$ k! J: U( h6 ^5 r1 A+ |
" L& a! }) K2 f1 U) w7 s
/* 配置通道1的PWM模式 */& O$ M' Z& n- \1 u
TIM_OC1_SetConfig(htim->Instance, sConfig); R" t2 f' Q! f4 B, ?. c: g0 z
f/ P- n6 ?, T4 d3 f
/*预装载使能，更新事件产生时写入有效 */, N# Y9 e. Y' e. ?# J4 ?
htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;
+ _4 ?6 T4 O/ a9 _: Y F
) V C: D9 `9 F. R$ o" {6 b; Y
/* 配置是快速输出模式 */
* t; i; T- Q! p2 _
htim->Instance->CCMR1 &= ~TIM_CCMR1_OC1FE;
1 F* m R& X0 \ y" I
htim->Instance->CCMR1 |= sConfig->OCFastMode;- u0 h& }# w5 _
}
8 Q4 i; L* [7 m5 s
break;1 [2 Z& K/ p: I1 Y. u, _+ J
! f9 ]8 y ?+ I2 f! `# J% r
case TIM_CHANNEL_2:8 [% P5 g9 Z: m5 N; l% w, Q) t( u& L
{
2 B, X0 ^; E9 Q& L3 D5 x) k
/* 省略 */1 z8 m0 I2 _1 p
}
, m/ |) ]8 D& W: q
break;
% w" F7 n* A) ]$ f: V
: E6 v! |( r% l; q! V
case TIM_CHANNEL_3:
9 ?, O. F2 j2 N# i7 X9 C* _
{
8 S( R9 G5 P6 ?' A
/* 省略 */& |" e3 T2 ?' o% F
}9 j- I1 P, ~( `! x# L
break;! l2 |9 y5 ?* f! a' W
6 A- O2 H8 K% \# a
case TIM_CHANNEL_4:1 ?( @, E8 u1 k# P2 J- a
{
7 K. `$ v% u, H6 B' h7 f
/* 省略 */: |0 C7 o% E: }9 M
}
% S( i/ F$ ]- _$ {2 c2 p
break;
' L/ p5 b! j9 i0 Y4 d
* _- @3 A1 ]4 v R" g9 [
case TIM_CHANNEL_5:2 ?4 ?" t/ k) X- I! I; @
{
9 t ^( \1 [* z+ U- j% [0 ?
/* 省略 */. R, p* T" a8 O! m- G
}
^1 W, @9 w4 M- K, p( D
break;
( ?0 I- Y& t0 x
; t. }. O( ~1 J4 X
case TIM_CHANNEL_6:
0 Y8 Q0 E, E7 b* C. c1 A& z) j" ]
{
+ F# V( u/ f* B8 H' ~
/* 省略 */! X& _. v5 ~. I3 P3 I2 Z
}2 I0 b4 q! B) J, G$ h& j
break;
+ r4 I0 f( V1 u& W9 ~8 s& E
b: m% T# e1 ]% A8 M9 q
default:
& k, @" h: D+ R) x
break;
+ \: }$ @- d1 Y% v# {9 l5 ]+ M5 f
}
3 |$ ?% z @: g
' v8 b& |0 \$ r% c+ _9 Y4 t# _" u
htim->State = HAL_TIM_STATE_READY;8 R# J0 C8 p7 ^$ r& M" w }
$ @" y/ D1 M8 D) e% @, u0 a/ u' C
/* 关锁 */: p2 h; @' l, ]& h2 |1 @
__HAL_UNLOCK(htim);
+ C; b4 V9 M+ ~6 T
1 o0 o9 u( K: x5 M c5 R! y U
return HAL_OK;
6 S9 g& b/ S$ U6 q' c; o V$ R* u
}

复制代码

函数描述：

此函数用于配置定时器的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};
- Y7 K% s0 ?* F/ H9 n
- x- H' O5 L( w! h8 @% d
/* PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
0 \3 ~8 D. K. I" d' c
TimHandle.Instance = TIM1;
2 Y6 D( F4 w" p& r, N
TimHandle.Init.Prescaler = usPrescaler;
" U4 A0 B) C" f& j" T( a/ d' \
TimHandle.Init.Period = usPeriod;9 X: v2 L6 V6 h& c* v- u, B4 ~# j
TimHandle.Init.ClockDivision = 0;
1 ^+ u) P. R; ?/ ~' b
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
1 G2 u; ?9 ^/ }) L
TimHandle.Init.RepetitionCounter = 0;
/ H4 D) g# ]! }& i3 H! U
TimHandle.Init.AutoReloadPreload = 0;' M1 i, [' a9 b
if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
' z( Z7 L6 t8 k3 W# S
{
" C" A) h* }& a& J7 a. U+ J
Error_Handler(__FILE__, __LINE__);
5 t: f& Y. x9 F8 G" D4 j) a9 A
}
8 M; g# O* r1 I2 D, Y/ j+ }
7 j( X! E4 P- T$ ^, B% [5 E
/* 配置定时器PWM输出通道 */' _6 ^, J, {% E# W2 @( p# y
sConfig.OCMode = TIM_OCMODE_PWM1;* C* ^2 p: u5 F) R: \* N
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
! x; Z) b4 y& g" \ a* p G& G
sConfig.OCFastMode = TIM_OCFAST_DISABLE;
: o9 j- B. U/ N) x
sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;) p! B; w- Y6 T% H6 B l
sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
8 w4 S3 N' U+ K2 D
sConfig.OCIdleState = TIM_OCIDLESTATE_RESET;
t( s" L2 r5 z2 j# R
' s+ J Y) D6 N% m+ p0 C7 M
/* 占空比 */
. a( y* q( S9 i8 v6 @2 A
sConfig.Pulse = pulse;
+ G- d+ [: w! w0 a1 e1 U- R8 @4 E
if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)0 U, _& ^ e: |0 P3 m C2 C% G
{' }& s% o$ m4 l
Error_Handler(__FILE__, __LINE__);
1 `$ {8 F! Y; J+ R
}

复制代码

32.4.5 函数HAL_TIM_PWM_Start
函数原型：

HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)6 Z. l; ^; M7 X; J0 e
{
' S1 q1 \# X4 s& V1 t8 f
/* 检测参数 */) J- w# U# J7 `! P, r2 Z4 U
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
0 ~5 }8 c" q& a# i; L2 S, d7 W
( \4 L2 o4 ^" v
/* 使能捕获比较通道 */
( C1 Q, b9 t. \0 o. ~4 c! q9 J
TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
: ?- Z% P6 f! ]8 E2 w
: w( d- r2 d, H
if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET) 9 ]& j+ B9 O3 M3 v# l
{
* c+ w* Q& z4 o5 @
/* 使能主输出 */) w3 {0 C; Y0 n) k" O6 O) ]
__HAL_TIM_MOE_ENABLE(htim);
, Z; y5 I% B' ~- w
}7 r7 g- _/ I3 `0 u d* H3 k
6 Y# i7 b6 S4 _, m% I* v
/* 使能定时器 */
- `4 f2 b( ]. [) Q
__HAL_TIM_ENABLE(htim);; h. p. ^' `( \- z/ w; [
S$ K& m% d5 q. Q- [
/* 返回状态*/& [% N# Y4 P9 I' l+ K
return HAL_OK;* m- v' H4 p5 B; A/ m: @ D3 n
}

复制代码

函数描述：

此函数用于启动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};
# a8 t2 e! z) J8 s" a0 z/ R
' P+ T" ~$ o/ X
/* PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
4 {! N T, k; w* J
TimHandle.Instance = TIM1;9 [6 o: G, c$ Y* r4 C$ J" @
TimHandle.Init.Prescaler = usPrescaler;2 L, ]* U; O/ U/ J4 J( o0 |6 P* {
TimHandle.Init.Period = usPeriod;( N) M! j3 E* w4 U4 I8 S% y2 n. K
TimHandle.Init.ClockDivision = 0;4 D) e+ Z" G/ F' w6 \: @8 A9 U
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;- H+ Z7 b- o) I, p W" r- c
TimHandle.Init.RepetitionCounter = 0;0 l! v7 d& v% O' Z0 y2 r% M
TimHandle.Init.AutoReloadPreload = 0;
- I" x4 _5 ~) o. j% |
if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)% x; T; Y, i/ R/ r; a Q
{
6 d- `" ] M8 M9 s5 e
Error_Handler(__FILE__, __LINE__);9 _! b9 h8 X% t6 x5 L
}6 G$ D' G" Y8 ?
7 Y/ p3 x% S4 V$ R: F
/* 配置定时器PWM输出通道 */
, n$ C& X+ ?; Q8 Q4 X4 @# u
sConfig.OCMode = TIM_OCMODE_PWM1;
) m; g$ E3 z0 b, T
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
: I( s! q9 F* W6 G( `0 o; p3 o& ], i$ E
sConfig.OCFastMode = TIM_OCFAST_DISABLE;
7 o# S; i. Z! Y+ h
sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;) I f' Y! p, l
sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
9 Y' m! ^$ g0 N( _9 s" m* p( d
sConfig.OCIdleState = TIM_OCIDLESTATE_RESET;0 S" L m0 e' K( ~# K6 @/ N3 `5 q
+ m r' E6 w, |. m% v
/* 占空比 */5 V5 v# f8 [6 V) a3 }$ z/ s% ^4 ?
sConfig.Pulse = pulse;
6 y2 E. N2 L$ o* ]; R2 `! z* J7 t
if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)% I% Q# |: F$ f! n& z
{3 K$ l' w4 e' v# D1 G
Error_Handler(__FILE__, __LINE__);* U8 h1 ~5 [- E9 |
}
' P& R1 `- j# c) N, w' a
4 ~- `; K4 ~0 Z7 f1 J8 G6 k
/* 启动PWM输出 */7 |) p: l$ s0 k% y1 q% U- ]
if (HAL_TIM_PWM_Start(&TimHandle, TimChannel[_ucChannel]) != HAL_OK)
3 [# X+ n8 x7 J7 q/ b0 ?
{1 \; S1 u) q' A0 _
Error_Handler(__FILE__, __LINE__);
# s) B: R4 O: l/ K& T' t# ?6 K
}

复制代码

32.4.6 函数HAL_TIM_IC_Init
函数原型：

HAL_StatusTypeDef HAL_TIM_IC_Init(TIM_HandleTypeDef *htim)
. p9 u5 l5 _0 c
{
4 p$ o( _" Q" Y- V7 r/ S c
/* 检测形参是否有效 */$ N' B& R5 z: J1 d( q/ d
if(htim == NULL)/ `/ K$ v }# S3 z: n* Y
{$ m- W* X( h# _4 d* l* q
return HAL_ERROR;- f) @4 j" r! e" V6 X% {
}
+ ?- U6 O8 M8 ?
2 [3 x- L- X# g# f! ~
/* 检测参数 */; A* H+ N/ E- j7 C6 u
assert_param(IS_TIM_INSTANCE(htim->Instance));! R4 K5 [$ U2 x* w3 L8 r0 M5 {0 I
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));3 K( q6 t% i8 Y( H" l! K6 l, e0 r
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision)); - y/ v1 B' n+ @6 W8 P+ @
) y* Z$ s' z1 R- P
if(htim->State == HAL_TIM_STATE_RESET)
( H5 R: q5 q7 c- u; k
{
% F; x7 x' D6 T$ L1 ?
/* 默认取消锁 */
7 H9 X. t* {* [
htim->Lock = HAL_UNLOCKED;( B$ M7 E5 `% e; U
- |$ U7 ` m4 h2 `) j9 j. h E
/* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */3 P* d/ V5 H/ x8 M, m% ~2 i* ~- ?4 W6 }
HAL_TIM_IC_MspInit(htim);
1 Y9 c4 x+ H$ k" @+ M5 g( h
}
0 _9 k) W/ O. h2 F3 o
1 O6 T2 {0 L3 R5 o9 `1 I' s
/* 设置定时器状态 */
L, N: t0 C1 p- I) i
htim->State= HAL_TIM_STATE_BUSY;
9 x. }: b& M5 M$ |( g4 d+ y
7 N" F" I3 @! e
/* 配置定时器为输入捕获模式 */ ) N# Z( x% w3 q
TIM_Base_SetConfig(htim->Instance, &htim->Init);
, |8 E0 b# q X' }$ [( `
" i' ?/ r( x: O9 D3 p# ?: c3 y
/* 设置定时器状态 */
: m1 \# |9 `: |! ?5 Q! p9 c
htim->State= HAL_TIM_STATE_READY;: ?8 U k0 ]7 d+ A1 d: N
6 \) V; h3 l; d& K9 e: t8 b
return HAL_OK;. S) x! l- H+ H: ~& g5 N. c
}

复制代码

函数描述：

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

函数参数：

  第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)
9 B9 ~# ~) O5 ]' R
{
' u t/ D; ~, H/ B( h0 y( @3 p
Error_Handler();
0 T; N J6 b7 u* f- q/ q+ b5 J
}
( _ U9 W, P2 Z) z7 ]7 y, z$ `* q
if(HAL_TIM_IC_Init(&UartHandle) != HAL_OK)9 ?; O/ Q) g& O" x: m7 ^. {8 ~
{
9 N0 R4 ~! R. R* Q3 p
Error_Handler();% p" e% F- U7 l8 j+ q. V5 ~* [
}

复制代码

32.4.7 函数HAL_TIM_IC_ConfigChannel
函数原型：

HAL_StatusTypeDef HAL_TIM_IC_ConfigChannel(TIM_HandleTypeDef *htim, TIM_IC_InitTypeDef* sConfig, uint32_t Channel)
# d& w/ y! m! ?
{
8 C9 j+ R/ y6 n$ U- `
/* 检查参数 */
; T6 I/ i8 {4 |! J0 c- @
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
' Z Z" ~9 }, o( }
assert_param(IS_TIM_IC_POLARITY(sConfig->ICPolarity));
2 H5 D& b+ `+ ~7 Q: L' X* I
assert_param(IS_TIM_IC_SELECTION(sConfig->ICSelection));
! v) g! i5 q1 `
assert_param(IS_TIM_IC_PRESCALER(sConfig->ICPrescaler));' Q+ m! P$ c2 i. U0 [$ p' u
assert_param(IS_TIM_IC_FILTER(sConfig->ICFilter));' |* ?& z/ }% f
$ T! Q% @! ]# C% e
/* 开锁 */
2 r: |6 o3 n5 `/ h
__HAL_LOCK(htim);+ U6 F2 a( V2 w9 Z c. E5 c3 A; `
# t' y7 |: T% U- @2 D
htim->State = HAL_TIM_STATE_BUSY;5 ?( A' x9 {6 }, m& M
2 g- K9 T5 \4 x$ z
if (Channel == TIM_CHANNEL_1)# w, y& k1 t; |4 B, a6 y8 d1 k
{4 `2 z3 ^- t9 A/ B6 Y
/* 配置输入通道1 */
+ S+ Z# i1 Z& `8 H, }/ M
TIM_TI1_SetConfig(htim->Instance,
: h3 I7 E. p* C
sConfig->ICPolarity,
* K; J: f5 ^/ K x1 @, |/ f
sConfig->ICSelection," m- A! L0 b$ F1 ]
sConfig->ICFilter);
3 K" v7 H4 w9 `9 a" \4 @* R/ D
# r: K, p4 `: o7 t% s# G
/* 清零IC1PSC位 */
& R# p5 E }, q# ]2 U% }7 f6 X
htim->Instance->CCMR1 &= ~TIM_CCMR1_IC1PSC;
$ J( A" V6 Z. T: \* l
8 ?2 A" M- I8 X9 G, Q s9 d% ]
/* 根据用户配置，设置分频 */# B ^9 P) \5 D$ z9 ~) T1 A
htim->Instance->CCMR1 |= sConfig->ICPrescaler;
9 u# c3 q5 J: G& [6 v7 z' l W
}# B: u/ f/ p; E4 d% ?8 z* p" o
else if (Channel == TIM_CHANNEL_2)' o# G* Y ^8 k0 ~* _
{
) A0 V" W$ G% w H) T1 Z0 l
/* 省略 */
6 `$ J9 z2 x w! L4 ~) u
}
% C/ C0 @, h! u2 V# Q
else if (Channel == TIM_CHANNEL_3)0 h `5 C) S$ ?4 A `; Z9 {" }! |$ \
{
$ K$ N' ^, [! e. y- d& L: ?
/* 省略 */
( n; B4 ?& |' C. d
}
1 P0 |8 A j5 N ]* ?# F
else
0 h& r) ^) q) N5 U9 y
{
5 L* Z- v! F! h8 x; V" [* c& W3 {
/* 省略 */
6 g% L, b) j3 I1 ?' F
}6 e2 r' S" @, q/ {5 e( y
( Z- h* t2 i/ S4 @$ W2 ]; J
htim->State = HAL_TIM_STATE_READY;
: A; h4 ], {9 G& M
6 e o2 I* A( t
__HAL_UNLOCK(htim);
! |' q* u7 K1 `; |+ q2 N/ p
: U2 e& B+ _! X1 ^) ]! h5 v9 q, Y7 z
return HAL_OK; ! T8 J8 g, I; g2 r
}

复制代码

函数描述：

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

函数参数：

  第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)* {; ~* ^! P+ C) W+ ?; G
{
1 f! K3 r( t: U: p/ L3 P- E& a8 X
/* 检查参数 */
( c5 S% f, Z: W# M8 _
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));. _# @: @! P% u5 W' A; d7 e7 @1 Y. B
# \* A$ ~* Z. g
switch (Channel)
6 Y, ?2 `! s V! p. M
{$ k8 Q1 Q1 Z. ^) W
case TIM_CHANNEL_1:7 u" v+ m# E7 i6 e1 N, U+ T
{ ! U% x) k2 w7 ^/ J, V
/* 使能CC1（Capture/Compare 1）中断 */# M. O0 ~, i, E: I
__HAL_TIM_ENABLE_IT(htim, TIM_IT_CC1);2 e! d( F5 Y- Y' A& d7 i
} ~' B) I0 x' Z. r R
break;. v( C1 s4 a J7 I
) F1 Q2 V+ T. h" ~) d- l4 |" O
case TIM_CHANNEL_2:
) y, t" f8 @3 L4 d1 P, t
{" P2 c. X0 J; G: b% N
/* 省略 */
- D H, c5 D0 K- Q: M0 U/ B$ \
}
- z3 ]' ^. M! L/ z4 a) N' x
break;* t% O: S- G: ?, U# ]
) w1 @" G9 m$ | i" H/ o, g
case TIM_CHANNEL_3:' v6 z1 E% _2 W: x! T3 C7 e
{2 Q, K9 D& W4 |' U
/* 省略 */7 Z, [" @+ ^, B* e9 V& E; l
}6 }- o" \+ x# L1 t9 K9 Z3 ~6 j
break;
) _: q" C3 t, [3 {; M
$ L7 Q- n [8 p( f
case TIM_CHANNEL_4:
1 [( f! Y3 k9 r, J* ]7 Z' ]! J
{7 ?4 x& g. B/ i( N
/* 省略 */
5 u0 [' o3 w. J1 e0 G: u1 g
}8 y1 }" p* O, K4 G8 D4 ]
break;! ^" s1 @5 N' R0 ^0 y" j* e
1 N8 ?& g( @. K
default:9 }$ R2 T# B% h) N
break;
0 _8 O k- N' _; H9 s- C" X
}
! F. ?1 k- n+ q( Q, ]8 @9 O8 f7 E% N
/* 使能输入捕获通道 */3 o Y" ?+ a2 b! L, Y, |9 ?. F- J
TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);7 N2 `: z. p7 `) L$ t- n* e" w
$ J0 {' Y5 W; a2 s2 M; P* f/ r3 A
/* 使能定时器 */% Y5 \9 L" r$ z1 ^9 Y9 }
__HAL_TIM_ENABLE(htim); 8 [( Y) K+ ^2 j* l5 g( y
2 U( Q6 k1 x) z6 {, `# a
/* 返回状态 */
: r) q& w0 m+ _& p1 b) x1 b5 o
return HAL_OK; , }' E! l( d3 M# z+ O
}

复制代码

函数描述：

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

函数参数：

  第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)
( b4 h8 o# b' Y% |
{: y8 N) k* G; \6 U, w2 t
/* 检测形参是否有效 Check */1 v$ L! {$ Y2 _* p0 z7 X
if(htim == NULL)
" B* z' W0 M, K; y+ B; I y6 {
{/ e2 I' e7 p. R- }, F4 U0 u. J
return HAL_ERROR;, F/ u, L4 W+ `' T7 A6 ^
}: w$ Q3 g9 H9 f
# D0 c, a& M+ s! S9 `# N$ G4 p2 g8 z
/* 检查参数 */1 M$ K$ e* D, o
assert_param(IS_TIM_INSTANCE(htim->Instance));
' I3 V* I9 \0 K
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));- d* [" E% { d# B0 i0 H8 [0 i0 D2 o
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
7 A( Q: F- `9 A" D# M8 j6 B- a
$ b; U' ^2 A! n( n
if(htim->State == HAL_TIM_STATE_RESET)! ~9 f* x2 U; m
{
: `% P4 k' X. U! \
/* 默认取消锁 */1 Y; G: i6 z E, f$ Z
htim->Lock = HAL_UNLOCKED;
3 B8 X% H% u O) o- J0 v2 [- E
8 R8 ?9 _, Q' e6 J$ f, _
/* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */# X/ _, `; E8 y- f( R5 _: X) ?
HAL_TIM_OC_MspInit(htim);
2 j, w$ z: N, T& @! P
}
+ R/ d( P6 h* S7 {( c
# C% M0 D/ w5 ~
/* 设置定时器状态Set the TIM state */* R6 h2 U/ q0 k# v
htim->State= HAL_TIM_STATE_BUSY;4 E0 v4 W* X- s6 y2 K
+ v2 t5 ^: Z6 u' S/ _2 N3 \/ R
/* 配置定时器为输出比较模式Init the base time for the Output Compare */ 4 `2 C! N& k! G* }# \2 N
TIM_Base_SetConfig(htim->Instance, &htim->Init);
- h2 T1 Z4 |% D( O
+ ]) ^8 h, `5 P
/* 设置定时器状态 */: G' C1 r1 V* ?( J+ U
htim->State= HAL_TIM_STATE_READY;! `3 z( a9 I0 P2 k+ K
/ s! p$ d2 k" Y
return HAL_OK;
8 e" v3 a1 h, \ n4 N+ m' U& Y# F
}

复制代码

函数描述：

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

函数参数：

  第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)& P1 i$ |8 R! ^/ H& K& d: s
{2 `+ b. u6 w, ~ {* ^' M
Error_Handler();
1 M: o/ y6 @( g, i0 C
}
. }! o+ _0 [4 y
if(HAL_TIM_OC_Init(&UartHandle) != HAL_OK)' Q5 a9 ^) h1 P' l; |1 F, i0 h
{
- ?8 C" p* k, \6 r F
Error_Handler();" p3 ]! x5 C0 a: l. y3 i7 [
}

复制代码

32.4.10 函数HAL_TIM_OC_ConfigChannel
函数原型：

HAL_StatusTypeDef HAL_TIM_OC_ConfigChannel(TIM_HandleTypeDef *htim,
, ~% w" V8 K: X6 o! ?7 l
TIM_OC_InitTypeDef* sConfig,
/ z) d" p; x5 N0 e0 z5 H
uint32_t Channel)2 C, ?' ~1 ^- K8 K2 p. F
{ 7 }1 Y% S6 A4 y3 A
/* Check the parameters */# Q1 A- Y2 ]$ | O
assert_param(IS_TIM_CHANNELS(Channel)); - E& c6 O3 a9 k0 H" v7 I
assert_param(IS_TIM_OC_MODE(sConfig->OCMode));
: W5 l2 h5 M& g: s; ^% Q4 D: M
assert_param(IS_TIM_OC_POLARITY(sConfig->OCPolarity));
- W! h/ g! |. ^. T; G. m
( q! k. ]9 Q; j0 X4 `: p3 d/ n
/* Process Locked */
9 i4 G5 S$ r. {9 d# d
__HAL_LOCK(htim); B. ^) E* ~" c9 a
: p- c. y/ K w
htim->State = HAL_TIM_STATE_BUSY;
' ~' ?5 ?# t1 k% |! M/ j5 o
% _/ s) R& H. A: c1 }
switch (Channel)
# Y3 ]0 [! d2 E# O
{
4 b7 ^0 k" e9 C" Y4 K
case TIM_CHANNEL_1:
* w9 }: g4 K5 _* U% S! U
{
- e; K3 G% n j5 N6 I
/* 检测参数Check the parameters */
5 v& M2 `' Q% p1 E7 ?, S- U
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
% b2 a2 p, f$ d, H
5 I; [6 y5 T6 s' e- n
/* 配置定时器输出比较通道1 */
/ n3 G7 a+ \( [! Q
TIM_OC1_SetConfig(htim->Instance, sConfig);
, s% {% Y' N* u
}# S& f# z; }9 c' ~2 K
break;- h# @# y4 K0 P3 V
" J; y( z* N7 x X
case TIM_CHANNEL_2:3 h L! W, D4 I. e6 K& {
{; z6 D3 ?, [' l6 f7 l
/* 省略 */
( O, E; P1 `5 l/ `3 V% o& n
}
0 u( B- j$ p0 D1 B
break;8 G) g7 P5 J- u; E
0 p( ^/ S/ F0 X7 v/ ~ ?
case TIM_CHANNEL_3:8 U4 U5 m9 N" r0 G9 F3 U, L
{
! M* E4 N6 K. x6 ?
/* 省略 */
# ~% W5 R H) b
}8 ~/ t( ?& e( z
break;
! S% U$ v% r5 M1 D" ]( r/ R
- }/ [- Q. u7 U, W
case TIM_CHANNEL_4:
! s! l9 s+ a0 g* V. G) W0 X
{
+ C7 a S% W9 s' R- G8 V. Y
/* 省略 */6 U. g3 p3 I% n1 O: ?
}
0 G9 v: r. D9 Q
break;% C: ~. h. _! a A) I; n1 b' k0 w
7 u% @: `( E+ [4 P$ n
case TIM_CHANNEL_5:
. E$ {8 H' M M* m
{* }- M+ ~$ W3 C% X0 H
/* 省略 */* k9 K }: J! p$ C2 s
}0 t5 S; O0 [9 }3 }! s/ m0 R5 m
break;
" n) }4 C/ t+ R/ y' s) o& z
h& a$ f: s4 C @
case TIM_CHANNEL_6:
& a( k2 F) W: u
{
- c) X/ @2 T2 O1 D/ r* I* N( n$ O6 t
/* 省略 */5 l4 s+ G z. @; A/ U
}. H x, E( u0 n! x7 @$ N
break;' O1 h1 ` U r! v, V
) y: I% I: c* |% v* p; u
default:
3 S7 w- v% Z( |' @8 {+ _
break;
9 ]( v: w, X2 I7 w
}
1 O) a3 C8 X! F# N# P1 Y4 I
- B) M. h1 a% O, [3 ^8 c
htim->State = HAL_TIM_STATE_READY;8 i, w" C+ @) {, y
: F2 A% e& O$ Z) F
__HAL_UNLOCK(htim); ) o0 O6 _8 N: F) H1 U# m8 o
e, ~ ?' p* J) K9 T
return HAL_OK;7 [ V9 f: a! N9 m
}

复制代码

函数描述：

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

函数参数：

  第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), a5 j4 B$ E- u1 l* p; X7 M S- N
{
3 W9 { O% {0 E [0 C& y% c
/* 检查参数 */
5 B1 m, ~: q1 q) x8 B
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
7 s5 F* h/ V9 S5 G) J. C$ z
3 |7 h b, Z1 A9 r3 Q1 a- C
/* 使能输出比较通道 */3 z7 } g% s4 O- r
TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
9 y$ ~" O" f' g# _) ^8 N7 f, F" M" {
2 E4 ?0 g5 P( x) _; w5 Z2 C
if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET) S5 W) U9 O$ w! Y7 W* ^
{
' l3 n% g! z2 R7 H5 X* F
/* 使能主输出 */! ]7 @0 E& _# Y2 i6 H5 F! _& `( C
__HAL_TIM_MOE_ENABLE(htim);( S( d) f$ x& i' `
}+ J9 @, w+ B- ?; y0 I/ p$ E
4 q7 p9 c8 c$ W1 j, b; i) Y
/* 使能定时器 */
( N4 s6 V0 N. e1 T6 N* y) X
__HAL_TIM_ENABLE(htim); 8 {+ Z8 S0 u8 z) O; D
( A' `, e8 T. H0 q" a* ] E" t8 `
/* 返回状态 */
5 t- d/ V R% {* f
return HAL_OK;
9 y0 a9 L+ u, O% M h
}

复制代码

函数描述：

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

函数参数：

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