高级定时器实验
' T, P; S- z3 v* v本章我们主要来学习高级定时器， STM32H750有2个高级定时器（TIM1和TIM8）。我们将通过四个实验来学习高级定时器的各个功能，分别是高级定时器输出指定个数PWM实验、高级定时器输出比较模式实验、高级定时器互补输出带死区控制实验和高级定时器PWM输入模式实验。
. _$ Q! D: j7 [4 W
$ {9 q: V: x, v% O* @7 Y2 Z' h22.1 高级定时器简介
高级定时器的框图和通用定时器框图很类似，只是添加了其它的一些功能，如：重复计数器、带死区控制的互补输出通道、断路输入等。这些功能在高级定时器框图的位置如下：

! f+ n" s; ?" Y& Q; s( H
1 w- g  }( C0 l) h; v7 x( U
  x5 E( d6 u  B图22.1.1 高级定时器框图
上图中，框出来三个部分，这是和通用定时器不同的地方，下面来分别介绍它们。
①重复计数器
- z: l' z3 j$ @/ q2 T在H7系列中，除了高级定时器TIM1和TIM8之外，通用定时器TIM15、TIM16和TIM17也有重复计数器。通过查看手册可以知道TIM15、TIM16和TIM17虽为通用定时器，但是高级定时器有的功能，它们也基本都有，所以它们是很特殊的。
8 r; D( m3 I, ^0 H4 P下面来介绍一下重复计数器有什么作用？在学习基本定时器和通用定时器的时候，我们知道定时器发生上溢或者下溢时，会直接生成更新事件。但是有重复计数器的定时器并不完全是这样的，定时器每次发生上溢或下溢时，重复计数器的值会减一，当重复计数器的值为0时，再发生一次上溢或者下溢才会生成定时器更新事件。如果我们设置重复计数器寄存器RCR的值为N，那么更新事件将在定时器发生N+1次上溢或下溢时发生。
6 `: V$ p( ~# `这里需要注意的是重复计数器寄存器是具有影子寄存器的，所以RCR寄存器只是起缓冲的作用。RCR寄存器的值会在更新事件发生时，被转移至其影子寄存器中，从而真正生效。
' f! e0 H1 E5 i重复计数器的特性，在控制生成PWM信号时很有用，后面会有相应的实验。
9 V8 S+ t, @" ~/ v- t0 K②输出比较
- a9 B! p: N8 }8 u+ @: M1 d高级定时器输出比较部分和通用定时器相比，多了带死区控制的互补输出功能。图22.1.1第②部分的TIMx_CH1N、TIMx_CH2N和TIMx_CH3N分别是定时器通道1、通道2和通道3的互补输出通道，通道4是没有互补输出通道的。DTG是死区发生器，死区时间由DTG[7:0]位来配置如果不使用互补通道和死区时间控制，那么高级定时器TIM1/8，以及TIM15/16/17和其它通用定时器的输出比较部分使用方法基本一样，只是要注意MOE位得置1定时器才能输出。
如果使用互补通道，那么就有一定的区别了，具体我们在高级定时器互补输出带死区控制实验小节再来介绍。
③断路功能
/ w7 a" |! g6 w断路功能也称刹车功能，一般用于电机控制的刹车。H7系列有两个断路通道。断路1通道可以收集系统级故障（时钟失效和奇偶校验错误等）和应用故障（来自输入引脚：TIMx_BKIN或者TIMx_BKIN2，还可以来自内置比较器），可以在死区持续时间后将输出强制为预定义的电平（有效或无效）。断路2通道只包含应用故障，能够将输出强制为无效状态。系统复位后，断路功能默认被禁止，MOE位为低。
使能断路功能的方法：将TIMx_BDTR的位BKE（或BK2E）置1。断路输入引脚TIMx_BKIN或者TIMx_BKIN2的输入有效电平可通过TIMx_BDTR寄存器的位BKP（或BK2P）设置。
使能刹车功能后：由TIMx_BDTR的MOE、OSSI、OSSR位，TIMx_CR2的OISx、OISxN位，TIMx_CCER的CCxE、CCxNE位控制OCx和OCxN输出状态。无论何时，OCx和OCxN输出都不能同时处在有效电平。
) h% X) d" G, s! O3 P当发生断路输入后，会怎么样？
1，MOE位被异步地清零，OCx和OCxN为无效、空闲或复位状态(由OSSI位选择)。
2，OCx和OCxN的状态：由相关控制位状态决定，当使用互补输出时：根据情况自动控制输出电平，参考《STM32H7xx参考手册_V3（中文版）.pdf》手册1465页的表313.具有断路功能的互补通道Ocx和OcxN的输出控制位。
9 o$ L/ X8 F' h3，BIF位置1，如果使能了BIE位，还会产生刹车中断；如果使能了TDE位，会产生DMA请求。
& J: `* L0 {5 ]. @- }4，如果AOE位置 1，在下一个 更新事件UEV时，MOE位被自动置 1。
6 w  R7 f9 e+ {- N" r7 k高级定时器框图部分就简单介绍到这里，下面通过实际的实验来学习高级定时器。
22.2 高级定时器输出指定个数PWM实验
4 A: G7 B3 k. S声明：本实验虽然名为高级定时器输出指定个数PWM实验，实际上我们以通用定时器15作为例子，前面也说过TIM15/16/17是比较特殊的通用定时器。只要有重复计数器的定时器就可以实现本实验的功能，比如高级定时器TIM1/ 8、通用定时器TIM15/16/17，这个请大家打开官方手册确认。本实验我们使用了通用定时器15。
: g+ I5 N( `, a6 k: ]* Z要实现定时器输出指定个数PWM，只需要掌握下面几点内容：
0 J% a( |' ]' k( l. p第一，如果大家还不清楚定时器是如何输出PWM的，请回顾通用定时器PWM输出实验的内容，这部分的知识是一样的。但是需要注意的是：本实验，我们需要把MOE位置1，这样定时器15的通道才能输出。
# z' H! O+ m" u3 A$ e第二，要清楚重复计数器特性，设置重复计数器寄存器RCR的值为N，那么更新事件将在定时器发生N+1次上溢或下溢时发生。换句话来说就是，想要指定输出N个PWM，只需要把N-1写入RCR寄存器。因为在边沿对齐模式下，定时器溢出周期对应着PWM周期，我们只要在更新事件发生时，停止输出PWM就行。
第三，为了保证定时器输出指定个数的PWM后，定时器马上停止继续输出，我们使能更新中断，并在定时器中断里关闭计数器。
原理部分我们就讲到这里，下面直接开始寄存器的介绍。

+ y( Q$ D) D! |0 B: O/ E22.2.1 TIM15寄存器
本实验用到定时器15，在《STM32H7xx参考手册_V3（中文版）.pdf》手册的41.5小节（1644页）可以找到TIM15的寄存器描述。这里我们将介绍TIM15寄存器里我们用到的几个重要的寄存器，具体如下：
控制寄存器 1（TIM15_CR1）
TIM15的控制寄存器1描述如图22.2.1.1所示：



图22.2.1.1 TIM15_CR1寄存器
; w2 U7 Y0 \( X' Y7 r上图中我们只列出了本章需要用的一些位，其中：位7（APRE）用于控制自动重载寄存器是否具有缓冲作用，在基本定时器的时候已经讲过，请回顾。在本实验中我们把该位要置1，这样就算改变ARR寄存器的值，该值也不会马上生效，而是等待之前设置的PWM完整输出后（发生更新事件）才生效。
因为TIM15只有递增计数模式，所以不用设置计数模式。
7 a2 `7 t9 u! K7 `: z- {2 c! cCEN位，用于使能计数器的工作，必须要设置该位为1，才可以开始计数。
捕获/比较模式寄存器1（TIM15_CCMR1）
TIM15的捕获/比较模式寄存器1，只有1个：TIM15 _CCMR1。TIM15_CCMR1刚好可以控制定时器15的两个通道CH1和CH2。TIM15_CCMR1寄存器描述如图22.2.1.2所示：
) Q  u" Y$ q9 P

0 P5 H7 n% f* O; U4 y8 R
图22.2.1.2 TIM15_CCMR1寄存器
该寄存器的有些位在不同模式下，功能不一样，我们前面已经说过。比如我们要让TIM15的CH1输出PWM波为例，该寄存器的模式设置位OC1M[3:0]就是对应着通道1的模式设置，此部分由4位组成。TIM15总共可以配置成12种模式，我们使用的是PWM模式，所以这4位必须设置为0110或者0111，分别对应PWM模式1和PWM模式2。这两种PWM模式的区别就是输出有效电平的极性相反，这里我们设置为PWM模式1。位3 OC1PE是输出比较通道1的预装使能，该位需要置1，另外CC1S[1:0]用于设置通道1的方向（输入/输出）默认设置为0，就是设置通道作为输出使用。
捕获/比较使能寄存器（TIM15_ CCER）
TIM15的捕获/比较使能寄存器，该寄存器控制着各个输入输出通道的开关。TIM15_CCER寄存器描述如图22.2.1.3所示：

) ~3 d/ o" p4 A# Z/ k+ A- p2 A

/ d) n0 ~& n% k+ B* Y2 w% O. b图22.2.1.3 TIM15_CCER寄存器
4 t% u, V" U* D$ `1 c/ @该寄存器比较简单，要让TIM15的CH1输出PWM波，这里我们要使能CC1E位，该位是通道1输入/输出使能位，要想PWM从IO口输出，这个位必须设置为1。CC1P位是设置通道1的输出极性，我们默认设置0，即OC1 高电平有效。
/ T% m) X3 [4 F; d事件产生寄存器（TIM15_ EGR）
$ B, {$ B3 i, iTIM15的事件产生寄存器，该寄存器作用是让用户用软件方式产生各类事件。TIM15_EGR寄存器描述如图22.2.1.4所示：


5 J. Q. h3 T4 z) J( N; l& b
图22.2.1.4 TIM15_EGR寄存器
. B/ m8 j8 A: DUG位是更新事件的控制位，作用和定时器溢出时产生的更新事件一样，区别是这里是通过软件产生的，而定时器溢出是硬件自己完成的。只有开启了更新中断，这两种方式都可以产更新中断。本实验用到该位去产生软件更新器事件，在需要的时候把UG位置1即可，会由硬件自动清零。
7 Y( Y& `& p/ q0 L重复计数器寄存器（TIM15_ RCR）
重复计数器寄存器用于设置重复计数器值，因为它具有影子寄存器，所以它本身只是起缓冲作用。当更新事件发生时，该寄存器的值会转移到其影子寄存器中，从而真正起作用。TIM15_ RCR寄存器描述如图22.2.1.5所示：



图22.2.1.5 TIM15_ RCR寄存器
该寄存器的REP[7:0]位是低8位有效，即最大值255。因为这个寄存器只是起缓冲作用，如果大家对该寄存器写入值后，想要立即生效，可以通过对UG位写1，产生软件更新事件。
$ a$ A4 u; U8 q2 m, i捕获/比较寄存器1/2（TIM15_ CCR1/2）
  s  @' S' B  @0 q1 r% l2 }/ t捕获/比较寄存器（TIM15_ CCR1/2），该寄存器总共有2个，对应TIM15的2个通道CH1和CH2。我们使用的是通道1，所以来看看TIM15_ CCR1寄存器描述如图22.2.1.6所示：
; P% _. q6 v- m& K7 Q

; A, E/ M1 `: C7 z" S2 U: D; n1 ]; X! C
图22.2.1.6 TIM15_ CCR1寄存器
在输出模式下，捕获/比较寄存器影子寄存器的值与CNT的值比较，根据比较结果产生相应动作，利用这点，我们通过修改这个寄存器的值，就可以控制PWM的占空比了。
断路和死区寄存器（TIM5_ BDTR）
STMH7系列，通用定时器TIM15/16/17，以及高级定时器TIM1/8在输出模式下，还需要配置：断路和死区寄存器（TIMx_BDTR），该寄存器各位描述如图22.2.1.7所示：
" N; V" Z. ~2 h  C3 C7 |; I: J
% z0 B' Q5 F: k# z( J0 v1 `
% o- ?  x* r' U& b1 N
图22.2.1.7 TIMx_ BDTR寄存器
0 @+ @) B0 ]* \# r: h# Q本实验，我们只需要关注该寄存器的位15（MOE），要想高级定时器的PWM正常输出，则必须设置MOE位为1，否则不会有输出。

22.2.2 硬件设计
2 o0 j+ u0 l5 E* P1 x9 e1.例程功能
通过TIM15_CH1（由PE5复用）输出PWM，来实现PWM输出控制LED0的亮灭。上电默认输出5个PWM控制LED2亮灭五次。之后按一下按键KEY0，就会输出5个PWM控制LED2亮灭五次。
2.硬件资源
+ c1 v; C) n2 {$ ^, ~1）RGB灯
+ @6 f! q2 _% L8 P) k' E/ P' BBLUE ：LED2 - PE5
# D$ W4 j, E+ ?1 t7 [; m) j1）独立按键
7 u6 z9 g, W, |/ C' [. bKEY0 - PA1
3 w2 f" t: y0 x/ |) q  B3）定时器15，使用TIM15通道1，由PE5复用。
3.原理图
' u. o! \6 m% i定时器属于STM32H750的内部资源，只需要软件设置好即可正常工作。我们通过LED2来指示STM32H750的定时器的PWM输出情况，同时还可以用按键KEY0进行控制。

: ~* X% w+ g: b5 Z22.2.3 程序设计
本实验用到的HAL库函数介绍请回顾通用定时器PWM输出实验。下面介绍一下定时器输出指定个数PWM的配置步骤。
定时器输出指定个数PWM配置步骤
1）开启TIMx和通道输出的GPIO时钟，配置该IO口的复用功能输出
首先开启TIMx的时钟，然后配置GPIO为复用功能输出。本实验我们默认用到定时器15通道1，对应IO是PE5，它们的时钟开启方法如下：
__HAL_RCC_TIM15_CLK_ENABLE(); /* 使能定时器15 /
& @; [$ I+ K0 S! a__HAL_RCC_GPIOE_CLK_ENABLE(); / 开启GPIOE时钟 */
IO口复用功能是通过函数HAL_GPIO_Init来配置的。
9 e- D+ _6 L1 \6 _: {3 e2）初始化TIMx,设置TIMx的ARR和PSC等参数
使用定时器的PWM模式功能时，我们调用的是HAL_TIM_PWM_Init函数来初始化定时器ARR和PSC等参数。
注意：该函数会调用：HAL_TIM_PWM_MspInit函数，我们可以通过后者存放定时器和GPIO时钟使能、GPIO初始化、中断使能以及优先级设置等代码。
3）设置定时器为PWM模式，输出比较极性，比较值等参数
: X& z" N9 c  N8 d  e/ B3 p4 ]2 e在HAL库中，通过HAL_TIM_PWM_ConfigChannel函数来设置定时器为PWM1模式或者PWM2模式，根据需求设置输出比较的极性，设置比较值（控制占空比）等。
本实验我们设置TIM15的通道1为PWM1模式，因为我们的LED2（连接PE5）是低电平亮，而我们希望输出最后一个PWM波的时候，LED2就灭，所以我们设置输出比较极性为高。捕获/比较寄存器的值（即比较值）设置为自动重装载值的一半，即PWM占空比为50%。
4）使能定时器更新中断，开启定时器并输出PWM，配置定时器中断优先级
' [; O' B6 T) l/ d$ w7 w通过__HAL_TIM_ENABLE_IT函数使能定时器更新中断。
通过HAL_TIM_PWM_Start函数使能定时器并开启输出PWM。
通过HAL_NVIC_EnableIRQ函数使能定时器中断。
! ^  b7 {' |. `( H0 f通过HAL_NVIC_SetPriority函数设置中断优先级。
/ I8 X& `) _1 U5）编写中断服务函数
8 u& i  A9 d3 {4 ?定时器中断服务函数为：TIMx_IRQHandler等，当发生中断的时候，程序就会执行中断服务函数。HAL库提供了一个定时器中断公共处理函数HAL_TIM_IRQHandler，该函数会根据中断类型调用相关的中断回调函数。用户根据自己的需要重定义这些中断回调函数来处理中断程序。本实验我们不使用HAL库的中断回调机制，而是把中断程序写在定时器中断服务函数里。详见本章例程源码。

22.2.3.1 程序流程图


/ J! q* Z! k0 M9 S# i( Z" y5 d. ]
3 _: q+ @1 _/ i4 _7 ^! E) \$ u图22.2.3.2.1 高级定时器输出指定个数PWM实验程序流程图
  b& D) |' H: a5 n- K
- j4 h2 h% D, R: U7 A( m) Z$ c22.2.3.2 程序解析
5 |; j! Y, H4 p这里我们只讲解核心代码，详细的源码请大家参考光盘本实验对应源码。本实验使用到TIM15，所以相关的BSP驱动代码还是存放到gtim.c和gtim.h文件中。
: C  q+ N/ `8 ]! B& u9 c首先看gtim.h头文件的几个宏定义：

0 m1 f" Y0 M+ n9 G9 N1 L% n/ i7 W

1. /*****************************************************************************/
   
2. /* TIMX 输出指定个数PWM 定义
   * i3 }. f* z2 C( k! L
3. * 这里输出的PWM控制LED2(BLUE)的亮灭,亮灭一次表示一个PWM波
   
4. * 默认是针对TIM2~TIM5, TIM12~TIM17.
   * a% x. F/ i# x# r* Y  z; Q
5. * 注意: 通过修改这8个宏定义,可以支持TIM1~TIM17任意一个定时器,任意一个IO口输出PWM
   
6. */
     r7 p: ~7 A) l0 c) o- d/ R+ n
7. #define GTIM_TIMX_NPWM_CHY_GPIO_PORT        GPIOE
   
8. #define GTIM_TIMX_NPWM_CHY_GPIO_PIN         GPIO_PIN_5
   
9. #define GTIM_TIMX_NPWM_CHY_GPIO_AF          GPIO_AF4_TIM15   /* AF功能选择 */
   
10. #define GTIM_TIMX_NPWM_CHY_GPIO_CLK_ENABLE()
    
11. do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)   /* PE口时钟使能 */
    
12. 
    
13. #define GTIM_TIMX_NPWM                     TIM15                       
    ) K$ K: W  W6 u- P8 K% `1 a
14. #define GTIM_TIMX_NPWM_IRQn               TIM15_IRQn
    ( B5 Q4 w+ u: Z
15. #define GTIM_TIMX_NPWM_IRQHandler        TIM15_IRQHandler
    
16. #define GTIM_TIMX_NPWM_CHY                TIM_CHANNEL_1   /* 通道Y,  1<= Y <=4 */
    ; B5 A- U' @6 ?3 x3 U; Y
17. #define GTIM_TIMX_NPWM_CHY_CCRX          TIM15->CCR1     /* 通道Y的输出比较寄存器 */
    
18. #define GTIM_TIMX_NPWM_CHY_CLK_ENABLE()   
    
19.      do{ __HAL_RCC_TIM15_CLK_ENABLE(); }while(0) /* TIMX 时钟使能 */
    
20. /*****************************************************************************/

复制代码

) `" e9 n" U6 {* F+ r6 y可以把上面的宏定义分成两部分，第一部分是定时器15输入通道1对应的IO口的宏定义，第二部分则是定时器15输入通道1的相应宏定义。
下面看gtim.c的程序，首先是输出指定个数PWM初始化函数，其定义如下：
) y$ m- V3 c7 i  t
" y; K  V3 P2 s: j

1. /**
   
2. * @brief      通用定时器TIMX 通道Y 输出指定个数PWM 初始化函数
   
3. * @note
   
4. *              通用定时器的时钟来自APB1,当D2PPRE1≥2分频的时候
   4 n# T" K; B: A
5. *              通用定时器的时钟为APB1时钟的2倍, 而APB1为120M, 所以定时器时钟 = 240Mhz
   " ]8 E# Q  u, _3 K0 h+ P
6. *              定时器溢出时间计算方法: Tout = ((arr + 1) * (psc + 1)) / Ft us.
   
7. *              Ft=定时器工作频率,单位:Mhz
   
8. *
   
9. * @param       arr: 自动重装值
   
10. * @param       psc: 时钟预分频数
    
11. * @retval      无
    4 J' J7 P/ x  W2 u0 _8 K/ H- s1 J+ O
12. */
    
13. void gtim_timx_npwm_chy_init(uint16_t arr,uint16_t psc)
    6 |0 Z7 t/ \8 z$ I$ l1 X
14. {
    
15.     GPIO_InitTypeDef gpio_init_struct;
    # r  [5 e$ [# I! a% M; {
16.     TIM_OC_InitTypeDef timx_oc_npwm_chy = {0};          /* 定时器输出 */
    3 `* C1 S. M0 K, i
17.     GTIM_TIMX_NPWM_CHY_GPIO_CLK_ENABLE();                /* 开启通道y的GPIO时钟 */
    
18.     GTIM_TIMX_NPWM_CHY_CLK_ENABLE();
    : l( `( y' t# {
19. 
    : ~; k# D7 t" ^% z
20.     g_timx_npwm_chy_handle.Instance = GTIM_TIMX_NPWM;  /* 定时器x */
    
21.     g_timx_npwm_chy_handle.Init.Prescaler = psc;        /* 定时器分频 */
    , s+ C9 A! h# d5 g
22.     g_timx_npwm_chy_handle.Init.CounterMode = TIM_COUNTERMODE_UP;/* 递增计数 */
    
23.     g_timx_npwm_chy_handle.Init.Period = arr;            /* 自动重装载值 */
    
24. g_timx_npwm_chy_handle.Init.AutoReloadPreload =
    
25. TIM_AUTORELOAD_PRELOAD_ENABLE; /* 使能TIMx_ARR 寄存器进行缓冲 */
    
26.     g_timx_npwm_chy_handle.Init.RepetitionCounter = 0; /* 重复计数器初始值 */
    
27.     HAL_TIM_PWM_Init(&g_timx_npwm_chy_handle);           /* 初始化PWM */
    & l, U4 i1 U) d% e2 N
28. 
    
29.     gpio_init_struct.Pin = GTIM_TIMX_NPWM_CHY_GPIO_PIN;/* 通道y的GPIO口 */
    " i8 Q0 X5 V  h. x
30.     gpio_init_struct.Mode = GPIO_MODE_AF_PP;             /* 复用推挽输出 */
    ! @3 ~; |  q3 m9 K* |  c* E
31.     gpio_init_struct.Pull = GPIO_PULLUP;                        /* 上拉 */
    
32.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;      /* 高速 */
    4 C* v7 o" I9 R6 b8 |
33.     gpio_init_struct.Alternate = GTIM_TIMX_NPWM_CHY_GPIO_AF;/* 复用 */
    % a% {4 q" J8 v  }# W
34.     HAL_GPIO_Init(GTIM_TIMX_NPWM_CHY_GPIO_PORT, &gpio_init_struct);
    - `6 P  K3 H# w
35. 
    
36.     timx_oc_npwm_chy.OCMode = TIM_OCMODE_PWM1;    /* 模式选择PWM1 */
    , g2 O; l2 @0 J  h6 O% ^
37.     timx_oc_npwm_chy.Pulse = arr/2;                 /* 设置比较值,此值用来确定占空比 */
    : L4 K& W4 P$ n8 \2 s
38.     timx_oc_npwm_chy.OCPolarity = TIM_OCPOLARITY_HIGH;  /* 输出比较极性为高 */
    
39. HAL_TIM_PWM_ConfigChannel(&g_timx_npwm_chy_handle, &timx_oc_npwm_chy,
    ) `9 G- o: B3 [2 R- _
40. GTIM_TIMX_NPWM_CHY);      /* 配置TIMx通道y */
    
41. /* 设置中断优先级，抢占优先级1，子优先级3 */
    " t1 ]" \' r* H  {( C& |6 L
42.     HAL_NVIC_SetPriority(GTIM_TIMX_NPWM_IRQn, 1, 3);                     
    
43.     HAL_NVIC_EnableIRQ(GTIM_TIMX_NPWM_IRQn);             /* 开启ITMx中断 */
    ! X; r5 h. }% v# F
44. 
    
45.     __HAL_TIM_ENABLE_IT(&g_timx_npwm_chy_handle, TIM_IT_UPDATE);/* 使能更新中断 */
    
46.     HAL_TIM_PWM_Start(&g_timx_npwm_chy_handle, GTIM_TIMX_NPWM_CHY);/* 使能输出 */
    
47. }
    " {* W" L. Z; e; d- T( Y

复制代码

gtim_timx_npwm_chy_init函数包含了输出通道对应IO的初始代码、NVIC、使能时钟、定时器基础工作参数和输出模式配置的所有代码。下面来看看该函数的代码内容。
第一部分使能定时器和GPIO的时钟。
第二部分调用HAL_TIM_PWM_Init函数初始化定时器基础工作参数，如：ARR和PSC等。
6 M4 X1 x! `6 g- H第三部分是定时器输出通道对应的IO的初始化。
8 K5 ~2 y9 r! |* h$ `第四部分调用HAL_TIM_PWM_ConfigChannel设置PWM模式以及比较值等参数。
/ N' [/ U# Z/ ~3 v% V第五部分是NVIC的初始化，配置抢占优先级、响应优先级和开启NVIC定时器中断。
; P0 _4 M+ E( k  M1 f最后是使能更新中断和使能通道输出。
为了方便代码的管理和移植性等，这里就没有使用HAL_TIM_PWM_MspInit这个函数来存放使能时钟、GPIO、NVIC相关的代码，而是全部存放在gtim_timx_npwm_chy_init函数中。
下面我们看设置PWM个数的函数，其定义如下：
/ y! t( F8 |% y6 A8 O) Y$ y, W
  m7 h/ O/ y. a+ F5 h

1. /* g_npwm_remain表示当前还剩下多少个脉冲要发送
   7 \' g# o( u& d+ k9 h7 v
2. * 每次最多发送256个脉冲
   
3. */
   % N& Q8 z) N1 K9 Q9 q0 c4 W- U" d$ _
4. static uint32_t g_npwm_remain = 0;
   ! _& }5 T8 g* [5 o7 `- ]$ N9 q+ ~
5. 
   0 g4 _/ G9 L8 M( z# {0 e+ q
6. /**
   
7. * @brief       通用定时器TIMX NPWM设置PWM个数
   . y8 E. ~9 {! Q& i8 ~/ i
8. * @param       rcr: PWM的个数, 1~2^32次方个
   ) f; k0 \6 y4 x* R1 X) ~
9. * @retval      无
   
10. */
    + p4 M: g4 E: z: c' t
11. void gtim_timx_npwm_chy_set(uint32_t npwm)
    
12. {
    
13.     if (npwm == 0)return ;
    
14. g_npwm_remain = npwm;                           /* 保存脉冲个数 */
    5 e0 M' z. s) M2 n1 q- V9 Y
15. /* 产生一次更新事件,在中断里面处理脉冲输出 */
    - h% M3 T7 D, i. u1 p' c
16.     HAL_TIM_GenerateEvent(&g_timx_npwm_chy_handle, TIM_EVENTSOURCE_UPDATE);
    
17.     __HAL_TIM_ENABLE(&g_timx_npwm_chy_handle);  /* 使能定时器TIMX */
    
18. }
    / b4 {6 y% b5 H" a7 T) }+ T
19. 我们要输出多少个周期的PWM就用这个函数来设置。该函数作用是把我们设置输出的PWM个数的值赋值给静态全局变量g_npwm_remain，该变量会在更新中断服务函数回调函数中发挥作用。最后对TIMx_EGR寄存器UG位写1，产生一次更新事件，并使能定时器。
    
20. 下面来介绍定时器中断服务函数，其定义如下：
    7 r3 D- C% Z4 j$ y( p
21. /**
    * Z: Y) E1 d0 g
22. * @brief       定时器中断服务函数
    
23. * @param       无
    
24. * @retval      无
    
25. */
    % J1 T2 Z2 P* [2 @
26. void GTIM_TIMX_NPWM_IRQHandler(void)
    
27. {
    
28.     uint16_t npwm = 0;
    
29. 
    ' U( \0 v6 j! F9 Q: t+ y  j  O* {3 _
30.     /* 以下代码没有使用定时器HAL库共用处理函数来处理，而是直接通过判断中断标志位的方式 */
    ( \. u; W9 ?' V1 a& d2 G* l
31.     if(__HAL_TIM_GET_FLAG(&g_timx_npwm_chy_handle, TIM_FLAG_UPDATE) != RESET)
    
32.     {
    
33.         if (g_npwm_remain > 256)       /* 还有大于256个脉冲需要发送 */
    1 G. }$ L/ t$ r! X: ]9 F
34.         {
    : D+ t" |- q4 C
35.             g_npwm_remain=g_npwm_remain - 256;
    
36.             npwm = 256;
    
37.         }
    , P# B$ a. S! ^  B1 d
38.         else if (g_npwm_remain % 256) /* 还有位数（不到256）个脉冲要发送 */
    
39.         {
    
40.             npwm = g_npwm_remain % 256;
    
41.             g_npwm_remain = 0;          /* 没有脉冲了 */
    
42.         }
    $ z% u9 `# l  c/ c0 q! r$ r6 h+ ^- H
43.         if (npwm)                        /* 有脉冲要发送 */
    
44.         {
    
45.             GTIM_TIMX_NPWM->RCR = npwm - 1; /* 设置RCR值为npwm-1, 即npwm个脉冲 */
    
46.             HAL_TIM_GenerateEvent(&g_timx_npwm_chy_handle,
    
47. TIM_EVENTSOURCE_UPDATE); /* 产生一次更新事件,以更新RCR寄存器 */
    - L0 i  c. o3 {" k8 ~3 `
48.             __HAL_TIM_ENABLE(&g_timx_npwm_chy_handle); /* 使能定时器TIMX */
    
49.         }
    
50.         else
    
51.         {
    . b( T$ h: O6 d6 W* C
52. /* 关闭定时器TIMX,使用__HAL_TIM_DISABLE需要失能通道输出，所以不用 */
    ) I4 I1 _2 p3 E! ?0 T% f
53.             GTIM_TIMX_NPWM->CR1 &= ~(1 << 0);           
    % y& ?; x* V* L$ R
54.         }
    " H  r+ a8 s: K- N3 d! y
55. 
    
56. /* 清除定时器更新中断标志位 */
    
57.         __HAL_TIM_CLEAR_IT(&g_timx_npwm_chy_handle, TIM_IT_UPDATE);  
    : v4 Q8 i7 ]+ s, k) X6 w% [  J
58.     }
    9 M- X9 {# }1 T
59. }

复制代码

这里我们没有使用HAL库的中断回调机制，而是想寄存器操作一样，直接通过判断中断标志位处理中断。通过__HAL_TIM_GET_FLAG函数宏判断是否发生更新中断，然后进行更新中断的代码处理，最后通过__HAL_TIM_CLEAR_IT函数宏清除更新中断标志位。
因为重复计数器寄存器 (TIM15_RCR)是8位有效的，所以在定时器中断服务函数中首先对全局变量g_npwm_remain（即我们要输出的PWM个数）进行判断，是否大于256，如果大于256，那就得分次写入重复计数器寄存器。写入重复计数寄存器后，需要产生软件更新事件把RCR寄存器的值更新到RCR影子寄存器中，最后一定不要忘记清除定时器更新中断标志位。
+ a$ }! K/ E3 R6 u+ a在main函数里面编写如下代码：
2 e* I! d3 j7 a% t7 W; @/ H

1. int main(void)
   
2. {
   7 e* }  I1 x1 q: K; C( C
3.     uint8_t key = 0;
   
4.     sys_cache_enable();                             /* 打开L1-Cache */
   8 U- L# _* h4 m2 N  R
5.     HAL_Init();                                      /* 初始化HAL库 */
   
6.     sys_stm32_clock_init(240, 2, 2, 4);         /* 设置时钟, 480Mhz */
   
7.     delay_init(480);                                /* 延时初始化 */
   
8.     usart_init(115200);                            /* 串口初始化为115200 */
   * i. S5 v* w! y
9.     led_init();                                             /* 初始化LED */
   ) d8 o, S& k$ Z
10.     key_init();                                             /* 初始化按键 */
    
11.     gtim_timx_npwm_chy_init(5000 - 1, 24000 - 1);/*10Khz的计数频率,2hz的PWM频率*/
    + @: ~" b% s5 Y' J6 j$ V
12. 
    
13. /* 设置PWM占空比,50%,这样可以控制每一个PWM周期,LED2(BLUE) 有一半时间是亮的,
    " t6 @$ Y/ p9 |7 f# A
14. *一半时间是灭的,LED2亮灭一次,表示一个PWM波 */
    
15.     GTIM_TIMX_NPWM_CHY_CCRX = 2500;
    3 O5 F2 }" T- L5 P$ P$ U' v8 Y
16. 
    
17.     gtim_timx_npwm_chy_set(5);    /* 输出5个PWM波(控制LED2(BLUE)闪烁5次) */
    
18.     while (1)
    9 l1 r* q3 m2 Z9 _
19.     {
    
20.         key = key_scan(0);
    
21.         if (key == KEY0_PRES)   /* KEY0按下 */
    
22.         {
    
23.             gtim_timx_npwm_chy_set(5);  /* 输出5个PWM波(控制LED2(BLUE)闪烁5次) */
    7 j( ]. a$ u' x/ ?+ K2 F! f
24.         }
    
25.         delay_ms(10);
    
26.     }
    
27. }

复制代码

先看gtim_timx_npwm_chy_init(5000 - 1, 24000 - 1);这个语句，这两个形参分别设置自动重载寄存器的值为4999，以及预分频器寄存器的值为23999。按照sys_stm32_clock_init函数的配置，定时器15的时钟频率为2倍的APB2总线时钟频率，即240MHz，可以得到计数器的计数频率是10KHz。自动重载寄存器的值决定的是PWM周期或频率（请回顾21.3小节的内容），计数器计5000个数所用的时间是PWM的周期。在边沿对齐模式下，定时器的溢出周期等于PWM的周期。根据定时器溢出时间计算公式，可得：
Tout= ((arr+1)(psc+1))/Tclk= ((4999+1)(23999+1))/240000000=0.5s
再由频率是周期的倒数关系得到PWM的频率为2Hz。
占空比则由捕获/比较寄存器（TIMx_CCRx）的值决定，这里就是由TIM15_CCR1寄存器决定。初始化定时器15时我们设置通道输出比较极性为高，GTIM_TIMX_NPWM_CHY_CCRX = 2500，就设置了占空比为50%。因为我们的LED灯是低电平点亮，所以正占空比期间LED灯熄灭，负占空比期间LED灯亮。
" Q1 p- u0 B6 ]3 e. `2 k' n6 p: U0 }" ^2 U
22.2.4 下载验证
下载代码后，可以看到LED2亮灭五次，然后我们每按一下按键KEY0，LED2都会亮灭五次。下面我们使用正点原子DS100手持数字示波器，把PE5引脚的波形截获，具体如下：



2 _$ U. C- t! S图22.2.4 PE5引脚波形图
由LED的原理图可以知道，PE5引脚输出低电平LED2亮、输出高电平LED2灭。图22.2.4中，从左往右看，可以知道，LED2一开始是熄灭的，然后经过5次亮灭，最后就是一直保持熄灭的状态。PWM频率是2Hz，占空比50%，大家可以自行测量。
# _0 Y7 k) M/ N) q% A
22.3 高级定时器输出比较模式实验
本小节我们来学习使用高级定时器输出比较模式下翻转功能，通过定时器4个通道分别输出4个50%占空比、不同相位的PWM。
输出比较模式下翻转功能作用是：当计数器的值等于捕获/比较寄存器影子寄存器的值时，OC1REF 发生翻转，进而控制通道输出（OCx）翻转。通过翻转功能实现输出PWM的具体原理如下：PWM频率由自动重载寄存器（TIMx_ARR）的值决定，在这个过程中，只要自动重载寄存器的值不变，那么PWM占空比就固定为50%。我们可以通过捕获/比较寄存器（TIMx_CCRx）的值改变PWM的相位。生成PWM的原理如图22.3.1所示：
9 f; ]1 [8 x0 p8 ~) O


1 E, _7 ]) n+ O; Y1 J1 o; {图22.3.1 翻转功能输出PWM原理示意图
本实验就是根据图22.3.1的原理来设计的，具体实验是：我们设置固定的ARR值为999，那么PWM占空比固定为50%，通过改变4个通道的捕获/比较寄存器（TIMx_CCRx）的值使得每个通道输出的PWM的相位都不一样，注意捕获/比较寄存器的值设置范围是：0 ~ ARR。比如：TIMx_CCR1=250-1，TIMx_CCR2=500-1，TIMx_CCR3=750-1，TIMx_CCR4=1000-1，那么可以得到通道1~通道4输出的PWM的相位分别是：25%、50%、75%、100%。翻转功能输出的PWM周期，这里用T表示，其计算公式如下：
T= 2*(arr+1)*((psc+1)/ Tclk)
其中：
, K( G/ n: O1 U, J) oT：翻转功能输出的PWM周期（单位为s）。
; {; D) y2 ?- I; }' ^Tclk：定时器的时钟源频率（单位为MHz）。
" Y0 ^! z, J* O" Y1 f" y. barr：自动重装寄存器（TIMx_ARR）的值。
psc：预分频器寄存器（TIMx_PSC）的值

22.3.1 TIM1/TIM8寄存器
高级定时器输出比较模式除了用到定时器的时基单元：计数器寄存器(TIMx_CNT)、预分频器寄存器(TIMx_PSC)、自动重载寄存器(TIMx_ARR) 之外。主要还用到以下这些寄存器：
  n! C) B$ P% I6 {* B- _9 L控制寄存器 1（TIMx_CR1）
! L# z, c# M" B, m4 i, ^& yTIM1/TIM8的控制寄存器1描述如图22.3.1.1所示：
/ J3 O, L& j# T. Z  P) T

1 i# m# E: ?6 w9 `
/ y6 W' F. L4 u- T! n" |' [图22.3.1.1 TIMx_CR1寄存器
上图中我们只列出了本实验需要用的一些位，其中：位7（APRE）用于控制自动重载寄存器是否具有缓冲作用，在基本定时器的时候已经讲过，请回顾。本实验中，我们把该位置1。
CEN位，用于使能计数器的工作，必须要设置该位为1，才可以开始计数。
. C$ K" q6 f' A8 q' |% r( f其它位保持复位值即可。
捕获/比较模式寄存器1/2（TIMx_CCMR1/2）
TIM1/TIM8的捕获/比较模式寄存器（TIMx_CCMR1/2），该寄存器一般有2个：TIMx_CCMR1和TIMx _CCMR2。TIMx_CCMR1控制CH1和CH2，而TIMx_CCMR2控制CH3和CH4。TIMx_CCMR1寄存器描述如图22.3.1.2所示：


: t5 g! k; V& Q/ f
" K! X% o+ J8 i2 y1 i图22.3.1.2 TIMx_CCMR1寄存器
* x7 F. z5 t1 T( z该寄存器的有些位在不同模式下，功能不一样，我们现在用到输出比较模式。关于该寄存器的详细说明，请参考《STM32H7xx参考手册_V3（中文版）.pdf》第1458页，38.4.7节。
本实验我们用到了定时器1输出比较的4个通道，所以我们需要配置TIM1_CCMR1和TIM1_CCMR2。以TIM1_CCMR1寄存器为例，模式设置位OC1M[3:0]就是对应着通道1的模式设置，此部分由4位组成，总共可以配置成14种模式，我们使用的是翻转功能，所以这4位必须设置为0011。通道2也是如此，将位OC2M[3:0] 设置为0011。通道3和通道4就要设置TIM1_CCMR2寄存器的位OC3M[3:0]和位OC4M[3:0]。除此之外，我们还要设置输出比较的预装载使能位，如通道1对应输出比较的预装载使能位OC1PE置1，其他通道也要把相应位置1。
, ?* f( W: _; f* W( [  w, X, q捕获/比较使能寄存器（TIMx_ CCER）
TIM1/TIM8的捕获/比较使能寄存器，该寄存器控制着各个输入输出通道的开关和极性。TIMx_CCER寄存器描述如图22.3.1.3所示：
0 j& a- e1 ^0 j2 K0 P- F


: l6 Q- o1 k/ B. P) p( \图22.3.1.3 TIMx_CCER寄存器
, K  q  c8 z2 L. F" g该寄存器比较简单，要让TIM1的4个通道都输出，我们需要把对应的捕获/比较1输出使能位置1。通道1到通道4的使能位分别是：CC1E、CC2E、CC3E、CC4E，我们把这4个位置1，使能通道输出。
1 I' P: b! ?) f8 O捕获/比较寄存器1/2/3/4（TIMx_ CCR1/2/3/4）
. T; ^/ C' k5 x捕获/比较寄存器（TIMx_ CCR1/2/3/4），该寄存器总共有4个，对应4个通道CH1~CH4。本实验4个通道都要使用到，以通道1对应的TIMx_ CCR1寄存器为例，其描述如下图所示：

& r( f- K# `$ q& f- }

图22.3.1.4 TIMx_ CCR1寄存器
  K) G' J, Z  [在本实验中，我们通过改变TIMx_ CCR1/2/3/4寄存器的值来改变4个通道输出的PWM的相位。
断路和死区寄存器（TIMx_ BDTR）
- ?6 O1 R( [3 e: R; c5 H" w. ~% [本实验用的是高级定时器，所以我们还需要配置：断路和死区寄存器（TIMx_BDTR），该寄存器各位描述如图22.3.1.5所示：

- f5 |8 M, a- I5 k, Q1 w/ o  W* {

( a5 E2 @5 Z. [图22.3.1.5 TIMx_ BDTR寄存器
1 @4 F: S" ^- L+ q' Z该寄存器，我们只需要关注位15（MOE），要想高级定时器的通道正常输出，则必须设置MOE位为1，否则不会有输出。
22.3.2 硬件设计
; d4 \9 [" z) e9 O7 c% R$ p; o1.例程功能
使用输出比较模式的翻转功能，通过定时器1的4路通道输出占空比固定为50%、相位分别是25%、50%、75%和100%的PWM。
2.硬件资源
1）RGB灯
9 |2 U1 T6 W5 n$ NRED ：LED0 - PB4
2）PE9复用为TIM1_CH1
PE11复用为TIM1_CH2
1 p! ~' w- X  S+ W  r8 @2 H# LPE13复用为TIM1_CH3
PE14复用为TIM1_CH4
1 W/ J0 b3 [% i- F1 r$ g/ ?% D: d3.原理图
定时器属于STM32H750的内部资源，只需要软件设置好即可正常工作。我们需要通过示波器观察PE9、PE11、PE13和PE14引脚PWM输出的情况。
22.3.3 程序设计
% G) Z5 ~: r. z3 e) N; f22.3.3.1 定时器的HAL库驱动
! O) u  n  B7 r9 j) O2 q定时器在HAL库中的驱动代码在前面已经介绍了部分，请回顾，这里我们再介绍几个本实验用到的函数。
. a: c7 A: d3 t5 y3 J4.HAL_TIM_OC_Init函数
" [! a& F/ D' X" J定时器的输出比较模式初始化函数，其声明如下：
8 {% s- o( P* ?3 ~8 |% x0 THAL_StatusTypeDef HAL_TIM_OC_Init(TIM_HandleTypeDef *htim);
% t3 g6 p% d! ?1 T/ u8 d/ _8 a8 |函数描述：
$ `) _. r" g. I5 B$ D  v8 y用于初始化定时器的输出比较模式。
- \9 |6 {4 k- K8 k函数形参：
形参1是TIM_HandleTypeDef结构体类型指针变量，基本定时器的时候已经介绍。
( ]: R0 u0 r0 b) v% Y' Q) n函数返回值：
HAL_StatusTypeDef枚举类型的值。
- P% y* j* Y1 U5.HAL_TIM_OC_ConfigChannel函数
定时器的输出比较通道设置初始化函数。其声明如下：
HAL_StatusTypeDef HAL_TIM_OC_ConfigChannel(TIM_HandleTypeDef *htim,
0 N! l2 V4 A! \# ZTIM_OC_InitTypeDef *sConfig, uint32_t Channel);
4 q) h/ L* y) i* a& R函数描述：
该函数用于初始化定时器的输出比较通道。
0 w$ u7 E5 S1 [1 P7 c3 i6 d函数形参：
8 g4 H! c! J* n; _/ l: ?形参1是TIM_HandleTypeDef结构体类型指针变量，用于配置定时器基本参数。
! n5 j# j3 I5 @/ b* E形参2是TIM_OC_InitTypeDef结构体类型指针变量，用于配置定时器的输出比较参数。在通用定时器PWM输出实验已经介绍过TIM_OC_InitTypeDef结构体指针类型。
形参3是定时器通道，范围：TIM_CHANNEL_1到TIM_CHANNEL_6。
函数返回值：
HAL_StatusTypeDef枚举类型的值。
6.HAL_TIM_OC_Start函数
  i1 C8 b" y2 P$ |! I; ^定时器的输出比较启动函数，其声明如下：
HAL_StatusTypeDef HAL_TIM_OC_Start(TIM_HandleTypeDef *htim, uint32_t Channel);
函数描述：
* i: N3 G0 V0 E. L$ y3 B用于启动定时器的输出比较模式。
+ X: a5 I5 z: \4 b0 y函数形参：
8 c# b0 y+ N7 {* `- S* D! b7 b& v形参1是TIM_HandleTypeDef结构体类型指针变量。
+ F$ s; }& W) s& m, r- v形参2是定时器通道，范围：TIM_CHANNEL_1到TIM_CHANNEL_6。
函数返回值：
HAL_StatusTypeDef枚举类型的值。
' }6 J& Z7 ^$ s5 u注意事项：
; }: _, c/ s4 J2 L/ ^HAL库也同样提供了单独使能定时器的输出通道函数，函数为：
void TIM_CCxChannelCmd(TIM_TypeDef TIMx, uint32_t Channel,
uint32_t ChannelState);
HAL_TIM_OC_Start函数内部也调用了该函数。
' Y6 d; d7 s* n! B! B+ Y( d  j定时器输出比较模式配置步骤
, ?! ~5 J3 L0 {# w7 z" t( q1）开启TIMx和通道输出的GPIO时钟，配置该IO口的复用功能输出
- h( U+ r; M. y4 s& n首先开启TIMx的时钟，然后配置GPIO为复用功能输出。本实验我们默认用到定时器1通道1、2、3、4，对应IO是PE9\PE11\PE13\PE14，它们的时钟开启方法如下：
__HAL_RCC_TIM1_CLK_ENABLE(); / 使能定时器1 /
__HAL_RCC_GPIOE_CLK_ENABLE(); / 开启GPIOE时钟 */
IO口复用功能是通过函数HAL_GPIO_Init来配置的。
6 k# @  d3 ]4 h# S" [2）初始化TIMx,设置TIMx的ARR和PSC等参数
, [! N/ ?. D5 g4 d/ g5 W使用定时器的输出比较模式时，我们调用的是HAL_TIM_OC_Init函数来初始化定时器ARR和PSC等参数。
' S$ \$ s% {9 [注意：该函数会调用HAL_TIM_OC_MspInit函数，我们可以通过后者存放定时器和GPIO时钟使能、GPIO初始化、中断使能以及优先级设置等代码。
3）设置定时器为输出比较模式，输出比较极性，输出比较值、翻转功能等参数
在HAL库中，通过HAL_TIM_OC_ConfigChannel函数来设置定时器为输出比较模式，根据需求设置输出比较的极性，设置输出比较值、翻转功能等。
最后我们通过__HAL_TIM_ENABLE_OCxPRELOAD函数使能通道的预装载。
- G: P1 @$ `4 p5 F8 {) ?: c# V4）开启定时器并输出PWM
. |7 n4 y7 @5 g# `# o3 H通过HAL_TIM_OC_Start函数使能定时器并开启输出。

) j( _# L! B( o9 ]9 u4 H* x22.3.3.2 程序流程图

3 T. O/ o6 i; ^1 S- V
  }! a7 q( u5 q  ?* B
7 [& [4 g. _1 b8 J图22.3.3.2.1 高级定时器输出比较模式实验程序流程图
21.3.3.3 程序解析
这里我们只讲解核心代码，详细的源码请大家参考光盘本实验对应源码。高级定时器驱动源码包括两个文件：atim.c和atim.h。
首先看atim.h头文件的几个宏定义：
/*****************************************************************************/
/* TIMX 输出比较模式 定义
' X+ L7 d7 }+ E$ z
这里通过TIM1的输出比较模式,控制PE9,PE11,PE13,PE14输出4路PWM,占空比50%,并且每一路
+ E7 I0 X) M$ a6 UPWM之间的相位差为25%
修改CCRx可以修改相位.
默认是针对TIM1/TIM8
; C1 H1 S& Z' G, M+ j- o9 W. n6 K( E注意: 通过修改这些宏定义,可以支持TIM1~TIM17任意一个定时器,任意一个IO口使用输出比较模式,

1. 输出PWM
   0 p* J7 G" q4 a+ X5 u
2. */
   
3. #define ATIM_TIMX_COMP_CH1_GPIO_PORT            GPIOE
   
4. #define ATIM_TIMX_COMP_CH1_GPIO_PIN             GPIO_PIN_9
   
5. #define ATIM_TIMX_COMP_CH1_GPIO_AF              GPIO_AF1_TIM1          /* AF功能选择 */
   # R. \7 y% H6 |! p2 ^9 V; q; F
6. #define ATIM_TIMX_COMP_CH1_GPIO_CLK_ENABLE()
   5 v( D' s! e0 Q
7. do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)          /* PE口时钟使能 */
   - g2 s. c4 m! Q& Z
8. 
   
9. #define ATIM_TIMX_COMP_CH2_GPIO_PORT            GPIOE
   
10. #define ATIM_TIMX_COMP_CH2_GPIO_PIN             GPIO_PIN_11
    ( h/ R' w- @5 s0 S/ k# M
11. #define ATIM_TIMX_COMP_CH2_GPIO_AF              GPIO_AF1_TIM1          /* AF功能选择 */
    7 ]. l; U) u- H( k8 t9 H" b% |9 `
12. #define ATIM_TIMX_COMP_CH2_GPIO_CLK_ENABLE()   
    
13. do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)           /* PE口时钟使能 */
    6 b" k3 b* {: P) v9 u
14. 
    
15. #define ATIM_TIMX_COMP_CH3_GPIO_PORT            GPIOE
    5 o  \/ n0 Y# i' G7 S+ U
16. #define ATIM_TIMX_COMP_CH3_GPIO_PIN             GPIO_PIN_13
    . `, N/ y; B9 [/ H5 `, e: e, ^
17. #define ATIM_TIMX_COMP_CH3_GPIO_AF              GPIO_AF1_TIM1          /* AF功能选择 */
    
18. #define ATIM_TIMX_COMP_CH3_GPIO_CLK_ENABLE()   
    : Y/ h8 B( s, c; R& |# l
19. do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)          /* PE口时钟使能 */
    
20. 
    ) j) y) X. W) T5 {% p: T0 X& v
21. #define ATIM_TIMX_COMP_CH4_GPIO_PORT            GPIOE
    
22. #define ATIM_TIMX_COMP_CH4_GPIO_PIN             GPIO_PIN_14
    
23. #define ATIM_TIMX_COMP_CH4_GPIO_AF              GPIO_AF1_TIM1          /* AF功能选择 */
    
24. #define ATIM_TIMX_COMP_CH4_GPIO_CLK_ENABLE()   
    
25. do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)           /* PE口时钟使能 */
    
26. 
    
27. #define ATIM_TIMX_COMP              TIM1            
    / E( a" }5 A% F3 `9 n. S
28. #define ATIM_TIMX_COMP_CH1_CCRX   ATIM_TIMX_COMP->CCR1  /* 通道1的输出比较寄存器 */
    & D4 p# O! o9 Z1 H: y
29. #define ATIM_TIMX_COMP_CH2_CCRX   ATIM_TIMX_COMP->CCR2  /* 通道2的输出比较寄存器 */
    
30. #define ATIM_TIMX_COMP_CH3_CCRX   ATIM_TIMX_COMP->CCR3  /* 通道3的输出比较寄存器 */
    9 w% O7 n: f' H1 k, c5 J
31. #define ATIM_TIMX_COMP_CH4_CCRX   ATIM_TIMX_COMP->CCR4  /* 通道4的输出比较寄存器 */
    
32. #define ATIM_TIMX_COMP_CLK_ENABLE()
    
33. do{ __HAL_RCC_TIM1_CLK_ENABLE(); }while(0)   /* TIM1 时钟使能 */
    0 i6 ?: U% G  O% R7 M: P: I
34. /*****************************************************************************/

复制代码

可以把上面的宏定义分成两部分，第一部分是定时器1输出通道1~通道4对应的IO口的宏定义。第二部分则是定时器1的相应宏定义。
下面来看到atim.c文件的程序，首先是高级定时器输出比较模式初始化函数，其定义如下：
* j% ~( P2 G8 \$ E  k" ?: |. I

1. /**
   2 P1 R/ M" r( Q2 z8 `$ Y+ L# Y5 H
2. * @brief       高级定时器TIMX 输出比较模式 初始化函数（使用输出比较模式）
   & G6 M% w' G& r1 ~8 c: s
3. * @note
   
4. *              配置高级定时器TIMX 4路输出比较模式PWM输出,实现50%占空比,不同相位控制
   ' ]1 M6 D" W& h; \0 G
5. *              注意,本例程输出比较模式,每2个计数周期才能完成一个PWM输出,因此输出频率减半
   
6. *              另外,我们还可以开启中断在中断里面修改CCRx,从而实现不同频率/不同相位的控制
   5 v+ N0 t+ W1 y; h' H6 W( ?
7. *              但是我们不推荐这么使用,因为这可能导致非常频繁的中断,从而占用大量CPU资源
   
8. *
   3 T0 ^7 F3 M$ x& k2 }8 N; T
9. *              高级定时器的时钟来自APB1,当D2PPRE2≥2分频的时候
   
10. *              高级定时器的时钟为APB2时钟的2倍, 而APB2为120M, 所以定时器时钟 = 240Mhz
    4 N$ w3 `/ c: B, {
11. *              定时器溢出时间计算方法: Tout = ((arr + 1) * (psc + 1)) / Ft us.
    . l8 H) c# C5 H9 A
12. *              Ft=定时器工作频率,单位:Mhz
    & K2 L& v3 [: Z3 g) {9 O! P8 q
13. * @param       arr: 自动重装值。
    
14. * @param       psc: 时钟预分频数
    
15. * @retval      无
    
16. */
    ! A0 a( r9 ?( c" W0 U5 _
17. void atim_timx_comp_pwm_init(uint16_t arr, uint16_t psc)
    
18. {
    % H+ V8 g" H1 b5 y1 F
19.     TIM_OC_InitTypeDef tim_oc_handle = {0};
    
20.     g_timx_comp_pwm_handle.Instance = ATIM_TIMX_COMP;      /* 定时器1 */
    
21.     g_timx_comp_pwm_handle.Init.Prescaler = psc  ;          /* 定时器分频 */
    2 ~* f% I) N0 n
22.     g_timx_comp_pwm_handle.Init.CounterMode = TIM_COUNTERMODE_UP;/* 递增计数模式*/
    5 P0 ]% |5 {" J* S3 u
23.     g_timx_comp_pwm_handle.Init.Period = arr;               /* 自动重装载值 */
    : K" d1 z  x) X! R2 q
24. g_timx_comp_pwm_handle.Init.AutoReloadPreload =
    ; Y$ T% g" v. r& ^" y( A  S' H
25. TIM_AUTORELOAD_PRELOAD_ENABLE;              /* 使能TIMx_ARR进行缓冲 */
    . z- H( Z% j6 |& \; U7 a; y
26.     HAL_TIM_OC_Init(&g_timx_comp_pwm_handle);           /* 输出比较模式初始化 */
    $ `2 z1 s' B; z7 q0 W1 k3 R* M
27. 
    
28.     tim_oc_handle.OCMode = TIM_OCMODE_TOGGLE;               /* 比较输出模式翻转功能 */
    : ~* q6 ^1 N% S
29.     tim_oc_handle.Pulse = 250;                                 /* 设置输出比较寄存器的值 */
    # h% ]! J& j" p: I. z4 ^
30.     tim_oc_handle.OCPolarity = TIM_OCPOLARITY_HIGH;        /* 输出比较极性为高 */ */
    
31. HAL_TIM_OC_ConfigChannel(&g_timx_comp_pwm_handle, &tim_oc_handle,
    - K; Q. ~, n7 b* h' ]" E
32. TIM_CHANNEL_1); /* 初始化定时器的输出比较通道1 */
    % ^$ X% S5 I- |6 G7 d
33. /* CCR1寄存器预装载使能 */
    $ |* X+ F" e. n7 i) j. [% @9 L- J
34.     __HAL_TIM_ENABLE_OCxPRELOAD(&g_timx_comp_pwm_handle, TIM_CHANNEL_1);
    9 D0 p6 @/ @! Q+ M$ {- u
35. 
    8 d& m4 L; {/ `" G3 B
36.     tim_oc_handle.Pulse = 500;
    
37. HAL_TIM_OC_ConfigChannel(&g_timx_comp_pwm_handle, &tim_oc_handle,
      v% `+ S4 Q' G1 K3 p+ U8 ?/ I# M
38. TIM_CHANNEL_2); /* 初始化定时器的输出比较通道2 */
    2 R4 w" O" I$ K2 _$ _9 f
39. /* CCR2寄存器预装载使能 */
    
40.     __HAL_TIM_ENABLE_OCxPRELOAD(&g_timx_comp_pwm_handle, TIM_CHANNEL_2);
    
41. 
    * c1 X$ k0 d0 X: g) W4 b& i7 F
42.     tim_oc_handle.Pulse = 750;
    
43. HAL_TIM_OC_ConfigChannel(&g_timx_comp_pwm_handle, &tim_oc_handle,
    " S, I7 V0 e6 M
44. TIM_CHANNEL_3); /* 初始化定时器的输出比较通道3 */
    
45. /* CCR3寄存器预装载使能 */
    5 M0 Z7 T' u9 V% g
46.     __HAL_TIM_ENABLE_OCxPRELOAD(&g_timx_comp_pwm_handle, TIM_CHANNEL_3);
    + ^' v) R6 k" e4 c
47.     tim_oc_handle.Pulse = 1000;
    
48. HAL_TIM_OC_ConfigChannel(&g_timx_comp_pwm_handle, &tim_oc_handle,
    
49. TIM_CHANNEL_4); /* 初始化定时器的输出比较通道4 */
    
50. /* CCR4寄存器预装载使能 */   
    . t2 `/ ^! E7 W' G( ~+ j7 v
51. __HAL_TIM_ENABLE_OCxPRELOAD(&g_timx_comp_pwm_handle, TIM_CHANNEL_4);
    6 P/ Z, D' X( [% i- s) c! K4 y4 T
52. 
    
53.     HAL_TIM_OC_Start(&g_timx_comp_pwm_handle,TIM_CHANNEL_1);
    
54.     HAL_TIM_OC_Start(&g_timx_comp_pwm_handle,TIM_CHANNEL_2);
    
55.     HAL_TIM_OC_Start(&g_timx_comp_pwm_handle,TIM_CHANNEL_3);
      s8 z- o" D0 b* d# A) O
56.     HAL_TIM_OC_Start(&g_timx_comp_pwm_handle,TIM_CHANNEL_4);
    
57. }

复制代码

在atim_timx_comp_pwm_init 函数中，首先调用HAL_TIM_OC_Init函数初始化定时器的ARR和PSC等参数。然后通过调用函数HAL_TIM_OC_ConfigChannel设置通道1通道4的工作参数，包括：输出比较模式功能、输出比较寄存器的值，输出极性等。接着调用__HAL_TIM_ENABLE_OCxPRELOAD函数宏使能CCR1/2/3/4寄存器的预装载。最后通过调用函数HAL_TIM_OC_Start来使能TIM1通道1通道4输出。
HAL_TIM_OC_Init函数会调用HAL_TIM_OC_MspInit回调函数，我们把使能定时器和通道对应的IO时钟、IO初始化的代码存放到该函数里，其定义如下：
; B7 q2 \% C" p# O0 Y! B0 y! O; o; s5 p
6 ^0 U! M) s! G4 h  g

1. /**
   1 ]) l5 z5 K* P/ L, f
2. * @brief       定时器输出比较底层驱动
   
3.                   HAL库调用的接口，用于配置不同的输入捕获
   2 Y8 H' o/ d$ S, @8 ~/ |( M: r
4. * @param       htim:定时器句柄
   5 ]8 \, N- [# V1 d1 h
5. * @note        此函数会被HAL_TIM_OC_Init()调用
   9 W3 q# `9 I- y, M$ [& G# r
6. * @retval      无
   8 ^9 K( }  z8 H) T
7. */
   , Z3 T8 H  O! i" h7 x1 s& [
8. void HAL_TIM_OC_MspInit(TIM_HandleTypeDef* htim)
   ) n+ p8 G& {  x& A# ~/ V
9. {
   
10.     if(htim->Instance == ATIM_TIMX_COMP)
    ; f' d1 W- z) U% l; ?  ?
11.     {
    
12.         GPIO_InitTypeDef gpio_init_struct = {0};
      p9 q( P5 @4 ^+ f
13.         ATIM_TIMX_COMP_CLK_ENABLE();
    
14.         ATIM_TIMX_COMP_CH1_GPIO_CLK_ENABLE();
    : j5 q! @4 E  C( }+ G( C5 b
15.         ATIM_TIMX_COMP_CH2_GPIO_CLK_ENABLE();
    
16.         ATIM_TIMX_COMP_CH3_GPIO_CLK_ENABLE();
    
17.         ATIM_TIMX_COMP_CH4_GPIO_CLK_ENABLE();
    7 W" t4 T& k, V3 `2 Q: P
18. 
    : m7 g  o( y0 ^0 D1 F/ s$ q: b
19.         gpio_init_struct.Pin = ATIM_TIMX_COMP_CH1_GPIO_PIN;
    
20.         gpio_init_struct.Mode = GPIO_MODE_AF_PP;
    0 p" k9 j$ r0 H" W6 Q) G, ~# K
21.         gpio_init_struct.Pull = GPIO_NOPULL;
    1 O8 B4 x5 g, U
22.         gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;
    + m3 D  [2 p& M% ?1 ]: F1 Y
23.         gpio_init_struct.Alternate = ATIM_TIMX_COMP_CH1_GPIO_AF;
    
24.         HAL_GPIO_Init(ATIM_TIMX_COMP_CH1_GPIO_PORT, &gpio_init_struct);
    
25. 
    : l/ M% r: u; z# A$ N# p2 S
26.         gpio_init_struct.Pin = ATIM_TIMX_COMP_CH2_GPIO_PIN;
    0 M; c. }" d  r: U# c4 b
27.         gpio_init_struct.Alternate = ATIM_TIMX_COMP_CH2_GPIO_AF;
    
28.         HAL_GPIO_Init(ATIM_TIMX_COMP_CH2_GPIO_PORT, &gpio_init_struct);
    
29. 
    , j2 I4 o5 U0 p
30.         gpio_init_struct.Pin = ATIM_TIMX_COMP_CH3_GPIO_PIN;
    : g  C" u7 ?0 ?  B
31.         gpio_init_struct.Alternate = ATIM_TIMX_COMP_CH3_GPIO_AF;
    9 q# _; T+ Y2 m( g5 R. O) U! M6 T
32.         HAL_GPIO_Init(ATIM_TIMX_COMP_CH3_GPIO_PORT, &gpio_init_struct);
    
33. 
    
34.         gpio_init_struct.Pin = ATIM_TIMX_COMP_CH4_GPIO_PIN;
    
35.         gpio_init_struct.Alternate = ATIM_TIMX_COMP_CH4_GPIO_AF;
    
36.         HAL_GPIO_Init(ATIM_TIMX_COMP_CH4_GPIO_PORT, &gpio_init_struct);
    * A- r- F! n* I% I- f, M
37.     }
    
38. }

复制代码

- u! J) q9 d1 z) I3 L" I该函数主要是使能定时器和通道对应的IO时钟，初始化IO口。要注意IO口的复用功能一定要选对了。
# P: X' t8 y3 }0 L: H. O在main.c里面编写如下代码：
: e8 G  q* w# J% l( G3 J' l, m

1. int main(void)
   
2. {
   + s: [- y0 A  j4 y3 Y( Q# O0 h
3.     uint8_t t = 0;
   * E" S1 k% u# V
4.     sys_cache_enable();                                  /* 打开L1-Cache */
   ! V  Y, Y/ n. `' K
5.     HAL_Init();                                          /* 初始化HAL库 */
   
6.     sys_stm32_clock_init(240, 2, 2, 4);         /* 设置时钟, 480Mhz */
   
7.     delay_init(480);                                    /* 延时初始化 */
   ) f. }" J5 b2 _, N4 Y
8.     usart_init(115200);                                 /* 串口初始化为115200 */
   
9.     led_init();                                                /* 初始化LED */
   
10.     atim_timx_comp_pwm_init(1000 - 1, 240 - 1);  /* 1Mhz的计数频率 1Khz的周期 */
    
11.     /* atim_timx_comp_pwm_init已经设置过输出比较寄存器，这是寄存器操作的方法 */
    
12.     ATIM_TIMX_COMP_CH1_CCRX = 250 - 1;          /* 通道1 相位25% */
    
13.     ATIM_TIMX_COMP_CH2_CCRX = 500 - 1;          /* 通道2 相位50% */
    5 _5 s  B' l8 `+ F5 L% a
14.     ATIM_TIMX_COMP_CH3_CCRX = 750 - 1;          /* 通道3 相位75% */
    ; X, u# m  l) J
15.     ATIM_TIMX_COMP_CH4_CCRX = 1000 - 1;         /* 通道4 相位100% */
    ) F# H: D  Y. q5 ?
16.     while (1)
    % k" ?) K6 {( F( e, O+ S; x
17.     {
    
18.         delay_ms(10);
    
19.         t++;
    ( D2 o, k. [( ]. |! S
20.         if (t >= 20)
    
21.         {
    ' y7 Y& n) t4 ~7 x0 m( w+ {
22.             LED0_TOGGLE();  /* LED0(RED)闪烁 */
    
23.             t = 0;
    
24.         }
    / a3 h. U, U  ?0 v9 n! N
25.     }
    
26. }

复制代码

0 g1 p/ B) g- d% n" E; z6 q( M本小节开头我们讲解了输出比较模式翻转功能如何产生PWM，下面结合程序一起计算出PWM的周期，频率等参数。
定时器1时钟源的时钟频率为2倍的APB2总线时钟频率，即240MHz，而调用atim_timx_comp_pwm_init(1000 - 1, 240 - 1)初始化函数之后，就相当于写入预分频寄存器的值为239，写入自动重载寄存器的值为999。将这些参数代入本小节介绍的翻转功能输出的PWM周期计算公式，可得：
T = 2*(arr+1)((psc+1)/ Tclk) = 2(999+1)*((239+1)/ 240000000) = 0.002s
由上述式子得到PWM周期为2ms，频率为500Hz。ARR值为固定为1000，所以占空比则固定为50%。定时器1通道1~通道4输出的PWM波的相位分别是：25%、50%、75%、100%。
* _% W0 B4 v; b5 V8 H
: t; e5 f; z$ K- t  k5 }22.3.4 下载验证
. _, }/ f" i) \" p- s. ]4 D下载代码后，可以看到LED0在闪烁，说明程序已经正常在跑了。 我们需要借助示波器观察PE9、PE11、PE13和PE14引脚PWM输出的情况，我们已经把示波器的显示内容截图出来，如图22.3.4.1所示：


( N" T: k$ _& P" G% K# k/ G
* O) Z$ Q# r3 K图22.3.4.1 相位为25%、50%、75%、100%的PWM波
图22.3.4.1中，由上到下分别是引脚PE9、PE11、PE13和PE14输出的PWM，即分别对应的是TIM1_CH1、TIM1_CH2、TIM1_CH3和TIM1_CH4输出的相位为25%、50%、75%和100%的PWM。大家可以把其中一个通道的捕获/比较寄存器的值设置为0，那么就可以得到PWM初相位的波形，即相位为0%。

: N6 N  A4 j! e$ U1 U) m* i  L22.4 高级定时器互补输出带死区控制实验
+ a* N4 \1 l: y: \6 M本小节我们来学习使用高级定时器的互补输出带死区控制功能。对于刚接触这个知识的朋友可能会问：什么是互补输出？还带死区控制？What？下面给大家简单说一下。



( C9 t& Z0 K9 z2 T4 h3 ?" K/ _/ H图22.4.1 互补输出
上图中，CH1输出黄色的PWM，它的互补通道CH1N输出绿色的PWM。通过对比，可以知道这两个PWM刚好是反过来的，CH1的PWM为高电平期间，CH1N的PWM则是低电平，反之亦然，这就是互补输出。
下面来看一下什么是带死区控制的互补输出？


2 q5 t* w+ V8 _
$ f0 Y) d( ?% ~图22.4.2 带死区控制的互补输出
/ w& \- u' @0 C; [0 b上图中，CH1输出的PWM和CH1N输出的PWM在高低电平转换间，插入了一段时间才实现互补输出。这段时间称为死区时间，可以通过DTG[7:0]位配置控制死区时间的长度，后面会详细讲解如何配置死区时间。上图中，箭头指出的两段死区时间的长度是一样的，因为都是由同一个死区发生器产生。
理解了互补输出和带死区控制的互补输出，下面来看一下带死区控制的互补输出有什么用？带死区控制的互补输出经常被用于控制电机的H桥中，下面给大家画了一个H桥的简图：



图22.4.3 H桥简图
+ e+ n1 y' U5 H7 T1 t/ w图22.4.3是H桥的简图，实际控制电机正反转的H桥会根据复杂些，而且更多的是使用MOS管，这里只是为了解释带死区控制的互补输出在H桥中的控制逻辑原理，大家理解原理就行。上图的H桥搭建全部使用的是NPN，并且导通逻辑都是基极为高电平时导通。如果Q1和Q4三极管导通，那么电机的电流方向是从左到右（假设电机正转）；如果Q2和Q3三极管导通，那么电机的电流方向是从右到左（假设电机反转）。上述就是H桥控制电机正反转的逻辑原理。但是同一侧的三极管是不可以同时导通的，否则会短路，比如：Q1和Q2同时导通或者Q3和Q4同时导通，这都是不可取的。
# T2 ]: c/ Q  @0 \1 S下面大家想一下图22.4.1的OC1（CH1）和OC1N（CH1N）输出的PWM输入到图22.4.3的H桥中，会怎样？按理来说应该是OC1N输出高电平的时候，OC1输出就是低电平，刚好Q2和Q3导通，电机的电流方向是从右到左（假设电机反转）；反之，OC1输出高电平的时候，OC1N输出就是低电平，刚好Q1和Q4导通，电机的电流方向是从左到右（假设电机正转），这似乎已经完美解决电机正反转问题了。实际上，元器件是有延迟特性的，比如：控制信号从OC1传导至电机，是要经过一定的时间的，复杂的H桥电路更是如此。由于元器件特性，就会导致直接使用互补输出信号驱动H桥时存在短路现象。为了避免这种情况，于是就有了带死区控制的互补输出来驱动H桥电路。如图22.4.2的死区时间就是为了解决元器件延迟特性的。用户必须根据与输出相连接的器件及其特性（电平转换器的固有延迟、开关器件产生的延迟）来调整死区时间。
( F+ u5 U! ~# s; ~( H死区时间计算
下面来看一下定时器的死区时间是怎么计算并设置的？死区时间是由TIMx_CR1寄存器的CKD[1:0]位和TIMx_BDTR寄存器的DTG[7:0]位来设置，如下图所示：
+ H/ i5 ^  ?/ c/ Z7 S* q

. f2 k+ w4 ~/ N& Z8 {
: y, K& m+ ^1 _2 c图22.4.4 CKD[1:0]和DTG[7:0]位
死区时间计算分三步走：
第一步：通过CKD[1:0]位确定tDTS。根据CKD[1:0]位的描述，可以得到下面的式子：

9 o$ Z6 L8 X5 t- c* K* _( C% d7 ~2 d其中：
CKD[1:0]：CKD[1:0]位设置的值。
  n) N3 o0 @5 MTclk：定时器的时钟源频率（单位为MHz）。
假设定时器时钟源频率是240MHz，我们设置CKD[1:0]位的值为2，代入上面的式子可得：
+ F7 f* z4 x1 w, I, G% k6 \
+ C- r! O% X( \7 y通过上式可得tDTS约等于16.67ns，本实验例程中我们也是这样设置的。
7 v8 b5 v% ~9 G& }6 W! q第二步：根据DTG[7:5]选择计算公式。
第三步：代入选择的公式计算。
下面给大家举个例子，假设定时器时钟源频率是240MHz，我们设置CKD[1:0]位的值为2，DTG[7:0]位的值为250。从上面的例子知道CKD[1:0]位的值为2，得到的tDTS=16.67ns。下面来看一下DTG[7:0]位的值为250，应该选择DTG[7:0]位描述中哪条公式？250的二进制数为11111010，即DTG[7:5]为111，所以选择第四条公式：DT=(32+ DTG[4:0]) * t dtg，其中t dtg = 16 * tDTS。可以看到手册上的式子符号大小写乱乱的，这里大小写不敏感。由手册的公式可以得到DT = (32+ DTG[4:0]) * 16 * tDTS = (32+ 26) * 16 * 16.67ns = 15469.76ns = 15.47us，即死区时间为15.47us。死区时间计算方法就给大家介绍到这里。
关于互补输出和死区插入的更多内容请看《STM32H7xx参考手册_V3（中文版）.pdf》手册的38.3.15小节（1423页），下面我们介绍相关的寄存器。
7 x0 k6 e4 g8 u9 j2 ^) W
8 {7 f$ e  H& f22.4.1 TIM1/TIM8寄存器
$ c3 j" y# H0 j5 p" h5 l7 L" `' B高级定时器互补输出带死区控制除了用到定时器的时基单元：计数器寄存器(TIMx_CNT)、预分频器寄存器(TIMx_PSC)、自动重载寄存器(TIMx_ARR) 之外。主要还用到以下这些寄存器：
控制寄存器 1（TIMx_CR1）
TIM1/TIM8的控制寄存器1描述如图22.4.1.1所示：


7 d/ N- j- _6 s1 X- T* G$ N
1 M* t/ q5 F7 U  L图22.4.1.1 TIMx_CR1寄存器
4 k% _5 P; G9 l2 R: i上图中我们只列出了本实验需要用的一些位，其中：位7（APRE）用于控制自动重载寄存器是否进行缓冲，在基本定时器的时候已经讲过，请回顾。本实验中，我们把该位置1。
CKD[1:0]位指示定时器时钟（CK_INT）频率与死区发生器以及数字滤波器（ETR、TIx）所使用的死区及采样时钟（tDTS）之间的分频比。我们设置CKD[1:0]位为10，结合定时器时钟源频率是2倍APB2总线时钟频率，即240MHz，可以得到tDTS=16.67ns。
CEN位，用于使能计数器的工作，必须要设置该位为1，才可以开始计数。
捕获/比较模式寄存器1/2（TIMx_CCMR1/2）
, Q/ e; s( u- I+ o) i: ?TIM1/TIM8的捕获/比较模式寄存器（TIMx_CCMR1/2），该寄存器一般有2个：TIMx_CCMR1和TIMx _CCMR2。TIMx_CCMR1控制CH1和CH2，而TIMx_CCMR2控制CH3和CH4。TIMx_CCMR1寄存器描述如图22.4.1.2所示：

# H& q2 R/ }- b5 \
8 ^) x% s5 ]6 e2 d4 H" b' f
图22.4.1.2 TIMx_CCMR1寄存器
该寄存器的有些位在不同模式下，功能不一样，我们现在用到输出比较模式。关于该寄存器的详细说明，请参考《STM32H7xx参考手册_V3（中文版）.pdf》第1458页，38.4.7节。
本实验我们用到了定时器1输出比较的通道1，所以我们需要配置TIM1_CCMR1模式设置位OC1M[3:0]，我们使用的是PWM模式1，所以这4位必须设置为0110。
捕获/比较使能寄存器（TIMx_ CCER）
TIM1/TIM8的捕获/比较使能寄存器，该寄存器控制着各个输入输出通道的开关和极性。TIMx_CCER寄存器描述如图22.4.1.3所示：


9 z- Y6 ]" K, r8 C7 V, r& ]
- K$ v1 Q. l1 |$ C/ P- M图22.4.1.3 TIMx_CCER寄存器
该寄存器比较简单，要让TIM1的通道1输出，我们需要把对应的捕获/比较1输出使能位CC1E置1。因为本实验中，我们需要实现互补输出，所以还需要把CC1NE位置1，使能互补通道输出。CC1P和CC1NP分别是通道1输出和通道1互补输出的极性设置位。这里我们把CC1P和CC1NP位都置1，即输出极性为低，就可以得到互补的PWM。
6 l& u+ a' [" O+ @6 [. c捕获/比较寄存器1/2/3/4（TIMx_CCR1/2/3/4）
捕获/比较寄存器（TIMx_ CCR1/2/3/4），该寄存器总共有4个，对应4个通道CH1~CH4。我们使用的是通道1，所以来看看TIMx_ CCR1寄存器描述如图22.4.1.4所示：


$ r1 v1 W  L: l, f' p
7 x8 A) G$ c" ]' Z图22.4.1.4 TIMx_ CCR1寄存器
+ v1 i! v: A& T9 n' }9 Y( Z对于TIM1和TIM8来说，该寄存器16位有效位，本实验中可以通过改变该寄存器的值来改变PWM的占空比。
断路和死区寄存器（TIMx_ BDTR）
TIM1/TIM8断路和死区寄存器，该寄存器各位描述如图22.4.1.5所示：
. x" K5 @! p- G: ^$ T  r
# \' o  `. w7 ~9 g) Y8 C) f
! C7 n- A8 A- s- i. R
图22.4.1.5 TIMx_ BDTR寄存器
6 b$ S  W, a+ T) x: o% Z6 k该寄存器控制定时器的断路和死区控制的功能。我们先看断路控制，H7系列的高级定时器TIM1/TIM8有两个断路通道，本实验我们用到断路1（断路输入引脚为PE15）。要使用断路1就要使能位BKE，置1即可。
3 K3 X  [, N1 D( J1 _$ x6 t  z位BKP选择断路输入信号有效电平。本实验中，我们选择低电平有效，即BKP置0。
1 `, t  Y- ~% C/ r4 e, K- v位AOE是自动输出使能位，如果使能AOE位，那么在我们输入刹车信号后再断开了刹车信号，互补的PWM会自动恢复输出，如果失能AOE位，那么在输入刹车信号后再断开了刹车信号，互补的PWM就不会恢复输出，而是一直保持刹车信号输入时的状态。为了方便观察，我们使能该位，即置1。
% U! L* j# u) i# SBKF[3:0]是断路输入信号的滤波器，这里我们不需要用滤波器，所以这4个位置0。
要使用断路2功能可以参考断路1的配置即可。
位MOE是使能主输出，想要高级定时器的通道正常输出，则必须设置MOE位为1。
最后是DTG[7:0]位，用于设置死区时间，前面已经教过大家怎么设置了。这里以我们例程的设置为例，CKD[1:0] 设置为10，定时器时钟源频率是240MHz，所以tDTS = 16.67ns。
! [% z  u8 G( P5 U2 a本例程的DTG[7:0]位的值设置为十进制100，即二进制数0110 0100。DTG[7:5]=011，符合第一条式子：DT=DTG[7:0] * t dtg，其中 t dtg = tDTS。DT是死区时间，可以得到DT = 100*16.67 ns = 1.67us。到后面下载验证小节，我们通过示波器验证一下这个死区时间计算的理论值和实际值是否一样。

, J# l9 o3 q# [2 }2 W+ @4 \22.4.2 硬件设计
1.例程功能
$ R" s, N! ]1 r  O4 t* B1，利用TIM1_CH1(PE9)输出70%占空比的PWM，它的互补输出通道(PE8)则是输出30%占空比的PWM。
5 x/ `, I4 }1 J( x2，刹车功能，当给刹车输入引脚(PE15)输入低电平时，进行刹车，即PE9和PE8停止输出PWM。
4 o* Z8 Y0 ]2 u1 ~3 Q3，LED0闪烁指示程序运行。
' L! v& C1 b& h' \2.硬件资源
" a1 y! O  n' ?, |& k1）RGB灯
- q8 K' m5 P/ b' tRED ：LED0 - PB4
2）定时器1
) g! [, T# p7 s: Q# z8 qTIM1正常输出通道 PE9
TIM1互补输出通道 PE8
TIM1刹车输入 PE15
$ X+ u" d& y3 Y- a& \4 d9 u3.原理图
7 l# D. L2 m# T+ \& S( w定时器属于STM32H750的内部资源，只需要软件设置好即可正常工作。我们需要通过示波器观察PE9和PE8引脚PWM输出的情况。还可以通过给PE15引脚接入低电平进行刹车。
' J% D$ X# H3 _: h6 J1 B
22.4.3 程序设计
22.4.3.1 定时器的HAL库驱动
定时器在HAL库中的驱动代码在前面已经介绍了部分，这里我们再介绍几个本实验用到的函数。
4.HAL_TIMEx_ConfigBreakDeadTime函数
0 P  @* M9 G+ I6 ~定时器的断路和死区时间配置初始化函数，其声明如下：
HAL_StatusTypeDef HAL_TIMEx_ConfigBreakDeadTime(TIM_HandleTypeDef *htim,
TIM_BreakDeadTimeConfigTypeDef *sBreakDeadTimeConfig);
函数描述：
用于初始化定时器的断路（即刹车）和死区时间。
' v0 y" X7 X& R) V函数形参：
" g) h; C2 b2 H, r1 L& v2 u形参1是TIM_HandleTypeDef结构体类型指针变量，基本定时器的时候已经介绍。
' H' y3 }4 Q, H$ J* D& A形参2是TIM_BreakDeadTimeConfigTypeDef结构体类型指针变量，用于配置断路和死区参数，其定义如下：
: t5 p- R0 w! q9 E) z. E6 c

1. typedef struct
   
2. {
   
3.   uint32_t OffStateRunMode;              /* 运行模式下的关闭状态选择 */
   
4.   uint32_t OffStateIDLEMode;             /* 空闲模式下的关闭状态选择 */
   
5.   uint32_t LockLevel;                     /* 寄存器锁定配置 */
   
6.   uint32_t DeadTime;                      /* 死区时间设置 */
   4 \& Q# {( j* }1 N2 O5 V7 X
7.   uint32_t BreakState;                    /* 断路（即刹车）输入使能控制 */
   
8.   uint32_t BreakPolarity;                /* 断路输入极性 */
   
9.   uint32_t BreakFilter;                          /* 断路输入滤波器 */
   
10.   uint32_t Break2State;                          /* 断路2输入使能控制 */
    
11.   uint32_t Break2Polarity;                      /* 断路2输入极性 */
    
12.   uint32_t Break2Filter;                 /* 断路2输入滤波器 */
    
13.   uint32_t AutomaticOutput;                     /* 自动恢复输出使能控制 */
    - A$ X5 p& R% j5 M
14. } TIM_BreakDeadTimeConfigTypeDef;

复制代码

函数返回值：
HAL_StatusTypeDef枚举类型的值。
1 m2 }3 L2 g  B# @. C/ j9 Q5 F$ X) s& B) s2. HAL_TIMEx_PWMN_Start函数
. w/ f: m4 x4 G6 _定时器的互补输出启动函数。其声明如下：
HAL_StatusTypeDef HAL_TIMEx_PWMN_Start(TIM_HandleTypeDef htim,
uint32_t Channel);
函数描述：
; M; P1 g4 M1 w4 a% x( _  b该函数用于启动定时器的互补输出。
0 o. U' {, Q3 u函数形参：
形参1是TIM_HandleTypeDef结构体类型指针变量，用于配置定时器基本参数。
形参2是定时器通道，范围：TIM_CHANNEL_1到TIM_CHANNEL_6。
函数返回值：
4 |' \  j5 \  V. W7 m/ XHAL_StatusTypeDef枚举类型的值。
定时器互补输出带死区控制配置步骤
1）开启TIMx和通道输出以及刹车输入的GPIO时钟，配置该IO口的复用功能输出
首先开启TIMx的时钟，然后配置GPIO为复用功能输出。本实验我们默认用到定时器1通道1，对应IO是PE9，互补输出通道引脚是PE8，刹车输入引脚是PE15，它们的时钟开启方法如下：
5 f, O) w8 ?% |+ b: r8 `__HAL_RCC_TIM1_CLK_ENABLE(); / 使能定时器1 /
& x9 S; H% ~- M& n: C__HAL_RCC_GPIOE_CLK_ENABLE(); / 开启GPIOE时钟 */
* o, {1 e2 n4 B" cIO口复用功能是通过函数HAL_GPIO_Init来配置的。
2）初始化TIMx，设置TIMx的ARR和PSC等参数
  }5 Q9 r# c6 e5 [" u% s: z- ~这里我们要使用定时器的PWM模式功能，所以调用的是HAL_TIM_PWM_Init函数来初始化定时器ARR和PSC等参数。注意：本实验要使用该函数配置TIMx_CR1寄存器的CKD[1:0]位，从而确定t DTS，方便后续设置死区时间。
注意：该函数会调用：HAL_TIM_PWM_MspInit函数，但是为不跟前面的实验共用该回调函数，提高独立性，我们就直接在atim_timx_cplm_pwm_init函数中，使能定时器时钟和GPIO时钟，初始化通道对应IO引脚等。
( S  v0 ^9 O7 R3）设置定时器为PWM模式，输出比较极性，互补输出极性等参数
( p- c" x* t  e2 z4 [0 a3 w通过HAL_TIM_PWM_ConfigChannel函数来设置定时器为PWM1模式，根据需求设置OCy输出极性和OCyN互补输出极性等。
8 G* ~2 v2 ]5 q+ ~, k1 j' W1 l4）设置死区参数
% U. J0 M5 o0 W& K8 r8 i8 _通过HAL_TIMEx_ConfigBreakDeadTime函数来设置死区参数，比如：设置死区时间、运行模式的关闭输出状态、空闲模式的关闭输出状态、刹车输入有效信号极性、刹车输入信号滤波设置、是否使用断路2和是否允许刹车后自动恢复输出等。
! V; e3 _3 V# B8 [: q5）启动Ocy输出以及OCyN互补输出
; t0 M/ k# X9 Z6 d通过HAL_TIM_PWM_Start函数启动OCy输出，通过HAL_TIMEx_PWMN_Start函数启动启动OCyN互补输出。
22.4.3.2 程序流程图

% c8 l2 f6 L0 p; q# \; H+ F

$ X4 R+ n# T+ Q8 i5 f4 X! b* I# c图22.4.3.2.1 高级定时器互补输出带死区控制实验
22.4.3.3 程序解析
& D8 T# h. c( C/ w+ ^# W这里我们只讲解核心代码，详细的源码请大家参考光盘本实验对应源码。高级定时器驱动源码包括两个文件：atim.c和atim.h。
0 t& C9 D3 E/ d; {! |首先看atim.h头文件的几个宏定义：

1. /*****************************************************************************/
   
2. /* TIMX 互补输出模式 定义
   * v7 W& P' N- ]
3. * 这里设置互补输出相关硬件配置, CHY即正常输出, CHYN即互补输出
   
4. * 修改CCRx可以修改占空比.
   1 k; S# q1 E) ]3 Y& j: o
5. * 默认是针对TIM1/TIM8
   
6. * 注意: 通过修改这些宏定义,可以支持TIM1~TIM17任意一个定时器,任意一个IO口(前提是该定时器必须有互补输出功能)
   
7. */
   
8. /* 输出通道引脚 */
   % k& \" M; w! O! |6 ~: j
9. #define ATIM_TIMX_CPLM_CHY_GPIO_PORT            GPIOE
   
10. #define ATIM_TIMX_CPLM_CHY_GPIO_PIN             GPIO_PIN_9
    
11. #define ATIM_TIMX_CPLM_CHY_GPIO_AF              GPIO_AF1_TIM1    /* AF功能选择 */
    * V/ ?6 B  l( K+ X
12. #define ATIM_TIMX_CPLM_CHY_GPIO_CLK_ENABLE()   
    3 h, K* N+ ~" u2 \, m3 q5 n
13. do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)   /* PE口时钟使能 */
    5 T& \$ ?; |* A& t& Z
14. 
    
15. /* 互补输出通道引脚 */
    
16. #define ATIM_TIMX_CPLM_CHYN_GPIO_PORT           GPIOE
    
17. #define ATIM_TIMX_CPLM_CHYN_GPIO_PIN            GPIO_PIN_8
    
18. #define ATIM_TIMX_CPLM_CHYN_GPIO_AF             GPIO_AF1_TIM1    /* AF功能选择 */
    
19. #define ATIM_TIMX_CPLM_CHYN_GPIO_CLK_ENABLE()   
    ; |2 x5 }9 V2 ^6 X2 S2 u$ ]/ {/ h
20. do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)   /* PE口时钟使能 */
    ( x# F# ]  ~) @& O4 h7 `
21. 
    
22. /* 刹车输入引脚 */
    
23. #define ATIM_TIMX_CPLM_BKIN_GPIO_PORT           GPIOE
    
24. #define ATIM_TIMX_CPLM_BKIN_GPIO_PIN            GPIO_PIN_15
    ; q& [& v7 F  A- \6 d
25. #define ATIM_TIMX_CPLM_BKIN_GPIO_AF             GPIO_AF1_TIM1    /* AF功能选择 */
    ! L% M4 A$ a+ o) K' h
26. #define ATIM_TIMX_CPLM_BKIN_GPIO_CLK_ENABLE()   
    + D& p* Q6 x$ C5 L9 d. ]
27. do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)   /* PE口时钟使能 */
    
28. 
    
29. /* 互补输出使用的定时器 */
    ) f& k5 c6 K" L3 A" I
30. #define ATIM_TIMX_CPLM                          TIM1
    * H) I$ p! m3 e" w1 m
31. #define ATIM_TIMX_CPLM_CHY                     TIM_CHANNEL_1
    
32. #define ATIM_TIMX_CPLM_CHY_CCRY               ATIM_TIMX_CPLM->CCR1
    : D4 r9 j; r0 y, A
33. #define ATIM_TIMX_CPLM_CLK_ENABLE()   
    
34.           do{ __HAL_RCC_TIM1_CLK_ENABLE(); }while(0)   /* TIM1 时钟使能 */
    
35. /*****************************************************************************/

复制代码

可以把上面的宏定义分成两部分，第一部分包括是定时器1输出、互补输出和刹车输入通道对应的IO口的宏定义，第二部分则是定时器1的相应宏定义。
下面来看atim.c文件的程序，首先是高级定时器互补输出初始化函数，其定义如下：
% B( }. m& {9 d
9 ?) `- A7 w/ }! ~/ x

1. /**
   
2. * @brief      高级定时器TIMX 互补输出 初始化函数（使用PWM模式1）
   2 V' t& X; \6 B3 n5 N$ T
3. * @note
   9 ~) N4 t5 ?7 _: }3 Z; W# D
4. *              配置高级定时器TIMX 互补输出, 一路OCy 一路OCyN, 并且可以设置死区时间
   
5. *
   
6. *              高级定时器的时钟来自APB1,当D2PPRE2≥2分频的时候
   ' [, I5 g+ k% s, }" l- N5 F
7. *              高级定时器的时钟为APB2时钟的2倍, 而APB2为120M, 所以定时器时钟 = 240Mhz
     R) R; t0 @+ Z2 k6 G
8. *              定时器溢出时间计算方法: Tout = ((arr + 1) * (psc + 1)) / Ft us.
   ( E$ T) g% \7 r8 W) O5 t' }
9. *              Ft=定时器工作频率,单位:Mhz
   
10. * @param       arr: 自动重装值。
    6 @# U% o2 p/ B9 @
11. * @param       psc: 时钟预分频数
    
12. * @retval      无
    / u+ @7 a% R/ V0 O& _. c
13. */
    % [; F9 J7 g' D
14. void atim_timx_cplm_pwm_init(uint16_t arr, uint16_t psc)
    
15. {
    
16.     TIM_OC_InitTypeDef tim_oc_handle = {0};
    
17.     GPIO_InitTypeDef gpio_init_struct = {0};
    
18. 
    
19.     ATIM_TIMX_CPLM_CLK_ENABLE();              /* TIMx 时钟使能 */
    % K8 Y2 [) V5 I: V- r# J
20.     ATIM_TIMX_CPLM_CHY_GPIO_CLK_ENABLE();   /* 通道X对应IO口时钟使能 */
    7 }2 ~2 Y0 w' [' o, Q( g  Q& \6 z
21.     ATIM_TIMX_CPLM_CHYN_GPIO_CLK_ENABLE();  /* 通道X互补通道对应IO口时钟使能 */
    
22.     ATIM_TIMX_CPLM_BKIN_GPIO_CLK_ENABLE();  /* 通道X刹车输入对应IO口时钟使能 */
    & f; h9 r. ?) ]$ G: {5 i9 M8 |
23. 
    
24.     gpio_init_struct.Pin = ATIM_TIMX_CPLM_CHY_GPIO_PIN;
    
25.     gpio_init_struct.Mode = GPIO_MODE_AF_PP;
    
26.     gpio_init_struct.Pull = GPIO_PULLUP;
    2 f  K5 x* ?/ E# b0 @# z
27.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH ;
    
28.     gpio_init_struct.Alternate = ATIM_TIMX_CPLM_CHY_GPIO_AF;
    
29.     HAL_GPIO_Init(ATIM_TIMX_CPLM_CHY_GPIO_PORT, &gpio_init_struct);
    4 j5 v2 u0 P3 B( `8 H% x' z
30. 
    
31.     gpio_init_struct.Pin = ATIM_TIMX_CPLM_CHYN_GPIO_PIN;
    
32.     gpio_init_struct.Alternate = ATIM_TIMX_CPLM_CHYN_GPIO_AF;
    6 r0 n, y( C3 F% T4 k
33.     HAL_GPIO_Init(ATIM_TIMX_CPLM_CHYN_GPIO_PORT, &gpio_init_struct);
    2 |1 K% K. [1 K7 A) U; w
34. 
    
35.     gpio_init_struct.Pin = ATIM_TIMX_CPLM_BKIN_GPIO_PIN;
    $ y" W, P% J' r8 G% N# K$ q
36.     gpio_init_struct.Alternate = ATIM_TIMX_CPLM_BKIN_GPIO_AF;
    
37.     HAL_GPIO_Init(ATIM_TIMX_CPLM_BKIN_GPIO_PORT, &gpio_init_struct);
    
38. 
    
39.     g_timx_cplm_pwm_handle.Instance = ATIM_TIMX_CPLM;     /* 定时器x */
    
40.     g_timx_cplm_pwm_handle.Init.Prescaler = psc;           /* 定时器预分频系数 */
    9 X2 I$ w+ L* L! t7 q
41.     g_timx_cplm_pwm_handle.Init.CounterMode = TIM_COUNTERMODE_UP;/* 递增计数 */
    
42. g_timx_cplm_pwm_handle.Init.Period = arr;              /* 自动重装载值 */
    
43. /* CKD[1:0] = 10, tDTS = 4 * tCK_INT = Ft / 4 = 60Mhz*/
    / m; W; L& H3 e4 l8 _3 n8 W- r
44.     g_timx_cplm_pwm_handle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV4;
    
45. g_timx_cplm_pwm_handle.Init.AutoReloadPreload =
    
46. TIM_AUTORELOAD_PRELOAD_ENABLE; /* 使能TIMx_ARR 寄存器进行缓冲 */
    / I+ V: i% }/ f  }
47.     HAL_TIM_PWM_Init(&g_timx_cplm_pwm_handle);
    
48. 
      b$ D. [2 `0 |3 a! w
49.     tim_oc_cplm_pwm.OCMode = TIM_OCMODE_PWM1;             /* PWM模式1 */
    ( W$ t9 h  \: c/ o. ^
50.     tim_oc_cplm_pwm.OCPolarity = TIM_OCPOLARITY_LOW;     /* OCy输出极性为低 */
    
51.     tim_oc_cplm_pwm.OCNPolarity = TIM_OCNPOLARITY_LOW;  /* OCyN互补输出极性为低 */
    
52.     tim_oc_cplm_pwm.OCIdleState = TIM_OCIDLESTATE_SET;  /* 当MOE=0，OCx=1 */
    9 u6 W  X) k: f/ v/ s' k
53.     tim_oc_cplm_pwm.OCNIdleState = TIM_OCNIDLESTATE_SET;/* 当MOE=0，OCxN=1 */
    
54. HAL_TIM_PWM_ConfigChannel(&g_timx_cplm_pwm_handle, &tim_oc_cplm_pwm,
    * P, W% Q* X( P9 k3 q: B
55. ATIM_TIMX_CPLM_CHY);
    
56. 
    
57. /* 设置死区参数 */
    
58. /* 运行模式的关闭输出状态 */
    
59. g_sbreak_dead_time_config.OffStateRunMode = TIM_OSSR_DISABLE;
    
60. /* 空闲模式的关闭输出状态 */
    7 ?4 H! O  S& X! e
61.     g_sbreak_dead_time_config.OffStateIDLEMode = TIM_OSSI_DISABLE;         
    
62.     g_sbreak_dead_time_config.LockLevel = TIM_LOCKLEVEL_OFF;/* 不用寄存器锁功能 */
    
63. g_sbreak_dead_time_config.BreakState = TIM_BREAK_ENABLE;/* 使能刹车输入 */
    8 J2 N0 z4 A- J  R  n
64. /* 刹车输入有效信号极性 */
    
65.     g_sbreak_dead_time_config.BreakPolarity = TIM_BREAKPOLARITY_LOW;        
    : F& x  k4 A- G- d3 v
66.     g_sbreak_dead_time_config.BreakFilter = 0;    /* 刹车输入信号滤波设置 */
    
67. g_sbreak_dead_time_config.Break2State = TIM_BREAK2_DISABLE; /* 不使用断路2 */
    
68. /* 使能AOE位，允许刹车结束后自动恢复输出 */
    
69.     g_sbreak_dead_time_config.AutomaticOutput = TIM_AUTOMATICOUTPUT_ENABLE;
    
70. HAL_TIMEx_ConfigBreakDeadTime(&g_timx_cplm_pwm_handle,
    1 F. z4 q; g+ ]9 k: K: m, I
71. &g_sbreak_dead_time_config);
    " [, l' T2 w2 f+ G) I
72. 
    
73.     HAL_TIM_PWM_Start(&g_timx_cplm_pwm_handle, ATIM_TIMX_CPLM_CHY);
    
74.     HAL_TIMEx_PWMN_Start(&g_timx_cplm_pwm_handle,ATIM_TIMX_CPLM_CHY);
    
75. }
    7 u; M* x" C. j( m! k  r

复制代码

在atim_timx_cplm_pwm_init函数中，没有使用HAL库的MSP回调，而是把相关的初始化都写到该函数里面。
第一部分，使能定时器和相关通道对应的GPIO时钟，以及初始化相关IO引脚。
' B0 |( u3 h" P# q3 T+ ^+ ~: P第二部分，通过HAL_TIM_PWM_Init函数初始化定时器的ARR和PSC等参数。
第三部分，通过HAL_TIM_PWM_ConfigChannel函数设置PWM模式1、输出极性，以及输出空闲状态等。
- w3 a3 h2 z( F. S( x第四部分，通过HAL_TIMEx_ConfigBreakDeadTime函数配置断路功能。
最后一定记得要调用HAL_TIM_PWM_Start函数和HAL_TIMEx_PWMN_Start函数启动通道输出和互补通道输出。
" h3 I4 h) ]- {& U为了方便，我们还定义了设置输出比较值和死区时间的函数，其定义如下：

! H) b+ }! e6 {" o0 a2 g

1. /**
   ; y- }. x+ [6 f: u& J
2. * @brief       定时器TIMX 设置输出比较值 & 死区时间
   . e0 O: o2 S9 [% H; l8 D# ?/ I
3. * @param       ccr: 输出比较值
   4 V: B# Q, Q; I: p8 |$ {  O) M+ k
4. * @param       dtg: 死区时间
   
5. *   @arg       dtg[7:5]=0xx时, 死区时间 = dtg[7:0] * tDTS
   
6. *   @arg       dtg[7:5]=10x时, 死区时间 = (64 + dtg[6:0]) * 2  * tDTS
   / w5 n5 X0 `! b3 O- X
7. *   @arg       dtg[7:5]=110时, 死区时间 = (32 + dtg[5:0]) * 8  * tDTS
   & g( j; |1 m7 h  J8 A
8. *   @arg       dtg[7:5]=111时, 死区时间 = (32 + dtg[5:0]) * 16 * tDTS
   
9. *   @note      tDTS = 1 / (Ft /  CKD[1:0]) = 1 / 60M = 16.67ns
   # N) W7 q; @+ e5 C
10. * @retval      无
    
11. */
    * \0 |4 {+ R0 W8 b( K5 P: L
12. void atim_timx_cplm_pwm_set(uint16_t ccr, uint8_t dtg)
    + A9 T1 w; `  _
13. {
    5 _. n9 j9 U: Y; q$ m
14.     sbreak_dead_time_Config.DeadTime = dtg;          /* 死区时间设置 */
    
15. HAL_TIMEx_ConfigBreakDeadTime(&g_timx_cplm_pwm_handle,
    
16. &sbreak_dead_time_Config);  /* 重设死区时间 */
    
17.     __HAL_TIM_MOE_ENABLE(&g_timx_cplm_pwm_handle);  /* MOE=1,使能主输出 */
    ! a! G4 B4 P0 d  Y7 \, A: N
18.     ATIM_TIMX_CPLM_CHY_CCRY = ccr;                     /* 设置比较寄存器 */
    
19. }

复制代码

通过重新调用HAL_TIMEx_ConfigBreakDeadTime函数设置死区时间，注意这里的g_sbreak_dead_time_config是全局结构体变量，在atim_timx_cplm_pwm_init函数已经初始化其他结构体成员了，这里只是对DeadTime成员（死区时间）配置。死区时间的计算方法前面已经讲解过，这里只要把要设置的DTG[7:0]值，通过dtg形参赋值给DeadTime结构体成员就行。另外一个形参是ccr，用于设置捕获/比较寄存器的值，即控制PWM的占空比。
( \) I; m5 P8 }在main.c里面编写如下代码：

1. int main(void)
   8 ~/ Q" p. W% S4 h2 P, c# t
2. {
   1 C2 B; r3 _; O, l; K% O# |  w
3.     uint8_t t = 0;
   
4.     sys_cache_enable();                                    /* 打开L1-Cache */
   
5.     HAL_Init();                                              /* 初始化HAL库 */
   ; t6 z4 C8 R8 p! q
6.     sys_stm32_clock_init(240, 2, 2, 4);                 /* 设置时钟, 480Mhz */
   + C) s: @# \1 H$ G0 r# G: l, Z
7.     delay_init(480);                                        /* 延时初始化 */
   5 D  c6 N/ m2 A4 v0 I: x
8.     usart_init(115200);                                    /* 串口初始化为115200 */
   , X8 v! H- B% P
9.     led_init();                                                     /* 初始化LED */
   
10.     atim_timx_cplm_pwm_init(1000 - 1, 24 - 1);        /* 10Mhz的计数频率 10Khz的周期 */
    . `9 w! d4 T3 Q& `
11.     atim_timx_cplm_pwm_set(300, 100);                  /* 占空比:7:3,死区时间100*tDTS */
    
12.     while (1)
    5 E4 b! x" z' E1 y% j# M
13.     {
    
14.         delay_ms(10);
    
15.         t++;
    
16.         if (t >= 20)
      I" w0 s5 c5 T0 M1 k, X
17.         {
    $ y- Y& O2 B) K) k
18.             LED0_TOGGLE();  /* LED0(RED)闪烁 */
    
19.             t = 0;
    
20.         }
    - q: j$ `  r2 X; P# \  j7 U
21.     }
    
22. }

复制代码

先看atim_timx_cplm_pwm_init(1000 - 1, 24 - 1)这个语句，这两个形参分别设置自动重载寄存器的值为999，以及定时器预分频器寄存器的值为23。先看预分频系数，我们设置为24分频，定时器1的时钟源频率是2倍的APB2总线时钟频率，即240MHz，可以得到计数器的计数频率是10MHz，即每0.1us计数一次。再到自动重载寄存器的值为999决定的是PWM的频率（周期），可以得到PWM的周期为(999+1)0.1us = 100us。边沿对齐模式下，使用PWM模式1或者PWM模式2，得到的PWM周期是定时器溢出时间。这里的100us，也可以直接通过定时器溢出时间计算公式Tout= ((arr+1)(psc+1))/Tclk得到。
  Q/ _' {7 b% d( q, b调用atim_timx_cplm_pwm_set(300, 100) 这个语句，相当于设置捕获/比较寄存器的值为300，DTG[7:0]的值为100。通过计算可以得到PWM的占空比为70%，死区时间为1.667us。根据PWM生成原理分析，再结合图21.3.2产生PWM示意图，以及我们在atim_timx_cplm_pwm_init函数配置PWM模式1、OCy输出极性为低，占空比的计算很简单，可以由(1000-300)/1000得到。关于死区时间的计算方法，前面已经讲解过，这里以DTG[7:0]的值为100为例，再来讲解一遍计算过程。由前面讲解的内容知道，我们例程配置CKD[1:0]位的值为2，可以得到tDTS= 16.67ns。基于这个前提，通过改变DTG[7:0]的值，可以得到不同的死区时间。这里我们配置DTG[7:0]的值为100，即二进制数0110 0100，符合第一种情况dtg[7:5]=0xx时，死区时间DT = DTG [7:0] * tDTS。可以得到死区时间DT = 100*16.67 ns = 1.67us。
下面我们下载到开发板验证一下。
22.4.4 下载验证
: E! z/ R% M* O) D下载代码后，可以看到LED0在闪烁，说明程序已经正常在跑了。 我们需要借助示波器观察PE9正常输出和PE8互补输出PWM的情况，示波器显示截图如图22.4.4.1所示：


0 b4 [" ^% z- N2 s
图22.4.4.1 PE9正常输出和PE8互补输出PWM的情况
6 \" K' s. A8 W4 G3 J图22.4.4.1中的由上到下分别是PE9输出70%占空比的PWM波和PE8互补输出30%占空比的PWM波。互补输出的PWM波的正脉宽减去正常的PWM的负脉宽的值除以2就是死区时间，也可以是正常的PWM的正脉宽减去互补输出的PWM波的负脉宽的值除以2。我们使用第一种方法得到：死区时间 =（31.7–28.3）/2 us= 1.7us。与我们理论计算得到的值1.67us差不多，这样的误差是正常的。
要是不相信，我们再举个例子，我们把调用的函数改为atim_timx_cplm_pwm_set(300, 250)，即配置DTG[7:0]的值为250，这个例子的计算过程在本实验前面死区时间计算的内容讲过，这里就不再赘述。经过计算得到死区时间DT =15.47us。修改好后，示波器显示截图如下图所示：

6 f6 \- p, Z$ u6 d7 W' \) I/ `
/ P: i5 }) Y* w+ Z0 g7 K6 g7 f, I
( R9 c  Y! H$ L, A图22.4.4.2 修改程序后PE9正常输出和PE8互补输出PWM的情况
由图22.4.4.2可得到，死区时间DT =（45.5–14.5）/2 us= 15.5us。与我们理论计算得到的值15.47us也是差不多的，误差在正常范围。由此证明我们的死区时间设置是没有问题。
, q& l0 v7 Z  ^2 i刹车功能验证：当给刹车输入引脚（PE15）接入低电平（这里直接用杜邦线把PE15连接到GND）时，就会进行刹车，MOE位被硬件清零。由《STM32H7xx参考手册_V3（中文版）.pdf》第1465页 表313可以知道刹车信号输入后，如果存在时钟，经过死区后OCx=OISx 且 OCxN=OISxN。在atim_timx_cplm_pwm_init函数中，我们设置当MOE=0时，OCx=1、OCxN=1，即PE9和PE8都是输出高电平。下面通过示波器来验证一下，如图22.4.4.3所示：

0 E4 f2 x: _: O4 k6 a
8 D0 {( |1 X' X  ]! _" y4 d
! V. Y+ J& w! Y3 S7 p2 |; J图22.4.4.3 刹车后的输出情况
6 c- Y+ @  H: H* ?! G
* R; ^: N  n! v$ d4 a6 z: k从上图可以看到PE9和PE8输出的都是高电平，符合我们预期的设置。
% K1 f( B6 C; O另外因为我们使能了AOE位（即把该位置1），如果刹车输入为无效极性时，MOE位在发生下一个更新事件时自动置1，恢复运行模式（即继续输出PWM）。因此当停止给PE15接入低电平（拔掉之前连接的杜邦线），PWM会自动恢复输出。
! n- m+ V. n$ v& ?" d- M3 w
8 ]2 Y/ H8 @2 [, ?# Q, L; A22.5 高级定时器PWM输入模式实验
9 L5 J2 `$ v8 x! G1 y9 t本小节我们来学习使用高级定时器PWM输入模式，此模式是输入捕获模式的一个特例。PWM输入模式经常被应用于测量PWM脉宽和频率。PWM输入模式在《STM32H7xx参考手册_V3（中文版）.pdf》手册1415页有详细的文字描述。下面我们结合这些文字，配合高级定时器框图给大家介绍PWM输入的工作原理。


1 f1 [/ [1 ?) Z
图22.5.1 PWM输入模式工作原理示意图
7 f1 F- H* _  G! w第一，确定定时器时钟源。本实验中我们使用内部时钟（CK_INT），H7系列高级定时器挂载在APB2总线上，按照sys_stm32_clock_init函数的配置，定时器时钟频率为2倍APB2总线时钟频率，即240MHz。计数器的计数频率确定了测量的精度。
第二，确定PWM输入的通道。PWM输入模式下测量PWM，PWM信号输入只能从通道1（CH1）或者通道2（CH2）输入。
$ `% U4 ~7 {  Y$ V( Z第三，确定IC1和IC2的捕获边沿。这里以通道1（CH1）输入PWM为例，一般我们习惯设置IC1捕获边沿为上升沿捕获，IC2捕获边沿为下降沿捕获。
  b. k2 A" q9 w, W0 g2 ~第四，选择触发输入信号（TRGI）。这里也是以通道1（CH1）输入PWM为例，那么我们就应该选择TI1FP1为触发输入信号。如果是通道2（CH2）输入PWM，那就选择TI2FP2为触发输入信号。可以看到这里并没有对应通道3（CH3）或者通道4（CH4）的触发输入信号，所以我们只选择通道1或者通道2作为PWM输入的通道。
/ U* j7 ]4 p0 {* s) ^! Q8 Y1 P' T第五，从模式选择：复位模式。复位模式的作用是：在出现所选触发输入 (TRGI) 上升沿时，重新初始化计数器并生成一个寄存器更新事件。
, ~4 P* `" J- I  w! v第六，读取一个PWM周期内计数器的计数个数，以及高电平期间的计数个数，再结合计数器的计数周期（即计一个数的时间），最终通过计算得到输入的PWM周期和占空比等参数。以通道1（CH1）输入PWM，设置IC1捕获边沿为上升沿捕获，IC2捕获边沿为下降沿捕获为例，那么CCR1寄存器的值+1就是PWM周期内计数器的计数个数，CCR2寄存器的值+1就是PWM高电平期间计数器的计数个数。通过这两个值就可以计算出PWM的周期或者占空比等参数。
, I! S& k2 s5 I再举个例子，以通道1（CH1）输入PWM，设置IC1捕获边沿为下降沿捕获，IC2捕获边沿为上升沿捕获为例，那么CCR1寄存器的值+1依然是PWM周期内计数器的计数个数，但是CCR2寄存器的值+1就是PWM低电平期间计数器的计数个数。通过这两个得到的参数依然可以计算出PWM的其它参数。这个大家了解一下就可以了，一般我们使用第六介绍的例子。
通过上面的描述，如果大家还不理解，下面我们结合PWM输入模式时序来分析一下。PWM输入模式时序图如图22.5.2所示：
$ e# A. j2 U0 t) L7 p" l& J$ p8 b


图22.5.2 PWM输入模式时序图
图22.5.2是以通道1（CH1）输入PWM，设置IC1捕获边沿为上升沿捕获，IC2捕获边沿为下降沿捕获为例的PWM输入模式时序图。
5 r5 D9 i) S* T& G; G从时序图可以看出，计数器的计数模式是递增计数模式。从左边开始看，当TI1来了上升沿时，计数器的值被复位为0（原因是从模式选择为复位模式），IC1和IC2都发生捕获事件。然后计数器的值计数到2的时候，IC2发生了下降沿捕获，捕获事件会导致这时候的计数器的值被锁存到CCR2寄存器中，该值+1就是高电平期间计数器的计数个数。最后计数器的值计数到4的时候，IC1发生了上升沿捕获，捕获事件会导致这时候的计数器的值被锁存到CCR1寄存器中，该值+1就是PWM周期内计数器的计数个数。
3 S5 V8 R0 a; u4 T4 C  `& P1 ?假设计数器的计数频率是240MHz，那我们就可以计算出这个PWM的周期、频率和占空比等参数了。下面就以这个为例给大家计算一下。由计数器的计数频率为240MHz，可以得到计数器计一个数的时间是4.167ns（即测量的精度是4.167ns）。知道了测量精度，再来计算PWM的周期，PWM周期 =(4+1)*(1/240000000) = 20.83ns，那么PWM的频率就是48MHz。占空比 = (2+1)/(4+1) =3/5（即占空比为60%）。
22.5.1 TIM1/TIM8寄存器
/ p+ R8 g0 f. D2 ?1 E0 |7 {) D高级定时器PWM输入模式实验除了用到定时器的时基单元：计数器寄存器(TIMx_CNT)、预分频器寄存器(TIMx_PSC)、自动重载寄存器(TIMx_ARR) 之外。主要还用到以下这些寄存器：
; l, i( B! B6 L, U8 C& |从模式控制寄存器（TIMx_SMCR）
/ g, L: y9 v  PTIM1/TIM8的从模式控制寄存器描述如图22.5.1.1所示：
6 u7 h# v+ v* O1 `- y
+ _/ _4 n& t! S
" f. k, |5 `2 t3 j; n) H) X
图22.5.1.1 TIMx_SMCR寄存器
/ o: b3 J. L4 G5 Z2 T该寄存器的SMS[3:0]位，用于从模式选择。比如本实验中我们要用复位模式，所以设置SMS[3:0]=0100。TS[2:0]位是触发选择，我们设置为TI1FP1，即TS[4:0]=00101。
捕获/比较模式寄存器1/2（TIMx_CCMR1/2）
  v# u5 }* g/ R' NTIM1/TIM8的捕获/比较模式寄存器（TIMx_CCMR1/2），该寄存器一般有2个：TIMx_CCMR1和TIMx _CCMR2。TIMx_CCMR1控制CH1和CH2，而TIMx_CCMR2控制CH3和CH4。TIMx_CCMR1寄存器描述如图22.5.1.2所示：


) A! T0 p- t2 F) o$ g
图22.5.1.2 TIMx_CCMR1寄存器
- n3 H6 ]5 y+ w3 l4 T$ {该寄存器的有些位在不同模式下，功能不一样，我们现在用到输入捕获模式。关于该寄存器的详细说明，请参考《STM32H7xx参考手册_V3（中文版）.pdf》第1458页，38.4.7节。
本实验我们通过定时器1通道1输入PWM信号，所以IC1和IC2都映射到TI1上。配置CC1S[1:0]=01、CC2S [1:0]=10，其他位不用设置，默认为0即可。
% a7 O+ [9 U) {' t  c4 E$ Y6 J 捕获/比较使能寄存器（TIMx_ CCER）
( X3 O2 H8 z" Y  ^. gTIM1/TIM8的捕获/比较使能寄存器，该寄存器控制着各个输入输出通道的开关和极性。TIMx_CCER寄存器描述如图22.5.1.3所示：



4 B1 e1 O$ I" x: K/ \图22.5.1.3 TIMx_CCER寄存器
% _3 }* I3 i9 e& K- ^IC1捕获上升沿，所以CC1P位置0，即捕获发生在IC1的上升沿。IC2捕获下降沿，所以CC2P位置1，即捕获发生在IC1的下降沿。设置好捕获边沿后，还需要使能这两个通道捕获，即CC1E和CC2E位置1。
' q: V/ H2 Q9 u6 C捕获/比较寄存器1/2/3/4（TIMx_CCR1/2/3/4）
6 d3 R9 S* @. X3 H6 ~* v. n1 \捕获/比较寄存器（TIMx_ CCR1/2/3/4），该寄存器总共有4个，对应4个通道CH1~CH4。我们使用的是通道1，所以来看看TIMx_ CCR1寄存器描述如图22.5.1.4所示：

2 _9 o9 Z4 S7 W3 F+ E3 O/ [+ }
: d+ P( g' W3 _$ P% {2 Y2 V
$ o5 f2 L. w8 ?5 X5 P* k, C. v图22.5.1.4 TIMx_ CCR1寄存器
本实验中，CCR1寄存器用于获取PWM周期内计数器的计数个数。CCR2寄存器用于获取PWM高电平期间计数器的计数个数。
DMA/中断使能寄存器（TIMx_DIER）
DMA/中断使能寄存器描述如图22.5.1.5所示：


' Z2 B9 S% T% Y& p* s$ @! R! }! W
. y5 [/ N$ Y) h' g; N图22.5.1.5 TIMx_DIER寄存器
该寄存器位0（UIE）用于使能或者禁止更新中断，因为本实验我们用到更新中断，所以该位需要置1。位1（CC1IE）用于使能或者禁止捕获/比较1中断，我们用到捕获中断，所以该位需要置1。
1 p2 D( l( a2 d6 H
' N' ~1 s; n/ ^& W+ n7 V22.5.2 硬件设计
1.例程功能
首先通过TIM12_CH1(PB14)输出PWM波。然后把PB14输出的PWM波用杜邦线接入PE9（定时器1通道1），最后通过串口打印PWM波的脉宽和频率等信息。LED0闪烁来提示程序正在运行。
2 f" @4 V' H- K, \3 Z" o3 @2.硬件资源
) S+ R1 \: t! [1）RGB灯
% ?7 g/ u1 J* u* x! {: FRED : LED0 - PB4
/ \+ p9 ]$ L" V7 {/ l( \2）定时器12通道1（PB14）输出PWM波
定时器1通道1（PE9）输入PWM波
9 v% z" r1 q4 _& T* ~, ~7 F9 X3.原理图
7 E0 j' Y: L4 r( Y定时器属于STM32H750的内部资源，只需要软件设置好即可正常工作。我们把PB14引脚输出的PWM波用杜邦线接入PE9引脚，然后通过电脑串口上位机软件观察打印出来的信息。

22.5.3 程序设计
1 O2 q* z; l( K+ Y# C. g$ u定时器PWM输入模式实验用到的HAL库中的驱动代码在前面实验都有介绍过了。 我们在程序解析再详细讲解应用到的函数，下面介绍一下高级定时器PWM输入模式的配置步骤。
' g' o4 B* M7 a! F( {高级定时器PWM输入模式配置步骤
1）开启TIMx和输入通道的GPIO时钟，配置该IO口的复用功能输入
4 R% c4 Q, t" q首先开启TIMx的时钟，然后配置GPIO为复用功能输出。本实验我们默认用到定时器1通道1，对应IO是PE9，它们的时钟开启方法如下：
__HAL_RCC_TIM1_CLK_ENABLE(); /* 使能定时器1 /
* j3 X, W0 o. T1 a0 }__HAL_RCC_GPIOA_CLK_ENABLE(); / 开启GPIOE时钟 */
IO口复用功能是通过函数HAL_GPIO_Init来配置的。
2）初始化TIMx，设置TIMx的ARR和PSC等参数
使用定时器的输入捕获功能时，我们调用的是HAL_TIM_IC_Init函数来初始化定时器ARR和PSC等参数。
" b! Z, T; b& |; Q; |8 Y, p& d' f注意：该函数会调用：HAL_TIM_IC_MspInit函数，但是为不跟前面的实验共用该回调函数，提高独立性，我们就直接在atim_timx_pwmin_chy_init函数中，使能定时器时钟和GPIO时钟，初始化通道对应IO引脚等。
$ S4 }# s2 W8 T7 A! [+ Q( V$ H6 z3）从模式配置，IT1触发更新
通过HAL_TIM_SlaveConfigSynchronization函数，配置从模式：复位模式、定时器输入触发源、边缘检测、是否滤波等。
+ n: S1 Z* `0 H: L4）设置IC1捕获相关参数
$ C; t4 r3 a9 z: ?* |* ?通过HAL_TIM_IC_ConfigChannel函数来设置定时器捕获通道1的工作方式，包括边缘检测极性、映射关系，输入滤波和输入分频等。
5）设置IC2捕获相关参数
通过HAL_TIM_IC_ConfigChannel函数来设置定时器捕获通道2的工作方式，包括边缘检测极性、映射关系，输入滤波和输入分频等。
6）使能定时器更新中断，开启捕获功能，配置定时器中断优先级
7 h0 q0 T6 Q9 Q& L* n. r4 ^6 w5 M" v通过__HAL_TIM_ENABLE_IT函数使能定时器更新中断。
通过HAL_TIM_IC_Start_IT函数使能定时器并开启通道1或者通道2的捕获功能，使能捕获中断。
通过HAL_NVIC_EnableIRQ函数使能定时器中断。
通过HAL_NVIC_SetPriority函数设置中断优先级。
  ~/ Z- W) o3 Y; G$ |0 _' ]0 i7）编写中断服务函数
H7系列的TIM1和TIM8 有独立的输入捕获中断服务函数，分别是TIM1_CC_IRQHandler和TIM8_CC_IRQHandler，其他定时器则没有，所以如果是TIM1和TIM8可以直接使用输入捕获中断服务函数来处理输入捕获中断。在使用TIM1的时候，如果要考虑定时器1溢出，可以重定义更新中断服务函数TIM1_UP_IRQHandler。如果使用HAL库的中断回调机制，可以在相关中断服务函数中直接调用定时器中断公共处理函数HAL_TIM_IRQHandler，然后我们直接重定义相关的中断回调函数来编写中断程序即可。本实验为了兼容性，我们自定义一个中断处理函数atim_timx_pwmin_chy_process，里面包含了捕获中断和更新中断的处理，具体看源码。
! v; N3 i+ C. R  l# L5 z
8 y& ^. ~# Y- u1 s  c! {3 I
/ b+ V/ i' b% a22.5.3.1 程序流程图
3 P& ~* b  N; S* e
* @% [' {" j7 z5 {; n- b# h9 B3 _" a
, y/ @* g! Z. l, h
" Z3 [9 ~9 k+ x. n, X* I图22.5.3.1.1 高级定时器PWM输入模式实验程序流程图
: t2 x* V5 E/ `, d# S22.5.3.2 程序解析
这里我们只讲解核心代码，详细的源码请大家参考光盘本实验对应源码。高级定时器驱动源码包括两个文件：atim.c和atim.h。
首先看atim.h头文件的几个宏定义：
5 b: n. q- d8 b, F

1. /*****************************************************************************/
   ; g5 y/ M& T, q9 s
2. /* TIMX PWM输入模式 定义
   
3. * 这里的输入捕获使用定时器TIM1_CH1,捕获WK_UP按键的输入
   - b+ G3 r: v" |  Z1 u; `3 |8 ^  f
4. * 默认是针对TIM1/TIM8等高级定时器
   # o2 ~: Y' _% Y8 D( q- T% L
5. * 注意: 通过修改这9个宏定义,可以支持TIM2~TIM5,TIM12/TIM15任意一个定时器的通道1/通道2
   
6. *       特别要注意:如果改其他IO, 通道选择, AF功能等也得改!
   
7. */
   
8. #define ATIM_TIMX_PWMIN_CHY_GPIO_PORT           GPIOE
   
9. #define ATIM_TIMX_PWMIN_CHY_GPIO_PIN            GPIO_PIN_9
   / M4 T9 O# N  d
10. #define ATIM_TIMX_PWMIN_CHY_GPIO_AF             GPIO_AF1_TIM1  /* AF功能选择 */
    5 q9 _+ k) U: C
11. #define ATIM_TIMX_PWMIN_CHY_GPIO_CLK_ENABLE()   
    
12. do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)   /* PE口时钟使能 */
    
13. 
    
14. #define ATIM_TIMX_PWMIN                        TIM1                       
    
15. #define ATIM_TIMX_PWMIN_IRQn                  TIM1_UP_IRQn
    
16. #define ATIM_TIMX_PWMIN_IRQHandler           TIM1_UP_IRQHandler
    
17. #define ATIM_TIMX_PWMIN_CHY                   TIM_CHANNEL_1   /* 通道Y,  1<= Y <=2*/
    2 K2 |7 j4 t! b' a9 Q
18. #define ATIM_TIMX_PWMIN_CHY_CLK_ENABLE()      
    " W. b& J% _& h* ^2 f' _! O
19. do{ __HAL_RCC_TIM1_CLK_ENABLE(); }while(0)  /* TIMX 时钟使能 */
    ) X* b6 X/ p/ v$ W9 h. O
20. 
    ) g0 I  m" D! e7 H) T1 K# }1 K7 e" S
21. /* TIM1 / TIM8 有独立的捕获中断服务函数,需要单独定义,对于TIM2~5/TIM12/TIM15等,
    
22. 则不需要以下定义 */
    
23. #define ATIM_TIMX_PWMIN_CC_IRQn                 TIM1_CC_IRQn
    % r( ^# k. ^( w0 q: m
24. #define ATIM_TIMX_PWMIN_CC_IRQHandler          TIM1_CC_IRQHandler
    
25. /*****************************************************************************/
    
26. 可以把上面的宏定义分成三部分，第一部分包括是定时器1通道1对应的IO口的宏定义，第二部分则是定时器1的相应宏定义，另外针对TIM1/ TIM8有独立的捕获中断服务函数，需要单独定义。
    
27. 下面看atim.c的程序，首先是高级定时器PWM输入模式初始化函数，其定义如下：
    ' h6 P; o) O- J6 v. |! z
28. /**
    
29. * @brief     定时器TIMX 通道Y PWM输入模式 初始化函数
    
30. * @note
    
31. *              通用定时器的时钟来自APB1,当D2PPRE1≥2分频的时候
    ( h) {+ k3 E! n' u
32. *              通用定时器的时钟为APB1时钟的2倍, 而APB1为120M, 所以定时器时钟 = 240Mhz
    
33. *              定时器溢出时间计算方法: Tout = ((arr + 1) * (psc + 1)) / Ft us.
    
34. *              Ft=定时器工作频率,单位:Mhz
    7 b1 m/ W1 y3 M3 E/ a
35. *
    7 E. s) ^' G. r' T& k* K9 @
36. *             本函数初始化的时候: 使用psc=0, arr固定为65535. 得到采样时钟频率为240Mhz,
    " |- A$ ]% W2 V" D8 ]
37. 精度4.167ns
    * U) Q' v3 z7 e% U2 F3 N8 J! q
38. *
    " ]9 ~  w# }' ]; G, l/ v6 O7 |4 s$ B9 _
39. * @param       无
    
40. * @retval      无
    
41. */
    
42. void atim_timx_pwmin_chy_init(void)
    
43. {
    
44. {
    ! q( S& c+ }8 J
45.     GPIO_InitTypeDef gpio_init_struct = {0};
    
46.     TIM_SlaveConfigTypeDef slave_config = {0};
    
47.     TIM_IC_InitTypeDef tim_ic_pwmin_chy = {0};
    / S% t7 ^+ `) B$ e
48. 
    
49.     ATIM_TIMX_PWMIN_CHY_CLK_ENABLE();
    
50.     ATIM_TIMX_PWMIN_CHY_GPIO_CLK_ENABLE();      /* TIMX 通道IO口时钟使能 */
    
51. 
    . x! N% n* S" o( m
52.     gpio_init_struct.Pin = ATIM_TIMX_PWMIN_CHY_GPIO_PIN;
    & v9 ~& r5 X( c: Q0 t' _
53.     gpio_init_struct.Mode = GPIO_MODE_AF_PP;
    - Q* x3 Q7 i+ X3 I3 z1 [5 @
54.     gpio_init_struct.Pull = GPIO_PULLDOWN;
    5 \  U) i4 W" o. {
55.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_VERY_HIGH ;
    & H7 a- g* [: C6 j
56.     gpio_init_struct.Alternate = ATIM_TIMX_PWMIN_CHY_GPIO_AF;
    
57.     HAL_GPIO_Init(ATIM_TIMX_PWMIN_CHY_GPIO_PORT, &gpio_init_struct);
    
58. 
    
59.     g_timx_pwmin_chy_handle.Instance = ATIM_TIMX_PWMIN;   /* 定时器x */
    4 [6 S6 p2 `- V& }- V6 g
60.     g_timx_pwmin_chy_handle.Init.Prescaler = 0;            /* 定时器预分频系数 */
    # C% z+ w# R$ F1 C' s6 |5 K3 {( ~" O
61.     g_timx_pwmin_chy_handle.Init.CounterMode = TIM_COUNTERMODE_UP; /* 递增计数 */
    
62.     g_timx_pwmin_chy_handle.Init.Period = 65535;           /* 自动重装载值 */
    
63.     HAL_TIM_IC_Init(&g_timx_pwmin_chy_handle);
    
64. 
    0 t3 D. f8 s7 c: m/ `* m0 \& D2 V
65.     /* 从模式配置,IT1触发更新 */
    
66.     slave_config.SlaveMode = TIM_SLAVEMODE_RESET;    /* 从模式: 复位模式 */
    ! {& A" D. F/ m) l
67.     slave_config.InputTrigger = TIM_TS_TI1FP1;       /* 定时器输入触发源: TI1FP1 */
    
68.     slave_config.TriggerPolarity = TIM_INPUTCHANNELPOLARITY_RISING;/*上升沿检测*/
    ! {+ _! |. S) I, y) j. ]  G. L) o3 p; D
69.     slave_config.TriggerFilter = 0;                                      /* 不滤波 */
    , O5 V- b9 t' l. L" u1 S
70.     HAL_TIM_SlaveConfigSynchronization(&g_timx_pwmin_chy_handle, &slave_config);
    
71. 
    3 b+ z( R4 Z. T& B* g
72.     /* IC1捕获：上升沿触发TI1FP1 */
    
73.     tim_ic_pwmin_chy.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;/* 上升沿检测 */
    
74.     tim_ic_pwmin_chy.ICSelection = TIM_ICSELECTION_DIRECTTI;/* IC1映射到TI1上 */
    
75.     tim_ic_pwmin_chy.ICPrescaler = TIM_ICPSC_DIV1;            /* 不分频 */
    , f8 j. N* l1 `( D$ Z& O7 n
76.     tim_ic_pwmin_chy.ICFilter = 0;                               /* 不滤波 */
    
77. HAL_TIM_IC_ConfigChannel(&g_timx_pwmin_chy_handle, &tim_ic_pwmin_chy,
    ( i2 D- }1 X4 |0 Q0 F
78. TIM_CHANNEL_1);
    
79. 
    
80.     /* IC2捕获：下降沿触发TI1FP2 */
    
81.     tim_ic_pwmin_chy.ICPolarity = TIM_INPUTCHANNELPOLARITY_FALLING;/*下降沿检测*/
    
82.     tim_ic_pwmin_chy.ICSelection = TIM_ICSELECTION_INDIRECTTI;/*IC2映射到TI1上*/
    ) l( s1 b. [" x+ y" |% P- y
83. HAL_TIM_IC_ConfigChannel(&g_timx_pwmin_chy_handle, &tim_ic_pwmin_chy,
    
84. TIM_CHANNEL_2);
    5 N1 L2 g/ R+ ?
85. /* 设置中断优先级，抢占优先级1，子优先级3 */
    % }9 K, ]: A! u5 t
86.     HAL_NVIC_SetPriority(ATIM_TIMX_PWMIN_IRQn, 1, 3);                       
    4 U: j! W. t2 E+ z! Z. [
87.     HAL_NVIC_EnableIRQ(ATIM_TIMX_PWMIN_IRQn);          /* 开启ITMx中断 */
    
88. 
    
89.     /* TIM1/TIM8 有独立的输入捕获中断服务函数 */
    
90.     if (ATIM_TIMX_PWMIN == TIM1 || ATIM_TIMX_PWMIN == TIM8)
    8 m8 \5 L' A# q; I
91. {
    & S6 Q4 J) U' ]1 d
92. /* 设置中断优先级，抢占优先级1，子优先级3 */
    
93.         HAL_NVIC_SetPriority(ATIM_TIMX_PWMIN_CC_IRQn, 1, 3);
    
94.         HAL_NVIC_EnableIRQ(ATIM_TIMX_PWMIN_CC_IRQn);  /* 开启ITMx中断 */
    $ m* Q, u% m2 @/ ]; n/ Y6 ?0 [+ t
95.     }
    + s3 x& V3 K$ J/ {. @
96. 
    % y& f+ @) j4 R' M# n$ a- Q
97.     __HAL_TIM_ENABLE_IT(&g_timx_pwmin_chy_handle, TIM_IT_UPDATE);
    
98.     HAL_TIM_IC_Start_IT(&g_timx_pwmin_chy_handle, TIM_CHANNEL_1);
    % e/ k6 z% g2 R2 p
99.     HAL_TIM_IC_Start_IT(&g_timx_pwmin_chy_handle, TIM_CHANNEL_2);
    : t: Y; B* H# \6 c& j+ h
100. }

复制代码

在atim_timx_pwmin_chy_init函数中，没有使用HAL库的MSP回调，而是把相关的初始化都写到该函数里面。
第一部分，使能定时器和相关通道对应的GPIO时钟，以及初始化相关IO引脚。
$ |. A% u1 U& r. G$ P0 Q8 v3 q第二部分，通过HAL_TIM_IC_Init函数初始化定时器的ARR和PSC等参数。
第三部分，通过HAL_TIM_SlaveConfigSynchronization函数配置从模式，复位模式等。
第四部分，通过HAL_TIM_IC_ConfigChannel函数分别配置IC1和IC2。
第五部分，配置NVIC，如使能定时器中断，配置抢占优先级和响应优先级。
. w, ~' O' \0 ~" @3 {7 o9 E; N/ u最后，通过调用HAL_TIM_IC_Start_IT函数和__HAL_TIM_ENABLE_IT函数宏使能捕获中断和更新中断，并且使能定时器。
8 C: e& p* K: ^为了方便，我们定义了重新启动捕获函数，其定义如下：

1. /**
   4 U# E# a+ h, a4 S1 Z! s+ s- `! G1 C& n
2. * @brief       定时器TIMX PWM输入模式 重新启动捕获
   
3. * @param       无
   $ }1 f1 h/ h9 G9 T' n, ^! ~
4. * @retval      无
   
5. */
   
6. void atim_timx_pwmin_chy_restart(void)
   
7. {
   / q  _, E6 |% @% f! D
8.     sys_intx_disable();                            /* 关闭中断 */
   / q4 U9 m5 n' q! a3 k4 M* p# q
9. 
   
10.     g_timxchy_pwmin_sta = 0;                      /* 清零状态,重新开始检测 */
    
11.     g_timxchy_pwmin_psc = 0;                      /* 分频系数清零 */
    
12. 
    0 N9 r6 \9 }! B# C5 `) G
13. /* 以最大的计数频率采集,以得到最好的精度 */
    % x  ]" t' I4 Q9 J
14.     __HAL_TIM_SET_PRESCALER(&g_timx_pwmin_chy_handle, 0);  
    3 j* J$ K% @# F8 m6 ]5 l
15.     __HAL_TIM_SET_COUNTER(&g_timx_pwmin_chy_handle, 0);       /* 计数器清零 */
    # {" r# W& H- A* r* Z, z
16. 
    
17.     __HAL_TIM_ENABLE_IT(&g_timx_pwmin_chy_handle, TIM_IT_CC1);/* 使能捕获中断 */
    
18.     __HAL_TIM_ENABLE_IT(&g_timx_pwmin_chy_handle, TIM_IT_UPDATE);/*使能更新中断*/
    ! A0 c6 ], f, O, P' R* \* }
19.     __HAL_TIM_ENABLE(&g_timx_pwmin_chy_handle);                /* 使能定时器TIMX */
    ; q- Q$ k5 Z% {. f  r2 h4 U/ r0 H
20. 
    
21. ATIM_TIMX_PWMIN->SR = 0;            /* 清除所有中断标志位 */
    ! W3 R6 @5 G1 E$ Q) z
22. 
    , C7 R; }2 z4 X. M% I! j
23.     sys_intx_enable();                   /* 打开中断 */
    ; x5 q9 t7 F! \4 X% ^* K( W
24. }

复制代码

该函数首先关闭所有中断，然后把一些状态标志位清零、设置定时器预分频系数、计数器值、使能相关中断、以及清除相关中断标志位，最后才允许被中断。
最后要介绍的是中断服务函数，在定时器1的输入捕获中断服务函数TIM1_CC_IRQHandler和更新中断服务函数TIM1_UP_IRQHandler里面都是直接调用atim_timx_pwmin_chy_process函数。输入捕获中断服务函数和更新中断服务函数都是用到宏定义的，这三个函数定义如下：
) l! f- L, R: ^+ d: F0 {

1. /**
   9 f9 B$ ^* @+ s0 o
2. * @brief       定时器TIMX 更新/溢出 中断服务函数
   2 c) m) u0 ^3 [8 g! M
3. *   @note      TIM1/TIM8的这个函数仅用于更新/溢出中断服务,捕获在另外一个函数!
   
4. *              其他普通定时器则更新/溢出/捕获,都在这个函数里面处理!
   - y8 r$ |1 W! Y$ `- c
5. * @param       无
   : |2 O+ M, t; }( `+ i$ c
6. * @retval      无
   3 m3 @5 z" Z( @. }' ]; @5 t
7. */
   
8. void ATIM_TIMX_PWMIN_IRQHandler(void)
   4 U% C) h. j/ s, O0 Y
9. {
   ( s: ~% B9 n  q$ l  h
10.     atim_timx_pwmin_chy_process();
    
11. }
    + i$ g$ o; C: c/ t4 V
12. 
    
13. /**
    
14. * @brief       定时器TIMX 输入捕获 中断服务函数
    
15. *   @note      仅TIM1/TIM8有这个函数,其他普通定时器没有这个中断服务函数!
    
16. * @param       无
    8 J1 D; w) w$ X( m1 V; W5 N
17. * @retval      无
    
18. */
    * L6 _5 i2 j/ F- o# O( }# k
19. void ATIM_TIMX_PWMIN_CC_IRQHandler(void)
    
20. {
    
21.     atim_timx_pwmin_chy_process();
    
22. }
    # X' q! C7 l% V) ]* @& H6 Z$ [
23. 
    
24. /**
    
25. * @brief       定时器TIMX 通道Y PWM输入模式 中断处理函数
    : v( j) e% z7 Z8 q+ R
26. * @note
    
27. * 因为TIM1/TIM8等有多个中断服务函数,而TIM2~5/TIM12/TIM15等普通定时器只有1个中断服务
    $ {/ a. n% K. M9 C$ ^2 m+ i
28. * 函数,为了更好的兼容,我们对中断处理统一放到atim_timx_pwin_chy_process函数里面进行处理
    
29. *
    
30. * @param       无
    * \, E9 @% t* U
31. * @retval      无
    
32. */
    ! W% r$ K: _5 {; H' G. w% U
33. static void atim_timx_pwmin_chy_process(void)
    
34. {
    9 b4 x( M# Y1 D5 S' ~4 F
35.     static uint8_t sflag = 0;               /* 启动PWMIN输入检测标志 */
    * Q0 x% n7 b0 |
36. 
    / m( d6 d) d$ ?  s9 |% n) R
37.     if (g_timxchy_pwmin_sta)
    
38.     {
    & c* d0 i& _- a* Z) `
39.         g_timxchy_pwmin_psc = 0;
    ( v* F  W9 K% k
40. ATIM_TIMX_PWMIN->SR = 0;            /* 清除所有中断标志位 */
    
41.         __HAL_TIM_SET_COUNTER(&g_timx_pwmin_chy_handle, 0);      /* 计数器清零 */
    . H4 T' d. F# i' Q( R$ N* B
42.         return ;
    
43. }
    
44. 
    
45. /* 如果发生了更新中断 */
    + t. A% W% G9 d* V$ W
46.     if (__HAL_TIM_GET_FLAG(&g_timx_pwmin_chy_handle, TIM_FLAG_UPDATE))
    
47. {
    
48. /* 清除更新中断标记 */
      W# X8 ?' C4 K7 p) W
49.         __HAL_TIM_CLEAR_FLAG(&g_timx_pwmin_chy_handle, TIM_FLAG_UPDATE);     
    " A0 \9 H4 q" h0 d% u& }
50. /* 没有发生周期捕获中断,且捕获未完成 */
    
51.         if (__HAL_TIM_GET_FLAG(&g_timx_pwmin_chy_handle, TIM_FLAG_CC1) == 0)   
    
52.         {
    
53.             sflag = 0;
    ! c( Z; \2 F- u- n! ^6 J
54.             if (g_timxchy_pwmin_psc == 0)   /* 从0 到 1 */
    
55.             {
    ! G! `& S$ Y6 ~, L* I, J
56.                 g_timxchy_pwmin_psc ++;
    
57.             }
    ( n$ ^9 T- b3 p/ Z  ^
58.             else
    
59.             {
    6 i. ?( n2 ~4 V$ k$ ~
60.                 if (g_timxchy_pwmin_psc == 65535)     /* 已经最大了,可能是无输入状态 */
    % U7 |; N  {" z# ?! h* T4 u: y
61.                 {
    6 j) J8 \) [8 Y& G5 K
62.                     g_timxchy_pwmin_psc = 0;            /* 重新恢复不分频 */
    
63.                 }
    
64.                 else if (g_timxchy_pwmin_psc > 32767)/* 不能倍增了 */
    9 F% G3 `% o! t
65.                 {
    
66.                     g_timxchy_pwmin_psc = 65535;       /* 直接等于最大分频系数 */
    7 L7 _6 f. x% q5 B
67.                 }
    
68.                 else
    
69.                 {
    
70.                     g_timxchy_pwmin_psc += g_timxchy_pwmin_psc; /* 倍增 */
    + Y" [, |$ J: c% z7 c6 c
71.                 }
    0 z; J2 V4 d* _
72.             }
    
73. 
    ! ?: H8 W1 n- c0 R3 A" D4 o8 h
74.             __HAL_TIM_SET_PRESCALER(&g_timx_pwmin_chy_handle,
    
75. g_timxchy_pwmin_psc); /* 设置定时器预分频系数 */
    
76.             __HAL_TIM_SET_COUNTER(&g_timx_pwmin_chy_handle, 0);  /* 计数器清零 */
    
77. ATIM_TIMX_PWMIN->SR = 0;            /* 清除所有中断标志位 */
    
78.             return ;
    , m6 h3 X8 j8 x7 |$ c! M. L
79.         }
    
80.     }
    
81. 
    
82.     if (sflag == 0)   /* 第一次采集到捕获中断 */
    
83. {
    6 S+ b3 N8 H6 T" w2 C* `
84. /* 检测到了第一次周期捕获中断 */
    1 V0 J' \% l2 B
85.         if (__HAL_TIM_GET_FLAG(&g_timx_pwmin_chy_handle, TIM_FLAG_CC1))   
    
86.         {
    
87.             sflag = 1;               /* 标记第一次周期已经捕获, 第二次周期捕获可以开始了 */
    ) |- Z0 F, E  p
88.         }
    
89. ATIM_TIMX_PWMIN->SR = 0;            /* 清除所有中断标志位 */
    
90.         return ;                     /* 完成此次操作 */
    4 @1 V5 a! K- T+ S2 Q
91.     }
    * p6 r$ x  @! X! w( k7 L
92. 
    
93.     if (g_timxchy_pwmin_sta == 0)/* 还没有成功捕获 */
    - \) i$ z  P8 J2 I( K( H
94. {
    
95.     /* 检测到了周期捕获中断 */
    0 }% V4 Q( t2 o( `  D5 x: }2 D
96.         if (__HAL_TIM_GET_FLAG(&g_timx_pwmin_chy_handle, TIM_FLAG_CC1))   
    0 B9 m4 A! }5 l/ V
97.         {
    + y5 z4 F  n, D* N( \- P! e
98.             g_timxchy_pwmin_hval = HAL_TIM_ReadCapturedValue(
    
99. &g_timx_pwmin_chy_handle, TIM_CHANNEL_2) + 1; /* 高定平脉宽捕获值 */
      \. L3 s* b" r9 Y) W' a
100.             g_timxchy_pwmin_cval = HAL_TIM_ReadCapturedValue(
     
101. &g_timx_pwmin_chy_handle, TIM_CHANNEL_1) + 1; /* 周期捕获值 */
     5 g, T8 ?7 ~/ }5 W
102. 
     
103.             /* 高电平脉宽必定小于周期长度 */
     
104.             if (g_timxchy_pwmin_hval < g_timxchy_pwmin_cval)
     & `& t6 J. m# X$ W: |5 X1 B. H5 c
105.             {
       `. w" t5 y; M* O
106.                 g_timxchy_pwmin_sta = 1;         /* 标记捕获成功 */
     
107. 
     
108.                 g_timxchy_pwmin_psc = ATIM_TIMX_PWMIN->PSC;/* 获取PWM输入分频系数 */
     
109. 
     
110.                 if (g_timxchy_pwmin_psc == 0)   /* 分频系数为0的时候, 修正读取数据 */
     - H8 ~$ [* d5 z( O& C6 x1 d0 n
111.                 {
     
112.                     g_timxchy_pwmin_hval++;      /* 修正系数为1, 加1 */
     : w; y! {0 _$ t+ }
113.                     g_timxchy_pwmin_cval++;      /* 修正系数为1, 加1 */
     
114.                 }
     4 q& h/ d( ^; t) c$ }( G* }0 o6 `
115. 
     : ^- s' D1 t" d& l
116.                 sflag = 0;
     
117.                 /* 每次捕获PWM输入成功后, 停止捕获,避免频繁中断影响系统正常代码运行 */
     7 c3 x6 }$ t2 _& m1 B
118.                 ATIM_TIMX_PWMIN->CR1  &= ~(1 << 0);        /* 关闭定时器TIMX */
     $ ^) P4 x* D" P  b* Z; q) H& ^
119.                 /* 关闭通道1捕获中断 */
     ! S) G1 S1 O1 u1 D3 n- u' E
120.                 __HAL_TIM_DISABLE_IT(&g_timx_pwmin_chy_handle, TIM_IT_CC1);
     
121.                 /* 关闭通道2捕获中断 */
     
122.                 __HAL_TIM_DISABLE_IT(&g_timx_pwmin_chy_handle, TIM_IT_CC2);
     
123. /* 关闭更新中断 */
     ) @" H9 S& i9 x
124.                 __HAL_TIM_DISABLE_IT(&g_timx_pwmin_chy_handle, TIM_IT_UPDATE);
     
125.                 ATIM_TIMX_PWMIN->SR = 0;            /* 清除所有中断标志位 */
     
126.             }
     
127.             else
     $ P9 s& Y% Z; P; w3 s
128.             {
     
129.                 atim_timx_pwmin_chy_restart();
     
130.             }
     
131.         }
     1 P( g% T" ~5 H5 L. ]/ ]& {  @
132.     }
     & u1 f4 x! I* a  k' ?) [
133.     ATIM_TIMX_PWMIN->SR = 0;            /* 清除所有中断标志位 */
     
134. }

复制代码

5 h5 x/ a, p1 Z3 z$ [+ X" e7 Eatim_timx_pwmin_chy_process函数包含了捕获中断程序和更新中断程序的处理。如果发生了更新中断（即定时器溢出），证明超出定时器量程，这里会加大预分频系数，以得到更大的量程。量程变大了，那么测量的精度就会降低，所谓鱼和熊掌不可兼得。代码中的“if (sflag == 0) /* 第一次采集到捕获中断 /”这个程序段，表示第一次采集到捕获中断。这时候相当于第一次捕获到上升沿，我们只是把sflag标志位置1，然后清除所有中断标志位，等待下次的捕获中断发生。如果再次发生捕获中断，就会来到“if (g_timxchy_pwmin_sta == 0) / 还没有成功捕获 */”程序段。通过HAL_TIM_ReadCapturedValue函数获取CCR1和CCR2寄存器的值，把这个获取到的寄存器值+1才是对应的计数器计数个数。如果预分频系数为0的时候，还要把这两个寄存器的值再+1，这样计算的结果更准确。其它的代码细节请大家自行查看源码，有详细的注释。
& V" e8 W+ d* f' F: B$ n2 f( e下面介绍一下待测试的PWM怎么得到。在实验9-2通用定时器PWM输出实验我们已经编写了PWM输出的程序，但是那个PWM的输出引脚是LED0的引脚。这里我们只需在gtim.h头文件添加一些宏定义就可以使PWM输出到PB14引脚（P5排针上有引出PB14）。这些宏定义如下：
, y# d. u# j6 Z2 f
; _4 x8 s& R! R1 Y7 U7 c, I# S

1. /* PB14输出的PWM当做高级定时器PWM输入实验的信号源 */
   
2. #define GTIM_TIMX_PWM_CHY_GPIO_PORT        GPIOB
   
3. #define GTIM_TIMX_PWM_CHY_GPIO_PIN         GPIO_PIN_14
   
4. #define GTIM_TIMX_PWM_CHY_GPIO_AF          GPIO_AF2_TIM12     /* AF功能选择 */
     j0 I' V' i5 I8 Q1 U" v! f: Y: D
5. #define GTIM_TIMX_PWM_CHY_GPIO_CLK_ENABLE()
   2 L* c) k! H. A/ r
6. do{ __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)    /* PB口时钟使能 */
   
7. 
   - S0 v- }7 G  J: P$ T
8. #define GTIM_TIMX_PWM                        TIM12
   6 \6 E; x, E' F* {. t4 V3 p
9. #define GTIM_TIMX_PWM_CHY                   TIM_CHANNEL_1 /* 通道Y,  1<= Y <=4 */
   
10. #define GTIM_TIMX_PWM_CHY_CCRX             TIM12->CCR1           /* 通道Y的输出比较寄存器 */
      a- A# \8 o, B5 w1 V9 q: A% o
11. #define GTIM_TIMX_PWM_CHY_CLK_ENABLE()      
    
12. do{ __HAL_RCC_TIM12_CLK_ENABLE(); }while(0)           /* TIM12 时钟使能 */
    
13. 添加好这些宏定义后，要把PWM控制LED0的宏定义屏蔽掉。然后在main函数调用PWM输出初始化函数就可以使得PB14输出PWM波。然后我们用杜邦线把PB14和PE9连接起来。这样PB14输出的PWM就可以输入到PE9（定时器1 通道1）进行测量。
    
14. 在main.c里面编写如下代码：
    5 ?  u' X) \. L1 B  J% x1 i
15. int main(void)
    
16. {
    
17.     uint8_t t = 0;
    ) L* h* u% U' [" H8 R
18.     double ht, ct, f, tpsc;
    
19.     sys_cache_enable();                                   /* 打开L1-Cache */
    
20.     HAL_Init();                                            /* 初始化HAL库 */
    
21.     sys_stm32_clock_init(240, 2, 2, 4);               /* 设置时钟, 480Mhz */
    
22.     delay_init(480);                                      /* 延时初始化 */
    
23.     usart_init(115200);                                  /* 串口初始化为115200 */
    
24.     led_init();                                           /* 初始化LED */
    ; P1 N) }; E/ R% o) @3 [  _
25.     gtim_timx_pwm_chy_init(100 - 1, 24 - 1);        /* 10Mhz的计数频率, 100Khz PWM */
    
26.     atim_timx_pwmin_chy_init();                        /* 初始化PWM输入捕获 */
    
27.     GTIM_TIMX_PWM_CHY_CCRX = 20;                      /* 低电平宽度20,高电平宽度80 */
    . C+ w5 j1 J& I/ r. C
28. 
    ' l3 c5 K1 x' t1 l: c- w
29.     while (1)
    
30.     {
    8 F1 x$ K% y! M2 L$ k* [) `; I
31.         delay_ms(10);
    : y7 j$ M' X) {: Y
32.         t++;
    
33. 
    $ h" a$ c. c' x% |; A" l7 P
34.         if (t >= 20)    /* 每200ms输出一次结果,并闪烁LED0,提示程序运行 */
    , a' E" S+ F" g6 J8 P  s
35.         {
    + A7 n3 k# u) ?1 U& n
36.             if (g_timxchy_pwmin_sta)    /* 捕获了一次数据 */
    0 M3 q' J1 W6 n9 |" W( W$ m
37.             {
    8 a9 _, p9 k  h6 m6 X" y: m0 v
38.                 printf("\r\n");                                     /* 输出空,另起一行 */
    ! [$ T2 D+ d- Q8 [. X) p7 L
39.                 printf("PWM PSC  :%d\r\n", g_timxchy_pwmin_psc); /* 打印分频系数 */
    
40.                 printf("PWM Hight:%d\r\n", g_timxchy_pwmin_hval);/* 打印高电平脉宽 */
    - A4 R7 O6 d: H+ o; ?+ k7 G. z
41.                 printf("PWM Cycle:%d\r\n", g_timxchy_pwmin_cval);/* 打印周期 */
    1 A5 n$ f  ^  E3 P; A! |% _4 V
42. /* 得到PWM采样时钟周期时间 */
    7 j" g; m2 T" n1 f# f
43.                 tpsc = ((double)g_timxchy_pwmin_psc + 1)/240;
    6 e) }+ e+ Q8 g* [+ H, ?
44.                 ht = g_timxchy_pwmin_hval * tpsc;              /* 计算高电平时间 */
    
45.                 ct = g_timxchy_pwmin_cval * tpsc;              /* 计算周期长度 */
    : ]4 h4 I- }6 a% [5 v% ?4 P( r
46.                 f = (1 / ct) * 1000000;                                /* 计算频率 */
    
47.                 printf("PWM Hight time:%.3fus\r\n", ht);             /* 打印高电平脉宽长度 */
    
48.                 printf("PWM Cycle time:%.3fus\r\n", ct);             /* 打印周期时间长度 */
    
49.                 printf("PWM Frequency :%.3fHz\r\n", f);              /* 打印频率 */
    - f' q9 A- Q: b. Y3 O/ r: ^# g
50. 
    
51.                 atim_timx_pwmin_chy_restart(); /* 重启PWM输入检测 */
    
52.             }
    
53. 
    
54.             LED0_TOGGLE();  /* LED0(RED)闪烁 */
    
55.             t = 0;
    
56.         }
    6 k1 i& z6 P3 P7 h3 @8 `) ]
57.     }
    
58. }

复制代码

先看gtim_timx_pwm_chy_init(100 - 1, 24 - 1)这个语句，这两个形参分别设置自动重载寄存器的值为99，以及定时器预分频寄存器的值为23。先看预分频系数，我们设置为24分频，定时器1的时钟频率是2倍的APB2总线时钟频率，即240MHz，可以得到计数器的计数频率是10MHz，即0.1us计数一次。再到自动重载寄存器的值为99决定的是PWM波的频率（周期），可以得到PWM的周期为100*0.1us = 10us。然后通过GTIM_TIMX_PWM_CHY_CCRX = 20这个语句设置占空比，低电平宽度20，总的周期宽度是100，所以高电平宽度80。即产生的PWM波周期为10us，频率为100KHz，占空比为80%。下载验证的时候验证一下捕获到的与输出的是否一致。
atim_timx_pwmin_chy_init这个语句，就初始化PWM输入捕获。然后在无限循环中每200ms判断是否g_timxchy_pwmin_sta标志变量，是否捕获到数据，捕获到就打印和计数相关信息。
. F+ c% |3 ]: e- H0 ~( |4 w1 d+ J' B下面我们下载到开发部验证一下。
, ^1 C. U; b. R: Q  P
$ [  g2 j+ a  [/ d( K/ F7 ?22.5.4 下载验证
下载代码后，可以看到LED0在闪烁，说明程序已经正常在跑了，我们再打开串口调试助手，选择对应的串口端口。然后用杜邦线把P5排针的PB14引脚连接到P4排针的PE9引脚，就可以看到串口助手不断打印PWM波的信息，如图22.5.4.1所示：



; F5 J. o' C9 h# m9 i* F# M% }图22.5.4.1 打印高电平脉冲次数
可以看到打印出来的PWM波信息为：周期是10us，频率是100KHz，占空比是80%，和我们的预想结果一样。
大家可以通过gtim_timx_pwm_chy_init函数的形参设置其他参数的PWM波，以及GTIM_TIMX_PWM_CHY_CCRX设置占空比。这里的测试的PWM波有一定的范围，不是全范围的PWM都可以进行准确的测试，大家可以进行验证。
1 b. l; C' i% V; A: o# a, u2 t& ^————————————————
* m4 F# A* @6 j5 m; H版权声明：正点原子
1 C1 l7 j; ?; Y
3 L, o6 Q: x" Z


. s$ m* p0 K$ y, T7 [, I/ o