【经验分享】STM32H7的高分辨率定时器HRTIM基础知识和HAL库API

[复制链接]

STMCU小助手发布时间：2021-11-1 22:21

文章
文章封面:
文章简介:	高分辨率定时器可以产生多达10路高分辨率信号。它主要用数字电源、照明，电源耗材，太阳能逆变器和无线充电等应用场合，当然，也可以作为通用目的。

63.1 初学者重要提示
  高分辨率定时器可以产生多达10路高分辨率信号。它主要用数字电源、照明，电源耗材，太阳能逆变器和无线充电等应用场合，当然，也可以作为通用目的。
  HRTIM模块化的架构允许产生独立或者叠加波形。通过带的时序控制单元和各种外部事件的配合，可以产生各种信号PWM，相移等。
  HRTIM定时器还具有定时测量功能和链接到内置ADC和DAC转换器。并且它还具有轻载管理模式和能够处理各种故障的方案以实现安全关闭。
  HRTIM有多个中断入口函数，使用的时候别搞错了：

HRTIM1_Master_IRQHandler
/ [; u J7 g& |% \2 B
HRTIM1_TIMA_IRQHandler
' O( s4 R8 i2 ~3 D# ~" i
HRTIM1_TIMB_IRQHandler 7 c- C) N/ |! |6 N
HRTIM1_TIMC_IRQHandler , \7 K9 l" w5 @- \
HRTIM1_TIMD_IRQHandler
5 l7 @2 h8 k$ }; T
HRTIM1_TIME_IRQHandler
- w* x& Y7 Y2 ~; B! V. v8 e
HRTIM1_FLT_IRQHandler
) d( \. u$ ^ M' m% u. q

复制代码

63.2 HRTIM基础知识
  HRTIM由6个定时器组成，分别是1个主定时器（Master Timer）和5个独立的定时器单元，从Timer A到Timer E。
这6个都是16bit定时器，每个定时器都包含 1 个独立计数器和 4 个比较单元。
主定时器（Master Timer）：
基于 16 位递增计数器。它可通过 4 个比较单元置位/ 复位 10 路输出中的任何一路，并向 5 个定时器单元提供同步信号。其主要用途是使定时器单元受唯一的时钟源控制。交错降压转换器是一个典型的应用示例，主定时器在其中管理多个单元之间的相移。

  5个定时器Timer A到Timer E：
既可以独立工作，也可以与其它定时器（包括主定时器）配合工作。每个定时器都可控制两路输出。输出置位/复位事件可以由定时单元比较寄存器触发，或者由主定时器事件、其他定时器的事件或外部事件触发。

  每个定时器的两路输出：
支持PWM互补输出，支持添加死区时间。
将载波频率添加到调制信号上。
通过将异步输出置为预定义的安全电平来管理故障事件。
  10个外部事件，可用于任何定时器单元。
可编程极性和边沿有效性。
  5个事件用于快速异步模式。
  5个事件用于可编程数字滤波器。
  利用消隐和窗口模式实现伪事件过滤。
  多条通道可连接到内置模拟外设。
  4个用于 ADC 转换器的触发信号。
  3个用于 DAC 转换器的触发信号。
  3个用于比较器。
丰富的保护机制。
  5 路故障输入可组合使用，而且可以关联到任何定时单元。
  可编程极性和边沿有效性。
  对谐振变换器配有专门的延时保护。
  不同HRTIM之间可以做同步输入/输出。
63.2.1 定时器的硬件框图
认识一个外设，最好的方式就是看他的框图，方便我们快速的了解HRTIM的基本功能，然后再看手册了解细节。

下面我们直接看HRTIM的框图：

aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDIwMDIvMTM3OTEwNy0yMDIw.png

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

  hrtim_in_sync[3:1]
同步输入端，将HRTIM与其他内部或外部定时器资源进行同步输入：

hrtim_in_sync[1]：保留。

hrtim_in_sync[2]：时钟源为通用TIMx定时器（通过片上互连）。

hrtim_in_sync[3]：时钟源为外部HRTIM（通过HRTIM_SCIN输入引脚）。

  hrtim_out_sync[2:1]
同步输出端，用于级联或同步多个片上或片外HRTIM，由于H7只有一个HRTIM，所以只能同步其它器件上带的HRTIM。

hrtim_out_sync[1]：保留。

hrtim_out_sync[2]：目标为片外 HRTIM 或外设（通过HRTIM_SCOUT输出引脚）。

  hrtim_adc_trg[4:1]
输出端，用于触发ADC转换。

  hrtim_dac_trg[3:1]
输出端，用于触发DAC转换。

  hrtim_mst_it[7:1]
输出端，用于发出中断请求。

  hrtim_dma[6:1]
输出端，用于发出DMA请求。

  hrtim_pclk
输入端，APB时钟。

  hrtim_ker_ck
输出端， HRTIM内核时钟。

  hrtim_evtX[4:1] 大写字母X的范围是1到10。
输入端，用于接收外部事件，支持接收10个事件，每个事件有4种输入源可以选择，可选择片上（来自其他内置外设：比较器、ADC模拟看门狗、TIMx定时器、触发输出等）或片外（HRTIM_EEVx输入引脚）。

  HRTIM_FLT[5:1]
hrtim_in_flt[5:1]

故障输入端，5 路片上输入和 5 路片外HRTIM_FLTx 输入。

当输入信号有效时立即禁止HRTIM 输出。

  hrtim_sys_flt
系统故障输入，比如时钟安全系统、 SRAM奇偶校验错误、 Cortex®-M7 LOCKUP (HardFault)、 PVD输出等。

  hrtim_upd_en[3:1]
输入端，HRTIM寄存器更新使能（片上互连）会触发从影子寄存器到活动寄存器的传输。

  hrtim_bm_trg
输入端，突发模式触发事件。

  hrtim_bm_ck
输入端，突发模式时钟。

HRTIM_CHA1
HRTIM_CHA2
HRTIM_CHB1
HRTIM_CHB2
HRTIM_CHC1
HRTIM_CHC2
HRTIM_CHD1
HRTIM_CHD2
HRTIM_CHE1
HRTIM_CHE2
对应定时器单元Timer A，B，C，D，E的输出，每个定时器有两路。

63.2.2 HRTIM时钟选择
HRTIM支持两种时钟输入，一个是通用定时器时钟输入，另一个是CPU主频时钟输入：

反映到程序代码上，通过下两个宏定义参数区分：

#define RCC_HRTIM1CLK_TIMCLK ((uint32_t)0x00000000)
8 U4 _8 D3 Z; P7 u" l
#define RCC_HRTIM1CLK_CPUCLK RCC_CFGR_HRTIMSEL + [1 U, e+ u# A$ d

复制代码

  使用CPU主频时钟，对应参数RCC_HRTIM1CLK_CPUCLK
  使用通用定时器时钟，对应参数RCC_HRTIM1CLK_TIMCLK。如果CPU主频时钟是400MHz的话，通用定时器时钟就是200MHz。
  具体实现，通过函数HAL_RCCEx_PeriphCLKConfig来配置：

PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_HRTIM1;7 h: X) m& \4 A' w' A/ Z0 z
PeriphClkInitStruct.Hrtim1ClockSelection = RCC_HRTIM1CLK_TIMCLK;
. @) r9 t. L% U- S
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
, \. D( [( _) k& i& v) L' O
{9 N8 \4 M7 s6 O9 e, l) _2 \; x' j
_Error_Handler(__FILE__, __LINE__);
/ f; [" D+ B5 B
}

复制代码

63.2.3 HRTIM主定时器
HRTIM的主定时器框图：

对于这个框图，了解到以下几点即可：

主定时器有1个计数器，4个比较单元，但没有捕获单元和输出。
主定时器的控制寄存器包含主定时器Master Timer和定时单元Timer A到E的所有定时器使能位。
63.2.4 HRTIM定时器单元（Timer A到E）
5个定时器单元的Timer A到E都是一样的，框图如下：

对于这个框图，了解到以下几点即可：

  有1个计数器，4个比较单元，2个捕获单元，带两个输出。
  比较单元2和比较单元4支持自带延迟。
  事件消隐和窗口模式可以实现伪事件过滤。
  REP，CMP1，CMP2，CMP3，CMP和定时器更新这几个信号可以设置输出端的置位/复位。
63.2.5 HRTIM的分辨率
STM32H7的主频配置为400MHz时，那么HRTIM的时钟最高就是400MHz。对于H7系列，HRTIM不支持倍频设置，仅支持1分频，2分频和4分频：

H7系列与F3以及G4的对比：

分辨率最高是G4系列，可以做到184ps。

63.2.6 HRTIM的PWM多路输出实现
这里我们先来看下单路PWM输出：

寄存器HRTIM_PERxR存储定时器的周期，寄存器HRTIM_CMP1xR存储比较值。执行过程如下：

计数器Counter计数到HRTIM_CMP1xR存储的比较值时，HRTIM_CHD1输出端复位。
计数到HRTIM_PERxR时，HRTIM_CHD1输出端置位，并且Counter重新从头开始计数。

理解了单路PWM输出后，再看实现这个功能对应的框图就很好理解了：

接下来再来看多路PWM输出：

截图上半部分波形是Timer D输出两路：

  HRTIM_CHD1输出是通过CMP1以及计数更新实现输出的置位/复位。
  HRTIM_CHD2输出是通过CMP2以及计数更新实现输出的置位/复位。
截图下半部分波形是Timer A输出两路：

  HRTIM_CHA1输出是通过CMP1以及计数更新实现输出的置位/复位。
  HRTIM_CHA2输出是通过CMP2，CMP3以及计数更新实现输出的置位/复位。
63.3 HRTIM定时器的HAL库用法
HRTIM的HAL库用法其实就是几个结构体变量成员的配置和使用，然后配置GPIO、时钟，并根据需要配置NVIC、中断和DMA。下面我们逐一展开为大家做个说明。

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

typedef struct {
# e& G" M( r/ {1 I, o
HRTIM_Master_TypeDef sMasterRegs;' r5 _- P4 ~! \' }1 q- `2 }
HRTIM_Timerx_TypeDef sTimerxRegs[5];* Z" S3 P7 ]0 l
uint32_t RESERVED0[32];
1 a7 V& J! f8 M j% \
HRTIM_Common_TypeDef sCommonRegs;
4 O* g7 ?/ ]# i4 T( O e# y; _6 W9 \
}HRTIM_TypeDef;: I; [! _' R* @' x& K2 X
& n$ A4 z* e4 l/ r# y
typedef struct- K8 m7 T- t" Y; e* M& S v
{9 p/ S$ j) |/ g
__IO uint32_t MCR; 1 r% E2 b7 J/ i( @5 D
__IO uint32_t MISR;
. ?- y, `9 D! B; H
__IO uint32_t MICR; 3 p0 n- \9 q/ v( Y
__IO uint32_t MDIER; ' n8 N9 I, R( H& |% {3 A
__IO uint32_t MCNTR; 3 U- H9 t+ Y! w5 a$ |$ k9 g# B/ f
__IO uint32_t MPER;
U2 v, `7 b) z5 _3 P. I9 a
__IO uint32_t MREP; 8 D/ [; p. E, U
__IO uint32_t MCMP1R; 7 G# {+ B" s' e4 P' k8 p
uint32_t RESERVED0;
( G. z j- I9 v$ I) _+ W
__IO uint32_t MCMP2R;
9 a. }, t8 ^3 x1 |* S
__IO uint32_t MCMP3R; # [' ~: \$ p' H; Y. r( A
__IO uint32_t MCMP4R;
3 a9 l$ k$ X' h( Q- I- [6 ^9 B
uint32_t RESERVED1[20];
3 q) x5 [/ u* D
}HRTIM_Master_TypeDef;
1 e2 m0 s* {6 @: ~
+ [9 m+ a9 ~1 N d* N: k
typedef struct2 R5 j( q" `9 k. l5 u
{
) b# I; L8 O7 p( M: [2 }
__IO uint32_t TIMxCR; , n( @. a* M; O- j
__IO uint32_t TIMxISR;
$ Y& S6 z! h( B" l) `+ A
__IO uint32_t TIMxICR; # Y# V; `2 f* X6 M
__IO uint32_t TIMxDIER; 2 |8 r5 m( e9 _0 V! E5 o
__IO uint32_t CNTxR;
8 Q- q6 V4 h9 Z p3 G5 ^3 @+ A
__IO uint32_t PERxR;
2 K; `. A! d! x: s1 i
__IO uint32_t REPxR;
- B, y* M" @) w! O. r
__IO uint32_t CMP1xR;
& c8 E$ W6 J* [5 X1 W
__IO uint32_t CMP1CxR;
8 J- A' t2 c2 M9 s( H0 U
__IO uint32_t CMP2xR; - \% O+ [1 ~. d) F; p" u- L5 X$ m
__IO uint32_t CMP3xR; 0 Z' ~$ J6 @$ V6 |: H
__IO uint32_t CMP4xR;
, ]6 W+ F3 P6 Y; n& T3 Y3 |
__IO uint32_t CPT1xR; 3 l+ C8 H+ x' n0 s1 H: p5 N) D3 D" c
__IO uint32_t CPT2xR;
! d0 q' J3 }2 w( j
__IO uint32_t DTxR; 6 U3 n7 [6 y/ B) H" J
__IO uint32_t SETx1R; 4 J( [ O/ R; b6 F
__IO uint32_t RSTx1R;
4 K+ n, C! I# W
__IO uint32_t SETx2R;
! O9 m p# {- y2 t. ^0 b$ }
__IO uint32_t RSTx2R;
! e6 W8 l+ G( F0 w0 T; H; f
__IO uint32_t EEFxR1;
+ D) d. a* E% D# x6 I9 @" R
__IO uint32_t EEFxR2; 4 B' o( ]: u8 f- J. h. G) W, o, k
__IO uint32_t RSTxR; 2 L& V$ E# ^1 I& A8 p9 E9 ^- U# }6 H- @
__IO uint32_t CHPxR;
+ r1 i# z$ b: j$ N0 S8 q% |* F. v
__IO uint32_t CPT1xCR; . F2 h* n- `& |1 v9 e* O. U) q6 @
__IO uint32_t CPT2xCR; , t4 @1 S' ~5 z% e$ q9 r
__IO uint32_t OUTxR; " C, U0 k& _8 v- h7 X- j& M
__IO uint32_t FLTxR;
0 P0 X) W# f4 d& k# t
uint32_t RESERVED0[5]; " l" X6 \ X( {/ u0 K3 P
}HRTIM_Timerx_TypeDef;
$ N- w- t7 m! R" Z
" {% e) _) e& ~
typedef struct
2 [3 d% b& V6 B
{
' H: v* D$ n+ l4 `$ ]
__IO uint32_t CR1; ; x. {( p. t8 R
__IO uint32_t CR2;
( j g' M$ o$ a! r/ P9 a* I4 P0 p
__IO uint32_t ISR;
0 X$ a" l, i7 ?9 B6 v6 S
__IO uint32_t ICR; # S u7 V0 L, w- P7 {0 v
__IO uint32_t IER;
' l! u' @. x, `/ d0 J1 z7 G
__IO uint32_t OENR; , P8 @. }& {. y
__IO uint32_t ODISR;
9 V p" M& P6 t; ?
__IO uint32_t ODSR;
# U5 |9 I, w, V5 P
__IO uint32_t BMCR;
; P4 Q( O& v! B7 K5 \
__IO uint32_t BMTRGR; / X( c1 p) X( `- f+ |+ Q0 n. u. v
__IO uint32_t BMCMPR; . f) D, }* R3 }+ Z0 q9 | ~$ b1 ~) o
__IO uint32_t BMPER; 0 J" ^1 j) u. I' w& u @5 E
__IO uint32_t EECR1;
2 l) ?! `: ~7 A+ y4 F9 b8 k
__IO uint32_t EECR2; * Y5 N3 m, t8 C
__IO uint32_t EECR3;
, W" d y' c' p. B
__IO uint32_t ADC1R; ; O8 }1 M0 @# Y9 v. j! S5 t
__IO uint32_t ADC2R;
6 t8 L" ?6 X" F2 J. ~' _/ ~
__IO uint32_t ADC3R; : D1 n& W% U+ R: e0 R; g. U
__IO uint32_t ADC4R;
* C& b2 \1 g! M+ Y$ Z
__IO uint32_t RESERVED0; 1 _4 x. K! U$ D# m9 t
__IO uint32_t FLTINR1;
( Q- D! e# X6 Q6 u* P. s3 p; ?- x
__IO uint32_t FLTINR2;
3 f1 ^4 [/ s8 R& T+ ^' Q [$ M
__IO uint32_t BDMUPR;
/ R6 g* M; f$ Q& [, R) W
__IO uint32_t BDTAUPR;
$ F2 X% ~- ^2 X0 {; ]
__IO uint32_t BDTBUPR;
) q1 w! R2 l D# ~# q; S+ ] T
__IO uint32_t BDTCUPR;
8 X/ U) Y W. Z6 C
__IO uint32_t BDTDUPR; 1 q' d5 a2 @$ E
__IO uint32_t BDTEUPR; % H( q( @) s; Q1 n9 u
__IO uint32_t BDMADR;
( n3 ?; L1 K* p
}HRTIM_Common_TypeDef;

复制代码

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

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

#define __O volatile /*!< Defines 'write only' permissions */; e: ], q1 ]9 Y/ v5 l; U) }# w& e
#define __IO volatile /*!< Defines 'read / write' permissions */

复制代码

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

#define PERIPH_BASE (0x40000000UL)
& a5 i+ e1 k. }0 n+ B
#define D2_APB2PERIPH_BASE (PERIPH_BASE + 0x00010000UL)
' T$ [2 Z. g2 x; k+ |9 W5 Z
) w4 o- P8 ^ y9 I/ C3 A$ O2 _. P
#define HRTIM1_BASE (D2_APB2PERIPH_BASE + 0x7400UL)
6 H8 ]0 d% `2 D) V% d% H; K
#define HRTIM1_TIMA_BASE (HRTIM1_BASE + 0x00000080UL)* u* ?2 W7 V9 W+ Q, g1 R$ m, J
#define HRTIM1_TIMB_BASE (HRTIM1_BASE + 0x00000100UL)+ h3 W7 f2 F& ^$ I! C
#define HRTIM1_TIMC_BASE (HRTIM1_BASE + 0x00000180UL)0 U. H2 _. }2 t
#define HRTIM1_TIMD_BASE (HRTIM1_BASE + 0x00000200UL)
! z/ B# y' q5 E. k* g
#define HRTIM1_TIME_BASE (HRTIM1_BASE + 0x00000280UL): |% M) Q7 e) ]' y6 I* r+ e3 p2 S
#define HRTIM1_COMMON_BASE (HRTIM1_BASE + 0x00000380UL)2 ~# X+ ]8 f: j* i/ Q. n. ~
# M5 y+ m( p+ @; r! ?
#define HRTIM1 ((HRTIM_TypeDef *) HRTIM1_BASE)<----- 展开这个宏，(HRTIM_TypeDef *)0x400174001 H& o; I5 _; {' L# p$ k* ~# o$ i
#define HRTIM1_TIMA ((HRTIM_Timerx_TypeDef *) HRTIM1_TIMA_BASE)
. [" ?1 t/ w& S2 I1 o6 f! b+ e
#define HRTIM1_TIMB ((HRTIM_Timerx_TypeDef *) HRTIM1_TIMB_BASE); D5 k; Q' o* i" t: g' W% Y5 j( V
#define HRTIM1_TIMC ((HRTIM_Timerx_TypeDef *) HRTIM1_TIMC_BASE)9 p( g6 r, ]- f' z: o& u; R& V
#define HRTIM1_TIMD ((HRTIM_Timerx_TypeDef *) HRTIM1_TIMD_BASE)
. L! X, p9 ` Q4 O3 \5 r' H/ z
#define HRTIM1_TIME ((HRTIM_Timerx_TypeDef *) HRTIM1_TIME_BASE)
& V: p p, ~3 f, z& b
#define HRTIM1_COMMON ((HRTIM_Common_TypeDef *) HRTIM1_COMMON_BASE)

复制代码

我们访问HRTIM的MCR寄存器可以采用这种形式：HRTIM1->sMasterRegs.MCR = 0；

63.3.2 定时器初始化结构体HRTIM_InitTypeDef
此结构体主要用于HRTIM初始化，定义如下：

typedef struct
. d& j6 E1 t T) B1 ^
{7 Y H) C+ d2 p2 }
uint32_t HRTIMInterruptResquests; ; d# o/ D4 D+ S$ a9 _ b
uint32_t SyncOptions; / r. Q& ?8 ~+ s
uint32_t SyncInputSource; , B @8 E T+ V) n
uint32_t SyncOutputSource; 3 c3 ?. v1 K( r2 E3 Y
uint32_t SyncOutputPolarity; + p! {0 m Q: G; \; E8 j
} HRTIM_InitTypeDef;
) {9 i4 x, V1 ~8 Z" I: A, b! w

复制代码

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

HRTIMInterruptResquests
用于配置支持的中断请求，支持的模式较多：

#define HRTIM_IT_NONE 0x00000000U /*!< No interrupt enabled */" z+ e% E+ ]0 H( }. E. u- r
#define HRTIM_IT_FLT1 HRTIM_IER_FLT1 /*!< Fault 1 interrupt enable */0 g. w J6 C" @; o5 B8 y/ |" O0 L
#define HRTIM_IT_FLT2 HRTIM_IER_FLT2 /*!< Fault 2 interrupt enable */, E' }" u8 K' L' o" b& O
#define HRTIM_IT_FLT3 HRTIM_IER_FLT3 /*!< Fault 3 interrupt enable */
' ^6 D" I3 z4 K- x: d3 w
#define HRTIM_IT_FLT4 HRTIM_IER_FLT4 /*!< Fault 4 interrupt enable */, H; G- J: ]! Q$ ?# e
#define HRTIM_IT_FLT5 HRTIM_IER_FLT5 /*!< Fault 5 interrupt enable */
9 J0 j8 B/ T) a9 u; t5 D) q" J0 L
#define HRTIM_IT_SYSFLT HRTIM_IER_SYSFLT /*!< System Fault interrupt enable */
* R6 Z1 l6 J+ O0 Y7 }' ]
#define HRTIM_IT_BMPER HRTIM_IER_BMPER /*!< Burst mode period interrupt enable */

复制代码

SyncOptions
配置HRTIM作为Master，发送同步信号，或者作为Slave，接收同步信号。

#define HRTIM_SYNCOPTION_NONE 0x00000000U , }' D' T+ t# |1 V$ a2 y& w* k
#define HRTIM_SYNCOPTION_MASTER 0x00000001U /* 作为MASTER, 同步输出SYNCOUT */$ _. c/ m0 L& \1 q" Y) N, F' [7 Z/ z
#define HRTIM_SYNCOPTION_SLAVE 0x00000002U /* 作为SLAVE, 同步输入SYNCIN */
; V3 K. p" N: O4 a4 v7 f

复制代码

SyncInputSource
设置外部同步输入源，只有当HRTIM配置为Slave时才可以使用。

#define HRTIM_SYNCINPUTSOURCE_NONE 0x00000000U
( Q4 Q5 [# S9 X+ k
/* 片上定时器做同步输入源 */
: {# v3 y; V( I$ _. c2 ]5 Y
#define HRTIM_SYNCINPUTSOURCE_INTERNALEVENT HRTIM_MCR_SYNC_IN_1
7 S# R( q- E5 |
/* 外部输入引脚SYNCIN做同步输入源 */
% _4 ~* t8 q# S; P# s. T
#define HRTIM_SYNCINPUTSOURCE_EXTERNALEVENT (HRTIM_MCR_SYNC_IN_1 | HRTIM_MCR_SYNC_IN_0)
9 ]% `2 _$ Z+ l5 e6 ?3 @2 Q6 U

复制代码

SyncOutputSource
设置同步脉冲输出源，只有当HRTIM配置为Master时才可以使用。

/* 主定时器启动事件触发SYNCOUT引脚发送脉冲 */
/ U; r% o2 S0 c7 }+ I
#define HRTIM_SYNCOUTPUTSOURCE_MASTER_START 0x00000000U / H9 ^* J3 j% N$ L$ O
6 D( \% p) U5 S& H4 V: ]5 {* l
/* 主定时器比较1事件触发SYNCOUT引脚发送脉冲 */ , p5 C/ X# ?" }$ l7 X
#define HRTIM_SYNCOUTPUTSOURCE_MASTER_CMP1 (HRTIM_MCR_SYNC_SRC_0)
% _; n" e8 P8 Q
1 q, C; P. ]6 K) r( \
/* Timer A启动或者复位事件触发SYNCOUT引脚发送脉冲 */
9 p+ \8 h, \ L: v. d1 p0 i
#define HRTIM_SYNCOUTPUTSOURCE_TIMA_START (HRTIM_MCR_SYNC_SRC_1)
$ m S4 w, ?2 L& w. i. L
9 ~1 T9 b; q* F, F5 x! |
/* Timer A比较1事件触发SYNCOUT引脚发送脉冲 */
: w4 m8 a% E R6 L$ Y
#define HRTIM_SYNCOUTPUTSOURCE_TIMA_CMP1 (HRTIM_MCR_SYNC_SRC_1 | HRTIM_MCR_SYNC_SRC_0)

复制代码

SyncOutputPolarity
同步输出极性。

/* 同步输出关闭 */
8 C \" {1 p( |9 {. a5 X" G
#define HRTIM_SYNCOUTPUTPOLARITY_NONE 0x00000000U 5 z, o% e1 ~6 O( u6 Z3 U
' `) Y& l2 Y5 c" e- V" c$ ?0 [4 B
/* SCOUT引脚空闲状态是低电平，发送一个长度为16个HRTIM时钟周期的正脉冲 */
! e/ P1 p) F1 @/ `- i
#define HRTIM_SYNCOUTPUTPOLARITY_POSITIVE (HRTIM_MCR_SYNC_OUT_1) ( r' I% {7 i5 C3 R( \ Z7 T: r4 u5 U
/ q+ Q5 f5 l2 W" E
/* SCOUT引脚空闲状态是高电平，发送一个长度为16个HRTIM时钟周期的负脉冲 */ ) \# j" @$ }8 }2 I) d v
#define HRTIM_SYNCOUTPUTPOLARITY_NEGATIVE (HRTIM_MCR_SYNC_OUT_1 | HRTIM_MCR_SYNC_OUT_0)

复制代码

63.3.3 定时器参数结构体HRTIM_TimerParamTypeDef
此结构体主要用于参数定义：

typedef struct
, o% L0 m' B, Z' ^
{* a& D+ c( i2 r' z5 G9 w
uint32_t CaptureTrigger1;
" F, v: |1 {' x" I; f
uint32_t CaptureTrigger2;
! J( L8 j1 A/ B# t d, h3 r4 C5 S; E
uint32_t InterruptRequests; 8 q) f+ G! R- ~7 Z- M j% w% ]# M- ^
uint32_t DMARequests; 3 F/ @, X& h3 s# ^
uint32_t DMASrcAddress; 4 f3 B8 E3 d% x4 M/ w
uint32_t DMADstAddress;
0 `7 {1 e8 i1 v$ B0 J0 i2 y8 O+ `
uint32_t DMASize; J% x R- f$ V2 L6 p' R
} HRTIM_TimerParamTypeDef;

复制代码

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

CaptureTrigger1
触发捕获单元1。

当HRTIM工作在Simple Mode，支持的参数如下：

#define HRTIM_EVENT_NONE (0x00000000U) /*!< Undefined event channel */9 b$ D Y3 r+ |% ?
#define HRTIM_EVENT_1 (0x00000001U) /*!< External event channel 1 identifier */
0 H1 p8 v; b0 V5 \* J
#define HRTIM_EVENT_2 (0x00000002U) /*!< External event channel 2 identifier */* e! m: g- d: E6 h: e* ?) Q; n
#define HRTIM_EVENT_3 (0x00000003U) /*!< External event channel 3 identifier */+ N4 x) j7 r% |2 O3 N" _- t
#define HRTIM_EVENT_4 (0x00000004U) /*!< External event channel 4 identifier */. a. b W1 G J. m: e
#define HRTIM_EVENT_5 (0x00000005U) /*!< External event channel 5 identifier */3 m0 N3 i: l! m1 R3 o7 d' Y1 q4 o
#define HRTIM_EVENT_6 (0x00000006U) /*!< External event channel 6 identifier */
/ q' C% [2 \- d5 Z( A4 S3 d
#define HRTIM_EVENT_7 (0x00000007U) /*!< External event channel 7 identifier */
6 J( q9 E6 Y$ j2 f" J" [/ ^
#define HRTIM_EVENT_8 (0x00000008U) /*!< External event channel 8 identifier */, l5 Q4 H7 n4 U
#define HRTIM_EVENT_9 (0x00000009U) /*!< External event channel 9 identifier */
) P7 e X' C5 O* B4 |
#define HRTIM_EVENT_10 (0x0000000AU) /*!< External event channel 10 identifier */

复制代码

当HRTIM工作在Waveform Mode，支持的参数如下：

#define HRTIM_CAPTURETRIGGER_NONE 0x00000000U
8 v+ n4 J: P/ r
#define HRTIM_CAPTURETRIGGER_UPDATE (HRTIM_CPT1CR_UPDCPT)
3 c2 @ v1 Y9 I, K" @- o
#define HRTIM_CAPTURETRIGGER_EEV_1 (HRTIM_CPT1CR_EXEV1CPT) % X$ g5 a+ E4 _* @* F7 Z; t2 ]7 }
#define HRTIM_CAPTURETRIGGER_EEV_2 (HRTIM_CPT1CR_EXEV2CPT)
, l. Z8 K+ G4 w( O X5 K
#define HRTIM_CAPTURETRIGGER_EEV_3 (HRTIM_CPT1CR_EXEV3CPT) 3 T$ W/ M& w6 L, I$ z% X
#define HRTIM_CAPTURETRIGGER_EEV_4 (HRTIM_CPT1CR_EXEV4CPT)
& `& [" n, o: Q# v" c
#define HRTIM_CAPTURETRIGGER_EEV_5 (HRTIM_CPT1CR_EXEV5CPT) , {( T0 m1 u2 p9 T
#define HRTIM_CAPTURETRIGGER_EEV_6 (HRTIM_CPT1CR_EXEV6CPT)
$ S7 p& |7 O& O4 m; u7 ^9 ?5 Z
#define HRTIM_CAPTURETRIGGER_EEV_7 (HRTIM_CPT1CR_EXEV7CPT) ) t0 _: c0 o- {0 d1 b
#define HRTIM_CAPTURETRIGGER_EEV_8 (HRTIM_CPT1CR_EXEV8CPT) 9 t7 v- r8 f8 d6 {
#define HRTIM_CAPTURETRIGGER_EEV_9 (HRTIM_CPT1CR_EXEV9CPT)
2 |. u4 \5 F+ X' @
#define HRTIM_CAPTURETRIGGER_EEV_10 (HRTIM_CPT1CR_EXEV10CPT)- `! A+ V* E# V0 {
#define HRTIM_CAPTURETRIGGER_TA1_SET (HRTIM_CPT1CR_TA1SET)
) P, @. L5 L. ~
#define HRTIM_CAPTURETRIGGER_TA1_RESET (HRTIM_CPT1CR_TA1RST)
n( A6 H+ G# x( _$ U. ~. O: [
#define HRTIM_CAPTURETRIGGER_TIMERA_CMP1 (HRTIM_CPT1CR_TIMACMP1) , c* ~) H" z% G6 h9 Z
#define HRTIM_CAPTURETRIGGER_TIMERA_CMP2 (HRTIM_CPT1CR_TIMACMP2)
/ Y* v- g6 g! S* K% _; L
#define HRTIM_CAPTURETRIGGER_TB1_SET (HRTIM_CPT1CR_TB1SET) & i4 w% V' {5 I3 L. c: }
#define HRTIM_CAPTURETRIGGER_TB1_RESET (HRTIM_CPT1CR_TB1RST) 7 L+ [* q! F* _8 o: y
#define HRTIM_CAPTURETRIGGER_TIMERB_CMP1 (HRTIM_CPT1CR_TIMBCMP1) ; O, O# L% G) Z4 ]. w8 q
#define HRTIM_CAPTURETRIGGER_TIMERB_CMP2 (HRTIM_CPT1CR_TIMBCMP2) ) E/ F: i, l, X/ ~ E. B$ u
#define HRTIM_CAPTURETRIGGER_TC1_SET (HRTIM_CPT1CR_TC1SET) + i+ K. z b3 ]6 o3 [0 _
#define HRTIM_CAPTURETRIGGER_TC1_RESET (HRTIM_CPT1CR_TC1RST) ; } g1 T5 D' u* s2 z# e5 \
#define HRTIM_CAPTURETRIGGER_TIMERC_CMP1 (HRTIM_CPT1CR_TIMCCMP1) 4 V7 \# H i4 U. V
#define HRTIM_CAPTURETRIGGER_TIMERC_CMP2 (HRTIM_CPT1CR_TIMCCMP2)
4 m" Q0 W4 A& y0 E5 i! f" M
#define HRTIM_CAPTURETRIGGER_TD1_SET (HRTIM_CPT1CR_TD1SET)
& j9 _$ o$ i9 `" ^& D, \$ C0 A
#define HRTIM_CAPTURETRIGGER_TD1_RESET (HRTIM_CPT1CR_TD1RST)
1 K8 F" ~6 V! m* ~' l: e
#define HRTIM_CAPTURETRIGGER_TIMERD_CMP1 (HRTIM_CPT1CR_TIMDCMP1)
; \& i. O8 s: p1 M5 l p6 w4 l
#define HRTIM_CAPTURETRIGGER_TIMERD_CMP2 (HRTIM_CPT1CR_TIMDCMP2)
$ t* @$ C; {9 A
#define HRTIM_CAPTURETRIGGER_TE1_SET (HRTIM_CPT1CR_TE1SET) 3 M: y: m# C- f7 g( B% e
#define HRTIM_CAPTURETRIGGER_TE1_RESET (HRTIM_CPT1CR_TE1RST)
" g9 ?, v3 i3 y3 v* q' n3 N9 {
#define HRTIM_CAPTURETRIGGER_TIMERE_CMP1 (HRTIM_CPT1CR_TIMECMP1)
! y& x2 \9 g3 E+ Y. `, g2 N
#define HRTIM_CAPTURETRIGGER_TIMERE_CMP2 (HRTIM_CPT1CR_TIMECMP2)

复制代码

  CaptureTrigger2
触发捕获单元2，支持的参数与CaptureTrigger1一样。

  InterruptRequests
定时器的中断请求使能。

  DMASrcAddress
DMA源地址。

  DMADstAddress
DMA目的地址。

  DMASize
DMA传输大小。

63.3.4 定时器时基配置HRTIM_TimeBaseCfgTypeDef
此结构体主要用于定时器时间基准配置：

7 n- \: R$ Z% A% R9 x% x* K' i' c
typedef struct
1 L1 E M C( ?) t8 t. L; J
{& @7 w1 j! D: |( e/ A
uint32_t Period;
6 a3 B( r6 N# `" I+ w+ v% v' g% H3 S
uint32_t RepetitionCounter;
. y, \ C; c( D5 q7 c
uint32_t PrescalerRatio;
% q ^9 b% i( s, k, |! K0 H
uint32_t Mode;
9 q" r# j6 R, w4 r4 ~7 E" `
} HRTIM_TimeBaseCfgTypeDef;

复制代码

下面将这几个参数一一做个说：

  Period
定时器周期，至少3个HRTIM时钟周期，最大值0xFFDF。

  RepetitionCounter
重复周期计数器，最小值0x00，最大值0xFF。

  PrescalerRatio
用于设置定时器分频，对于H7系列，此参数仅支持分频，也就是下面参数的后三个：

#define HRTIM_PRESCALERRATIO_MUL32 (0x00000000U)
3 `" z$ D4 d' u, b# d
#define HRTIM_PRESCALERRATIO_MUL16 (0x00000001U)
% Y6 {" N" c6 Z8 ~( u! o" ^
#define HRTIM_PRESCALERRATIO_MUL8 (0x00000002U)
}" f6 D* E4 ?, L8 I- s
#define HRTIM_PRESCALERRATIO_MUL4 (0x00000003U)
' K6 h3 w/ P8 ]
#define HRTIM_PRESCALERRATIO_MUL2 (0x00000004U) * Y l% |- D/ A! N2 p% V
/* STM32H7仅支持下面这三种 */ $ `) y; [, c$ J+ U+ W. n
#define HRTIM_PRESCALERRATIO_DIV1 (0x00000005U)
n ^8 L' M' b2 V5 y
#define HRTIM_PRESCALERRATIO_DIV2 (0x00000006U) ' s1 M+ `$ c. R$ I& C1 a. \
#define HRTIM_PRESCALERRATIO_DIV4 (0x00000007U)

复制代码

Mode
设置工作模式，支持的参数如下：

#define HRTIM_MODE_CONTINUOUS (0x00000008U) % U9 W/ ]* l" u
#define HRTIM_MODE_SINGLESHOT (0x00000000U)
4 Q, [8 K( w9 p* b: k7 W
#define HRTIM_MODE_SINGLESHOT_RETRIGGERABLE (0x00000010U) - q& }& t$ K2 `( }9 G7 y) j- D

复制代码

63.3.5 定时器配置HRTIM_TimerCfgTypeDef
此结构体主要用于定时器配置：

typedef struct
$ B, I' U! R" E1 Z9 g8 o
{4 S- h) { v* U* L/ n4 K0 k
/* 下面这些参数支持所有定时器，含主定时器和Timer A到Timer E*/
( Q1 u4 P8 q& T) b
uint32_t InterruptRequests;
2 c( s7 Z) ]2 a& T. b- t
uint32_t DMARequests;
6 c0 D: o2 t7 U5 M1 S. h1 I, L
uint32_t DMASrcAddress; ( l2 n& [& i2 ^: x
uint32_t DMADstAddress; 2 B; B" @0 k" K8 o9 {3 C8 `' ^
uint32_t DMASize;
! O( [5 Z8 n* u6 C
uint32_t HalfModeEnable; u' H! y- o" p2 k4 i* U: h+ z# l
uint32_t StartOnSync; 2 h0 r# p: m: ~8 r1 P; `
uint32_t ResetOnSync;
5 j" k, ?% K5 r2 e" L% b. s
uint32_t DACSynchro; & p$ E3 C9 K2 O( m4 H9 E
uint32_t PreloadEnable;
1 G1 J- k$ x2 ^4 A" k
uint32_t UpdateGating; - H5 D, R5 \6 M) X& D' @
uint32_t BurstMode; . s2 n1 {9 ^$ Q4 j( k: F y. J1 b8 G
uint32_t RepetitionUpdate;
9 D8 D. U- g+ w3 [ c; m5 `
/* 下面这些参数仅支持Timer A到Timer E */
' K# P# T5 \. z& W9 u) l
uint32_t PushPull; : M0 ?# ]: i1 F# ~8 v: s9 `
uint32_t FaultEnable; ' ?) P7 {4 S6 M8 @: v. d
uint32_t FaultLock;
+ A, P. Y# ~3 R. w4 ]
uint32_t DeadTimeInsertion; * Z0 |+ S. [% ?# M8 }
uint32_t DelayedProtectionMode;
) I$ e# s# M7 [" j, v8 L4 Z+ e z
uint32_t UpdateTrigger;
: ^0 N+ }. O1 B% L
uint32_t ResetTrigger; * F* j9 k& D9 ?# ~ u
uint32_t ResetUpdate;
! a8 j+ ^2 p* S: v# ]! }
} HRTIM_TimerCfgTypeDef;
* s& [$ |6 v6 a& V$ @. b

复制代码

下面将这几个参数一一做个说：

InterruptRequests
用于使能HRTIM的中断，支持的中断如下：

#define HRTIM_MASTER_IT_NONE 0x00000000U /*!< No interrupt enabled */0 [1 u& x6 R4 x6 ?. w& @& Y0 Y i; N
#define HRTIM_MASTER_IT_MCMP1 HRTIM_MDIER_MCMP1IE /*!< Master compare 1 interrupt enable */, p3 F: }6 G5 D8 ~9 r7 j6 Q
#define HRTIM_MASTER_IT_MCMP2 HRTIM_MDIER_MCMP2IE /*!< Master compare 2 interrupt enable */1 P- M' C0 E1 z$ |8 k3 N% E
#define HRTIM_MASTER_IT_MCMP3 HRTIM_MDIER_MCMP3IE /*!< Master compare 3 interrupt enable */
" O/ Y% ~3 z# n
#define HRTIM_MASTER_IT_MCMP4 HRTIM_MDIER_MCMP4IE /*!< Master compare 4 interrupt enable */2 q/ U8 a, S# u G* r6 h" y) ]8 {6 ^
#define HRTIM_MASTER_IT_MREP HRTIM_MDIER_MREPIE /*!< Master Repetition interrupt enable */0 l. {9 C0 ^/ I P/ C
#define HRTIM_MASTER_IT_SYNC HRTIM_MDIER_SYNCIE /*!< Synchronization input interrupt enable */
% A9 a2 [- v% m+ \0 Q( \
#define HRTIM_MASTER_IT_MUPD HRTIM_MDIER_MUPDIE /*!< Master update interrupt enable */

复制代码

DMARequests
用于设置支持的DMA请求，此参数支持两种类型的参数，下面是HRTIM Master支持的请求

#define HRTIM_MASTER_DMA_NONE 0x00000000U /*!< No DMA request enable */
4 e) Q& L3 W/ K3 [: O
#define HRTIM_MASTER_DMA_MCMP1 HRTIM_MDIER_MCMP1DE /*!< Master compare 1 DMA request enable */9 `1 A' ]' {: J2 J( \* E
#define HRTIM_MASTER_DMA_MCMP2 HRTIM_MDIER_MCMP2DE /*!< Master compare 2 DMA request enable */% `- B( m3 F6 C
#define HRTIM_MASTER_DMA_MCMP3 HRTIM_MDIER_MCMP3DE /*!< Master compare 3 DMA request enable */" |4 H# m8 O& Z! w+ B6 R
#define HRTIM_MASTER_DMA_MCMP4 HRTIM_MDIER_MCMP4DE /*!< Master compare 4 DMA request enable */
8 v1 P5 w. P/ V0 }- ~+ s9 p% t
#define HRTIM_MASTER_DMA_MREP HRTIM_MDIER_MREPDE /*!< Master Repetition DMA request enable */
# b: d; Z3 }5 m: n- w8 V4 `: Z1 D
#define HRTIM_MASTER_DMA_SYNC HRTIM_MDIER_SYNCDE /*!< Synchronization input DMA request enable */
: Z. p4 {$ Z2 W2 H# ?* R8 h
#define HRTIM_MASTER_DMA_MUPD HRTIM_MDIER_MUPDDE /*!< Master update DMA request enable */

复制代码

下面是HRTIM 的TIMER A到TIMER E支持的请求：

#define HRTIM_TIM_DMA_NONE 0x00000000U /*!< No DMA request enable */! p9 O8 j0 m& M! P! [) i
#define HRTIM_TIM_DMA_CMP1 HRTIM_TIMDIER_CMP1DE /*!< Timer compare 1 DMA request enable */: L$ Q- `$ j7 X+ y" R
#define HRTIM_TIM_DMA_CMP2 HRTIM_TIMDIER_CMP2DE /*!< Timer compare 2 DMA request enable */: S- Q# g( k* B$ z) ]& y/ p
#define HRTIM_TIM_DMA_CMP3 HRTIM_TIMDIER_CMP3DE /*!< Timer compare 3 DMA request enable */
. D+ e4 P7 ~( e* T
#define HRTIM_TIM_DMA_CMP4 HRTIM_TIMDIER_CMP4DE /*!< Timer compare 4 DMA request enable */8 p& T- V6 B3 Z0 }6 S9 Z
#define HRTIM_TIM_DMA_REP HRTIM_TIMDIER_REPDE /*!< Timer repetition DMA request enable */0 |' \0 Q2 s z% N
#define HRTIM_TIM_DMA_UPD HRTIM_TIMDIER_UPDDE /*!< Timer update DMA request enable */) e& |8 q$ e! a3 W% g
#define HRTIM_TIM_DMA_CPT1 HRTIM_TIMDIER_CPT1DE /*!< Timer capture 1 DMA request enable */* l# F2 }5 K7 v0 a s; D
#define HRTIM_TIM_DMA_CPT2 HRTIM_TIMDIER_CPT2DE /*!< Timer capture 2 DMA request enable */
" I: j D# x; _ K# R* ~* Z
#define HRTIM_TIM_DMA_SET1 HRTIM_TIMDIER_SET1DE /*!< Timer output 1 set DMA request enable */
9 {% t2 a( |) S( v
#define HRTIM_TIM_DMA_RST1 HRTIM_TIMDIER_RST1DE /*!< Timer output 1 reset DMA request enable */8 R0 `5 R9 V. x f
#define HRTIM_TIM_DMA_SET2 HRTIM_TIMDIER_SET2DE /*!< Timer output 2 set DMA request enable */
: s3 H% C F1 a. B1 r" F) E* d% ]
#define HRTIM_TIM_DMA_RST2 HRTIM_TIMDIER_RST2DE /*!< Timer output 2 reset DMA request enable */
( }2 D1 J1 F, c8 P( y
#define HRTIM_TIM_DMA_RST HRTIM_TIMDIER_RSTDE /*!< Timer reset DMA request enable */
9 _5 A$ \9 k. K4 U; H
#define HRTIM_TIM_DMA_DLYPRT HRTIM_TIMDIER_DLYPRTDE /*!< Timer delay protection DMA request enable

复制代码

  DMASrcAddress
用于设置DMA源地址。

  DMADstAddress
用于设置DMA目的地址。

  DMASize
用于设置DMA大小。

  HalfModeEnable
用于使能Half Mode。

#define HRTIM_HALFMODE_DISABLED (0x00000000U) /* 禁止 *// T" x7 S/ j8 Y( C3 Q7 v# X
#define HRTIM_HALFMODE_ENABLED (0x00000020U) /* 使能 */

复制代码

StartOnSync
设置同步输入端接收到上升沿信号后，是否启动定时器：

#define HRTIM_SYNCSTART_DISABLED (0x00000000U) /* 禁止 */
- J. A* E+ v) e
#define HRTIM_SYNCSTART_ENABLED (HRTIM_MCR_SYNCSTRTM) /* 使能 */

复制代码

ResetOnSync
设置同步输入端接收到上升沿信号后，是否复位定时器。

#define HRTIM_SYNCRESET_DISABLED (0x00000000U) /* 禁止 */
7 A+ H% e o$ @4 w T
#define HRTIM_SYNCRESET_ENABLED (HRTIM_MCR_SYNCRSTM) /* 使能 */

复制代码

DACSynchro
用于设置是否使能DAC同步事件。

/* 禁止DAC同步事件 */! S- a N2 `7 T5 {# @ v1 N
#define HRTIM_DACSYNC_NONE 0x00000000U ; v0 e+ E6 Y2 J4 l- S; x, X
8 C! s) D; U; t; _( a) D" u
/* 定时器更新时，DACTrigOut1输出同步事件 */1 g, n: _0 m1 |1 s+ O
#define HRTIM_DACSYNC_DACTRIGOUT_1 (HRTIM_MCR_DACSYNC_0) , n; q7 j9 \# A
0 q& U' n' W8 E, j1 n
/* 定时器更新时，DACTrigOut2输出同步事件 */1 P. F) M e9 Q9 x- t
#define HRTIM_DACSYNC_DACTRIGOUT_2 (HRTIM_MCR_DACSYNC_1) ! z9 _7 x- R3 o4 x3 P- t
, \ G" H1 A# c! W
/* 定时器更新时，DACTrigOut3输出同步事件 */
& k& V0 r) F8 `( h
#define HRTIM_DACSYNC_DACTRIGOUT_3 (HRTIM_MCR_DACSYNC_1 | HRTIM_MCR_DACSYNC_0)

复制代码

PreloadEnable
用于设置是否使能寄存器预加载。

/* 禁止预加载，写操作是直接写入到寄存器里面 */
0 `1 k, I( X! U$ @
#define HRTIM_PRELOAD_DISABLED (0x00000000U)
9 t) X. A0 Q/ |7 W
, h2 F. I( F4 o: q! I8 j& Z
/* 使能预加载，写操作是写入到预加载寄存器里面 */, L2 x% P6 k, ^+ o# ^! G
#define HRTIM_PRELOAD_ENABLED (HRTIM_MCR_PREEN)

复制代码

UpdateGating
用于设置HRTIM更新方式来源。

/* 独立更新，不受DMA突发传输完成影响 */# N+ V7 j- v7 i* H
#define HRTIM_UPDATEGATING_INDEPENDENT 0x00000000U
$ H' o2 B$ p. `: A( D6 K# A
/ ~$ \, |3 w4 D5 |! ^
/* 突发传输完成时，完成更新!< Update done when the DMA burst transfer is completed */
3 _$ @+ b! J9 ~
#define HRTIM_UPDATEGATING_DMABURST (HRTIM_TIMCR_UPDGAT_0) 6 B# M, T+ w3 ?& }* ? T
G( P& K) O$ b3 S
/* 代码太长，其它定义省略未写 */

复制代码

BurstMode
设置定时器在突发模式下表现。

/* 定时器计数器时钟保持，定时器正常操作 */+ ?, s0 l/ |+ q- i: \
#define HRTIM_TIMERBURSTMODE_MAINTAINCLOCK 0x00000000U
7 j2 k2 a# |8 G$ j- {3 W
5 B6 S) e+ J7 C! T; t' t' \' @* r3 P
/* 定时器计数时钟停止，计数器复位 */ " }- P' S# ?$ P$ E7 ^" Z0 M% ~3 q
#define HRTIM_TIMERBURSTMODE_RESETCOUNTER (HRTIM_BMCR_MTBM)

复制代码

RepetitionUpdate
设置重复计数事件是否可以触发寄存器更新。

#define HRTIM_UPDATEONREPETITION_DISABLED 0x00000000U /* 禁止 */2 ^* p6 V+ @: w. f. {
#define HRTIM_UPDATEONREPETITION_ENABLED (HRTIM_MCR_MREPU) /* 使能 */

复制代码

PushPull
设置是否使能HRTIM的TIMER（A到E）的推挽模式。

#define HRTIM_TIMPUSHPULLMODE_DISABLED 0x00000000U /* 禁止推挽输出 */5 l- k7 D* F. W. E W- M
#define HRTIM_TIMPUSHPULLMODE_ENABLED (HRTIM_TIMCR_PSHPLL) /* 使能推挽输出 */
& f$ m2 P0 I, r- {6 y. K

复制代码

FaultEnable
使能HRTIM TIMER的Fault通道。

#define HRTIM_TIMFAULTENABLE_NONE 0x00000000U 4 X6 r4 Z4 f- j2 M
#define HRTIM_TIMFAULTENABLE_FAULT1 (HRTIM_FLTR_FLT1EN)
& `- N- ]2 w( _# s' w
#define HRTIM_TIMFAULTENABLE_FAULT2 (HRTIM_FLTR_FLT2EN)
+ m. \7 V* a+ r/ p: e, R1 A
#define HRTIM_TIMFAULTENABLE_FAULT3 (HRTIM_FLTR_FLT3EN) - c( c8 r6 g2 u& o; P, H
#define HRTIM_TIMFAULTENABLE_FAULT4 (HRTIM_FLTR_FLT4EN) ) N$ ?( X7 y( g+ H5 r- S3 m
#define HRTIM_TIMFAULTENABLE_FAULT5 (HRTIM_FLTR_FLT5EN)

复制代码

FaultLock
设置HRTIM TIMER的异常使能状态是否写保护。

#define HRTIM_TIMFAULTLOCK_READWRITE (0x00000000U) /* 可读可写 */
V. c M# ], x* o# x% t3 _
#define HRTIM_TIMFAULTLOCK_READONLY (HRTIM_FLTR_FLTLCK) /* 只读 */

复制代码

DeadTimeInsertion
设置HRTIM TIMER的死区插入。

#define HRTIM_TIMDEADTIMEINSERTION_DISABLED (0x00000000U) /* 输出1和输出2信号是独立的 */" x% U3 r, I+ M8 i! P! i5 t
#define HRTIM_TIMDEADTIMEINSERTION_ENABLED HRTIM_OUTR_DTEN /* 输出1和输出2之间插入死区时间 */

复制代码

DelayedProtectionMode
设置HRTIM TIMER的延迟保护模式。

#define HRTIM_TIMER_A_B_C_DELAYEDPROTECTION_DISABLED (0x00000000U) /* 代码太长，其它定义省略未写 */

复制代码

UpdateTrigger
设置Master或者TIMER（A到E）更新时，同步更新寄存器。

#define HRTIM_TIMUPDATETRIGGER_NONE 0x00000000U ! O# _% O$ E' o3 z
#define HRTIM_TIMUPDATETRIGGER_MASTER (HRTIM_TIMCR_MSTU) L; B6 k& W8 G2 ]/ B# b
#define HRTIM_TIMUPDATETRIGGER_TIMER_A (HRTIM_TIMCR_TAU) n% v% U' w% ?) q0 j* e0 ]; P
#define HRTIM_TIMUPDATETRIGGER_TIMER_B (HRTIM_TIMCR_TBU)
. A5 R6 J7 S1 s5 K) m$ s4 h
#define HRTIM_TIMUPDATETRIGGER_TIMER_C (HRTIM_TIMCR_TCU) ( I: v0 \3 U6 S% [1 I
#define HRTIM_TIMUPDATETRIGGER_TIMER_D (HRTIM_TIMCR_TDU) 2 V3 }$ T0 Y3 Z. X# v, p
#define HRTIM_TIMUPDATETRIGGER_TIMER_E (HRTIM_TIMCR_TEU)
: u" b& _8 e3 J/ z6 z* L0 e5 ^1 u

复制代码

ResetTrigger
设置那个事件可以触发定时器计数复位。

#define HRTIM_TIMRESETTRIGGER_NONE 0x00000000U /* 无触发 *// _' q' w' v, v! t/ ~) m/ b
/* 代码太长，其它定义省略未写 *// C3 c" | F+ C" K$ a; n

复制代码

ResetUpdate
当HRTIM TIMER的计数器复位时或者计数回滚到0时，是否触发寄存器更新。

7 e# {$ u7 \& `: G; ^& Z2 y7 Z6 K
#define HRTIM_TIMUPDATEONRESET_DISABLED 0x00000000U /* 禁止 */1 t, `: S2 a. `! {, {8 i8 m
#define HRTIM_TIMUPDATEONRESET_ENABLED (HRTIM_TIMCR_TRSTU) /* 使能 */

复制代码

63.3.6 定时器输出配置HRTIM_OutputCfgTypeDef
此结构体主要用于定时器输出配置：

typedef struct2 y2 P, D- \, I
{
4 ]+ | n9 g6 y; H2 ^5 W& \7 I. S1 S
uint32_t Polarity; 0 u! _+ u& ?" M- w" G/ Q2 P; e
uint32_t SetSource; - w8 c# n- J8 G
uint32_t ResetSource;
! ]+ ]3 ]- V" v# _' |
uint32_t IdleMode;
# h4 K3 ~% G- L: c$ y/ K8 s
uint32_t IdleLevel; 0 `2 b( D+ T4 U: d7 ~; t
uint32_t FaultLevel; 4 V# `8 i8 O- M0 @' C1 j
uint32_t ChopperModeEnable;
5 z. f; k$ {/ e! z6 e5 ^
uint32_t BurstModeEntryDelayed;
$ r0 T0 f! {0 F! u, U
} HRTIM_OutputCfgTypeDef;

复制代码

下面将这几个参数一一做个说：

Polarity
输出极性是用来设置激活状态Active对应的高电平还是低电平

#define HRTIM_OUTPUTPOLARITY_HIGH (0x00000000U) ; H3 H7 H4 p1 A2 B& \ n) n' w
#define HRTIM_OUTPUTPOLARITY_LOW (HRTIM_OUTR_POL1)

复制代码

SetSource
可以将输出由Inactive状态转为Active状态的事件，即输出置位。

#define HRTIM_OUTPUTSET_NONE 0x00000000U
5 D+ L4 H1 L; a6 V2 T4 n
#define HRTIM_OUTPUTSET_RESYNC (HRTIM_SET1R_RESYNC)
5 I6 n, Q/ T7 _
#define HRTIM_OUTPUTSET_TIMPER (HRTIM_SET1R_PER) ; X+ @0 V% J" ]+ v0 k5 c! H- c
#define HRTIM_OUTPUTSET_TIMCMP1 (HRTIM_SET1R_CMP1)
& _2 T3 K; q- t- [
#define HRTIM_OUTPUTSET_TIMCMP2 (HRTIM_SET1R_CMP2)
' A7 S* a/ b r9 x8 G) d
#define HRTIM_OUTPUTSET_TIMCMP3 (HRTIM_SET1R_CMP3) . k7 i. H- U. X5 P3 I# q
#define HRTIM_OUTPUTSET_TIMCMP4 (HRTIM_SET1R_CMP4)
5 F2 }9 E% a/ [
/* 代码太长，其它定义省略未写 */
/ ~0 t7 x1 w, E7 L- m% I) X) }- y

复制代码

ResetSource
可以将输出由Active状态转为Inactive状态的事件，即输出复位。

" B( N9 O: S# L! n
#define HRTIM_OUTPUTRESET_NONE 0x00000000U
' ~. F6 J# p, D k8 Y
#define HRTIM_OUTPUTRESET_RESYNC (HRTIM_RST1R_RESYNC)
0 a# b3 {' ?! o9 c/ ?8 q! l
#define HRTIM_OUTPUTRESET_TIMPER (HRTIM_RST1R_PER)
) L( ^* h' _1 ^9 _2 v
#define HRTIM_OUTPUTRESET_TIMCMP1 (HRTIM_RST1R_CMP1) 7 l7 P% n6 b1 B1 y! j
#define HRTIM_OUTPUTRESET_TIMCMP2 (HRTIM_RST1R_CMP2)
! s8 e* J% }: r7 H2 \, Z
#define HRTIM_OUTPUTRESET_TIMCMP3 (HRTIM_RST1R_CMP3)
) h9 T; m8 @3 W0 ]( N* ~0 s
#define HRTIM_OUTPUTRESET_TIMCMP4 (HRTIM_RST1R_CMP4)

复制代码

/* 代码太长，其它定义省略未写 */

IdleMode
设置进入突发模式后，输出空闲状态。

#define HRTIM_OUTPUTIDLEMODE_NONE 0x00000000U /* 输出不受突发模式影响 */7 j8 j7 K$ p4 ^
#define HRTIM_OUTPUTIDLEMODE_IDLE (HRTIM_OUTR_IDLM1) /* 进入突发模式后，输出空闲状态*/

复制代码

IdleLevel
设置输出为空闲状态时，输出电平为Inactive或者Active。

#define HRTIM_OUTPUTIDLELEVEL_INACTIVE 0x00000000U $ w" C' C \. r! w
#define HRTIM_OUTPUTIDLELEVEL_ACTIVE (HRTIM_OUTR_IDLES1)

复制代码

FaultLevel
设置输出为Fault状态时，输出电平为Inactive，Active或者HIGHZ（高阻）。

#define HRTIM_OUTPUTFAULTLEVEL_NONE 0x00000000U i& M5 q" g w1 [3 w1 }+ h- b
#define HRTIM_OUTPUTFAULTLEVEL_ACTIVE (HRTIM_OUTR_FAULT1_0) 8 N) d" i/ j- E& D- z
#define HRTIM_OUTPUTFAULTLEVEL_INACTIVE (HRTIM_OUTR_FAULT1_1)
" a' [/ {: Q* e6 h
#define HRTIM_OUTPUTFAULTLEVEL_HIGHZ (HRTIM_OUTR_FAULT1_1 | HRTIM_OUTR_FAULT1_0)

复制代码

ChopperModeEnable
设置是否使能chopper模式

#define HRTIM_OUTPUTCHOPPERMODE_DISABLED 0x00000000U /* 禁止 */! G8 h3 x' {. @4 D
#define HRTIM_OUTPUTCHOPPERMODE_ENABLED (HRTIM_OUTR_CHP1) /* 使能 */

复制代码

BurstModeEntryDelayed
设置从突发模式切换到空闲模式前，是否插入一个死区时间。

#define HRTIM_OUTPUTBURSTMODEENTRY_REGULAR 0x00000000U /* 立即进入空闲状态 */
# c0 w8 k: Z5 R
#define HRTIM_OUTPUTBURSTMODEENTRY_DELAYED (HRTIM_OUTR_DIDL1) /* 进入空闲状态前，插入死区时间 */

复制代码

63.3.7 定时器比较配置HRTIM_CompareCfgTypeDef
此结构体主要用于定时器比较配置：

typedef struct' B! D. l$ G) ?1 k6 W0 t8 h
{
# x8 u% @5 J! d9 e* I0 n$ Q
uint32_t CompareValue; " R$ `7 ], a" k) y+ H
uint32_t AutoDelayedMode; # W0 ^7 O- F, A1 b- o+ I5 Q
uint32_t AutoDelayedTimeout;
7 g, f9 h$ e, R q* A+ }! b
} HRTIM_CompareCfgTypeDef;

复制代码

下面将这几个参数一一做个说：

CompareValue
设置定时器比较单元的比较值。

最小值要大于等于3个HRTIM时钟周期。

最大值要小于等于0xFFFF – 1。

AutoDelayedMode
设置比较单元2和4的自动延迟模式。

#define HRTIM_AUTODELAYEDMODE_REGULAR (0x00000000U)
9 b0 J2 M2 @5 q
#define HRTIM_AUTODELAYEDMODE_AUTODELAYED_NOTIMEOUT (HRTIM_TIMCR_DELCMP2_0)
( ]3 H2 u, K" y0 K
#define HRTIM_AUTODELAYEDMODE_AUTODELAYED_TIMEOUTCMP1 (HRTIM_TIMCR_DELCMP2_1)
$ N9 J. |8 j% N0 Y! s2 X" u9 @! D
#define HRTIM_AUTODELAYEDMODE_AUTODELAYED_TIMEOUTCMP3 (HRTIM_TIMCR_DELCMP2_1 | HRTIM_TIMCR_DELCMP2_0)

复制代码

AutoDelayedTimeout
当选择了溢出时间的自动延迟模式时，指定计时单元1或3的比较值。

注意：CompareValue + AutoDelayedTimeout必须小于0xFFFFU

63.3.8 定时器句柄结构体HRTIM_HandleTypeDef
HAL库在前面几个结构体的基础上封装了一个结构体HRTIM_HandleTypeDef，定义如下：

#if (USE_HAL_HRTIM_REGISTER_CALLBACKS == 1)5 t& R5 c$ D: Y) D/ ?
typedef struct __HRTIM_HandleTypeDef# S/ P) |: I( r# y' R' z+ k6 p5 ^
#else7 j9 s. h! D* }0 `2 B% ?0 e
typedef struct8 P0 J8 P4 X X4 }, T/ U# I4 p
#endif 5 {$ w- D$ f' w
{
: Z+ B- F4 L3 V; R9 S
HRTIM_TypeDef * Instance; /*!< Register base address */
0 l# @1 C8 L6 v/ N
; {. ?5 q* D( e
HRTIM_InitTypeDef Init; /*!< HRTIM required parameters */9 M+ D* Z8 o( b# p' I9 V
9 C9 h, \( w: _
HRTIM_TimerParamTypeDef TimerParam[MAX_HRTIM_TIMER]; /*!< HRTIM timers */
0 {7 k( N* I% b @9 {
8 w2 V# d2 |( B5 d5 a+ Z' r
HAL_LockTypeDef Lock; /*!< Locking object */& K0 }0 }# g' v6 Z
% B2 b4 l) t1 Q) V( J |
__IO HAL_HRTIM_StateTypeDef State; /*!< HRTIM communication state */
2 r; q7 w0 F+ E+ T; j+ b
, c0 n4 y1 [; u# [, `
DMA_HandleTypeDef * hdmaMaster; /*!< Master timer DMA handle parameters */
' Q9 L, n6 Y* f
DMA_HandleTypeDef * hdmaTimerA; /*!< Timer A DMA handle parameters */
, R% m9 X$ O8 l* j( y
DMA_HandleTypeDef * hdmaTimerB; /*!< Timer B DMA handle parameters */$ u4 r( m5 r& B8 v7 F# v% P! l
DMA_HandleTypeDef * hdmaTimerC; /*!< Timer C DMA handle parameters */' L, B3 Q) \ k! _! ^0 T1 P( B
DMA_HandleTypeDef * hdmaTimerD; /*!< Timer D DMA handle parameters */
1 o% w& [) Q1 g
DMA_HandleTypeDef * hdmaTimerE; /*!< Timer E DMA handle parameters */( d( @, [9 D' }$ R
' J; k7 B) P" w4 @
#if (USE_HAL_HRTIM_REGISTER_CALLBACKS == 1)9 c* ?( O7 e6 [4 J$ Z
void (* Fault1Callback)(struct __HRTIM_HandleTypeDef *hhrtim); 7 S: Z% @' m4 }; \1 ~
void (* Fault2Callback)(struct __HRTIM_HandleTypeDef *hhrtim); N5 C, a1 p" y' p$ i J% Z
void (* Fault3Callback)(struct __HRTIM_HandleTypeDef *hhrtim);
7 r7 B0 c/ L! }! o
void (* Fault4Callback)(struct __HRTIM_HandleTypeDef *hhrtim);
. R$ n' W* ]) B9 {9 Q W4 _
void (* Fault5Callback)(struct __HRTIM_HandleTypeDef *hhrtim); / k9 E, J! w+ O
void (* SystemFaultCallback)(struct __HRTIM_HandleTypeDef *hhrtim);
o! _) Q" l) E- z! O
void (* BurstModePeriodCallback)(struct __HRTIM_HandleTypeDef *hhrtim);
( K9 h& Y& X7 \6 E
void (* SynchronizationEventCallback)(struct __HRTIM_HandleTypeDef *hhrtim); ' V- N8 f5 r6 `; [- R1 I
void (* ErrorCallback)(struct __HRTIM_HandleTypeDef *hhrtim); ( f! p( i7 C! _. [. t/ H
void (* RegistersUpdateCallback)(struct __HRTIM_HandleTypeDef *hhrtim, uint32_t TimerIdx); ( |7 ~- {3 n; i" E' e% Q7 H
void (* RepetitionEventCallback)(struct __HRTIM_HandleTypeDef *hhrtim, uint32_t TimerIdx);
& t( U: h9 V* C+ U
void (* Compare1EventCallback)(struct __HRTIM_HandleTypeDef *hhrtim, uint32_t TimerIdx);
2 J% \! f( C- }: K0 Z
void (* Compare2EventCallback)(struct __HRTIM_HandleTypeDef *hhrtim, uint32_t TimerIdx); & W k+ g' X( @* o5 z
void (* Compare3EventCallback)(struct __HRTIM_HandleTypeDef *hhrtim, uint32_t TimerIdx); / m" e8 }0 c9 U, A) J7 ~: k3 S
void (* Compare4EventCallback)(struct __HRTIM_HandleTypeDef *hhrtim, uint32_t TimerIdx);
+ |9 Q3 \8 B- ?& `4 X! B
void (* Capture1EventCallback)(struct __HRTIM_HandleTypeDef *hhrtim, uint32_t TimerIdx); " S& S# V: |/ z; d9 Z% ?
void (* Capture2EventCallback)(struct __HRTIM_HandleTypeDef *hhrtim, uint32_t TimerIdx); & f: ^) N/ L8 A7 {! l
void (* DelayedProtectionCallback)(struct __HRTIM_HandleTypeDef *hhrtim, uint32_t TimerIdx);1 x8 V; v5 Z* j- L, x
void (* CounterResetCallback)(struct __HRTIM_HandleTypeDef *hhrtim, uint32_t TimerIdx); $ N. y4 d; Q+ g1 G7 I% `
void (* Output1SetCallback)(struct __HRTIM_HandleTypeDef *hhrtim, uint32_t TimerIdx); , S2 W; c& k/ y0 f. l+ M
void (* Output1ResetCallback)(struct __HRTIM_HandleTypeDef *hhrtim, uint32_t TimerIdx);
M0 b" [/ h1 o# F: h
void (* Output2SetCallback)(struct __HRTIM_HandleTypeDef *hhrtim, uint32_t TimerIdx);
8 j, I: c& Z3 N" k" |
void (* Output2ResetCallback)(struct __HRTIM_HandleTypeDef *hhrtim, uint32_t TimerIdx);
: ?0 M, i7 C$ C- s8 d8 v+ J
void (* BurstDMATransferCallback)(struct __HRTIM_HandleTypeDef *hhrtim, uint32_t TimerIdx); 0 j+ ?+ w/ |8 ]: p
void (* MspInitCallback)(struct __HRTIM_HandleTypeDef *hhrtim);
4 Y, L1 L, Z4 |" e% c6 M
void (* MspDeInitCallback)(struct __HRTIM_HandleTypeDef *hhrtim); 8 ]! K8 I; \0 c2 n1 n
#endif . F' w6 C3 S* H- f, j. L7 L$ ~
} HRTIM_HandleTypeDef;" }( F; y. ? B3 K8 s) l

复制代码

这里注意条件编译USE_HAL_HRTIM_REGISTER_CALLBACKS，用来设置使用自定义回调还是使用默认回调，此定义一般放在stm32h7xx_hal_conf.h文件里面设置：

#define USE_HAL_HRTIM_REGISTER_CALLBACKS 1

复制代码

下面将这几个参数一一做个说：

HRTIM_TypeDef * Instance;

复制代码

这个参数是寄存器的例化，方便操作寄存器，比如设置MCR寄存器。

SET_BIT(hrtim->sMasterRegs.MCR, 0)

复制代码

HRTIM_InitTypeDef Init
HRTIM初始化配置，在本章的63.3.2小节进行了说明。

HRTIM_TimerParamTypeDef TimerParam[MAX_HRTIM_TIMER]

复制代码

HRTIM的主定时器和5个定时器单元Timer A到E的配置。在本章的63.3.3小节进行了说明。

HAL_LockTypeDef Lock
__IO HAL_HRTIM_StateTypeDef State
这两个变量主要供函数内部使用。Lock用于设置锁状态，State用于设置HRTIM状态。

DMA_HandleTypeDef * hdmaMaster; 4 i, x; g/ S5 w& I# P* W3 U
DMA_HandleTypeDef * hdmaTimerA; , Y+ \, B# }8 ~* _/ i, M( b, ?
DMA_HandleTypeDef * hdmaTimerB; / T- K7 ~; y2 S( {8 c9 s7 f
DMA_HandleTypeDef * hdmaTimerC;
( K8 W$ L# ]$ G8 ~
DMA_HandleTypeDef * hdmaTimerD;
# J$ E" r! M! f6 f1 @' @
DMA_HandleTypeDef * hdmaTimerE;

复制代码

用于关联DMA。

其它所有参数
用于自定义回调。

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

__weak void HAL_HRTIM_MspInit(HRTIM_HandleTypeDef * hhrtim): {5 z$ }6 B6 X2 a
{
9 g/ E0 d! ], }6 C' G
/* Prevent unused argument(s) compilation warning */
4 v4 l( N' l; W, m# w9 }4 m. B7 p( W
UNUSED(hhrtim);
6 I0 ]( q+ E8 Q9 ~1 Y% V
# T5 u" y3 Y# R$ X
/* NOTE: This function should not be modified, when the callback is needed,+ Z2 b- {4 V z9 `8 p
the HAL_HRTIM_MspInit could be implemented in the user file# I1 M9 n% [' ?; f% t
*/
* |0 {' o7 ^+ l c3 m3 R+ z
}

复制代码

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

除了默认回调，用户也可为HRTIM句柄成员MspInitCallback注册一个回调函数，然后设置宏定义USE_HAL_HRTIM_REGISTER_CALLBACKS为1即可。这样以来，用户调用了HAL_HRTIM_Init后，此函数就会调用用户注册的回调函数。使用注册回调好处是每个定时器可以有独立的回调，无需多少个定时器共用

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

关于这个底层配置有以下几点要着重说明下：

定时器所使用引脚的复用模式选择已经被HAL库定义好，放在了stm32h7xx_hal_gpio_ex.h文件里面。但是里面却有三个复用：

#define GPIO_AF1_HRTIM1 ((uint8_t)0x01)3 T) T v. J4 I: [% C% z* i" q
#define GPIO_AF2_HRTIM1 ((uint8_t)0x02)
" F6 n* z, M4 }3 |; s4 {
#define GPIO_AF3_HRTIM1 ((uint8_t)0x03)

复制代码

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

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

  HRTIM的API主要分为两类，Simple mode和waveform mode

  Simple mode
与通用定时器的相同，只是分辨率更高，支持的模式如下：

a、输出比较模式。

b、PWM输出模式。

c、输入捕获模式。

d、单脉冲模式。

函数以HAL_HRTIM_Simple开头。

  Waveform mode
这个模式下的API可以充分发挥HRTIM的所有特性。所有功能都可以使用，而且没有任何限制。函数以HAL_HRTIM_Waveform开头。

  第1步：通过函数HAL_HRTIM_MspInit实现HRTIM的底层初始化是

函数__HRTIMx_CLK_ENABLE()使能时钟。
初始化使用了的IO引脚，__HAL_RCC_GPIOx_CLK_ENABLE和HAL_GPIO_Init。
使用DMA方式控制数据传输，比如HAL_HRTIM_SimpleBaseStart_DMA。
a、使能DMA接口时钟__DMAx_CLK_ENABLE。

b、初始化DMA句柄。

c、调用函数__HAL_LINKDMA关联DMA和HRTIM句柄。

d、调用函数HAL_DMA_Init初始化DMA。

e、HAL_NVIC_SetPriority配置DMA优先级，HAL_NVIC_EnableIRQ使能DMA中断。

  使用中断方式控制数据传输，比如HAL_HRTIM_SimpleBaseStart_IT，
      HAL_NVIC_SetPriority配置DMA优先级，HAL_NVIC_EnableIRQ使能DMA中断。

  第2步：初始化HRTIM使用函数HAL_HRTIM_Init

此函数除了配置HRTIM句柄的结构体成员，还包括外部同步配置，HRTIM既可以作为master发出同步信号，也可以作为slave，等待接收同步信号。

  第3步：配置HRTIM

  突发模式控制器
HAL_HRTIM_BurstModeConfig突发模式配置

外部事件条件
HAL_HRTIM_EventConfig 配置外部事件条件

HAL_HRTIM_EventPrescalerConfig 配置外部事件采样时钟

异常条件
HAL_HRTIM_FaultConfig 配置异常通道

HAL_HRTIM_FaultPrescalerConfig 预分频配置

HAL_HRTIM_FaultModeCtl 使能或者禁止输入电路

ADC触发
HAL_HRTIM_ADCTriggerConfig 配置触发ADC

  第4步，配置HRTIM时基

使用函数HAL_HRTIM_TimeBaseConfig配置定时器时间基准，不管用于Simple Mode还是Waveform Mode，都必须调用这个函数进行配置。

  HRTIM定时器计数操作模式。
  HRTIM定时器时钟分频。
  HRTIM定时器周期。
  HRTIM重复计数器。

  第5步，如果HRTIM工作在Simple Mode可以调用的API

  时间基准模式：
HAL_HRTIM_SimpleBaseStart(),HAL_HRTIM_SimpleBaseStop(),

HAL_HRTIM_SimpleBaseStart_IT(),HAL_HRTIM_SimpleBaseStop_IT(),

HAL_HRTIM_SimpleBaseStart_DMA(),HAL_HRTIM_SimpleBaseStop_DMA()。

  输出比较：
HAL_HRTIM_SimpleOCChannelConfig(),

HAL_HRTIM_SimpleOCStart(),HAL_HRTIM_SimpleOCStop(),

HAL_HRTIM_SimpleOCStart_IT(),HAL_HRTIM_SimpleOCStop_IT(),

HAL_HRTIM_SimpleOCStart_DMA(),HAL_HRTIM_SimpleOCStop_DMA()。

  PWM输出：
HAL_HRTIM_SimplePWMChannelConfig(),

HAL_HRTIM_SimplePWMStart(),HAL_HRTIM_SimplePWMStop(),

HAL_HRTIM_SimplePWMStart_IT(),HAL_HRTIM_SimplePWMStop_IT(),

HAL_HRTIM_SimplePWMStart_DMA(),HAL_HRTIM_SimplePWMStop_DMA()。

  输入捕获：
HAL_HRTIM_SimpleCaptureChannelConfig(),

HAL_HRTIM_SimpleCaptureStart(),HAL_HRTIM_SimpleCaptureStop(),

HAL_HRTIM_SimpleCaptureStart_IT(),HAL_HRTIM_SimpleCaptureStop_IT()。

  单脉冲模式：
HAL_HRTIM_SimpleOnePulseChannelConfig(),

HAL_HRTIM_SimpleOnePulseStart(),HAL_HRTIM_SimpleOnePulseStop(),

HAL_HRTIM_SimpleOnePulseStart_IT(),HAL_HRTIM_SimpleOnePulseStop_It()。

第6步，如果HRTIM工作在waveform模式可以调用的API

  HAL_HRTIM_WaveformTimerConfig
使能HRTIM中断和DMA请求。

使能HRTIM的HALF Mode。

定义HRTIM如何响应外部同步输入。

使能HRTIM的推挽模式。

使能HRTIM的异常通道。

使能dead-time插入。

设置HRTIM的延迟保护。

设置HRTIM的更新和复位触发。

设置HRTIM寄存器的更新策略。

配置外部事件消隐和开窗电路。

Blanking：在规定的时间内屏蔽外部事件。

Windowing：只能在规定的时间内使能外部事件。

HAL_HRTIM_DeadTimeConfig
配置HRTIM的死区插入，用于配置互补信号。

HAL_HRTIM_ChopperModeConfig
用于配置在定时之上添加的高频载波信号输出，HRTIM的每个输出都可以单独使能或者禁止 Chopper。

HAL_HRTIM_BurstDMAConfig
配置HRTIM的DMA突发模式。

HAL_HRTIM_WaveformCompareConfig
配置HRTIM的比较单元。

  HAL_HRTIM_WaveformCaptureConfig
配置HRTIM的捕获单元。

  HAL_HRTIM_WaveformOutputConfig
配置HRTIM输出。

HAL_HRTIM_WaveformSetOutputLevel
配置激活或者非激活态。

使能或者禁止waveform timer输出
HAL_HRTIM_WaveformOutputStart(),HAL_HRTIM_WaveformOutputStop().。

启动或者禁止HRTIM
HAL_HRTIM_WaveformCountStart(), HAL_HRTIM_WaveformCountStop(),

HAL_HRTIM_WaveformCountStart_IT(), HAL_HRTIM_WaveformCountStop_IT(),

HAL_HRTIM_WaveformCountStart_DMA(), HAL_HRTIM_WaveformCountStop_DMA()。

  突发模式控制器使能:
HAL_HRTIM_BurstModeCtl()。

  软件触发：
HAL_HRTIM_BurstModeSoftwareTrigger()

HAL_HRTIM_SoftwareCapture()

HAL_HRTIM_SoftwareUpdate()

HAL_HRTIM_SoftwareReset()。

  第7步，根据需要可以做动态注册回调

首先使能宏定义USE_HAL_HRTIM_REGISTER_CALLBACKS。

然后调用函数HAL_HRTIM_RegisterCallback() 就可以注册如下回调函数：

(+) Fault1Callback

(+) Fault2Callback

(+) Fault3Callback

(+) Fault4Callback

(+) Fault5Callback

(+) SystemFaultCallback

(+) BurstModePeriodCallback

(+) SynchronizationEventCallback

(+) ErrorCallback

(+) MspInitCallback

(+) MspDeInitCallback

函数HAL_HRTIM_TIMxRegisterCallback允许注册的回调函数如下：

(+) RegistersUpdateCallback

(+) RepetitionEventCallback

(+) Compare1EventCallback

(+) Compare2EventCallback

(+) Compare3EventCallback

(+) Compare4EventCallback

(+) Capture1EventCallback

(+) Capture2EventCallback

(+) DelayedProtectionCallback

(+) CounterResetCallback

(+) Output1SetCallback

(+) Output1ResetCallback

(+) Output2SetCallback

(+) Output2ResetCallback

(+) BurstDMATransferCallback

关于动态注册回调函数注意以下几点：

  卸载注册使用HAL_HRTIM_UnRegisterCallback和HAL_HRTIM_TIMxUnRegisterCallback
  默认情况下，HAL_HRTIM_Init调用后将使用默认的弱定义回调，如果用户注册了回调，将使用用户设置的。
  回调函数只能在HAL_HRTIM_STATE_READY状态下才可以注册/注销。
回调函数MspInit和MspDeInit除外，这两个函数可以在HAL_HRTIM_STATE_READY 或 HAL_HRTIM_STATE_RESET状态下注册，这样的话，用户调用函数HAL_HRTIM_DeInit()或者HAL_HRTIM_Init()时，就可以在其函数内运行MspInit/DeInit。
用户可以在调用HAL_HRTIM_DeInit()或者HAL_HRTIM_Init()之前调用HAL_HRTIM_RegisterCallback()为MspInit/MspDeInit注册回调。

HRTIM常用的功能，通过上面这几步即可实现。

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

  HAL_HRTIM_Init
  HAL_HRTIM_TimeBaseConfig
  HAL_HRTIM_WaveformTimerConfig
  HAL_HRTIM_WaveformCompareConfig
  HAL_HRTIM_WaveformOutputConfig
  HAL_HRTIM_WaveformOutputStart
  HAL_HRTIM_WaveformCounterStart
63.4.1 函数HAL_HRTIM_Init
函数原型：

HAL_StatusTypeDef HAL_HRTIM_Init(HRTIM_HandleTypeDef * hhrtim)' ?' a3 g( f f
{
: M) r4 w! a, h
uint8_t timer_idx;) k" b O; S' f& x. N
uint32_t hrtim_mcr;
- Z6 }* j& E0 ?9 u/ T( i
! E& C3 J% C7 K5 u- J! ^) y
/* 检查句柄是否有效 */7 G# K& f/ ]. U. [
if(hhrtim == NULL)8 x7 p2 g% \3 Q. ^, v1 R1 r
{ Y% _" v+ a+ p P. O
return HAL_ERROR;' U2 B* p% D5 E! d
}
3 }- K. l$ [/ p L9 p0 L- l
( M- N" S5 Q+ G4 z
/* 检测参数 */
: T5 k8 i. z2 }& c
assert_param(IS_HRTIM_ALL_INSTANCE(hhrtim->Instance));
; u" E! T y3 y
assert_param(IS_HRTIM_IT(hhrtim->Init.HRTIMInterruptResquests));: d) p1 L( M1 W
" Y) Q! _8 h+ E0 s+ U5 J8 m+ h
/* 使用注册回调，这样每个定时器可以有独立的回调，无需多个定时器共用 */( c4 _4 g5 C) T \
#if (USE_HAL_HRTIM_REGISTER_CALLBACKS == 1): H |" _7 n' J
if (hhrtim->State == HAL_HRTIM_STATE_RESET)4 s8 Y1 u* j$ X0 X) Z6 R. \
{$ f) t6 \" n- Z; p3 j% C
/* 初始化回调函数到默认值，' T. ?4 p* p* f" q( W
也就是说，如果用户使能了回调函数的注册功能，但是没有指定具体回调，就是用默认的 */. J6 u1 ?) m( D! A' @+ a
hhrtim->Fault1Callback = HAL_HRTIM_Fault1Callback;
; K- f# {) F! O$ v: Q
hhrtim->Fault2Callback = HAL_HRTIM_Fault2Callback;6 a! Q4 P* W# T8 W' b6 g/ Q
hhrtim->Fault3Callback = HAL_HRTIM_Fault3Callback;
6 }' b" d. h( N+ T, [
hhrtim->Fault4Callback = HAL_HRTIM_Fault4Callback;. Y7 \$ ]' r8 N$ p2 d: |
hhrtim->Fault5Callback = HAL_HRTIM_Fault5Callback;+ e0 B* ]8 o: C/ I' V9 |' \" I0 l8 `
hhrtim->SystemFaultCallback = HAL_HRTIM_SystemFaultCallback;
, @( W9 N G8 r/ T0 D
hhrtim->BurstModePeriodCallback = HAL_HRTIM_BurstModePeriodCallback;. k# F; \9 `8 c, d* M
hhrtim->SynchronizationEventCallback = HAL_HRTIM_SynchronizationEventCallback;+ R$ M: ]* U4 s
hhrtim->ErrorCallback = HAL_HRTIM_ErrorCallback;" t/ [& R' O/ E3 j
hhrtim->RegistersUpdateCallback = HAL_HRTIM_RegistersUpdateCallback;
: i2 K8 B: }; S+ J5 z
hhrtim->RepetitionEventCallback = HAL_HRTIM_RepetitionEventCallback;
1 P# F9 x3 L5 [5 [6 }
hhrtim->Compare1EventCallback = HAL_HRTIM_Compare1EventCallback;& c" R- z% s3 U! W; M" ~
hhrtim->Compare2EventCallback = HAL_HRTIM_Compare2EventCallback;
4 m1 K: j, y3 E! [9 n% A
hhrtim->Compare3EventCallback = HAL_HRTIM_Compare3EventCallback;
3 P; a- a$ H9 I, |" e H, V6 [
hhrtim->Compare4EventCallback = HAL_HRTIM_Compare4EventCallback;* j1 p' K4 t( e7 U) Y
hhrtim->Capture1EventCallback = HAL_HRTIM_Capture1EventCallback;( A# I9 O1 O- [6 x' U7 z
hhrtim->Capture2EventCallback = HAL_HRTIM_Capture2EventCallback;
! X. r* k8 r, }" E
hhrtim->DelayedProtectionCallback = HAL_HRTIM_DelayedProtectionCallback;
2 K3 i0 P* M; j/ a8 Q
hhrtim->CounterResetCallback = HAL_HRTIM_CounterResetCallback;
$ j5 O, C% c5 U5 R+ A
hhrtim->Output1SetCallback = HAL_HRTIM_Output1SetCallback;
2 Z& [& p R: x0 x
hhrtim->Output1ResetCallback = HAL_HRTIM_Output1ResetCallback;) y4 D9 B: j S$ a- m6 l
hhrtim->Output2SetCallback = HAL_HRTIM_Output2SetCallback;
( F6 k* y, E' |# O# @
hhrtim->Output2ResetCallback = HAL_HRTIM_Output2ResetCallback;+ `8 R* v/ Z0 b$ M" F! E
hhrtim->BurstDMATransferCallback = HAL_HRTIM_BurstDMATransferCallback;) H* f b4 C# h, y1 A" B* ?
if (hhrtim->MspInitCallback == NULL)
. J& K. ` ]5 }. i- K2 [& T
{$ L7 b, d) \ H' }- V/ r8 ~$ m2 a
hhrtim->MspInitCallback = HAL_HRTIM_MspInit;
# |% n- y: |# j7 I
}7 _% s; o4 J, u" s6 t+ m
}- V" k* p2 R6 }+ ^8 e' |0 [$ d2 |5 K J
#endif /* USE_HAL_HRTIM_REGISTER_CALLBACKS */
( D" _3 h q& H: B1 g5 H7 T* o
; M/ B! p H/ R+ o9 H% I2 R
/* 设置HRTIM忙 */
2 C$ E! H; ~% R' o9 }/ g( t
hhrtim->State = HAL_HRTIM_STATE_BUSY;
/ n6 r; G2 W( N. C
/ ~, W( f9 Q5 Y
/* 初始化DMA句柄 */
3 F8 d( Y& v& o. c% u; U" V
hhrtim->hdmaMaster = (DMA_HandleTypeDef *)NULL;) M! y; X1 [9 N3 A+ e" u; P
hhrtim->hdmaTimerA = (DMA_HandleTypeDef *)NULL;2 v+ i$ B, u. c3 i
hhrtim->hdmaTimerB = (DMA_HandleTypeDef *)NULL;
9 ^8 n7 N( R) u/ j& x
hhrtim->hdmaTimerC = (DMA_HandleTypeDef *)NULL;
; {3 f8 L: K N+ T4 a3 k
hhrtim->hdmaTimerD = (DMA_HandleTypeDef *)NULL;
* z. H6 @* k0 l: y2 x
hhrtim->hdmaTimerE = (DMA_HandleTypeDef *)NULL;3 F, P! u7 w7 \- C7 _" f
/ H. I9 @8 Q+ t/ a
/* HRTIM输出同步配置 */; b5 F: l1 P: z, @7 L9 y4 i
if ((hhrtim->Init.SyncOptions & HRTIM_SYNCOPTION_MASTER) != (uint32_t)RESET) e% v) a$ I/ Z t
{
' w4 f! m0 c4 N) [" H& H- \
/* 检测参数 */
5 N# \+ k( Z7 B# E
assert_param(IS_HRTIM_SYNCOUTPUTSOURCE(hhrtim->Init.SyncOutputSource));
4 \6 r3 d9 g% _0 p4 u2 B
assert_param(IS_HRTIM_SYNCOUTPUTPOLARITY(hhrtim->Init.SyncOutputPolarity));( }4 G- M6 N5 }& q
# b' E1 }3 x, u0 [
/* 同步输出初始化必须优先于MCU输出配置(通过HAL_HRTIM_MspInit) */( d* H k/ U; P! Y# N9 w
if (hhrtim->Instance == HRTIM1)6 f1 H# t+ I' n: W6 T: B, F
{- D4 j; m. m% c1 {9 ?( W
/* 使能HRTIM外设时钟 */6 p0 i3 G) ~- f) D
__HAL_RCC_HRTIM1_CLK_ENABLE();
. _ _% i' c2 ~' D+ s; l/ B- y
}
- W' C7 b; x3 Z& M* c3 w
- f) S# K/ t7 b7 y' I3 D4 b
hrtim_mcr = hhrtim->Instance->sMasterRegs.MCR;9 ?; b7 {5 d+ a* @& m5 K1 _% }
1 _0 ?3 S7 ^ C3 [2 _* m: H! R& P7 E
/* 设置同步输出事件 */
( ?7 m7 F) \5 @' E/ u. T0 I
hrtim_mcr &= ~(HRTIM_MCR_SYNC_SRC);
$ r2 c4 P( ~* @5 W$ g3 h
hrtim_mcr |= (hhrtim->Init.SyncOutputSource & HRTIM_MCR_SYNC_SRC);
. p- c7 }' q! O+ K1 ~/ ~2 B
. N; y+ D/ s% k+ q7 {7 D# P0 V6 B
/* 设置同步输出极性 */# ?: `8 z# {8 K2 K) U
hrtim_mcr &= ~(HRTIM_MCR_SYNC_OUT);
" M/ G# x0 L: e A' p
hrtim_mcr |= (hhrtim->Init.SyncOutputPolarity & HRTIM_MCR_SYNC_OUT);
! ~7 P K/ k% o
; }/ A. Y, x% p+ @3 }6 i
/* 更新HRTIM寄存器 */: L& w% _: m6 W5 Q5 h( |
hhrtim->Instance->sMasterRegs.MCR = hrtim_mcr;( Z# P4 T( ]: v& @7 ?
}+ K5 ?- X- \5 e. i- U* [
: E% T4 G+ b/ J! I0 D2 s
/* 初始化底层硬件: GPIO, CLOCK, NVIC 和 DMA */$ a0 {8 i. L0 f' S
#if (USE_HAL_HRTIM_REGISTER_CALLBACKS == 1)' e. ]7 b% J( H8 ]+ s% H
hhrtim->MspInitCallback(hhrtim);
1 f& v% j( ^* C# P
#else$ [) @7 ]" t5 t! [: ^/ d
HAL_HRTIM_MspInit(hhrtim);0 _( }/ N* {. j" ^" ?- n
#endif /* USE_HAL_HRTIM_REGISTER_CALLBACKS */. @8 }! H7 O4 a" V1 a4 m$ L9 T% C
' {& h" j7 {7 Q: o% f
/* HRTIM同步输入配置 HRTIM */
0 F- z; _. o H9 `6 [# _
if ((hhrtim->Init.SyncOptions & HRTIM_SYNCOPTION_SLAVE) != (uint32_t)RESET)+ e" o) |* X- g ]7 V1 `
{
/* 检测参数 */
4 P6 \4 Y5 i! S, ]3 Z
assert_param(IS_HRTIM_SYNCINPUTSOURCE(hhrtim->Init.SyncInputSource));
6 M( I) D: [+ g1 M9 t
- [( `4 g3 w( r6 \' t2 X
hrtim_mcr = hhrtim->Instance->sMasterRegs.MCR;# E1 u2 l3 H4 L: f4 R2 V
Z4 N3 W( ^$ j+ {# h( n1 r- w
/* 设置同步输入源 */# P' K$ W9 Q: u1 \6 c P3 }
hrtim_mcr &= ~(HRTIM_MCR_SYNC_IN);
8 K7 Q ^! I5 w
hrtim_mcr |= (hhrtim->Init.SyncInputSource & HRTIM_MCR_SYNC_IN);
2 t/ J- W1 d+ C% s
+ f3 i! v: V4 H( S3 N9 p& c+ G" H6 b3 i
/* 更新HRTIM寄存器 */
) F# y+ |7 ?4 F( I8 [/ f
hhrtim->Instance->sMasterRegs.MCR = hrtim_mcr;7 c! W( N" B! `$ r2 \7 @, S# `
}* H$ }2 W- ]$ h; R" c
( c" f& l; C; ]: C9 o: d
/* 设置HRTIM寄存器就绪 */
9 o- M& D- T) n: t; p% A. q
hhrtim->State = HAL_HRTIM_STATE_READY;. c, Y. x, @$ \- d
2 a* u! Q2 a. l) J/ l2 H
/* 初始化HRTIM HAL API的锁状态，即开锁 */6 ^! n" O9 R3 g+ u+ `6 o% l% N4 w
__HAL_UNLOCK(hhrtim);
7 V+ P3 `6 ]: j
7 m: @/ f8 y/ t, o3 j
/* 初始化HRTIM TIMER相关参数 */
+ J% q/ @0 H9 m7 @4 h2 }
for (timer_idx = HRTIM_TIMERINDEX_TIMER_A ;8 s ]; E/ f+ ?$ r2 D0 r" Q
timer_idx <= HRTIM_TIMERINDEX_MASTER ;( g- `% t4 X( G$ q. y
timer_idx++)) O+ f) H% j* A7 @9 E* G, l
{
8 F9 O# L3 x6 M# k
hhrtim->TimerParam[timer_idx].CaptureTrigger1 = HRTIM_CAPTURETRIGGER_NONE;: s _" r" k+ o/ K
hhrtim->TimerParam[timer_idx].CaptureTrigger2 = HRTIM_CAPTURETRIGGER_NONE;
: }. m/ K$ S' x; f, E O1 B) i
hhrtim->TimerParam[timer_idx].InterruptRequests = HRTIM_IT_NONE;( G9 o6 X; p( k' F3 X
hhrtim->TimerParam[timer_idx].DMARequests = HRTIM_IT_NONE;9 U1 Q/ r7 }7 J& O; Y
hhrtim->TimerParam[timer_idx].DMASrcAddress = 0U;
. Y+ @1 d8 C& u& U* C; I
hhrtim->TimerParam[timer_idx].DMASize = 0U;
+ Y3 ^, t$ V7 q p! P
}
1 V2 n; y; l+ ]6 A) F- x7 G
, T/ ~) S, X7 @9 z
return HAL_OK;
9 l# I2 J( j) \, M) ?
}

复制代码

函数描述：

此函数用于初始化HRTIM。

函数参数：

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

1、宏定义USE_HAL_HRTIM_REGISTER_CALLBACKS可以放在stm32h7xx_hal_conf.h文件里面使能

#define USE_HAL_HRTIM_REGISTER_CALLBACKS  1

使用注册回调好处是每个定时器可以有独立的回调，无需多个定时器共用。

2、函数HAL_HRTIM_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能，由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。

3、如果形参htim的结构体成员State没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量HRTIM_HandleTypeDef HRTimHandle。

对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_HRTIM_STATE_RESET  = 0x00U。

解决办法有三：

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

方法2：定义HRTIM_HandleTypeDef HRTimHandle为全局变量。

方法3：下面的方法

if(HAL_HRTIM_DeInit(&HRTimHandle) != HAL_OK)
1 P7 u7 J1 R# N" m- ?
{) O8 g+ @ P- r2 S: r, f& m, z
Error_Handler();
6 g: z' U! x3 {; g, L3 e
}
9 }/ ^+ B9 V) @- Q+ V6 |5 ~
if(HAL_HRTIM_Init(&HRTimHandle) != HAL_OK). [: y. t" ?7 }( Y9 F
{; v! E9 Z. v( j: a
Error_Handler();: V( D# U* J2 ~
}

复制代码

使用举例：

HRTIM_HandleTypeDef HrtimHandle = {0};7 I- w0 q' \2 C
% }6 Z! k! X9 G! ?' ]
/* 例化，使用的HRTIM1 */
, ]2 S, H2 C' Z6 c3 B5 G! R5 f
HrtimHandle.Instance = HRTIM1;
/ G" `; w' A: O* E9 l' y
- u# ^6 l0 V9 f, a1 c) u8 m& ^2 v3 D G
/* 用于配置支持的中断请求，当前配置无中断 */
# c6 W1 x6 O" Q3 c0 y
HrtimHandle.Init.HRTIMInterruptResquests = HRTIM_IT_NONE;
( Y4 J0 z6 I# ^0 {8 U8 O
# y1 X+ j; j( C7 z- `/ ?7 ^3 A @
/* 配置HRTIM作为Master，发送同步信号，或者作为Slave，接收同步信号，当前配置没有做同步功能 */
8 j* v& R5 m% R- |" u
HrtimHandle.Init.SyncOptions = HRTIM_SYNCOPTION_NONE;
' B: X. Q: J! E0 O
& W) e4 p2 v# |4 T! N
HAL_HRTIM_Init(&HrtimHandle);

复制代码

63.4.2 函数HAL_HRTIM_TimeBaseConfig
函数原型：

HAL_StatusTypeDef HAL_HRTIM_TimeBaseConfig(HRTIM_HandleTypeDef *hhrtim,
                                       uint32_t TimerIdx,
                                       HRTIM_TimeBaseCfgTypeDef * pTimeBaseCfg)
{
  /* 检查参数 */
  assert_param(IS_HRTIM_TIMERINDEX(TimerIdx));
  assert_param(IS_HRTIM_PRESCALERRATIO(pTimeBaseCfg->PrescalerRatio));
  assert_param(IS_HRTIM_MODE(pTimeBaseCfg->Mode));

  if(hhrtim->State == HAL_HRTIM_STATE_BUSY)
  {
   return HAL_BUSY;
  }

  /* 设置HRTIM状态忙 */
  hhrtim->State = HAL_HRTIM_STATE_BUSY;

  if (TimerIdx == HRTIM_TIMERINDEX_MASTER)
  {
/* 配置MASTER TIMER时基 */
HRTIM_MasterBase_Config(hhrtim, pTimeBaseCfg);
  }
  else
  {
/* 配置Timing单元时基（Timer A到Timer E） */
HRTIM_TimingUnitBase_Config(hhrtim, TimerIdx, pTimeBaseCfg);
  }

  /* 设置HRTIM就绪 */
  hhrtim->State = HAL_HRTIM_STATE_READY;

  return HAL_OK;
}

函数描述：

配置定时器时基单元。

函数参数：

  第1个参数是HRTIM_HandleTypeDef类型结构体指针变量。
  第2个参数是使用的定时器索引，支持的参数如下：
  HRTIM_TIMERINDEX_MASTER。
  HRTIM_TIMERINDEX_TIMER_A。
  HRTIM_TIMERINDEX_TIMER_B。
  HRTIM_TIMERINDEX_TIMER_C。
  HRTIM_TIMERINDEX_TIMER_D。
  HRTIM_TIMERINDEX_TIMER_E。
  第3个参数是HRTIM_TimeBaseCfgTypeDef类型结构指针变量。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：

启动定时器前，优先调用此函数。
配置定时器计数器工作在连续或者单次模式以及时钟分频，周期和重复计数器。
使用举例：

HRTIM_TimeBaseCfgTypeDef sConfig_time_base = {0};+ _; s# w; R( O
( q7 n. e2 q; f3 w5 T/ P+ ?
/** f* V+ M0 d' h
PWM的频率 = 400MHz / HRTIM_TIMD_PERIOD
1 D3 N4 [) R1 A! G8 C$ Y/ ]
= 400000000 / 4000
: @& d8 [( N7 p# X/ x
= 100KHz" S1 J* x2 l- j
*/
$ z o( x# W) f4 L
sConfig_time_base.Mode = HRTIM_MODE_CONTINUOUS; /* 连续工作模式 */
4 G- o% I5 P1 {6 N
sConfig_time_base.Period = HRTIM_TIMD_PERIOD; /* 设置周期 */5 c3 U5 ?& _: h
/ b: W3 s' n- F$ l) u. [
/* 设置HRTIM分频，当前设置的1分频，也就是不分频 */5 w$ m" @# f6 y+ ?* o& q# N2 t& f+ K
sConfig_time_base.PrescalerRatio = HRTIM_PRESCALERRATIO_DIV1;- m, A7 j! Z+ M# ~: v& C4 T% h
sConfig_time_base.RepetitionCounter = 0; /* 设置重复计数器为0，即不做重复计数 */
# ~0 j6 }! P! ~/ e, ~' @
! l5 p- T) w K- s& k0 \: A
HAL_HRTIM_TimeBaseConfig(&HrtimHandle, HRTIM_TIMERINDEX_TIMER_D, &sConfig_time_base);

复制代码

63.4.3 函数HAL_HRTIM_WaveformTimerConfig
函数原型：

HAL_StatusTypeDef HAL_HRTIM_WaveformTimerConfig(HRTIM_HandleTypeDef * hhrtim,
& h& S- c* p% n# W/ s0 h6 a
uint32_t TimerIdx,: R. l$ Y, q& {/ A* t. Z
HRTIM_TimerCfgTypeDef * pTimerCfg)
5 G+ n+ T9 u2 W2 b: L
{
, Y% P1 }; q# V# b" B
/* 检查参数是否有效 */
# | q$ p" d6 ~( o" L8 o" e
assert_param(IS_HRTIM_TIMERINDEX(TimerIdx));* P4 i5 b4 `6 l0 c! A! |6 Y
assert_param(IS_HRTIM_HALFMODE(pTimerCfg->HalfModeEnable));
/ A4 G/ n" ~5 }
assert_param(IS_HRTIM_SYNCSTART(pTimerCfg->StartOnSync));
: ` S2 q; P3 r; x1 i+ u
assert_param(IS_HRTIM_SYNCRESET(pTimerCfg->ResetOnSync));" Y; v! e4 q1 @, ^8 ]# z0 w9 g
assert_param(IS_HRTIM_DACSYNC(pTimerCfg->DACSynchro));
% D! K8 }# \* |2 Y% a7 m+ N" f
assert_param(IS_HRTIM_PRELOAD(pTimerCfg->PreloadEnable));
) r! x$ {! K, U1 o$ o
assert_param(IS_HRTIM_TIMERBURSTMODE(pTimerCfg->BurstMode));
% i8 C& L1 W. X# P1 ^ K
assert_param(IS_HRTIM_UPDATEONREPETITION(pTimerCfg->RepetitionUpdate));
. P2 u$ B) m! |$ S Q- g0 y9 q
% h& k# l, C. M5 g
/* 检测HRTIM是否处于忙状态 */! J6 P' M$ }6 |+ M& G
if(hhrtim->State == HAL_HRTIM_STATE_BUSY) c7 o6 B, l f. z# Y- o7 l
{& R! H& V( O7 g* d, c( ]5 O$ J
return HAL_BUSY;; j- l/ V. V5 x' x0 D
}8 u$ _ x1 u5 ^& A
: k) B, p. e, `4 x* C
/* 操作期间，上锁 */
5 n) h |7 V8 w& M8 _/ c. t
__HAL_LOCK(hhrtim);0 c4 P" P. F! Z+ N# o3 @
% K# ]! a% i; {. }6 w
hhrtim->State = HAL_HRTIM_STATE_BUSY;4 k. i7 d3 u+ `6 e+ Q: U8 @
9 _/ |" x% @, R/ _9 m8 F" ]- h: v' c
if (TimerIdx == HRTIM_TIMERINDEX_MASTER)
+ I! o2 M' m! h% t1 u! D4 g5 [
{& J- @1 U$ d/ E! f0 ^
/* 检查参数 */
; P6 R' I7 t6 v
assert_param(IS_HRTIM_UPDATEGATING_MASTER(pTimerCfg->UpdateGating));
; U& l/ y7 o3 a) ~7 l
assert_param(IS_HRTIM_MASTER_IT(pTimerCfg->InterruptRequests));
' f: h/ l* j/ D5 _ L: @/ T
assert_param(IS_HRTIM_MASTER_DMA(pTimerCfg->DMARequests));
2 M# @( T+ m& ^$ ~* P/ L
7 A5 @' o; X) k4 G% C0 w7 y7 E8 n
/* 配置Master Timer */, k) N! C( o1 x1 t- `9 Z3 z. e
HRTIM_MasterWaveform_Config(hhrtim, pTimerCfg);
; ~8 h7 V- d; Z* }3 l9 i& P
}/ Z M: X) l4 b1 L6 ]& e5 v7 Y: }
else4 y, r% V9 ~6 F/ F1 d0 V
{. f( T0 C% V/ }4 @ ?; k3 J
/* 检查参数 */
0 G" _4 ?; U! N; D
assert_param(IS_HRTIM_UPDATEGATING_TIM(pTimerCfg->UpdateGating));2 D3 x/ t2 V' {
assert_param(IS_HRTIM_TIM_IT(pTimerCfg->InterruptRequests));
2 @0 K9 b5 ~/ A( H9 S; A
assert_param(IS_HRTIM_TIM_DMA(pTimerCfg->DMARequests));
( b: j1 H/ P$ Y% }% P) a, t5 Q
assert_param(IS_HRTIM_TIMPUSHPULLMODE(pTimerCfg->PushPull));* R& X* s) c) o- F
assert_param(IS_HRTIM_TIMFAULTENABLE(pTimerCfg->FaultEnable));+ C3 N- l4 Z V8 \/ t) c- ^
assert_param(IS_HRTIM_TIMFAULTLOCK(pTimerCfg->FaultLock));
5 m9 k* N9 g8 o4 ]+ K
assert_param(IS_HRTIM_TIMDEADTIMEINSERTION(pTimerCfg->PushPull,& {! T7 S: b6 k& H/ X
pTimerCfg->DeadTimeInsertion));. B- y$ Y5 ^# i \2 t( V
assert_param(IS_HRTIM_TIMDELAYEDPROTECTION(pTimerCfg->PushPull,
1 N8 Q: ~, [4 ^7 u- s- C2 U
pTimerCfg->DelayedProtectionMode));# @7 o i7 |* H4 J" |7 r
assert_param(IS_HRTIM_TIMUPDATETRIGGER(pTimerCfg->UpdateTrigger));
4 s6 @$ T' u3 m- X6 m
assert_param(IS_HRTIM_TIMRESETTRIGGER(pTimerCfg->ResetTrigger));
, \4 C4 W; r& `5 q* S4 r* x
assert_param(IS_HRTIM_TIMUPDATEONRESET(pTimerCfg->ResetUpdate));
7 j7 ]" N8 J! |
2 u& C3 s7 S; u; n% p' i% a
/* 配置时序单元，从TIMER A到TIMER D */8 G" [4 i' {3 s; U8 W
HRTIM_TimingUnitWaveform_Config(hhrtim, TimerIdx, pTimerCfg);6 }; B* P# I# J3 I# O; t7 U
}
0 q& k9 X% r$ U3 S. N) |
; I/ |4 [, B! k& T$ J1 n
/* 更新定时器参数 */
# t: e$ H6 K' s- y
hhrtim->TimerParam[TimerIdx].InterruptRequests = pTimerCfg->InterruptRequests;
, E5 m# r3 A5 {% r8 _
hhrtim->TimerParam[TimerIdx].DMARequests = pTimerCfg->DMARequests;1 N8 q: P( N* T! a" X
hhrtim->TimerParam[TimerIdx].DMASrcAddress = pTimerCfg->DMASrcAddress;! J% Z1 _: G$ I% I4 p: x' g
hhrtim->TimerParam[TimerIdx].DMADstAddress = pTimerCfg->DMADstAddress;
hhrtim->TimerParam[TimerIdx].DMASize = pTimerCfg->DMASize;; j! Q' J, J9 i. H1 D
$ S. u" o4 P8 l) e( _
/* 强制软件更新 */, V! d- x I& ]9 b0 u! l: L" Y
HRTIM_ForceRegistersUpdate(hhrtim, TimerIdx);
: c K2 E7 I6 {' \
; A) k2 k' x7 }/ a
hhrtim->State = HAL_HRTIM_STATE_READY;
2 f" k+ M6 f2 V7 M4 g5 Z
2 x/ j0 _$ U% [! ]0 v% g( r
/* 解锁 */
7 n9 {' `# e* K7 I( t! }3 k
__HAL_UNLOCK(hhrtim);
% L/ d: d; p4 b" P$ f) p% t
0 }: D Z: L9 m# U7 u9 `7 u, _
return HAL_OK;
/ c3 X5 G! N w" q' Z( l# n
}
2 {# g4 l# U% c' t" f$ _' |
~. H7 g5 N3 u$ o. m2 V

复制代码

函数描述：

此函数用于配置HRTIM在waveform模式的工作方式。

函数参数：

  第1个参数是HRTIM_HandleTypeDef类型结构体指针变量。
  第2个参数是使用的定时器索引，支持的参数如下：
  HRTIM_TIMERINDEX_MASTER。
  HRTIM_TIMERINDEX_TIMER_A。
  HRTIM_TIMERINDEX_TIMER_B。
  HRTIM_TIMERINDEX_TIMER_C。
  HRTIM_TIMERINDEX_TIMER_D。
  HRTIM_TIMERINDEX_TIMER_E。
  第3个参数是HRTIM_TimerCfgTypeDef类型结构指针变量。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：

启动定时器前，优先调用此函数。
HRTIM工作在waveform模式才能发挥HRTIM全功能特性。
使用举例：

HRTIM_TimerCfgTypeDef sConfig_timerD = {0};
" o$ y; d; L1 x7 T
# R7 i) ^: ]8 _) D& h' s" u
sConfig_timerD.DMARequests = HRTIM_TIM_DMA_NONE; /* 不使用DMA */
; {! N# D: K4 B
sConfig_timerD.HalfModeEnable = HRTIM_HALFMODE_DISABLED;/* 关闭HALF模式 */
( {/ E/ `" {* z9 n5 e- w6 y
sConfig_timerD.StartOnSync = HRTIM_SYNCSTART_DISABLED; /* 设置同步输入端接收到上升沿信号后，不启动定时器 */
% n. Y6 @8 N* `2 {3 \: p! ]
sConfig_timerD.ResetOnSync = HRTIM_SYNCRESET_DISABLED; /* 设置同步输入端接收到上升沿信号后，不复位定时器 */
4 F% G0 U w! E* C9 [/ ?) z% i
sConfig_timerD.DACSynchro = HRTIM_DACSYNC_NONE; /* 不使用DAC同步事件 */
; L6 _ M; _6 g8 }+ g4 z! D6 r
sConfig_timerD.PreloadEnable = HRTIM_PRELOAD_ENABLED; /* 使能寄存器预加载 */
0 \2 ~# L) G! z* h1 Y7 W
sConfig_timerD.UpdateGating = HRTIM_UPDATEGATING_INDEPENDENT; /* 独立更新，与DMA突发传输完成无关 */1 Q. C {! ?0 N+ k. K$ D( C
sConfig_timerD.BurstMode = HRTIM_TIMERBURSTMODE_MAINTAINCLOCK; /* 在突发模式下，定时器正常运行 */& p! M7 a, i. t) }
sConfig_timerD.RepetitionUpdate = HRTIM_UPDATEONREPETITION_ENABLED;/* 设置重计数器事件可以触发寄存器更新 */
8 C% _6 _" V3 L. Q; M7 r5 Y! K& v: @1 k
/* 当HRTIM TIMER的计数器复位时或者计数回滚到0时，不触发寄存器更新 */+ l: s) T6 d7 ?+ A1 a1 u
sConfig_timerD.ResetUpdate = HRTIM_TIMUPDATEONRESET_DISABLED; - r* b9 q/ h( q) x! P9 y9 d6 a0 [
sConfig_timerD.InterruptRequests = HRTIM_TIM_IT_NONE; /* 不使用中断 */5 ~, n- y, Z/ ?; u
sConfig_timerD.PushPull = HRTIM_TIMPUSHPULLMODE_DISABLED; /* 不开启推挽模式 */
7 ?' c! |+ |0 g6 h. r
sConfig_timerD.FaultEnable = HRTIM_TIMFAULTENABLE_NONE; /* 不使用HRTIM TIMER的Fault通道 */
5 E4 F" b7 w w: g6 F' G
sConfig_timerD.FaultLock = HRTIM_TIMFAULTLOCK_READWRITE; /* 不开启HRTIM TIMER的异常使能状态写保护 */- Z' R Q, n& I6 O! Z# K$ w
sConfig_timerD.DeadTimeInsertion = HRTIM_TIMDEADTIMEINSERTION_DISABLED;/* 不开启死区时间插入 */' x! M: E: V" ^ Y0 t: I" q
/* 不开启HRTIM TIMER的延迟保护模式 */
1 y$ T' b% y" E* H. C& y- b- n E
sConfig_timerD.DelayedProtectionMode = HRTIM_TIMER_D_E_DELAYEDPROTECTION_DISABLED;
/ Z( f; W( f, _" t2 `
/* Master或TIMER（A到E）更新时，不同步更新寄存器 */' Y1 ~) U% E. s) v/ w. c6 {. ?: s" s
sConfig_timerD.UpdateTrigger= HRTIM_TIMUPDATETRIGGER_NONE;$ {3 s5 s- P8 |6 h. q& j) H1 w) z h
sConfig_timerD.ResetTrigger = HRTIM_TIMRESETTRIGGER_NONE; /* 无复位触发 */2 `! r0 Z& g3 k3 J4 r
HAL_HRTIM_WaveformTimerConfig(&HrtimHandle, HRTIM_TIMERINDEX_TIMER_D, &sConfig_timerD);" N: `$ T! J1 R$ ~

复制代码

63.4.4 函数HAL_HRTIM_WaveformCompareConfig
函数原型：

HAL_StatusTypeDef HAL_HRTIM_WaveformCompareConfig(HRTIM_HandleTypeDef * hhrtim,
9 X3 p8 Y2 _% E# ]5 s4 u: u
uint32_t TimerIdx,, o2 M5 q+ h0 }6 x6 l* e% ?8 W
uint32_t CompareUnit,
5 y- t( X: i7 p& d. I+ w$ ~, r ]
HRTIM_CompareCfgTypeDef* pCompareCfg) V; N/ `" Y' h% D# ?5 F, J+ V
{- ?) ^: d2 T6 T+ r" S1 x
/* 检查参数 */3 E( [4 V, X; i" D* S5 V
assert_param(IS_HRTIM_TIMERINDEX(TimerIdx));
! g& M( @. c8 p, [8 ?
7 F' Y0 ^0 D" j) K
if(hhrtim->State == HAL_HRTIM_STATE_BUSY)
) \. _* t* q8 a' [7 S
{5 v5 Z' O8 x9 x& {$ l0 s _/ X
return HAL_BUSY;
3 m5 q# m8 Z# n6 t( h# t
}1 K0 p- N# @0 T5 ]% S8 N
; I. x Y9 ]* f9 }- U; C7 X1 S; U
/* 处理过程上锁 */
( [4 a ^. N! _6 w
__HAL_LOCK(hhrtim);
! S% J9 j* \3 m+ S$ }
5 z9 i/ X8 y. B* s1 X
hhrtim->State = HAL_HRTIM_STATE_BUSY;7 y7 \8 O4 }( |. A! m
, h" ~( R& m: V4 b* q. B* f
/* 配置比较单元 */, S; r# O! e5 l; ]/ A0 @2 w3 v
if (TimerIdx == HRTIM_TIMERINDEX_MASTER)
! h8 |9 `' j: E; l8 \3 S% D
{
) H, ~8 J T: U& L8 |
/* 省略switch里面的具体内容 */, t/ G {; d' @( a& Z
switch (CompareUnit)
* p3 z+ ]4 c& b( j$ q" j8 o
{7 `" h( L& y3 Q1 b3 D" r- f4 I
case HRTIM_COMPAREUNIT_1:# O0 ]. m* \5 f
0 v# ~9 O6 K' f: Z6 ^" L0 a% R7 N9 P
case HRTIM_COMPAREUNIT_2:5 ?) F0 k ~" _: r# y% F! [
1 i( c' v f, w: d7 y- r) i
case HRTIM_COMPAREUNIT_3:
4 F& r# ?; N$ B2 I% U
9 ?3 B( `* ?" X5 a" \
case HRTIM_COMPAREUNIT_4:3 i. \4 A8 ]1 G) J4 {* L
+ ~: i3 \) i. R0 A9 S
default:
, n* J& a. ^, E' W* i+ Z& N! R
' q% Y2 q, g: u0 P* Q/ ]( m9 l8 v
}, J+ g+ r" I! x9 ^
) |9 X3 @9 \* Y T0 Y p
if(hhrtim->State == HAL_HRTIM_STATE_ERROR), }' Z6 O7 k ?
{
/ i( _5 k6 C) u( ]+ D; }
return HAL_ERROR;7 t$ c6 K; F$ v# y* p
}
4 Y, ]) O$ w @$ Z) j; i [
- O8 J5 C, T) r( s- H+ y
}( T7 [, q+ [) ~4 g; l
else$ K1 b7 j) T+ T
{' v* X% s6 T: g x2 O
/* 省略switch里面的具体内容 */
* y) `5 ?( L- v- E2 q
switch (CompareUnit)
, {9 E' H& b+ } q
{
3 I) |4 f' ?) X: N0 f9 Q( Z
case HRTIM_COMPAREUNIT_1:6 U. ?9 |/ L5 q, V: ?1 w
' p7 Y5 ^" F, T9 e6 C# J1 n+ K( x! T: g2 ]
case HRTIM_COMPAREUNIT_2:* X- J9 t: u3 z$ e+ s' h+ ^4 i% J
0 x5 x2 e+ Q# h# S" O
case HRTIM_COMPAREUNIT_3:# r* t! @6 A/ Q# ]
1 v" t& d7 q Z
case HRTIM_COMPAREUNIT_4:6 s5 D/ D6 F' }: l# y8 f
, R) y; H6 n( l
& I2 J, \7 u. Z+ v
default:* E% H% o" h* t. T" v1 j
}
: X) E2 Q# r# ~3 L# g6 v7 n# n
( A# \2 [! d! @* Y. l
if(hhrtim->State == HAL_HRTIM_STATE_ERROR)
* V7 U4 [. t% _
{
7 a0 n8 e' d3 w% [2 \
return HAL_ERROR;, i: J5 f2 y. P2 e+ o0 D) d
}
C+ S" s# K. |' V0 b5 X
2 X! y7 P+ N& @& S5 _
}
0 l, O* ]; |! G" ]
hhrtim->State = HAL_HRTIM_STATE_READY;
# D( e% I+ O% a8 Z0 A' u
4 W0 Y, o8 X! a9 j
/* 解锁 */! n0 A1 J5 Z4 U0 `
__HAL_UNLOCK(hhrtim);
2 T2 f, M' x1 a5 W" j2 E) v# K3 `* g
3 r' J( i1 ?) v& ] Z
return HAL_OK;. ?4 s* Q7 f* m4 x! n0 k
}+ D+ y$ G: l7 K: j
/ o; k/ C" d! O- \7 q

复制代码

函数描述：

此函数用于配置HRTIM的定时器比较单元。

函数参数：

  第1个参数是HRTIM_HandleTypeDef类型结构体指针变量。
  第2个参数是使用的定时器索引，支持的参数如下：
  HRTIM_TIMERINDEX_MASTER。
  HRTIM_TIMERINDEX_TIMER_A。
  HRTIM_TIMERINDEX_TIMER_B。
  HRTIM_TIMERINDEX_TIMER_C。
  HRTIM_TIMERINDEX_TIMER_D。
  HRTIM_TIMERINDEX_TIMER_E
  第3个参数是比较单元，支持的参数如下：
  HRTIM_COMPAREUNIT_1。
  HRTIM_COMPAREUNIT_2。
  HRTIM_COMPAREUNIT_3。
  HRTIM_COMPAREUNIT_4。
  第4个参数是HRTIM_CompareCfgTypeDef类型结构体变量。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：

启动定时器前，优先调用此函数。
如果比较单元2或比较单元4需要自动延迟模式，应用程序必须单独配置捕获单元。
输出比较2的自动延迟：捕获单元1必须配置。
输出比较4的自定延迟：捕获单元2必须配置。
使用举例：

HRTIM_CompareCfgTypeDef sConfig_compare = {0};
+ a% ]; C9 t; q8 s/ n A0 B
1 X; U$ G+ k9 u* t6 ^. @ A
sConfig_compare.AutoDelayedMode = HRTIM_AUTODELAYEDMODE_REGULAR; /* 这里使用标准模式，即未使用自动延迟 */! P7 q- D2 e4 p$ J$ m, g6 z r
sConfig_compare.AutoDelayedTimeout = 0; /* 由于前面的参数未使用自动延迟模式，此参数无作用 */0 N" W- s; v- [ P4 t' t, H
/*1 ?5 t7 @) Y. w7 }. ^
设置定时器比较单元的比较值：7 C9 l* C V# ^2 F' O6 L( P
最小值要大于等于3个HRTIM时钟周期。; y2 w$ V' [; n+ f
最大值要小于等于0xFFFF – 1) |) e4 F2 w5 `) g9 F3 V
*/
7 T9 I0 C) b5 D: M# }$ D) M& `
sConfig_compare.CompareValue = 4000 / 2; /* 占空比50% */& D# M( M" s& }! m' t
HAL_HRTIM_WaveformCompareConfig(&HrtimHandle, HRTIM_TIMERINDEX_TIMER_D, HRTIM_COMPAREUNIT_1,
& q/ W6 `: Y- D( N
&sConfig_compare);5 G# n. @; } O
7 n E/ @ B$ ?. k) V# Z' o6 w7 U

复制代码

63.4.5 函数HAL_HRTIM_WaveformOutputConfig
函数原型：

HAL_StatusTypeDef HAL_HRTIM_WaveformOutputConfig(HRTIM_HandleTypeDef * hhrtim,
3 u* z6 B# O7 @7 o0 g! R8 \5 r& W
uint32_t TimerIdx,. W( {* H4 K' V: Z/ n% q. T2 r
uint32_t Output," L2 G9 s; W9 b2 `2 J$ ?
HRTIM_OutputCfgTypeDef * pOutputCfg)5 y9 s) _3 Q6 ~% ]0 e, P) X" `
{; i! h; K) {+ h8 f
/* 检查参数 */
) H5 @. x. D1 v% e1 Y ]( n
assert_param(IS_HRTIM_TIMER_OUTPUT(TimerIdx, Output));
1 j" K) J! e" U. \
assert_param(IS_HRTIM_OUTPUTPOLARITY(pOutputCfg->Polarity));* g6 X7 x r0 |0 m. L7 E1 {
assert_param(IS_HRTIM_OUTPUTIDLELEVEL(pOutputCfg->IdleLevel));
# b2 ?+ [' m, B8 C
assert_param(IS_HRTIM_OUTPUTIDLEMODE(pOutputCfg->IdleMode));
4 L" s0 @! r% a! V5 F
assert_param(IS_HRTIM_OUTPUTFAULTLEVEL(pOutputCfg->FaultLevel));
& y$ ~0 y7 p4 _; p
assert_param(IS_HRTIM_OUTPUTCHOPPERMODE(pOutputCfg->ChopperModeEnable));
6 o5 z* P$ \1 n. H5 {! v# u
assert_param(IS_HRTIM_OUTPUTBURSTMODEENTRY(pOutputCfg->BurstModeEntryDelayed));
: B! \9 Q+ p+ [' K: |
1 j8 J/ U" h/ J* ?
if(hhrtim->State == HAL_HRTIM_STATE_BUSY), y1 \# J/ ^$ B$ P3 [4 J& c
{
, ]6 ^ ?9 c; P) z- w$ o, j
return HAL_BUSY;
7 D6 q' ?5 J4 w" |" k2 q& O
}
- j: g% y7 J8 I+ u
7 Y; r( e9 {7 ^" r* N
/* 处理过程上锁 */
" s1 B9 T( E3 n( W6 _! ^- G0 o5 G
__HAL_LOCK(hhrtim);( w% ? v2 r6 D5 x2 e' D
% l( G# ^4 B1 p% W
hhrtim->State = HAL_HRTIM_STATE_BUSY;1 c7 \. a+ t# P6 `! X o
; W. ]% Q1 R$ q! ]+ U; ~$ z. v
/* 配置定时器输出 */% Y3 y8 Q! T6 B* p1 V
HRTIM_OutputConfig(hhrtim,
6 U" p5 c+ D1 x" d) U
TimerIdx,
- p! b7 E Z& \( S' o$ [9 J
Output,
( I& B h8 H; G- ^5 s" c/ w
pOutputCfg);
! a/ G' z0 h: x' n" l
5 Q8 m# n, {. S# b4 m
hhrtim->State = HAL_HRTIM_STATE_READY;- C9 r/ g' j2 B
6 n9 E( ^% z! G( Y& g8 O
/* 解锁 */
% w8 l2 ?0 @- \0 t* @7 N
__HAL_UNLOCK(hhrtim);2 B! t6 b( ?9 l) q( ~- H
return HAL_OK;+ Y0 F' A/ ~ a& N3 F4 Z8 ^
}2 d, N( y5 }5 _
0 L' D V& O# t/ p

复制代码

函数描述：

此函数用于配置HRTIM的定时器（TIMER A到TIMER E）在waveform模式下的输出。

函数参数：

  第1个参数是HRTIM_HandleTypeDef类型结构体指针变量。
  第2个参数是使用的定时器索引，支持的参数如下：
  HRTIM_TIMERINDEX_TIMER_A。
HRTIM_TIMERINDEX_TIMER_B。
  HRTIM_TIMERINDEX_TIMER_C。
  HRTIM_TIMERINDEX_TIMER_D。
  HRTIM_TIMERINDEX_TIMER_E
  第3个参数是具体的输出通道，支持的参数如下：
  HRTIM_OUTPUT_TA1: Timer A - Output 1
  HRTIM_OUTPUT_TA2: Timer A - Output 2
  HRTIM_OUTPUT_TB1: Timer B - Output 1
  HRTIM_OUTPUT_TB2: Timer B - Output 2
  HRTIM_OUTPUT_TC1: Timer C - Output 1
  HRTIM_OUTPUT_TC2: Timer C - Output 2
  HRTIM_OUTPUT_TD1: Timer D - Output 1
  HRTIM_OUTPUT_TD2: Timer D - Output 2
  HRTIM_OUTPUT_TE1: Timer E - Output 1
HRTIM_OUTPUT_TE2: Timer E - Output 2
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：

配置定时器前，必须调用此函数。并且在配置死区时间插入之前调用（如果需要配置死区时间）。
使用举例：

HRTIM_OutputCfgTypeDef sConfig_output_config = {0}; H+ ]" R% ?( p4 f" d( u _4 t
1 O% I' ?. b! \5 O2 q9 F4 t6 ?
sConfig_output_config.Polarity = HRTIM_OUTPUTPOLARITY_LOW; /* 设置定时器输出极性 */# o7 e' e4 F$ N" c; [3 y( W2 n
sConfig_output_config.SetSource = HRTIM_OUTPUTRESET_TIMCMP1; /* 定时器比较事件1可以将输出置位 */1 Z9 A* |. U! f( E7 ~' \
sConfig_output_config.ResetSource = HRTIM_OUTPUTSET_TIMPER; /* 定时器周期性更新事件可以将输出清零 */- I+ l# |5 m; I
sConfig_output_config.IdleMode = HRTIM_OUTPUTIDLEMODE_NONE; /* 输出不受突发模式影响 */7 f" W* q/ d! @$ a# V3 ?# G+ _
sConfig_output_config.IdleLevel = HRTIM_OUTPUTIDLELEVEL_INACTIVE; /* 设置空闲状态输出低电平 */
% i" e+ Z" e) N# S: f7 _
sConfig_output_config.FaultLevel = HRTIM_OUTPUTFAULTLEVEL_NONE; /* 输出不受异常输入影响 */
* J- }: ^1 u9 ~, Z+ e
sConfig_output_config.ChopperModeEnable = HRTIM_OUTPUTCHOPPERMODE_DISABLED; /* 关闭Chopper模式 */$ | [, z9 f* U
sConfig_output_config.BurstModeEntryDelayed = HRTIM_OUTPUTBURSTMODEENTRY_REGULAR; /* 设置从突发模式切换到空- ~& O; L# g. N4 _7 X9 \5 B
闲模式，不插入死区时间 */
: f( E) H. N* {% h5 O
2 Z8 C" J2 F0 L3 j) d2 A4 T- z- f
HAL_HRTIM_WaveformOutputConfig(&HrtimHandle, HRTIM_TIMERINDEX_TIMER_D, HRTIM_OUTPUT_TD1,7 V+ _, r* @$ o& B# |
&sConfig_output_config);) F4 b. U# R; x" Y# z! a, X

复制代码

63.4.6 函数HAL_HRTIM_WaveformOutputStart
函数原型：

HAL_StatusTypeDef HAL_HRTIM_WaveformOutputStart(HRTIM_HandleTypeDef * hhrtim,
( G! ^5 E/ v5 {: U5 P; O2 X9 {
uint32_t OutputsToStart)& v9 C# Q5 c9 c' z9 v+ H! d- m
{8 s% ^" Z1 e. C; {. X+ w
/* 检查参数 */- D3 d2 Q6 R3 G+ @% e. K* q
assert_param(IS_HRTIM_OUTPUT(OutputsToStart));! w9 P# |) A: S! Y6 d8 V9 l7 ]
8 u3 P& s( Y4 x" ^; x! C- d
/* 处理过程上锁 */
& H# I: d7 j$ K i+ n) z
__HAL_LOCK(hhrtim);
; |" E0 O9 b( `2 z
& [0 L! M, W' p* ~( M9 N
hhrtim->State = HAL_HRTIM_STATE_BUSY;
& l: ^; a7 j. }' K P) x
4 H/ _7 a/ y$ V1 Y; c; t4 ]
/* 使能HRTIM输出 */
: o1 ^* _# H7 {; S+ O4 `; m! W, W
hhrtim->Instance->sCommonRegs.OENR |= (OutputsToStart);/ w& c+ j [* | P3 {8 u1 f
X( ]3 t2 E; p" J6 X0 H
hhrtim->State = HAL_HRTIM_STATE_READY;
" |2 p+ t. |3 K, A/ L) c% K
, d4 v7 {8 O" v0 a+ W
/* 处理完毕解锁 */
& N& {1 k# R, Q
__HAL_UNLOCK(hhrtim);! k5 \* B& w8 k
% Y' l! d1 s, `- o
return HAL_OK;5 m/ ^! J0 J) \8 W" `6 A* [% b% j
}

复制代码

函数描述：

此函数用于启动HRTIM的waveform模式输出。支持多个通道同时配置，即参数支持或操作。

函数参数：

  第1个参数是HRTIM_HandleTypeDef类型结构体指针变量。
  第2个参数用于使能要输出的通道，这些参数支持或操作。
  HRTIM_OUTPUT_TA1: Timer A - Output 1
  HRTIM_OUTPUT_TA2: Timer A - Output 2
  HRTIM_OUTPUT_TB1: Timer B - Output 1
  HRTIM_OUTPUT_TB2: Timer B - Output 2
  HRTIM_OUTPUT_TC1: Timer C - Output 1
  HRTIM_OUTPUT_TC2: Timer C - Output 2
  HRTIM_OUTPUT_TD1: Timer D - Output 1
  HRTIM_OUTPUT_TD2: Timer D - Output 2
  HRTIM_OUTPUT_TE1: Timer E - Output 1
  HRTIM_OUTPUT_TE2: Timer E - Output 2
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
使用举例：

/* 启动Timer D的通道1和通道2的PWM */
* q( [1 n: f) M% j& F4 g
if (HAL_HRTIM_WaveformOutputStart(&HrtimHandle, HRTIM_OUTPUT_TD1 + HRTIM_OUTPUT_TD2) != HAL_OK)3 S3 p6 J( u( S- [& L3 O. A {/ l
{ a6 m6 d$ ~! n, [, c- u E
Error_Handler(__FILE__, __LINE__);
5 x8 r- L! }$ k
}8 J9 u6 \" m: }* y7 M1 q: s3 d

复制代码

63.4.7 函数HAL_HRTIM_WaveformCounterStart
函数原型：

#define HAL_HRTIM_WaveformCounterStart HAL_HRTIM_WaveformCountStart2 a! a& W- q4 [+ ^! t
9 ?5 g+ T! A$ W+ c/ J
HAL_StatusTypeDef HAL_HRTIM_WaveformCountStart(HRTIM_HandleTypeDef * hhrtim,$ h7 n: i' q& j, P
uint32_t Timers)2 X. w+ W9 M, y
{
! l0 Y2 B" E: B$ }( p* D
/* 检查参数 */
, H" \' H2 F+ C( l$ r# w
assert_param(IS_HRTIM_TIMERID(Timers));
; M. Q2 G; o; f/ V% z3 W
6 l- A! M$ G5 S
/* 处理过程上锁 */# D: |) T1 v' F5 z
__HAL_LOCK(hhrtim);
( j- d& r y$ F _. }& C
5 A$ r9 ^; P4 `9 m" Y
hhrtim->State = HAL_HRTIM_STATE_BUSY;
: x Y3 g. r. s$ p/ J
* m3 V: i( u$ D( Q& W! A
/* 使能定时器计数器 */8 O4 P) }. H7 V5 F3 ^. z) O! M
hhrtim->Instance->sMasterRegs.MCR |= (Timers);
! C" V" }8 Y) R: I: E7 P3 U% p
- o! k3 s. U3 H* z# u& Y
hhrtim->State = HAL_HRTIM_STATE_READY;
! g6 |' |8 d) U% i4 ~! \: X
, t( i9 |& d1 j* H- |5 e
/* 处理过程解锁 */9 R* I' l$ w) O% C2 r# i1 h
__HAL_UNLOCK(hhrtim);' e& I. v5 C% p) F- d# n; A# p9 S# A
, `0 m: Z- i1 }& A
return HAL_OK;6 [# E) ?1 U- E; P* K/ y
}
1 m4 }0 i8 V0 L
6 W& r( a0 {1 y; G5 r& D# B

复制代码

函数描述：

此函数用于启动定时器计数。

函数参数：

  第1个参数是HRTIM_HandleTypeDef类型结构体指针变量。
  第2个参数是定时器索引，支持以下参数，支持或操作：
HRTIM_TIMERID_MASTER
HRTIM_TIMERID_TIMER_A
HRTIM_TIMERID_TIMER_B
HRTIM_TIMERID_TIMER_C
HRTIM_TIMERID_TIMER_D
HRTIM_TIMERID_TIMER_E
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
使用举例：

/* 启动Timer D的计数器 */
' [, r+ x8 e' ?8 I' \
if (HAL_HRTIM_WaveformCounterStart(&HrtimHandle, HRTIM_TIMERID_TIMER_D) != HAL_OK)
% X( r; L! A. N# I7 k4 M+ t% Y& ]
{; w. h, Z" r/ S U' B1 m9 ~6 S
Error_Handler(__FILE__, __LINE__);
/ k$ w- [+ q: [: g+ S6 b
}

复制代码

63.5 总结
本章节就为大家讲解这么多，HRTIM涉及到的知识点非常多，大家看完本章节后可以再学习STM32H7的参考手册做进一步了解。

赞收藏 1 评论0 发布时间：2021-11-1 22:21

0个回答

【经验分享】STM32H7的高分辨率定时器HRTIM基础知识和HAL库API

所属标签

相似分享