你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

【经验分享】STM32H7的TIM定时器基础知识和HAL库API

[复制链接]
STMCU小助手 发布时间:2021-12-21 23:00
32.1 初学者重要提示
9 O, g) f) P8 ]6 U3 w4 }- m2 _; z3 y& w  学习定时器外设推荐从硬件框图开始了解基本的功能特性,然后逐步深入了解各种特性,这种方式方便记忆和以后查阅。# D) ]! A' m7 O% R
  STM32H7的定时器输出100MHz方波是完全没问题。
; ~$ w% M0 a7 d4 W  STM32H7定时器进出中断的速度能跑到12.5MHz,所有程序在TCM和Flash运行没差别。
$ N! i* P% M( Y% a  STM32H7的定时器输入捕获可以实现12MHz方波的双边沿捕获,单边沿可以做到24MHz。( m" T/ W6 w/ }+ G. g
  特别注意STM32H7的TIM1,8,15,16,17才有RCR重复计数器,其它都没用的。
* W' ?, ~# D7 e% A& ]' `- k  STM32H7的单个定时器中不同通道可以配置不同频率PWM。0 b3 G# K& ]+ _, }+ N5 w) h, A2 f1 ^) `
  STM32H7的TIM1-TIM17中断入口函数名使用时要注意,别搞错了:
3 e5 v5 ~2 o7 s) d) @0 G
  1. TIM1_BRK_IRQHandler               S- N* e4 v+ o2 _8 a  y9 I0 {
  2. TIM1_UP_IRQHandler              
    7 e- X$ p4 V4 @4 W( T
  3. TIM1_TRG_COM_IRQHandler        
    ( H: R9 t* \6 T6 |: k
  4. TIM1_CC_IRQHandler                                                    - [% ]& y) J! ~/ |
  5. TIM2_IRQHandler                                           : [  U- w. a9 A! P' N- ]0 P  e6 u" z+ u
  6. TIM3_IRQHandler                                                 : e2 P& ?  q9 C% Y1 {6 v2 p
  7. TIM4_IRQHandler                 
    $ i" o* S' n; P9 N
  8. TIM5_IRQHandler            9 Y. z: w: P; D/ h; z7 H9 F
  9. TIM6_DAC_IRQHandler           <------------------要注意            
    ; Y4 M$ k9 d, q; X0 L0 y
  10. TIM7_IRQHandler 3 c( l5 n9 g# w8 D
  11. TIM8_BRK_TIM12_IRQHandler      <------------------要注意,定时器12也是用的这个
    : J9 W& z0 ?; H3 r  x2 x5 D; a( ]: P; f# n
  12. TIM8_UP_TIM13_IRQHandler       <------------------要注意,定时器13也是用的这个
    ! K% r6 ~) ^7 w% ^7 H  x& X& l
  13. TIM8_TRG_COM_TIM14_IRQHandler  <------------------要注意,定时器14也是用的这个
    3 t2 a9 F8 H3 ~. j. Y
  14. TIM8_CC_IRQHandler            J% N; F4 T' {8 E" N
  15. TIM15_IRQHandler ) b+ A- ^1 R0 A8 N5 N
  16. TIM16_IRQHandler
    4 S2 V" c& x7 Y6 o( |, V
  17. TIM17_IRQHandler
复制代码

4 A  R( [) J: C3 U, U1 U32.2 定时器基础知识
. S: E4 [' ?& M5 y# N/ B注,不同定时支持的功能略有区别,基础定时器功能较少,TIM1和TIM8高级定时器功能多些。
% e3 B( a8 H/ d1 x2 m4 H8 P7 `/ Y) R6 g3 X! x/ C# i
  TIM2和TIM5是32位定时器,其它定时器都是16位定时器。16位和32位的区别是CNT计数器范围不同,32位的范围是0 到2^32 – 1,而16位的是0到65535;它们支持的分频是范围是一样的,都是1到65535。: |# S9 T. g  B5 |
  计数器支持递增、递减和递增/递减二合一。
" l: K0 R* z; g( r& C  多个独立通道,可用于:+ P1 b( V- K9 o8 Y) {7 p  x$ e
– 输入捕获。$ ~7 y& O3 _4 f1 X  H

: y4 G0 U" w* \3 v0 F– 输出比较。
  B: m$ D0 K! B( h  g
$ A* `5 G- F4 t( X1 ?) |– PWM 生成(边沿和中心对齐模式)。1 y' m: o# U6 v# u0 x/ K( X
4 n( Y$ J% Z# p! c4 ], F" Q
– 单脉冲模式输出。
4 s  |: p) O% b5 O) V6 ~* n; ~1 d, q9 x) g* E
  带死区插入,断路功能和PWM互补输出
- ^& v* j5 k( P% r+ N" ~  发生如下事件时生成中断/DMA 请求:) U3 J( p1 Y9 @! }$ O
– 更新:计数器上溢/下溢、计数器初始化(通过软件或内部/外部触发)
5 u: X0 s7 M: l8 s: Z/ J6 O* D, g, p% a
– 触发事件(计数器启动、停止、初始化或通过内部/外部触发计数)
& A4 D  B! l+ z* D2 k: w0 v
7 G2 ?4 I7 Z4 X; I0 ^8 p– 输入捕获  w1 R1 e0 x0 x7 z, f* T+ m; a

% b& Q: B3 `3 r/ _– 输出比较
' l& O; S; _* l9 n" F( Y
0 Y4 W. D* b/ E; \  支持增量式编码器和霍尔传感器。" z+ G4 a  Q% H. p' `
32.2.1 定时器TIM1-TIM17的区别
7 ~1 w3 v8 O' j9 \# w5 Z9 W" LSTM32H7支持的定时器有点多,要简单的区分下。STM32H7支持TIM1-TIM8,TIM12-TIM17共14个定时器,而中间的TIM9,TIM10,TIM11是不存在的,这点要注意。3 N. h% v  T! i( M
( W, I  Y6 _) }5 e
粗略的比较如下:: ]0 \/ T' y* J$ t/ ]2 I

4 U( R5 o; D6 h
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png
+ ?7 ], P+ P5 h3 T* G: Y8 l
# ~/ I! h# B5 D4 j4 @
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png
  F2 V. Q% Z" g. U$ |

  X! \9 n' d8 T7 k& y6 O7 H% }通过上面的表格,至少要了解到以下两点:4 o, J5 l; W; }) ~, Y( h' F6 x9 f, v/ m

- O5 C+ f0 b3 l+ h" c  STM32H7的定时器主要分为高级定时器,通用定时器,基础定时器和低功耗定时器。
1 U- f& Y/ t+ t& ]! |  TIM2和TIM5是32位定时器,其它都是16位定时器。" o5 X  W) O8 J& I/ Q3 y' j! Z* N  t! o
2 q8 w0 ~8 H1 a) U0 ]
32.2.2 定时器的硬件框图
5 G9 Q" q% m7 }4 l4 x) n认识一个外设,最好的方式就是看他的框图,方便我们快速的了解定时器的基本功能,然后再看手册了解细节。" E7 o. H0 o% g" S
# x4 Z% `; @+ Y/ E& F
下面我们直接看最复杂的高级定时器TIM1&TIM8框图:! b' j6 R% F8 h
0 z2 S7 C6 i' r
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png
0 r5 q! I. @5 v

( J. L2 t3 }, j- F通过这个框图,我们可以得到如下信息:% U3 P, K# |3 I. e

% u# z2 U& n8 g; N8 Y) |+ y  TIMx_ETR接口
5 k, V% ^& u9 L( s6 V3 |1 D$ h外部触发输入接口。ETR支持多种输入源:输入引脚(默认配置)、比较器输出和模拟看门狗。
: c4 ~6 ?) `! Z. b4 T$ v( i
4 w. t  T' I! I; {
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png

9 B6 K. ]% l$ }( z' V. q% N3 ?6 Z! T7 \. K( B/ I" a
  截图左侧的TIMx_CH1,TIMx_CH2,TIMx_CH3和TIMx_CH4接口- D' t+ N& L$ ^9 W8 I
这四个通道主要用于输入捕获,可以计算波形频率和脉宽。                                                                                                                             , V9 z4 {# z/ e7 c
& x& s8 Y) n$ X1 C  L/ l
  TIMx_BKIN和TIMx_BKIN2接口5 f7 U- r7 e$ t. Y
断路功能,主要用于保护由 TIM1 和 TIM8 定时器产生的 PWM 信号所驱动的功率开关' m/ e) P9 G& k
6 `0 |) x/ T. V) U9 B
  TRGO内部输出通道0 q( ?# w/ C5 f& J; _- P
主要用于定时器级联,ADC和DAC的定时器触发。
9 d& R: A8 p- G8 [
: K; x3 c; K% F+ q$ V3 q  6组输出比较单元OC1到OC6
8 M* ^) u/ i9 G0 {) G! [OC1到OC4有对应的输出引脚,而OC5和OC6没有对应的输出引脚,主要用于内部控制。2 {" D/ D8 G+ K" K2 J
3 e7 c5 b0 W' S/ d
  截图右侧的输出比较通道TIMx_CH1,TIMx_CH1N,TIMx_CH2,TIMx_CH2N,TIMx_CH3,TIMx_CH3N和TIMx_CH4
' Y3 o: M) B0 A: r/ a7 L主要用于PWM输出,注意CH1到CH3有互补输出,而CH4没有互补输出。. q" Q) d6 i; f5 l# S$ W% {

7 d, ?6 Z5 q: B9 O' L0 P  其它框图里面未展示出来功能) i6 |- @0 I  E  B. c: K
定时器TIM1&TIM8还支持的其它功能在用到的时候再做说明。
! K) E9 E2 s3 w
% i1 t0 Y7 J% D" P( q32.2.3 定时器的时基单元' f* E( C* s& x1 j+ N$ s1 o
定时器要工作就需要一个基本时基单元,而基本的时基单元是由下面几个寄存器组成的:
9 c* C5 N( ]/ s& J( F' R1 n; C6 H9 [. ?; x+ d- e& x
  预分频器寄存器 (TIMx_PSC)
- O( Q5 d( @/ N4 i1 ?  l$ e! b用于设置定时器的分频,比如定时器的主频是200MHz,通过此寄存器可以将其设置为100MHz,50MHz,25MHz等分频值。
6 P/ {7 b9 f& T" E) ^. @/ u6 y; m
注:预分频器有个缓冲功能,可以让用户实时更改,新的预分频值将在下一个更新事件发生时被采用(以递增计数模式为例,就是CNT计数值达到ARR自动重装寄存器的数值时会产生更新事件)。
  Z4 a- y# ]# \5 A. ?/ ~% C3 l0 o" M* D- a
  计数器寄存器 (TIMx_CNT)" v7 o1 C! W# |# X( P
计数器是最基本的计数单元,计数值是建立在分频的基础上面,比如通过TIMx_PSC设置分频后的频率为100MHz,那么计数寄存器计一次数就是10ns。4 X4 i6 I3 [# I% q

1 }: @7 ?' z9 N9 N9 G% u5 `& G9 R  b  自动重载寄存器 (TIMx_ARR)$ x% z& M) H, E2 e, W2 v: z. d0 p
自动重装寄存器是CNT计数寄存器能达到的最大计数值,以递增计数模式为例,就是CNT计数器达到ARR寄存器数值时,重新从0开始计数。  |* F$ ^# X6 D5 o- T& a+ K) [
+ v) x& D! [( D! \* q1 y/ }
注,自动重载寄存器是预装载的。对自动重载寄存器执行写入或读取操作时会访问预装载寄存器。预装载寄存器的内容既可以立即传送到影子寄存器(让设置立即起到效果的寄存器),也可以在每次发生更新事件时传送到影子寄存器。简单的说就是让ARR寄存器的数值立即更新还是更新事件发送的时候更新。; Z: B8 Q5 Z4 |
. f3 n4 L+ S$ s7 d4 O. D
  重复计数器寄存器 (TIMx_RCR)( e( [" r2 N2 [9 c, ~) o
以递增计数模式为例,当CNT计数器数值达到ARR自动重载数值时,重复计数器的数值加1,重复次数达到TIMx_RCR+ 1后就,将生成更新事件。
$ S1 U2 T- L1 [5 q0 h/ r
4 F5 B& U5 {  L/ {, y( b! `& ]! M注,只有TIM1,TIM8,TIM15,TIM16,TIM17有此寄存器。
5 ~5 [6 ]2 V! i
. O/ {( L5 Y" i! _: M' X0 f) X比如我们要配置定时器实现周期性的中断,主要使用这几个寄存器即可。0 E0 d& J* D, p3 j
$ _) i; |7 D$ h9 E
32.2.4 定时器输出比较(PWM)9 T  o5 F# B; z( h
使用定时器时基单元的那几个寄存器仅仅能设置周期,还不能设置占空比。针对这个问题,还需要比较捕获寄存CCR的参与,这样就可以设置占空比了。& m7 B  t- K9 Z

  X6 s% j# |# p' U- _7 z  V为了方便大家理解,以PWM 边沿对齐模式,递增计数配置为例:, u9 |4 C9 K% e, v% W
7 \8 ^: q( o  A1 U; M
  当计数器TIMx_CNT < 比较捕获寄存器TIMx_CCRx期间,PWM参考信号OCxREF输出高电平。; i; Q) ?  j5 j6 \  Z  T
  当计数器TIMx_CNT >= 比较捕获寄存器TIMx_CCRx期间, PWM参考信号OCxREF输出低电平。& H2 ~9 d0 |* p, Y+ c/ n
  当比较捕获寄存器TIMx_CCRx > 自动重载寄存器TIMx_ARR,OCxREF保持为1。
# H: Q& O; P1 i8 I" E  当比较捕获寄存器TIMx_CCRx = 0,则OCxRef保持为0。
  j& j4 }& V- }6 t$ i! c( _" S8 E下面是TIMx_ARR=8的波形效果:! k1 v$ m0 ~; |$ Q6 u
+ k; t, U: n% \( x
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png

7 c3 F/ W2 ]& K; }7 s2 G  P3 I% _, C% _
32.2.5 定时器输入捕获2 F* I+ p/ h- \8 U1 r' Z. S; q' a
与PWM一样,使用定时器实现输入捕获,仅靠时基单元的那几个寄存器是不行的,我们需要一个寄存器来记录发生捕获时的具体时间,这个寄存器依然由比较捕获寄存器TIMx_CCRx来实现。
5 P6 X/ F) q. P8 M
+ U2 o9 y: p! b+ F5 ?比如我们要测量一路方波的周期:
3 @3 E- L0 B' u! G0 u/ v6 n+ H6 h! Z/ c, v% G* O4 j
  配置定时器为输入捕获模式,上升沿触发,设置分频,自动重装等寄存器,比如设置的CNT计数器计数1次是1微秒。4 H6 C! m% t) |+ D
  当有上升沿触发的时候,TIMx_CCRx寄存器就会自动记录当前的CNT数值,然后用户就可以通过CC中断,在中断复位程序里面保存当前的TIMx_CCRx寄存器数值。等下次再检测到上升沿触发,两次时间求差就可以得到方波的周期。# [: _& B% i! O
不过这里要特别注意一点,如果CNT发生溢出(比如16位定时器,计数到65535就溢出了)就需要特别处理下,将CNT计数溢出考虑进来。+ Z9 b  _6 `: ]5 j/ O

! E) g; U* R6 R2 I  g32.3 定时器的HAL库用法# P/ \% y' T/ c) s/ k7 T4 i
定时器的HAL库用法其实就是几个结构体变量成员的配置和使用,然后配置GPIO、时钟,并根据需要配置NVIC、中断和DMA。下面我们逐一展开为大家做个说明。
% K; w# U) p+ Z' l
) a6 L0 L3 y" B  ~/ ^32.3.1 定时器寄存器结构体TIM_TypeDef: i/ _* N& f1 v  G' Y
定时器相关的寄存器是通过HAL库中的结构体TIM_TypeDef定义的,在stm32h743xx.h中可以找到这个类型定义:
/ O( H: \" a/ d8 \+ e7 z' D9 k
" o  G7 T/ p+ V( N( W
  1. typedef struct" i  t# X; \4 s- t; v$ [  A
  2. {9 a% p8 L: d& j8 S# K
  3.   __IO uint16_t CR1;         /*!< TIM control register 1,                   Address offset: 0x00 */2 X9 N6 I0 K. w* U" n+ e# E. j- {& c
  4.   uint16_t      RESERVED0;   /*!< Reserved, 0x02                                                 */6 J1 M! q& q5 D  s) ~/ N2 _
  5.   __IO uint32_t CR2;         /*!< TIM control register 2,                   Address offset: 0x04 */% |. @( E5 A8 q; d+ {
  6.   __IO uint32_t SMCR;        /*!< TIM slave mode control register,          Address offset: 0x08 */0 |  X/ g& T9 k2 I) c& }2 U4 x7 E
  7.   __IO uint32_t DIER;        /*!< TIM DMA/interrupt enable register,        Address offset: 0x0C */
    2 G% u3 e% [7 M' ^7 ?* |
  8.   __IO uint32_t SR;          /*!< TIM status register,                      Address offset: 0x10 */
    & e! h9 Z  J( u7 X4 ^/ w
  9.   __IO uint32_t EGR;         /*!< TIM event generation register,            Address offset: 0x14 */8 |2 {+ C2 ?' r: m4 T+ P
  10.   __IO uint32_t CCMR1;       /*!< TIM capture/compare mode register 1,      Address offset: 0x18 */! g5 m% q) \+ K' K$ C4 Y" D7 Z
  11.   __IO uint32_t CCMR2;       /*!< TIM capture/compare mode register 2,      Address offset: 0x1C */: E( h# A* M; D5 h8 S5 y' z7 t0 _
  12.   __IO uint32_t CCER;        /*!< TIM capture/compare enable register,      Address offset: 0x20 */
    " B# p% `& f1 K& B
  13.   __IO uint32_t CNT;         /*!< TIM counter register,                     Address offset: 0x24 */
    + i) m' y' K) \( l
  14.   __IO uint16_t PSC;         /*!< TIM prescaler,                            Address offset: 0x28 */7 ^! Y9 v/ \( [% B7 v  u3 I% e* j
  15.   uint16_t      RESERVED9;   /*!< Reserved, 0x2A                                                 */
    ! u; O! @( b4 k5 x
  16.   __IO uint32_t ARR;         /*!< TIM auto-reload register,                 Address offset: 0x2C */% B% W# ~/ r6 }& \' Q# s0 j
  17.   __IO uint16_t RCR;         /*!< TIM repetition counter register,          Address offset: 0x30 */
    7 p9 C" H0 O0 q0 m! p$ F( M
  18.   uint16_t      RESERVED10;  /*!< Reserved, 0x32                                                 */" _5 y5 A! U1 |  ^8 q4 _
  19.   __IO uint32_t CCR1;        /*!< TIM capture/compare register 1,           Address offset: 0x34 */, Q7 T- w) L' ^& s5 V7 A( o
  20.   __IO uint32_t CCR2;        /*!< TIM capture/compare register 2,           Address offset: 0x38 */
    & m" t9 j' A9 ?4 d% {3 N
  21.   __IO uint32_t CCR3;        /*!< TIM capture/compare register 3,           Address offset: 0x3C */
    7 Z0 D( a) S! L
  22.   __IO uint32_t CCR4;        /*!< TIM capture/compare register 4,           Address offset: 0x40 */) P4 `" u: X6 |! v0 A
  23.   __IO uint32_t BDTR;        /*!< TIM break and dead-time register,         Address offset: 0x44 */" B8 F  `7 I/ j; G. g8 L
  24.   __IO uint16_t DCR;         /*!< TIM DMA control register,                 Address offset: 0x48 */5 G3 k: H  ~- E% G$ [5 c+ |
  25.   uint16_t      RESERVED12;  /*!< Reserved, 0x4A                                                 */; ~/ a( d0 d+ U) ?" q8 C  j$ S
  26.   __IO uint16_t DMAR;        /*!< TIM DMA address for full transfer,        Address offset: 0x4C */
    / }% h! b$ {" \" j9 S2 s' O/ f
  27.   uint16_t      RESERVED13;  /*!< Reserved, 0x4E                                                 */* j+ [8 R; A9 f. t& l
  28.   uint16_t      RESERVED14;  /*!< Reserved, 0x50                                                 */  w! D, \# P' N5 l# H* o, t) E
  29.   __IO uint32_t CCMR3;       /*!< TIM capture/compare mode register 3,      Address offset: 0x54 */$ y4 I- T' A6 k# G: v; \- Q. N6 s3 U8 u
  30.   __IO uint32_t CCR5;        /*!< TIM capture/compare register5,            Address offset: 0x58 */3 F( f) q/ E( g
  31.   __IO uint32_t CCR6;        /*!< TIM capture/compare register6,            Address offset: 0x5C */, {. a' n, W4 v  R; Z2 }' ?
  32.   __IO uint32_t AF1;         /*!< TIM alternate function option register 1, Address offset: 0x60 */4 K/ W; |* F2 p
  33.   __IO uint32_t AF2;         /*!< TIM alternate function option register 2, Address offset: 0x64 */  a7 O, S. s! T# I2 g
  34.   __IO uint32_t TISEL;       /*!< TIM Input Selection register,             Address offset: 0x68 */) W5 m6 Q8 W/ w: h. e% u6 K) x
  35. } TIM_TypeDef;
复制代码
0 Q. a9 x6 K5 ?( |6 d  u
这个结构体的成员名称和排列次序和CPU的定时器寄存器是一 一对应的。/ V: O% }# f0 `) Q- K  Q8 q4 F9 {
( o4 k. @' B: z" z0 V
__IO表示volatile, 这是标准C语言中的一个修饰字,表示这个变量是非易失性的,编译器不要将其优化掉。core_m7.h 文件定义了这个宏:/ Y6 o( w* r3 b& h  e6 T0 J6 w1 @
' i0 v) u, {/ s
  1. #define     __O     volatile             /*!< Defines 'write only' permissions */5 V$ Z# r( G) c- q7 l. y
  2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */
复制代码
! N- A2 J4 q5 I4 j' w% i& d1 J7 R
下面我们看下定时器的定义,在stm32h743xx.h文件。( O4 `# p1 c* t# m3 |; B

* B2 C# l/ j1 F- T" P0 r, U8 p% U
  1. #define PERIPH_BASE         ((uint32_t)0x40000000)! i3 G; ?3 D/ o- I6 m% t$ Q
  2. #define D2_APB1PERIPH_BASE   PERIPH_BASE
    ) o2 H- ^4 l# N% }5 a, {, K! r' I
  3. #define D2_APB2PERIPH_BASE   (PERIPH_BASE + 0x00010000)
    . u. d: K0 o8 e

  4. 8 ~' [6 I3 o! E# T% p
  5. /*!< D2_APB1PERIPH 外设 */! k- i' `  u0 w9 D
  6. #define TIM2_BASE             (D2_APB1PERIPH_BASE + 0x0000) <----- 展开这个宏,(TIM_TypeDef *) 0x40000000
    - X3 |* _* `) @+ L: I
  7. #define TIM3_BASE             (D2_APB1PERIPH_BASE + 0x0400)4 ^( a9 x2 R8 _. Y, C
  8. #define TIM4_BASE             (D2_APB1PERIPH_BASE + 0x0800)2 q+ f- Y  P3 F# v
  9. #define TIM5_BASE             (D2_APB1PERIPH_BASE + 0x0C00)
    7 q5 r! L) j* l
  10. #define TIM6_BASE             (D2_APB1PERIPH_BASE + 0x1000)7 q( r  Z7 Z' v# l7 D1 l
  11. #define TIM7_BASE             (D2_APB1PERIPH_BASE + 0x1400)7 P3 t9 m& D! x- B& s* t7 X+ v
  12. #define TIM12_BASE            (D2_APB1PERIPH_BASE + 0x1800): y! @, R- K2 N% [; V1 {2 F
  13. #define TIM13_BASE            (D2_APB1PERIPH_BASE + 0x1C00)
    2 O" ~! }# U+ A: O* o! k( O4 D
  14. #define TIM14_BASE            (D2_APB1PERIPH_BASE + 0x2000)4 n/ \, i6 W/ H' X1 @: {* z, r5 M

  15. + X4 i& g% h# [9 X+ F/ o2 F6 C" _
  16. /*!< D2_APB1PERIPH 外设 */
    5 N- }2 ~9 p# b7 k  i
  17. #define TIM1_BASE             (D2_APB2PERIPH_BASE + 0x0000)
    % Q! a/ F1 P0 S* d: w$ i
  18. #define TIM8_BASE             (D2_APB2PERIPH_BASE + 0x0400)% |- }; \2 D2 F* `, p8 E
  19. #define TIM15_BASE            (D2_APB2PERIPH_BASE + 0x4000)
    ! ^% e2 }; n8 Z, V& W
  20. #define TIM16_BASE            (D2_APB2PERIPH_BASE + 0x4400)' X+ H( {7 @: j/ @4 j; N0 {! F# ^
  21. #define TIM17_BASE            (D2_APB2PERIPH_BASE + 0x4800)
    7 D9 I. X1 I  `; f6 n( V" t
  22. % Q7 a% e+ q* g
  23. #define TIM1                ((TIM_TypeDef *) TIM1_BASE)8 w9 C. _% Z$ Q) U
  24. #define TIM2                ((TIM_TypeDef *) TIM2_BASE). U' |. j7 c& L. Z0 J  j
  25. #define TIM3                ((TIM_TypeDef *) TIM3_BASE)
    ' t6 ]4 K9 D$ g) G! Y/ L
  26. #define TIM4                ((TIM_TypeDef *) TIM4_BASE)
    2 m& j9 y, V6 N# I% m( E
  27. #define TIM5                ((TIM_TypeDef *) TIM5_BASE); `5 S2 y* ~( Q& i# b
  28. #define TIM6                ((TIM_TypeDef *) TIM6_BASE)
    : _, Z8 U' `4 i: S9 \
  29. #define TIM7                ((TIM_TypeDef *) TIM7_BASE)
    7 }; C3 Y9 b/ `" s) |
  30. #define TIM8                ((TIM_TypeDef *) TIM8_BASE). y3 X" a- ?  k5 W6 [
  31. #define TIM12               ((TIM_TypeDef *) TIM12_BASE)
    ; [# s8 w* @* y0 K& e% s) ^- b3 n% ^
  32. #define TIM13               ((TIM_TypeDef *) TIM13_BASE)
    3 r* ~! o3 f' b4 }
  33. #define TIM14               ((TIM_TypeDef *) TIM14_BASE)
      Y* Y5 M! y8 f/ O) `* y) o
  34. #define TIM15               ((TIM_TypeDef *) TIM15_BASE)
    " {- u2 O6 X8 N0 j: \
  35. #define TIM16               ((TIM_TypeDef *) TIM16_BASE)$ i) p4 }! `& r) p) J! X4 R
  36. #define TIM17               ((TIM_TypeDef *) TIM17_BASE)
复制代码

6 F, r; y3 s. f8 ~% z我们访问TIM2的CR1寄存器可以采用这种形式:TIM2->CR1 = 0;. `# D  I& M% C8 U8 p9 `' d
5 P8 k6 G- |7 a1 |- Z5 x: g  H
32.3.2 定时器句柄结构体TIM_HandleTypeDef
2 R/ N& F6 [7 I7 B( \& N8 vHAL库在TIM_TypeDef的基础上封装了一个结构体TIM_HandleTypeDef,定义如下:. p& V* h6 v/ ?7 s3 ~$ A& Z4 Q. a7 A

+ s0 y  ^, ]: S3 c
  1. typedef struct! p# m4 z1 r0 d# M; Q: u
  2. {
    - X. @$ L& w0 A, n
  3.   TIM_TypeDef              *Instance;     /*!< Register base address             */ $ I! v* C0 \1 q
  4.   TIM_Base_InitTypeDef     Init;          /*!< TIM Time Base required parameters */$ `, _: S# g8 G9 ^3 {
  5.   HAL_TIM_ActiveChannel    Channel;       /*!< Active channel                    */   C  K# o4 z* U' h6 l0 f

  6. + X1 p' E. O0 s, Y$ e
  7. /*!< DMA Handlers array This array is accessed by a @ref DMA_Handle_index */4 B( d! `7 C; @7 g4 y
  8.   DMA_HandleTypeDef        *hdma[7];      1 V2 O7 x# @5 N) p% |
  9.   HAL_LockTypeDef          Lock;          /*!< Locking object                    */
    & O5 Z$ \& _2 J
  10.   __IO HAL_TIM_StateTypeDef   State;      /*!< TIM operation state               */  $ I4 i, A. F& y( A* ?; t
  11. }TIM_HandleTypeDef;
复制代码
7 d' `% E+ \" Q( q
这里重点介绍前四个参数,其它参数主要是HAL库内部使用的。' ^% w4 q2 K( U" m% ]) p# D7 z
6 M& V# U& a2 J$ ~, g. x( ?( S
  TIM_TypeDef  *Instance
. K* G! m0 `& I0 C4 ]4 \( H2 d- g5 `+ F
这个参数是寄存器的例化,方便操作寄存器,比如使能定时器的计数器。
0 S  P: ]1 d* W# o6 h
1 X  X2 T5 J  |- v+ P; e9 PSET_BIT(huart->Instance->CR1,  TIM_CR1_CEN)。0 G& p- A- l( A1 a
6 E* _5 S7 t3 v- W+ K
  TIM_Base_InitTypeDef  Init
/ F" I, r+ H. T  i" d' U3 _$ g6 f" v% \6 N& ^; _* h4 r
这个参数是用户接触最多的,用于配置定时器的基本参数。7 z. i6 C! O9 z) {

- `% ?& q) U$ W. F# W8 YTIM_Base_InitTypeDef结构体的定义如下:
! m' v. M' a% Y$ J9 g
& W/ y# O' T; |' m6 y
  1. typedef struct8 _5 q/ x' _. k" e( V9 U' C
  2. {* U. F5 s1 A3 n* Q! D1 I8 }
  3.   uint32_t Prescaler;      8 f6 S1 q; l+ @$ F$ `% R
  4.   uint32_t CounterMode;    * m5 T  r) v* j
  5.   uint32_t Period;         
    0 x; k. P. R0 v! D
  6.   uint32_t ClockDivision;    0 f  D# W+ d$ O/ ]1 u& t3 I4 z) a6 H
  7.   uint32_t RepetitionCounter;
    6 E1 B5 L. a5 V  i: ~
  8.   uint32_t AutoReloadPreload;  $ x) e0 c, |: H+ V% o" M
  9. } TIM_Base_InitTypeDef;
复制代码

# g6 f- r3 i$ y) h" A' |, S0 `1 q  成员Prescaler! A2 U( t4 D, r5 y5 b
用于设置定时器分频,对于32位的TIM2和TIM5范围是0到0xFFFFFFFF,其它定时器是0到0xFFFF。& G' j7 ?5 r: C# E
% c. Y" M; V6 a9 V5 U- R
  成员CounterMode
6 J6 K4 }- f" D0 _用于设置计数模式,向上计数模式、向下计数模式和中心对齐模式。/ }& B. G. M7 f( @
0 Y2 \# l/ R. g
  1. #define TIM_COUNTERMODE_UP                ((uint32_t)0x0000U)   /*!< Up counting mode */
    ' b3 r- Q' m' c  K6 ~
  2. #define TIM_COUNTERMODE_DOWN               TIM_CR1_DIR          /*!< Down counting mode */
    . Y6 }; L# T) }7 c  T2 ~; R
  3. #define TIM_COUNTERMODE_CENTERALIGNED1     TIM_CR1_CMS_0        /*!< Center-aligned counting mode 1 */
    * D' e8 h, m. y8 e1 o' N, l, t4 f
  4. #define TIM_COUNTERMODE_CENTERALIGNED2     TIM_CR1_CMS_1        /*!< Center-aligned counting mode 2 */
    : R% I, M, @- C7 }* A. L
  5. #define TIM_COUNTERMODE_CENTERALIGNED3     TIM_CR1_CMS          /*!< Center-aligned counting mode 3 */
复制代码

9 r. w1 x6 O. i; u5 e  成员Period6 x) Z+ G  P! R5 N
用于设置定时器周期,对于32位的TIM2和TIM5范围是0到0xFFFFFFFF,其它定时器是0到0xFFFF。
" `9 p$ F7 h; J% r0 z* i% f; [
! J9 `7 m3 W5 F  成员ClockDivision1 k5 k) \  J2 H; z
用于指示定时器时钟 (CK_INT) 频率与死区发生器以及数字滤波器(ETR、TIx)所使用的死区及采样时钟 (tDTS) 之间的分频比。3 `3 b& D! w8 L# d# d/ X8 [
& `" C. o' L4 t5 ?
  1. #define TIM_CLOCKDIVISION_DIV1       ((uint32_t)0x0000U)        /*!< Clock Division DIV1 */
    - J; f/ g% J8 d  U! b- s- O
  2. #define TIM_CLOCKDIVISION_DIV2       (TIM_CR1_CKD_0)            /*!< Clock Division DIV2 */& I1 X$ g2 ~, A+ o0 p$ b! _* u
  3. #define TIM_CLOCKDIVISION_DIV4       (TIM_CR1_CKD_1)             /*!< Clock Division DIV4 */
复制代码

7 [! s# w* |, k8 j4 R  成员RepetitionCounter( {, w# L2 p8 G3 Y0 P
用于设置重复计数器,仅TIM1和TIM8有,其它定时器没有。作用是每当计数器上溢/下溢时,重复计数器减1,当减到零时,才会生成更新事件,这个在生成PWM时比较有用。  F' E1 D% `8 U
% W" h# y3 M2 g- h6 G
  成员AutoReloadPreload
- `3 E- Q0 F" m) z用于设置定时器的ARR自动重装寄存器是更新事件产生时写入有效还是立即写入有效。如果使能了表示更新事件产生时写入有效,否则反之。6 B* |" U: t4 T$ n% l# G# m- I
0 G4 A. M! L; S( d6 C
  1. #define TIM_AUTORELOAD_PRELOAD_DISABLE   ((uint32_t)0x0000U)   /*!< TIMx_ARR register is not buffered */
    " ^! ~2 p4 h7 |8 `
  2. #define TIM_AUTORELOAD_PRELOAD_ENABLE    (TIM_CR1_ARPE)        /*!< TIMx_ARR register is buffered */
复制代码
( M) y! V  p' @" }: m
  HAL_TIM_ActiveChannel    Channel;4 F. m8 S+ b& Z: c' C

$ J1 x, H/ h7 f5 B用于设置定时器通道,比如TIM1和TIM8都是6个通道。
1 F8 S/ B% |8 H
* @$ U- Q: a8 g6 D6 ~! @+ B: _- V9 Q
  1. typedef enum
    ) G  M7 N* {8 F# k
  2. {
    : B- {: M! e# [2 w% m- |
  3.   HAL_TIM_ACTIVE_CHANNEL_1        = 0x01U,    /*!< The active channel is 1     */
    $ w/ m1 @- q! r/ q) C/ S0 n
  4.   HAL_TIM_ACTIVE_CHANNEL_2        = 0x02U,    /*!< The active channel is 2     */
    6 R& u) L! o+ I" y
  5.   HAL_TIM_ACTIVE_CHANNEL_3        = 0x04U,    /*!< The active channel is 3     */   
    ) B  a$ R8 V4 `& E6 ?
  6.   HAL_TIM_ACTIVE_CHANNEL_4        = 0x08U,    /*!< The active channel is 4     */
    2 Q9 w+ y% D* e- _5 g$ t( S% ^) ]
  7.   HAL_TIM_ACTIVE_CHANNEL_5        = 0x10U,    /*!< The active channel is 5     */
    . J- j. A/ R) Q) {( G% B
  8.   HAL_TIM_ACTIVE_CHANNEL_6        = 0x20U,    /*!< The active channel is 6     */3 {4 e- z0 h" o
  9.   HAL_TIM_ACTIVE_CHANNEL_CLEARED  = 0x00U     /*!< All active channels cleared */    ) D+ `7 I- g( R, |$ E# }; t
  10. }HAL_TIM_ActiveChannel;
      v5 W) @& E6 C) {% j
  11.   DMA_HandleTypeDef        *hdma[7];
复制代码

6 h/ c9 @. q8 Z" P& d  d用于关联DMA。- f5 |/ D4 c: i- J" D  h" P
2 q- m. }' w4 m$ ~7 E
配置定时器参数,其实就是配置结构体TIM_HandleTypeDef的成员。$ Y& t1 G2 v" N6 h) s

1 W% ]6 c9 n' U! R7 H2 b
  1. TIM_HandleTypeDef   TimHandle = {0};" g) A7 m9 y6 H# A9 K
  2. : q! g2 E* r( C. ^9 _
  3. /* ! P: |  s; V- M* _0 e
  4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1)/usPeriod + 1)
    . C3 i5 f7 l- J% g/ A
  5. */
    ; g4 c. h' B1 S4 K% y6 c
  6. TimHandle.Instance = TIMx;2 l8 W7 q5 L! M+ H; m* J- I
  7. TimHandle.Init.Prescaler         = usPrescaler;6 \& u+ W' p3 S
  8. TimHandle.Init.Period            = usPeriod;        
    $ o5 f% j" p* A
  9. TimHandle.Init.ClockDivision     = 0;
      F/ [1 `1 Q# f" [/ c4 g
  10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    : t) I1 D! R) Y3 w( D
  11. TimHandle.Init.RepetitionCounter = 0;; ~- q3 f) x( h4 Y5 N2 t% O
  12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    & `& h" D6 T6 x5 m) F) D5 ~
  13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    0 K1 I. }8 a  c7 x, A. l  y
  14. {
    ' P5 ]% M* C* ?! p+ r$ ]; i4 I& q( m
  15.         Error_Handler(__FILE__, __LINE__);
    0 Q1 c' R8 n' c- m
  16. }
复制代码
$ p( `8 z; H0 E/ w1 M
32.3.3 定时器输出比较结构体TIM_OC_InitTypeDef
& f( Q/ c; U! ~' }( w& s
此结构体主要用于定时器的输出比较,定义如下:5 f! z8 k5 V) m8 `2 N2 a; M: T
% b8 U7 y2 p9 K' O( r( E; V
  1. typedef struct
    : V5 @) \4 L( C
  2. {                                 
    " h8 o1 p; x5 T3 ?3 F- ]( y
  3.   uint32_t OCMode;      
    1 {; t8 m% t5 P, a
  4.   uint32_t Pulse;      
    ; G" ~$ h7 I8 Y: T7 Z
  5.   uint32_t OCPolarity;   
    . j0 |6 x# C" G* t
  6.   uint32_t OCNPolarity;   ; E4 G8 z* t2 ~  ]
  7.   uint32_t OCFastMode;  
    4 j' d) N$ x! E8 V4 F" p+ \' T
  8.   uint32_t OCIdleState;   $ [5 ^- `0 S* j: E" t
  9.   uint32_t OCNIdleState;  ' Z6 S( e0 g# P! M& F- Z
  10. } TIM_OC_InitTypeDef;  
复制代码

/ j1 |: |- c4 w# D下面将这几个参数一 一做个说明。
' O. `6 t! {. A( S0 X1 r: r$ d5 d
: [( q% t. x" @; p5 C  OCMode
# r9 u9 p/ g8 ~7 Z1 B. m( o用于配置输出比较模式,支持的模式较多:
9 |% @! ^; a) W& W; K" b( ~
6 V! b" ?; q- O$ y4 T% H
  1. /*!< TIM Output timing mode */8 W: u+ d6 ]* c6 O8 C" b
  2. #define TIM_OCMODE_TIMING                ((uint32_t)0x0000U)      
    2 S( G) Z) p* m% [6 r- L

  3. 3 I* T. c% `- I5 J4 c
  4. /*!< TIM Output Active mode */                          
    6 d+ p& Y$ g- N- Q% C: z. c4 @
  5. #define TIM_OCMODE_ACTIVE                ((uint32_t)TIM_CCMR1_OC1M_0) & c7 u5 M! ^- S& \

  6. ( z7 K* O% [  g. ?
  7. /*!< TIM Output Inactive mode */                       
    3 X* y) K2 v' w9 W& T6 Q2 K0 f& y% l) K
  8. #define TIM_OCMODE_INACTIVE              ((uint32_t)TIM_CCMR1_OC1M_1)           
    & ]5 K; M4 o' x1 M$ x

  9. 0 Y; f0 I& [( W. ?+ ?4 w
  10. /*!< TIM Output Toggle mode */               
    + T* L& B% R1 e$ v! D. o
  11. #define TIM_OCMODE_TOGGLE                 ((uint32_t)TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)         , \* m4 o$ f+ b+ |- ]7 [4 j. W
  12. : {( y( W& e7 `
  13. /*!< TIM PWM mode 1 */! I# W# Z9 U/ r+ i! G1 D( R0 R! s1 Q: ~. Y
  14. #define TIM_OCMODE_PWM1                   ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1) - l" t" J$ d  M- l. Z- f- F* Y

  15. 4 Z8 e) ?2 _1 N) `4 o3 P) k# b
  16. /*!< TIM PWM mode 2 */                    
    2 m7 z" c! G( S6 A0 y$ N/ }
  17. #define TIM_OCMODE_PWM2                    ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0)   0 _1 @: V. _4 _6 K  c
  18. & o' M4 S+ E1 z1 J3 K
  19. /*!< TIM Forced Active mode */   
    4 ~3 T, M: t4 C8 G; P9 a: U" e' W
  20. #define TIM_OCMODE_FORCED_ACTIVE           ((uint32_t)TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0)         
    $ A6 _& y0 T7 }  }7 w
  21. , A" h& M- U7 ^9 U  s4 i
  22. /*!< TIM Forced Inactive mode */             ) X( U# S' v2 u. I! Q
  23. #define TIM_OCMODE_FORCED_INACTIVE         ((uint32_t)TIM_CCMR1_OC1M_2)                                        6 E$ `) `, p0 U0 w- H9 X9 z

  24. % V& {# L4 u' D, v) ~
  25. /*!< TIM Rettrigerrable OPM mode 1 */  
    % l5 t2 A: [' e; F
  26. #define TIM_OCMODE_RETRIGERRABLE_OPM1      ((uint32_t)TIM_CCMR1_OC1M_3)   
    ! Y) G$ ?( {, T) A( o

  27. $ b7 u; M+ a: d: x
  28. /*!< TIM Rettrigerrable OPM mode 2 */                                        8 G$ q. R- b9 }3 Y% |+ c
  29. #define TIM_OCMODE_RETRIGERRABLE_OPM2      ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0)    # D$ R% V9 }, }4 q. v5 c
  30. 0 M6 }6 E0 n) f8 o( m4 G4 ?% S  \
  31. /*!< TIM Combined PWM mode 1 */                     
      [6 K$ \. Q& f9 F: ~* [. ?
  32. #define TIM_OCMODE_COMBINED_PWM1           ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_2)     ( q) \2 l1 }) K; i$ o

  33. / t- ^% M) t, @/ L
  34. /*!< TIM Combined PWM mode 2 */                  $ B: E; q4 G$ h+ t0 |
  35. #define TIM_OCMODE_COMBINED_PWM2           ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_0 | TIM_CCMR1_OC1M_2)   
    . {% l- X* X' N9 D# Y0 c  S6 e

  36. : ]& i: A/ N2 i+ u( o: J
  37. /*!< TIM Asymetruc PWM mode 1 */  8 ~" E. ~7 C) Q) o
  38. #define TIM_OCMODE_ASSYMETRIC_PWM1         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2)  
    ; ?" Z# w- o% |9 P

  39. 0 [* h% a! m( N, c+ u; _8 x; ?9 E8 p
  40. /*!< TIM Asymetruc PWM mode 2 */    1 t! ]* [' F" @  c* G4 Z
  41. #define TIM_OCMODE_ASSYMETRIC_PWM2         ((uint32_t)TIM_CCMR1_OC1M_3 | TIM_CCMR1_OC1M)  
复制代码
* o, O2 c% n4 A6 X& b& Z; [
  
: _  q- S7 k/ \: v. m  Pulse
, v) i0 `8 y, I$ @0 G0 l. I: c可用于设置占空比,对应定时器的CCR寄存器,32位的TIM2和TIM5范围是0到0xFFFFFFFF。
; K" q$ U: {' }! G0 f2 ^' x8 u
4 }! H9 d4 R" Q0 x  OCPolarity& @9 s0 K3 T9 i' G
设置输出极性,可选高电平或低电平有效。
# `1 w0 u5 S$ r* k
% F  Y' L% ~- N
  1. #define TIM_OCPOLARITY_HIGH                ((uint32_t)0x0000U)& n- F" e/ ~5 x- x
  2. #define TIM_OCPOLARITY_LOW                 (TIM_CCER_CC1P)
复制代码
  A9 w* ~( ]5 D3 r! b* i
  OCNPolarity
* C2 ]& {4 R" F- j6 r, N, K互补输出极性设置,可选高电平或者低电平有效。- R$ _% c- U) \: M6 ?6 n) D6 p! ?
1 {% ?+ S9 N+ p0 I
  1. #define TIM_OCNPOLARITY_HIGH               ((uint32_t)0x0000U)1 u% |0 {+ U0 V7 h
  2. #define TIM_OCNPOLARITY_LOW                (TIM_CCER_CC1NP)
复制代码
" }% S, Z; J& W; o* X% U- t5 E( q
  OCFastMode
' T$ A+ {! A; g6 h: G' {. U快速输出模式使能,仅OCMode配置为PWM1或者PWM2模式时才有意义。6 q# W1 c2 @: f8 H+ v
; |' V# g5 [/ m! _
  1. #define TIM_OCFAST_DISABLE                ((uint32_t)0x0000U): W  g- m  q/ b
  2. #define TIM_OCFAST_ENABLE                 (TIM_CCMR1_OC1FE)
复制代码

- E% a- e3 f; X9 H+ T: e+ c. S  OCIdleState
' @% ?1 h+ F4 q" e空闲状态时,设置输出比较引脚的电平状态。5 o) P6 m7 p$ k* G

9 z6 i9 j/ C) N" K2 h
  1. #define TIM_OCIDLESTATE_SET                (TIM_CR2_OIS1)4 w" x0 w0 Y% \+ g- i# i
  2. #define TIM_OCIDLESTATE_RESET              ((uint32_t)0x0000U)
复制代码
# N9 q6 F7 n$ k  q4 z
  OCNIdleState
1 \* T9 z. W# _6 F2 m空闲状态时,设置互补输出引脚的电平状态。
, X, d$ W; l. y- v0 f2 Z" e  Y; q
  1. #define TIM_OCNIDLESTATE_SET               (TIM_CR2_OIS1N)" p$ S) a' f1 Q# W$ e" m
  2. #define TIM_OCNIDLESTATE_RESET             ((uint32_t)0x0000U)
复制代码
( H6 ^! X! W) Q# z! E5 E
32.3.4 定时器输入捕获结构体TIM_IC_InitTypeDef
' X' Q4 k5 P! _  Q- M# Z/ `  ~+ G此结构体主要用于定时器的输入捕获,定义如下:
# `4 ?  m% y% z7 M" \& \- t
( F1 J) |3 a7 ]% T
  1. typedef struct! O! m0 q! K) J
  2. {                                 
    : }* w4 q  b; @
  3.   uint32_t ICPolarity;   # c  {% w2 ~0 `* P! b/ H, `( X4 h: r
  4.   uint32_t ICSelection;   a' S8 Y8 w" o) u" D5 W
  5.   uint32_t ICPrescaler;
    3 J6 X7 w6 w" b
  6.   uint32_t ICFilter;   
    " `6 g" G2 |" |5 ~0 i% X( ^
  7. } TIM_IC_InitTypeDef;
复制代码
5 [% z: ]/ S3 f7 _7 B5 \; X
下面将这几个参数一 一做个说明。& Z  _8 t7 l, x

) ~( L% B9 S7 W  \. }  ICPolarity
, ^, V" j6 R, g. A0 K输入触发极性,可以选择上升沿,下降沿或者双沿触发。& T  k  n; j1 W+ {+ ?( }. a) _
( ~2 n& \1 n: |  [0 K
  1. #define  TIM_ICPOLARITY_RISING             TIM_INPUTCHANNELPOLARITY_RISING# z& b, W1 Z; z9 W) E
  2. #define  TIM_ICPOLARITY_FALLING            TIM_INPUTCHANNELPOLARITY_FALLING
    2 k. v  C' W8 W
  3. #define  TIM_ICPOLARITY_BOTHEDGE           TIM_INPUTCHANNELPOLARITY_BOTHEDGE
复制代码
6 b& _+ T/ c9 q# x
  ICSelection
9 _4 c' }) L1 V+ N% J5 o% O8 r1 N输入捕获通道选择,可以选择直接输入(即CC1选择TI1,CC2选择TI2等),间接输入(CC1选择TI2,CC3选择TI4等)或者TRC。
7 x, j8 O& Q4 B4 @2 n# u/ h2 ~. N6 s# I
  1. #define TIM_ICSELECTION_DIRECTTI       (TIM_CCMR1_CC1S_0)   * G, r! o: N* \+ X- @2 y
  2. #define TIM_ICSELECTION_INDIRECTTI     (TIM_CCMR1_CC1S_1)  7 H4 X6 _; ?4 e" Q% E8 R
  3. #define TIM_ICSELECTION_TRC            (TIM_CCMR1_CC1S)   
复制代码

0 p, i! L9 B8 T( ]# F, g6 v: r  ICPrescaler& c# a. R$ w4 ^; {' O
输入捕获分频,表示每捕获1,2,4或8个事件后表示一次捕获。
# h* b/ l/ G" Q, ?! [5 o7 N5 A* f. h6 A
  1. #define TIM_ICPSC_DIV1       ((uint32_t)0x0000U)                 - d& z* t( ~' G) W/ [
  2. #define TIM_ICPSC_DIV2       (TIM_CCMR1_IC1PSC_0)    ( u% U5 }) P9 j  H
  3. #define TIM_ICPSC_DIV4       (TIM_CCMR1_IC1PSC_1)    ) S2 r4 ?) Y4 n4 A+ F) O9 Q
  4. #define TIM_ICPSC_DIV8       (TIM_CCMR1_IC1PSC)
复制代码

$ b  @# l2 P& S4 N! O7 ]  ICFilter
" J+ i9 l) j, [& S; O0 m输入捕获滤波器,可以定义采样频率和多少个连续事件才视为有效的触发,参数范围0到15。具体定义如下,其中fCK_INT表示定时器时钟,fDTS表示死区时间采样率,N表示这么多个事件代表一次有效边沿。7 ^+ f' Y% n% O4 d# ?

' @3 Z6 j1 Y5 G4 z
  1. 0000:无滤波器,按 fDTS 频率进行采样- ]9 @  Z2 ~1 }# |% h  W
  2. 0001: fSAMPLING=fCK_INT, N=2* M9 a" a/ c+ c9 F1 m( D
  3. 0010: fSAMPLING=fCK_INT, N=44 c: T; h9 A% J0 F9 F% e# A
  4. 0011: fSAMPLING=fCK_INT, N=8
    * |% ?1 B; u. c
  5. 0100: fSAMPLING=fDTS/2, N=6$ z9 o4 J; |0 y, J& n2 S
  6. 0101: fSAMPLING=fDTS/2, N=8
    $ q, B% W% _7 r
  7. 0110: fSAMPLING=fDTS/4, N=6
    # K- f5 u) c3 J
  8. 0111: fSAMPLING=fDTS/4, N=8$ ]# K9 t/ F8 L3 z2 _7 p
  9. 1000: fSAMPLING=fDTS/8, N=6
    2 f2 g  C. {% P4 R8 D3 B; x' m
  10. 1001: fSAMPLING=fDTS/8, N=8
    6 h5 ?7 |. V) E+ \
  11. 1010: fSAMPLING=fDTS/16, N=5* q8 |0 S' _6 g5 i) o* \" ?
  12. 1011: fSAMPLING=fDTS/16, N=6" }" E( j5 m- p) @
  13. 1100: fSAMPLING=fDTS/16, N=8
    4 t7 M6 d  u8 S/ @- g- `
  14. 1101: fSAMPLING=fDTS/32, N=5
    % u% A( H1 {4 h5 m& a, q9 D
  15. 1110: fSAMPLING=fDTS/32, N=6
复制代码
8 c1 A% l4 f- C" \; x
32.3.5 定时器的底层配置(GPIO,时钟,中断等)3 F" }* K' l- \5 [# W$ z
HAL库有个自己的底层初始化回调函数,比如调用函数HAL_TIM_Base_Init就会调用HAL_TIM_Base_MspInit,此函数是弱定义的。
* i% s* U& z5 ]% q! Y* v& D: ]( G! g% f- R, k% F, c
  1. __weak void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)' I( c& [/ ]. B" k7 ~7 o
  2. {+ u. T- `+ w3 _" t
  3.   /* Prevent unused argument(s) compilation warning */7 h3 _9 O4 d4 m6 s
  4.   UNUSED(htim);
    ; V# A# G$ k  J( g6 x
  5.   /* NOTE : This function Should not be modified, when the callback is needed,  p( m5 \# E3 L! I& p3 |; A
  6.             the HAL_TIM_Base_MspDeInit could be implemented in the user file
    4 h' x. n+ J6 N5 m5 @$ C: b
  7.    */+ F% |+ k: F2 s
  8. }
复制代码

, }: n! ]. M& h3 z$ ?9 z: n# l+ y6 F用户可以在其它的C文件重定向,并将相对的底层初始化在里面实现。对应的底层复位函数HAL_TIM_Base_DeInit是在函数HAL_TIM_Base_MspDeInit里面被调用的,也是弱定义的。$ b+ f7 T1 E* u  r* e0 t- F( t
0 H$ Q9 [# p: [1 e
当然,用户也可以自己初始化,不限制必须在两个函数里面实现。
# J( ]2 G: S, y0 v" x: K& Z; R
- B: D7 J8 N: R$ c2 h定时器外设的基本参数配置完毕后还不能使用,还需要配置GPIO、时钟、中断等参数,比如下面配置TIM1使用PA8做PWM输出。; d5 b* k. N0 h2 {& Y

, h- n, F- n7 @6 Q, z& K
  1. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)) q7 F) I' n- i
  2. {
    . x" W/ I9 b% C  q& j5 f0 k/ f
  3.   GPIO_InitTypeDef   GPIO_InitStruct;
      \) p, F: ^3 o, I! M$ V
  4. 9 j% Q; X- e) [0 G3 Q
  5.   /* 使能TIM1时钟 */
    8 Z( A6 B+ K, Y  p
  6.   __HAL_RCC_TIM1_CLK_ENABLE ();
    5 G* B7 M& T4 d: ?5 b. S! \
  7. 9 b9 ~1 m6 X+ l
  8.   /* 使能GPIOA时钟 */
    8 Z% _4 ^! j5 G8 c; @6 S
  9.   __HAL_RCC_GPIOA_CLK_ENABLE ();5 E$ ]6 _. h, Y3 _

  10. 8 \' Z7 u# @& m. c+ a) ^
  11.   /* 设置TIM1使用PA8做PWM输出引脚,将其配置为输出,推挽,复用模式 */
    ! I4 ^. h3 t- l$ M
  12.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;+ N; d$ r' K  L0 T
  13.   GPIO_InitStruct.Pull = GPIO_PULLUP;  g/ L, M# q4 _
  14.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    ) m6 _4 p( V' F  v# ]

  15. - L6 x% a& d  Y5 E8 j1 u
  16.   GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
    ! N% V& l* T$ b
  17.   GPIO_InitStruct.Pin = GPIO_PIN_8;$ f% a: `7 ?" d) {+ a
  18.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    $ C( ]/ \' h$ ~6 G' _+ X

  19. # v1 F7 C6 h# ^( n) n4 d+ l
  20. }
复制代码
0 u2 E) Z% e. ^  G3 Y
总结下来就是以下几点:8 W) d/ T7 N" h7 _9 |8 I* r" i
7 I0 K6 m  ^- O2 p4 k
  配置TIM时钟。
& T/ W6 F; [/ @( u+ u  配置TIM所用到引脚和对应的GPIO时钟。) R. y+ s$ @5 c
  如果用到定时器中断,还需要通过NVIC配置中断。
# z! F8 z+ K( G7 R* ~0 |  如果用到DMA,还要配置DMA。* o7 V! x% }$ ]9 C
关于这个底层配置有以下几点要着重说明下:
$ \4 X- L+ E, ?1 r( U7 }7 G
8 s  v. ]. u" t, T  定时器所使用引脚的复用模式选择已经被HAL库定义好,放在了stm32h7xx_hal_gpio_ex.h文件里面。比如TIM1有一个复用,
3 v$ E- H$ s8 s' l
  1. #define GPIO_AF1_TIM1      ((uint8_t)0x01)  /* TIM1 Alternate Function mapping */
复制代码
5 _6 o# P, {5 i* k
但是却有4个输出通道,每个通道都有几个支持的输出引脚:
  y9 |/ ]8 M/ e3 ^1 t" F2 s6 g1 \
( a& O. U( Q" ?9 Z1 T
  1. TIM1_CH1,  PA8   PE9    PK1# O5 p0 ~1 C# O
  2. TIM1_CH2,  PA9   PE11; i  l8 _9 a0 v7 Z: c
  3. TIM1_CH3,  PA10  PE13   PJ9
    6 ?* i/ S' F3 {- V' t+ K4 x# b
  4. TIM1_CH4,  PA11  PE14   PJ11
复制代码

9 J: H8 m6 v7 E. x具体使用哪个,配置对应引脚的复用即可:
5 O- T8 |7 X+ Y: U% U- M- p
: i: z* y( J( G& ^4 g
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png

4 B1 Q) Y& j6 f. n
8 J% G& f" X- e' T32.3.6 定时器的状态标志清除问题5 q' `0 n+ X2 j
下面我们介绍__HAL_TIM_GET_FLAG函数。这个函数用来检查定时器标志位是否被设置。, A* o% M: W) C
  1. & P% l. G* r  y8 n) ?2 }
  2. /** @brief  Check whether the specified TIM interrupt flag is set or not.
    9 B, u  t5 C/ h' H7 a  X+ g5 S
  3.   * @param  __HANDLE__: specifies the TIM Handle.8 }- c! f# ~( i  i  A" P. ]- q: Q
  4.   * @param  __FLAG__: specifies the TIM interrupt flag to check.6 k+ J* }+ T- S6 ~, N/ S
  5.   *        This parameter can be one of the following values:/ K6 y4 h9 w( H  p. B
  6.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag3 r) g9 }! y& T3 x% s; H
  7.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag% `6 ?& r! o8 N! y6 ?8 x) v
  8.   *            @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
    2 ?" j$ `# v9 j4 F
  9.   *            @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag
    7 _2 w% q9 e7 x, F7 \: h- B
  10.   *            @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag' H+ e7 v" ?$ e) t
  11.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag
    4 P4 G  A) r4 T4 l" `. T
  12.   *            @arg TIM_FLAG_CC6: Compare 6 interrupt flag/ p  w: y' d0 N# N9 ^
  13.   *            @arg TIM_FLAG_COM:  Commutation interrupt flag4 y9 I7 c* l' {8 G
  14.   *            @arg TIM_FLAG_TRIGGER: Trigger interrupt flag4 V) N4 h6 ^0 n4 s2 P- w) |% q
  15.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   2 r- A, Z- ?& b$ g
  16.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     + T9 ?4 u( Z( r% h4 t" L4 k
  17.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
    0 V3 \8 d8 y. P5 w9 j
  18.   *            @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag/ m) i8 b( l& m7 o6 c& z4 i) `
  19.   *            @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag  g% R/ A5 P! ?9 ?  i
  20.   *            @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag
    0 V6 T2 ^6 F( W  f+ i4 K: H
  21.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag
    ; U& f0 `4 U, y5 K* X- D7 V
  22.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    6 M7 E& H3 ~3 ?6 u
  23.   */) v) D7 F  F% _6 O% }. O
  24. #define __HAL_TIM_GET_FLAG(__HANDLE__, __FLAG__)   (((__HANDLE__)->Instance->SR &(__FLAG__)) == (__FLAG__))
复制代码

+ N; H( ~% x) e. R: }+ c) P( I; C( A前5个是比较常用的中断标志。: q( `& X! N0 t0 f6 C. N

. h9 I8 x, C2 T+ Y9 a+ p9 }  TIM_FLAG_UPDATE
1 k; d/ ^& `& r3 J  p# w' I8 t定时器更新标准,配置一个周期性的定时器中断要用到。
  {+ h! F4 H7 L4 E
0 z; `5 i8 I- @4 |) v  Q     TIM_FLAG_CC1, G! L, J5 `6 P
TIM_FLAG_CC2
5 `$ e5 H# ^4 d* G  L, Z) x- U* ~& W8 \3 [2 l4 i
TIM_FLAG_CC3
+ R& F+ x& _& e) k* Y
0 O0 b' M6 F1 z4 q  b% oTIM_FLAG_CC4  o6 K, ^' N! r% H
% N* t! {5 a! _3 M; g8 S
捕获/比较标志,配置了捕获/比较中断要用到。2 _6 I* O2 o3 h3 _5 U9 B
8 n9 o6 ^! h0 B
与标志获取函数__HAL_TIM_GET_FLAG对应的清除函数是__HAL_TIM_CLEAR_FLAG:
( s8 T1 K" w8 Y1 }) I
/ V8 Y/ L! U! L# E/ q3 R+ |8 H
  1. /** @brief  Clear the specified TIM interrupt flag./ e4 l. U, Y) c8 Z
  2.   * @param  __HANDLE__: specifies the TIM Handle.! Y7 y1 K& Q* }( J3 D$ q1 d8 F
  3.   * @param  __FLAG__: specifies the TIM interrupt flag to clear.- L$ s* z7 D; i$ w* z/ Q
  4.   *        This parameter can be one of the following values:! Y+ ?% k. D, d9 r
  5.   *            @arg TIM_FLAG_UPDATE: Update interrupt flag9 }$ `# T) E( M: ^5 z- Y# T$ X
  6.   *            @arg TIM_FLAG_CC1: Capture/Compare 1 interrupt flag, \5 t. L6 P" y$ n- u" T! Y
  7.   *            @arg TIM_FLAG_CC2: Capture/Compare 2 interrupt flag
    ( K! f- }9 T+ q/ r. \+ f7 P( L
  8.   *            @arg TIM_FLAG_CC3: Capture/Compare 3 interrupt flag, K4 Q. o3 s9 V$ s% M9 ^
  9.   *            @arg TIM_FLAG_CC4: Capture/Compare 4 interrupt flag
    4 |- P- {8 k& y: A! g% ^. q- |
  10.   *            @arg TIM_FLAG_CC5: Compare 5 interrupt flag& j  e) b. J' x) {% o' J0 \
  11.   *            @arg TIM_FLAG_CC6: Compare 6 interrupt flag
    & [# p9 m0 g  G
  12.   *            @arg TIM_FLAG_COM:  Commutation interrupt flag
    8 H& p# W' `8 q& j0 |( v, E0 f
  13.   *            @arg TIM_FLAG_TRIGGER: Trigger interrupt flag6 y% }0 |# X; w2 }4 ]
  14.   *            @arg TIM_FLAG_BREAK: Break interrupt flag   . `8 Z$ R# D+ @% s
  15.   *            @arg TIM_FLAG_BREAK2: Break 2 interrupt flag                     $ G9 C+ p9 u! S1 r( x0 x/ Z
  16.   *            @arg TIM_FLAG_SYSTEM_BREAK: System Break interrupt flag
      g- x  D" G& [) c& M2 g. [7 L7 ~9 ~
  17.   *            @arg TIM_FLAG_CC1OF: Capture/Compare 1 overcapture flag2 M7 E6 n7 i! Y% X% b
  18.   *            @arg TIM_FLAG_CC2OF: Capture/Compare 2 overcapture flag
    + [3 k4 w% l: ]( `% q/ W$ I
  19.   *            @arg TIM_FLAG_CC3OF: Capture/Compare 3 overcapture flag3 R; i9 y, s2 O
  20.   *            @arg TIM_FLAG_CC4OF: Capture/Compare 4 overcapture flag5 x: i$ Y9 V$ @/ h
  21.   * @retval The new state of __FLAG__ (TRUE or FALSE).- \: f8 G8 a1 i; j
  22.   */
    & M. ?0 s! h$ @$ u; E0 `1 C( z. Y1 B
  23. #define __HAL_TIM_CLEAR_FLAG(__HANDLE__, __FLAG__)       ((__HANDLE__)->Instance->SR = ~(__FLAG__))
复制代码
1 W4 V9 ~3 j4 Y
清除标志函数所支持的参数跟获取函数是一 一对应的。除了这两个函数,还是定时器的中断开启和中断关闭函数用的也比较多。1 C* p3 g1 Z% N; _% }9 J

3 ?# C. T. b" u/ g! e, E! U
  1. /** @brief  Enable the specified TIM interrupt.
    , \- h( }2 V) P; v  Z$ L( I( A. I
  2. * @param  __HANDLE__: specifies the TIM Handle.
    " m) j. _* E: a2 R
  3. * @param  __INTERRUPT__: specifies the TIM interrupt source to enable.
    5 o7 Z& S( f" \3 e
  4. *          This parameter can be one of the following values:
    / y" k* R4 c9 |& Q' X+ M9 n
  5. *            @arg TIM_IT_UPDATE: Update interrupt
    ! _! }" b0 y3 S; _- Y
  6. *            @arg TIM_IT_CC1:   Capture/Compare 1 interrupt
    5 Z4 ?: {, Q2 Y
  7. *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt) G' X! }1 @1 b8 x8 |, |* h% D
  8. *            @arg TIM_IT_CC3:  Capture/Compare 3 interrupt  |1 w, Q( \0 @3 h: E: n
  9. *            @arg TIM_IT_CC4:  Capture/Compare 4 interrupt
    / b7 J: o: q4 K$ F. {, s4 j
  10. *            @arg TIM_IT_COM:   Commutation interrupt* m( R# P1 X; q; Z7 l$ r2 `9 t
  11. *            @arg TIM_IT_TRIGGER: Trigger interrupt2 S" o1 g; v  C9 g
  12. *            @arg TIM_IT_BREAK: Break interrupt
      Y2 ?0 i/ s; d+ R; `
  13. * @retval None
    ( ^& D& W8 n. D3 ~3 _. s
  14. */$ w9 F7 i( x& J8 R: Q" v, D
  15. #define __HAL_TIM_ENABLE_IT(__HANDLE__, __INTERRUPT__)  ((__HANDLE__)->Instance->DIER |= (__INTERRUPT__))3 A4 t: [6 ]3 \& o2 J

  16. / o! N$ O4 s  S
  17.   /** @brief  Disable the specified TIM interrupt.
      r5 a0 K$ v  d! @5 t
  18.   * @param  __HANDLE__: specifies the TIM Handle.4 n2 R: S  X' y/ j# @
  19.   * @param  __INTERRUPT__: specifies the TIM interrupt source to disable.& r7 i* V' g( W$ |  h* p. V  i
  20.   *          This parameter can be one of the following values:
    ) ~; Z0 C! {# D0 X
  21.   *            @arg TIM_IT_UPDATE: Update interrupt7 f8 N0 C  t  ]8 f* r
  22.   *            @arg TIM_IT_CC1:   Capture/Compare 1 interrupt6 H5 O6 v: c8 Q+ Q, o: b
  23.   *            @arg TIM_IT_CC2:  Capture/Compare 2 interrupt
    5 ^, ?0 L& ?7 S* _; r( K
  24.   *            @arg TIM_IT_CC3:  Capture/Compare 3 interrupt: ]3 T) T6 I! r+ Q3 z$ ^  D
  25.   *            @arg TIM_IT_CC4:  Capture/Compare 4 interrupt& Z0 ]8 O5 a6 e- o( ^
  26.   *            @arg TIM_IT_COM:   Commutation interrupt& b- U: w- V; x* k& H
  27.   *            @arg TIM_IT_TRIGGER: Trigger interrupt
    ' r5 O+ |# j0 Z- F
  28.   *            @arg TIM_IT_BREAK: Break interrupt0 R0 q& D' B3 ^) {8 s0 F! t
  29.   * @retval None+ u6 K: `  ~& x/ o. X! n6 q& c
  30.   */+ K" q' I  B' G* d0 m* ?5 H
  31. #define __HAL_TIM_DISABLE_IT(__HANDLE__, __INTERRUPT__)   ((__HANDLE__)->Instance->DIER &= ~(__INTERRUPT__))
复制代码
2 |# z! Y& L& z3 s1 v; c
常用的也是前五个参数,1个定时器更新中断以及4个CC中断 。" H$ }" W# t5 `7 @- e
# x# k' B+ k: r, j& s; k+ O& X
注意:操作定时器的寄存器不限制必须要用HAL库提供的API,比如要操作寄存器CR1,直接调用TIM1->CR1操作即可。1 {1 J" q, N& Y; R5 \# \: i! h# h8 k
3 o( X6 o/ M9 ]8 b; F6 P
32.3.7 定时器初始化流程总结( V4 ^2 O% J$ j) H- r+ C/ t8 H& i% P
使用方法由HAL库提供:3 C3 P4 t+ O3 p% `# H
3 r) N1 p1 q% D9 K
  第1步:通过下面几个函数配置定时器工作在相应的模式# J" {, i/ E# A4 f

* F7 i; |  e5 j) `  HAL_TIM_Base_Init
- a0 t' S7 y& A简单的定时器时基础功能8 \5 u& K9 j: r

1 J" s8 U9 z- x9 `( c' f  HAL_TIM_OC_Init 和 HAL_TIM_OC_ConfigChannel
0 @" v9 L- m" w. \配置定时器产生输出比较信号' e. x9 V% }9 A! `& Q

; i6 n' n- h& j4 S0 d* y  HAL_TIM_PWM_Init 和 HAL_TIM_PWM_ConfigChannel
  T2 R+ L4 \! v; r, r配置定时器产生PWM信号
3 S& I% c" Z3 h$ \$ {7 J
! J' s1 F5 N/ A0 ]- y8 H4 ?  HAL_TIM_IC_Init 和 HAL_TIM_IC_ConfigChannel
- N  x5 `% o8 C  Q: a配置定时器测量外部信号% }$ B/ i8 M! {1 ^

2 Z+ g/ t& x/ |& E( P  {9 U  HAL_TIM_OnePulse_Init 和 HAL_TIM_OnePulse_ConfigChannel
" w( L$ Y# V4 }4 R' Y) d配置定时器工作在单脉冲模式
, L3 E6 J( L. s/ {$ Z* \( r2 O( P5 x4 R% v$ X6 h: j7 A) t" V: ?
  HAL_TIM_Encoder_Init
9 P* w8 g+ d9 M( V配置定时器使用编码器接口2 \8 u7 v. E! E& y

; o* M- V; @0 C- M  第2步:定时器几个常用功能的底层初始化API,这个里面需要用户自己填' \3 l% {  E+ q" ^
% k6 V+ A, b- a1 {& t
第1步里面的几个函数会调用下面的API。9 \/ K( b' U  d: Z; [+ Z  R( R

5 f3 p" a8 q& J2 A+ ?  定时器基本功能 : HAL_TIM_Base_MspInit(). O% X" X- {, q' }2 O5 I
  输入捕获 : HAL_TIM_IC_MspInit()
7 J1 `' j- C; }6 k) H1 n  输出比较 : HAL_TIM_OC_MspInit()* Q& A, m6 u5 h) ^# F, o
  PWM输出 : HAL_TIM_PWM_MspInit()
9 c/ f# M7 h7 P. J3 z  单脉冲输出模式: HAL_TIM_OnePulse_MspInit()
  [9 d* O5 b! W7 g0 B  i6 ^  编码器模式 : HAL_TIM_Encoder_MspInit()6 `  m8 k6 y' u6 A
  第3步:底层初始化具体实现% C8 q( J+ t# `

  y) C4 P7 Z( O8 X, u% e第2步中函数的具体实现。, \6 `" n, n$ t. b/ v1 s+ T
& G) C# ?9 |# r$ Q+ U
  使用函数__HAL_RCC_TIMx_CLK_ENABLE()使能定时器时钟。; j% D. |2 H, N
  使用函数__HAL_RCC_GPIOx_CLK_ENABLE()使能定时器使用到的引脚时钟。
& j" ?! P$ n, p9 f' v$ f  使用函数HAL_GPIO_Init()配置GPIO的复用功能。5 d+ C8 B! t! e  _" E) {
  如果使能了定时器中断,调用函数HAL_NVIC_SetPriority和HAL_NVIC_EnableIRQ配置。$ y- X3 \1 q" r, j
  如果使能了DMA,还需要做DMA的配置。' g" Y; B' N- x' b: D0 Q! ]+ M
  定时器默认使用APB时钟,如果使用外部时钟,调用函数HAL_TIM_ConfigClockSource可以配置。
9 n/ [  ~9 i) ]# C' Z, z- P  第4步:启动定时器外设; [7 q8 A* ?, w9 g, \$ K
" f( w$ }. P$ u! A  E! K
  定时器基础功能:
: g6 E! n8 Y1 d3 c5 [) q  R6 U1 gHAL_TIM_Base_Start()2 Z) X; a3 E8 w8 y4 k1 x' W
  S4 N) L- o& l
HAL_TIM_Base_Start_DMA()
0 I& S; m! s4 m0 O% L% L% K
, m# \8 }8 n; t7 [( }HAL_TIM_Base_Start_IT()2 J+ e. A# U- F6 s! B" U. t
6 ^% L; [3 n3 W' y7 \5 k
  输入捕获 :& u) f; L- \  z+ d
HAL_TIM_IC_Start()
% d7 I' N- {  Y8 q+ h* x
% r4 P( _6 {* ^8 S! `5 zHAL_TIM_IC_Start_DMA()8 j7 ?5 j9 |# L

; Y0 N7 g% Q5 c; E* s1 QHAL_TIM_IC_Start_IT()
+ f7 {1 X0 D- J7 n- t5 L* C# t1 \+ s& s% h
  输出比较 :1 Y! c% W1 _* z+ U" t- f
HAL_TIM_OC_Start()  A8 B9 W* X% r. h/ R. Z
% S0 }' |- A& o( a/ V0 L/ Z
HAL_TIM_OC_Start_DMA()8 O( [- ?. V+ c9 N3 ~

; h' b: H  N% t; J$ J+ A) QHAL_TIM_OC_Start_IT()
9 N% y9 G8 q( U6 M+ l9 P- ?
% G) Q0 [) o5 U% j5 s  PWM输出:' K  C  N/ H0 U9 g3 v
HAL_TIM_PWM_Start()
) Q( S/ {" R: G9 b" q* \3 Q5 X! _9 L1 M" p9 C
HAL_TIM_PWM_Start_DMA()
; N$ d9 z* a7 A  W6 J" M; v! U) T+ g  V. Y  u
HAL_TIM_PWM_Start_IT()) F, {* `2 {0 u
" g/ r/ l3 y5 |
  单脉冲模式:- I" P. B8 p9 l  n
HAL_TIM_OnePulse_Start()
0 }! B/ Z5 p' A; Z1 J- |' f* q+ A8 s
: A$ |* k9 Z, I# b. MHAL_TIM_OnePulse_Start_IT().# {; A8 R  i8 x) O
/ d2 D+ x# D' r& O/ ^. r! }8 O
  编码器模式:
# J2 j& Q+ D7 l: w* aHAL_TIM_Encoder_Start()
( Z8 H; w6 ?3 v. Y% A
% [7 j: j: M* _: qHAL_TIM_Encoder_Start_DMA()
) O0 h9 u4 P% |9 t
- M2 E# J( j1 _HAL_TIM_Encoder_Start_IT().
5 v3 r' r- D, N- u
" Q( S  G4 p; z! l  第5步:定时器的DMA突发使用下面两个函数
6 f& A( P% g& T1 U/ X- Z6 ]
5 G0 T0 w; G) E3 q/ v% A. _# S  HAL_TIM_DMABurst_WriteStart()$ l. M# y! _; }; j. M/ V, r
  HAL_TIM_DMABurst_ReadStart()
7 H4 u+ Y, I' q# Z" ?' L  ?定时器常用的功能,通过上面这几步即可实现。# i; g: _4 {8 H
2 @# _$ W$ p7 q- t
32.4 源文件stm32h7xx_hal_tim.c
; J9 @. d& v6 `此文件涉及到的函数非常多,这里把几个常用的函数做个说明:0 s1 h3 ]0 G9 K" u
9 v& M7 b6 f6 `3 g# T+ T6 x/ `
  HAL_TIM_Base_Init
+ _  X2 t" n& k. D$ E2 K( X  HAL_TIM_Base_Start7 W2 q2 R! R0 |# p
  HAL_TIM_PWM_Init) B- i- \4 p5 j4 X
  HAL_TIM_PWM_ConfigChannel
! i0 D" x# F& S3 W8 @: M& E' K  HAL_TIM_PWM_Start6 k, X$ i' L7 c& o1 v+ E1 Y- Y
  HAL_TIM_IC_Init
, r, H% o+ J" v9 s, L! ?" w  HAL_TIM_IC_ConfigChannel
( M# r+ w) n& c/ a+ i  HAL_TIM_IC_Start_IT9 Z% ~4 j6 K: j' @  w4 G8 Q
  HAL_TIM_OC_Init
0 T) i8 r2 h$ \3 P+ C; t  HAL_TIM_OC_ConfigChannel1 Z6 S2 w2 ?( l" X, R
  HAL_TIM_OC_Start
4 y% ?; T- k0 K) p+ m1 N3 q32.4.1 函数HAL_TIM_Base_Init
. b; B. ?# Z$ T% m+ H, j7 l函数原型:; h$ I9 X  Y" b  q1 C
% ^. d, B0 K5 p$ [0 e
  1. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
    4 t& |& O( U' b! i- j0 K% `
  2. {
    3 C& w  ?8 m5 u% s1 X  ]
  3.   /* 检测是否是有效句柄 */: i- j2 l+ j9 r- p7 `
  4.   if(htim == NULL)/ f0 N$ V- w2 i1 G. L, |. I' {
  5.   {& M( Y1 H% y2 q0 P
  6.     return HAL_ERROR;
    7 V4 X& H  f. T/ x4 ^
  7.   }) x+ B9 x; b5 c" W+ z: {. C
  8. . I8 m4 b5 v9 j- O1 ?: |
  9.   /* 检测参数 */
    ! `' c$ e9 e, Q+ u
  10.   assert_param(IS_TIM_INSTANCE(htim->Instance)); 4 L7 D+ ]  T! O( @3 S5 h! X
  11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));3 _, \# x2 R% l# e( v" W9 k
  12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));0 L! X) G1 P- B0 A0 }! T% l

  13. - o% B1 o" d$ P
  14.   if(htim->State == HAL_TIM_STATE_RESET)
    . L3 Z! o0 s# J
  15.   { 4 d5 p& M! R+ w: M! o; R
  16.     /* 默认取消锁 */5 |" Q7 o6 A$ K- r& v! c8 z
  17.     htim->Lock = HAL_UNLOCKED;
    . {4 r) |1 [& V& x$ W  q) @  e  L
  18.     /* 初始化底层硬件 : GPIO, CLOCK, NVIC */5 p$ t3 ]) r" r
  19.     HAL_TIM_Base_MspInit(htim);
    : x9 u3 m; ?( W; [3 ~) ^
  20.   }+ N* e8 W4 a/ @0 z! g* @3 R

  21. ( z( f/ T/ p& T3 I2 X, l; z
  22.   /* 设置TIM状态 */' X- K! l8 Z3 v. o5 ~
  23.   htim->State= HAL_TIM_STATE_BUSY;# V7 Z$ u2 b, ^- D

  24. 7 P& n. X6 E7 Y* u& {
  25.   /* 基本参数配置 */$ f  i- D; P3 n1 ?4 ?6 `1 m
  26.   TIM_Base_SetConfig(htim->Instance, &htim->Init); # e1 Q  T7 I# G  Q, w" i

  27. 3 J; J/ F1 L- B. L5 b9 o
  28.   /* 设置TIM就绪 */
    & f1 S* M1 d2 x- _2 }- i8 ^
  29.   htim->State= HAL_TIM_STATE_READY;+ M% o5 R$ r8 K, ~
  30. 1 y, I% ?3 X; Z8 w
  31.   return HAL_OK;
    : [0 l4 i) U( R; U2 r2 o9 ]
  32. }
复制代码
; n6 ~2 k, l! s% Q" W5 \5 y
函数描述:
3 d& }6 U& q5 W% g, X
0 c6 ]$ S, z6 t7 K8 ?8 w此函数用于初始化定时器用于PWM。
# S' j* @; P; ^& s$ ]. o8 T4 K4 }8 n' [& Z! c
函数参数:# ~! g- S: h9 \  W! y8 d0 A& k
* B5 N& O$ N4 [  n; a) I, t
  第1个参数是TIM_HandleTypeDef类型结构体指针变量,用于配置要初始化的参数。
1 C3 |* Q4 |3 M7 O% q0 y6 k, O) f* m  返回值,返回HAL_ERROR表示配置失败,HAL_OK表示配置成功,HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出。% z* H7 E5 k( S  p2 j" U
注意事项:
# I( a3 R2 m2 Q3 z# w. `
( f+ `8 Z% \7 u函数HAL_TIM_Base_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能,由于这个函数是弱定义的,允许用户在工程其它源文件里面重新实现此函数。当然,不限制一定要在此函数里面实现,也可以像早期的标准库那样,用户自己初始化即可,更灵活些。
. f) ]8 W4 I/ K如果形参htim的结构体成员gState没有做初始状态,这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
( u/ J) f. S0 Q% ^. W" E对于局部变量来说,这个参数就是一个随机值,如果是全局变量还好,一般MDK和IAR都会将全部变量初始化为0,而恰好这个 HAL_TIM_STATE_RESET  = 0x00U。
8 L; Q0 |$ }: u- E
: @' g& E( O1 u/ d3 W) h  c- K解决办法有三:
3 y- s3 v2 o4 J8 C. E+ @' B# s
6 A, K6 j$ m* o3 k; L方法1:用户自己初始定时器和涉及到的GPIO等。
# }. D* q$ P  z' h5 q5 c1 N) G( n4 c
. O4 w6 X( I& {7 Y- t方法2:定义TIM_HandleTypeDef TimHandle为全局变量。
7 D: f* e4 a! f7 P, Z8 W3 C
4 p8 Q7 B# z# ?) z7 G方法3:下面的方法: v" E1 U. |5 M0 S
( Q: ?0 @. J$ k
  1. if(HAL_TIM_Base_DeInit(&TimHandle) != HAL_OK)
    ! d% Z0 L) {& j1 m, h
  2. {
    ; `/ g" W# l; ~" ?0 V: W
  3.     Error_Handler();
    % H5 L# x. |; t
  4. }  8 j2 {9 A# [4 i" a
  5. if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK); w& Z8 J3 d" x/ u% ~! \7 r% S) ^1 z
  6. {
    2 ^9 w1 {9 }- i# I
  7.     Error_Handler();
    ! j' W9 j/ e! s3 [8 A- @; r% h
  8. }
复制代码

8 Y3 ~& o% [3 i) ~4 m+ o/ a使用举例:
' x' Z/ O4 A( W# D9 `& Y
; t+ b0 o6 O  u8 w5 i/ H( f& k6 {2 e
  1. TIM_HandleTypeDef   TimHandle = {0};4 k* M4 ?  _, v4 U: D
  2.   C; v9 V0 P: O7 ]1 B) M) n
  3. /*
    ( H/ @, K2 t  K! s& {  e; t
  4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1)/usPeriod + 1)
    3 V% D4 W$ C9 z6 M# i7 z9 z  U  c, Z) a
  5. */% K5 ?& B4 D: C0 G
  6. TimHandle.Instance = TIMx;
    , [' v4 ]1 O; _" \7 H
  7. TimHandle.Init.Prescaler         = usPrescaler;
    * W. `  x+ i- B
  8. TimHandle.Init.Period            = usPeriod;        0 Q; d' g7 k) {% v* K7 }
  9. TimHandle.Init.ClockDivision     = 0;
    : f# t1 M8 L0 `0 b
  10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    ( \0 f6 i# d2 I: x# m2 w5 n5 N
  11. TimHandle.Init.RepetitionCounter = 0;
    9 y- u! |% a& ?  ^+ I% f1 F
  12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    / d0 A( [8 i+ ]
  13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    ( [$ P5 d6 {; o( k; T: y1 f
  14. {
    3 k# a+ p9 L% y
  15.         Error_Handler(__FILE__, __LINE__);; x$ _$ m+ S1 v' ^" S
  16. }
复制代码

6 G& Z/ k7 N& W2 l  Y32.4.2 函数HAL_TIM_Base_Start
- p; v. v# a$ H7 }5 K/ M( t" K2 e函数原型:( R4 D5 X- x* M) l4 r

2 \6 `% t4 }' y0 D- g
  1. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)* t/ h0 Z0 g% w  n4 U5 Y2 E
  2. {
    ) W8 e- t' T9 n  F9 m* \
  3.   /* 检测参数状态 */
    9 U9 C1 V* R( N+ w5 T2 J2 ^: \( b
  4.   assert_param(IS_TIM_INSTANCE(htim->Instance));) }8 u& |4 `  q9 `. }  l# O# U8 `

  5. 4 y; @9 @3 M* L  T9 G$ W
  6.   /* 设置定时器状态 */
    6 s' [1 ?2 S  S9 b/ ^
  7.   htim->State= HAL_TIM_STATE_BUSY;# w3 J! E+ K# `
  8. , ?: C9 s$ n5 m  y
  9.   /* 使能定时器 */
    ! V+ f& m. Z* _3 O
  10.   __HAL_TIM_ENABLE(htim);8 j- M1 ~9 j. f8 o- R8 y7 l

  11. ' W, \0 @) D' v1 N# p' s
  12.   /* 设置定时器状态 */4 k% G) Z' j( U. F+ e
  13.   htim->State= HAL_TIM_STATE_READY;) f7 h3 s6 n* x6 K# e
  14. # P) Q' V, v! v1 h# s3 o
  15.   /* 返回HAL_OK */9 F3 b$ T4 Z* d' Y# i! C' w8 [
  16.   return HAL_OK;2 D' }$ t" g9 Y0 |
  17. }
复制代码
$ \/ o) |9 d& S8 }
函数描述:- a: A( `/ Q; ?4 P3 X
  H2 m' K2 L) ]) u# z$ q
此函数比较简单,调用函数HAL_TIM_Base_Init配置了基础功能后,启动定时器。
3 V* \$ B+ T7 C2 |+ W
! N. L% s  j; U1 ?* Q函数参数:
; {" E* o: }( U! B' X8 q4 ~6 Z, n' c! }
  第1个参数是TIM_HandleTypeDef类型结构体指针变量。
, j) ^/ _7 }8 ^4 k3 |* r  返回值,固定返回HAL_OK,表示初始化成功。
, k  W7 r6 Z. W& d$ c使用举例:6 {) {" G; T6 |2 S8 W4 c
5 y8 p4 r7 A6 m
  1. TIM_HandleTypeDef   TimHandle = {0};" H% s& l/ @& R# S; }9 g

  2. " n( E! E1 T, [5 U/ Q( \
  3. /*
    " \, _) d1 E" X. S4 I) O+ S
  4.     定时器中断更新周期 = TIMxCLK / usPrescaler + 1)/usPeriod + 1)
    4 ~( D. ]0 _- ?+ w7 k2 r
  5. */" b  ?* D7 h; O: O
  6. TimHandle.Instance = TIMx;
    % B/ S: A) e: u* M7 Y3 r
  7. TimHandle.Init.Prescaler         = usPrescaler;
      b# t4 x) o1 ~: v$ W  T- I3 n
  8. TimHandle.Init.Period            = usPeriod;        
    6 T% p" d. M% Y3 l
  9. TimHandle.Init.ClockDivision     = 0;4 y( k' Z8 Y# p
  10. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    ) w5 f& H3 K7 P7 X4 Q
  11. TimHandle.Init.RepetitionCounter = 0;( W% O7 z) n( `! _( |5 j" a  _
  12. TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    8 k! T& k1 L4 \9 g& v. N
  13. if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    % s7 b9 @  i% u2 a5 F
  14. {
    . u2 N: G: J3 j+ v: X
  15.         Error_Handler(__FILE__, __LINE__);
    - P6 P* ]: m  B) n% W
  16. }
    $ U3 {0 Q& b8 ?6 k/ A6 ?7 K

  17. / ~; C6 e- r" ^, Z
  18. /* 启动定时器 */
    8 h) A% D2 a. h4 B+ ^! _) k! P  F
  19. if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
    / C: Y, V6 l/ T# p* e
  20. {
    + S# G" ]% w& k' S! R! i
  21. Error_Handler(__FILE__, __LINE__);
      A# Q( i% w  A' p  ]8 e9 h
  22. }
复制代码

* ]' u) p' ]9 `* n2 c32.4.3 函数HAL_TIM_PWM_Init
) i8 {2 Q$ a- v9 B( s, k- t函数原型:
' |; Z2 ^; _$ x0 h: I! x  v# [6 ]- T: s2 Z3 t
  1. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)$ z; v; L( I1 C# o
  2. {, \7 A4 Q5 M$ p0 T3 d9 r
  3.   /* 检查句柄是否有效 */! o5 s7 M) w+ n7 Y8 j
  4.   if(htim == NULL)
    & M- }+ j* H: u, i' R
  5.   {4 `# I8 u7 I  ?2 ?* B
  6.     return HAL_ERROR;
    5 C1 A# e! i' |1 [7 I, q
  7.   }5 J3 ~- s& R: x

  8. * ~: H# B# C4 G1 f/ [2 R$ b
  9.   /* 检测参数 */
    9 Q0 M1 E0 H/ K5 H/ a" b7 c
  10.   assert_param(IS_TIM_INSTANCE(htim->Instance));# t% L+ i! p9 o( {' x+ R7 w
  11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));& x$ n8 I: ^6 |5 [' i+ u! o- Q
  12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));* d8 _, L% S* U; N% d

  13. # Q6 m% {  e6 |+ y6 e- M" D
  14.   if(htim->State == HAL_TIM_STATE_RESET)
    6 Y( [7 x3 o" X' ?/ c3 F% i, d
  15.   {
    ' v; J& S- e9 F* w- ^) A5 t
  16.     /* 默认取消锁 */
    & a& j9 ]' r! s* m$ l
  17.     htim->Lock = HAL_UNLOCKED;
    : Y" H+ r/ I4 |' `7 f# i5 n2 L
  18. + t+ _7 \( X8 w) j7 b- L
  19.     /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */
    9 p8 ?; O; c3 \  J
  20.     HAL_TIM_PWM_MspInit(htim);# Q. Q+ M4 q( g9 b
  21.   }: c; L+ g0 R/ m
  22. + d1 ^- E3 H' c5 Y! w: `
  23.   /* 设置定时状态 */
    9 ~% K( d; ?7 g
  24.   htim->State= HAL_TIM_STATE_BUSY;
    1 G% {7 l* K' r4 V6 y

  25. 7 A& |) R: H* D& Y
  26.   /* 配置定时器用于PWM */  : N& c) b% m6 M: r" ?2 T
  27.   TIM_Base_SetConfig(htim->Instance, &htim->Init); + Q, `: P/ s' \$ c

  28. 6 e; I' s; a, ~' M
  29.   /* 设置定时器状态 */
    * }' N+ h: Y( ?6 a* v) {; M) F- W& d
  30.   htim->State= HAL_TIM_STATE_READY;% g% p+ ?" R9 q# u9 f  C$ z

  31. : y, p& K7 g6 y% y& J
  32.   return HAL_OK;
    " r, A: _  T8 f; r- E
  33. }
复制代码

$ o$ `+ e. P  x5 d6 Q函数描述:; P- l; ?9 _$ N$ n8 S

, c0 M) P3 P/ A1 @5 c此函数用于初始化定时为PWM方式。3 L7 }% ^* b3 D1 S

5 L& |- E- o8 a函数参数:. S2 I0 H* z( @& H* [+ v& J

6 n2 L& r! n' X  X' v7 c  第1个参数是TIM_HandleTypeDef类型结构体指针变量,用于配置要初始化的参数。
# e3 x- \! s+ W0 c& A  返回值,返回HAL_ERROR表示配置失败,HAL_OK表示配置成功,HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出。
2 ^, V/ |0 C2 F9 B注意事项:
& j; ]2 n( h1 [, D
7 _- @! |) r' C5 E函数HAL_TIM_PWM_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能,由于这个函数是弱定义的,允许用户在工程其它源文件里面重新实现此函数。当然,不限制一定要在此函数里面实现,也可以像早期的标准库那样,用户自己初始化即可,更灵活些。% |4 |! F# [; J0 \. G
如果形参htim的结构体成员gState没有做初始状态,这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。( H! n+ H: `1 I8 b
对于局部变量来说,这个参数就是一个随机值,如果是全局变量还好,一般MDK和IAR都会将全部变量初始化为0,而恰好这个 HAL_TIM_STATE_RESET  = 0x00U。$ y9 G  ]" L% s9 ]$ `

! c. V5 R. l9 m: y( a解决办法有三:
. H, s  s5 J3 x9 b8 g* r& E7 D/ z0 \
方法1:用户自己初始定时器和涉及到的GPIO等。) f; s( Z/ ?; Z$ Z, F
2 h: V! T% L  `- u5 w( c( l" _5 f
方法2:定义TIM_HandleTypeDef TimHandle为全局变量。' s( j$ M$ t$ J. i: D5 z6 [
; U3 k( w; B" E+ q5 I
方法3:下面的方法
+ e# L9 N7 }$ d. `, E  f: t3 h( ^
4 `: f, o8 i1 d/ K2 i. q
  1. if(HAL_TIM_PWM_DeInit(&TimHandle) != HAL_OK)
    ! I9 l9 K% Q8 T' l
  2. {) U" {: I7 S# a! e9 R) W3 }, H
  3.     Error_Handler();2 z9 e$ L+ L% u' Y, z! e8 q
  4. }    Z# b5 O+ g; T3 o
  5. if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)  A8 x2 {/ x' ^) L
  6. {
    0 U$ ~* k1 m4 }7 X
  7.     Error_Handler();& V7 B5 l0 D7 T5 x0 u  U' y" o
  8. }
复制代码

: Z7 [" x+ h; O8 Q  i. ?) ~: [: F  U/ y使用举例:
$ \& `: E$ C* e1 F: M' Z  {% U/ I, L) K& H
  1. TIM_HandleTypeDef  TimHandle = {0};
    , c& j  q* N+ q5 t
  2. % G( e/ ~# ]/ Z5 x( ?+ Q; M2 s. X
  3. /*  PWM频率 = TIMxCLK / usPrescaler + 1)/usPeriod + 1)*/
    ; W; W0 N' m/ s$ i6 o! Z. D- [" ^+ ]
  4. TimHandle.Instance = TIM1;
    4 G# G+ t8 J) t* m. F6 C( q
  5. TimHandle.Init.Prescaler         = usPrescaler;
    3 `! h) ]! _& r( d7 }
  6. TimHandle.Init.Period            = usPeriod;+ B- X# @2 d$ J. u5 k9 F
  7. TimHandle.Init.ClockDivision     = 0;1 |$ M. q8 W2 B, d0 i- E9 W
  8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    ! k4 o# d2 n- q
  9. TimHandle.Init.RepetitionCounter = 0;
    2 v9 |, @) p9 l
  10. TimHandle.Init.AutoReloadPreload = 0;
    ; s* ?/ h! b6 V
  11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
      e# H/ W  h* i, W
  12. {4 d* U( c1 D) N9 K% t6 r2 K4 y8 h5 u3 g! W
  13.     Error_Handler(__FILE__, __LINE__);" C$ y7 K6 I# _
  14. }
复制代码
; c% L' M: g3 E
32.4.4 函数HAL_TIM_PWM_ConfigChannel
& h) F& ~2 y, L+ _: J, K/ i函数原型:
  p& p3 K% U3 Q; x" b9 ~. `( s
& K5 T9 F4 {) Q4 F) A: i
  1. HAL_StatusTypeDef HAL_TIM_PWM_ConfigChannel(TIM_HandleTypeDef *htim,6 M: O0 G% [: K
  2.                                             TIM_OC_InitTypeDef* sConfig,
    : q. _3 p) W8 {; k
  3.                                             uint32_t Channel)
    . r7 R% o6 j1 Z% M/ I+ h+ G2 p
  4. {
    # X; f, f. T3 k; f
  5.    /* 省略 */
    % {, E. f% `2 e  Y

  6. , W5 E! N2 k" z
  7.   /* 开锁 */
    + o: f8 t/ L+ N! Y
  8.   __HAL_LOCK(htim);
    8 ]! k  ?9 X0 _4 M3 R- t
  9. : O6 Y) M4 e) w9 S( Q
  10.   htim->State = HAL_TIM_STATE_BUSY;
    ) {% Y3 v: T4 U8 ]6 e) \* C

  11. # r/ Q: y$ H7 @9 a4 {
  12.   switch (Channel)
      l' `' k/ f4 t  @0 X$ F& {
  13.   {9 ^1 e7 b% \& \$ ]. s
  14.     case TIM_CHANNEL_1:
    $ p# i. N5 i* K* Z" G2 k8 Z, x
  15.     {* y, ?: K! O  ~2 w  W
  16.       /* 检查参数 */
    ' ]! h  Y& u3 y6 `( F  Y  s
  17.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    - n7 o  c: m- F& H, D
  18. 5 l1 b& o( l# C8 H
  19.       /* 配置通道1的PWM模式 */: {2 ^& c6 a9 [/ p) A# X
  20.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    " T: _- I% G7 b8 r& W5 \/ J
  21. 9 i" m' v7 d% R5 C- W3 r% r( S
  22.       /*预装载使能,更新事件产生时写入有效 */& L1 V5 g' g  }$ J6 a% e
  23.       htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;
    + k2 I( ~' u# Z0 s* B& }

  24. % E2 Z0 D% Y2 W' n' b
  25.       /* 配置是快速输出模式 */
    0 [+ Z0 S/ {# n  D& _7 p
  26.       htim->Instance->CCMR1 &= ~TIM_CCMR1_OC1FE;! _' V. B2 Z- t; C9 D. M
  27.       htim->Instance->CCMR1 |= sConfig->OCFastMode;
    - C' A% u; E, W/ @1 d
  28.     }
    : i" H0 r5 Y0 u
  29.     break;
    # }* l2 S* l6 c2 e/ c* \9 F! r

  30. ' Z# N+ W, G' h2 r
  31.     case TIM_CHANNEL_2:
    8 Z1 w/ K% L/ b% Y
  32.     {
    1 @/ S0 [" o# Q$ @. G+ t5 b
  33.        /* 省略 */
    1 {+ J/ s/ B7 _
  34.     }
    3 N& R# B' }$ d0 n
  35.     break;/ o: j/ F* z# G$ P+ ?( z

  36. ; F3 r7 b, I* B. u; R, _
  37.     case TIM_CHANNEL_3:
    ( ]: c8 C7 s3 F( e% \5 L1 b# [
  38.     {% e! B0 M: o' F) h7 p6 k* c
  39.        /* 省略 */
    6 O" s6 I# ~/ D$ V. g3 _5 \# y
  40.     }0 W: a8 c7 |8 W# u( q' ^# l' j( b
  41.     break;3 |* W* r, u. _" I: D
  42. 9 h& R# W/ R; g$ v. B/ @" ^
  43.     case TIM_CHANNEL_4:
    $ _' G9 `4 V4 n+ j$ q4 d
  44.     {
    $ J7 S# k* m0 B6 j' y$ n, F
  45.       /* 省略 */
    8 Y  d" z: n( E! c3 v
  46.     }6 M8 H  ]$ [; I" X* J
  47.     break;
    ( \2 _1 e0 }; A' i

  48. - V7 C3 [( M3 v6 J1 g  L
  49.     case TIM_CHANNEL_5:
    * T( w, g+ t# d5 [  t- S
  50.     {
    0 D0 ^1 ~. w7 ~- n
  51.        /* 省略 */: o$ B& e  _$ b' a0 ^7 F' L
  52.     }
    # K" w1 K3 R: v' K- i8 x% c
  53.     break;
    + q# U, S4 ]5 O* V7 t  U  Z

  54. : ~6 J( ^1 Z. U2 E8 Y% c! x
  55.     case TIM_CHANNEL_6:' u% {6 [$ N1 ~6 u) W0 h
  56.     {
    9 O+ u9 w' z4 M) C2 G3 f0 X
  57.         /* 省略 */
    * ?0 F  a2 h$ q' O+ L2 `
  58.     }' X! O& ]  D+ V
  59.     break;7 c/ q, n, J4 h' K

  60. 4 N* f; X5 ~! D; e' }
  61.     default:
    $ I3 ]2 z- B+ ~4 D
  62.     break;3 r: t8 y0 m* W+ t8 e
  63.   }: Y" J4 C3 X4 I$ t' g
  64. $ q. [! K. X) {4 I% Z3 o
  65.   htim->State = HAL_TIM_STATE_READY;# C4 P" O% ]) O. C

  66. ' x. O( q1 f; y. Y9 I( h
  67.   /* 关锁 */
    8 v, ~( z9 U, o
  68.   __HAL_UNLOCK(htim);  V5 O: B' I6 Z5 z* I2 L

  69. 2 p3 R0 T: h  {, o6 b! \+ B- v0 v3 q
  70.   return HAL_OK;
    8 `. b0 I$ l; r0 S
  71. }
复制代码

* z, U5 V& O  H0 d) X; O函数描述:/ V% s' ~/ D$ j
  ^# K1 n6 v* I! D6 B
此函数用于配置定时器的PWM通道。
2 Z7 w0 @/ c$ b( v1 X9 T! K- n$ Q
& g; L9 A+ G* H" X# y" [  L- H函数参数:" B# ?* l2 G' c, n- m% _
  M- }: w! j( w3 w4 F8 O# N4 B0 _
  第1个参数是TIM_HandleTypeDef类型结构体指针变量,用于定时器基本参数配置。
8 F7 Z6 k1 n! q0 v. s  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量,用于定时器输出比较参数配置。$ }& l& N4 q7 F" H1 p' H
  第3个参数是通道设置,支持以下参数:
0 X$ E# k+ {4 I" FTIM_CHANNEL_1
& L2 @7 q1 l2 b$ N( w3 U* l
0 |. O: A4 m. k5 q1 {TIM_CHANNEL_2, \& m) d0 i$ _( h7 d
# L1 L! q1 V* p( K5 I) Z5 e
TIM_CHANNEL_3
9 D- }, N: a+ C" Y8 T6 [: i' q6 {& p6 K& M) K2 U, [( S
TIM_CHANNEL_4+ p9 g, `: I1 S1 ?! T; E: J
) Q, u% d+ B3 v' p( Y" Q
TIM_CHANNEL_54 Q. |$ ~. q  b+ t* X! A1 g) U

2 l6 D# T- V) V3 L( D+ kTIM_CHANNEL_6
- ~) A: a. G; I% ~) |. E9 u* `! T9 h; ]1 O. H. ~* J
  返回值,返回HAL_ERROR表示配置失败,HAL_OK表示配置成功,HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出。% X4 R) }# O# v+ L" v; K& X6 G5 Y! h
使用举例:! Q& C4 |, E6 b5 y3 Z

8 C: l: s) N. _. z1 q, e! P
  1. TIM_HandleTypeDef  TimHandle = {0};! C- g3 S5 z* L7 E0 {* m+ F
  2. 0 I3 A: b" \9 O$ B. a
  3. /*  PWM频率 = TIMxCLK / usPrescaler + 1)/usPeriod + 1)*/. V) U* ^2 l: p- m* o) P% |
  4. TimHandle.Instance = TIM1;
    & i5 {* {9 }' d8 V( l/ t$ ]
  5. TimHandle.Init.Prescaler         = usPrescaler;
    4 X# ~0 G+ H/ F% Z) u2 X
  6. TimHandle.Init.Period            = usPeriod;
    / d! A7 R9 X: J+ T+ U- Y, l
  7. TimHandle.Init.ClockDivision     = 0;9 R3 a& p2 l6 y7 o& e* I
  8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;9 Q8 t1 Q2 c' N" H. ?0 |9 q4 G7 \$ d
  9. TimHandle.Init.RepetitionCounter = 0;
    , o0 r: L" H, j
  10. TimHandle.Init.AutoReloadPreload = 0;5 H& o* B, w, |) C: x/ G
  11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    ) b+ a( c! m9 h+ J# g. F
  12. {' z& c! ~8 C4 C! C$ {6 v6 G
  13.     Error_Handler(__FILE__, __LINE__);' B" d( o% U3 S
  14. }
    4 [* t& W# T5 A7 ^. z* f: d
  15. ; X/ \/ _  B: N
  16. /* 配置定时器PWM输出通道 */! X' l/ C/ c; }$ t7 |0 T. E8 j
  17. sConfig.OCMode       = TIM_OCMODE_PWM1;
    : q2 G" a" |" |3 d: E' E3 s
  18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    6 h( R: `0 t' N. d6 E
  19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
    8 m+ o8 u8 b6 T
  20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
    $ E8 e# k7 K: [- j/ Y& s, s
  21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    . I1 m, ^: B5 |: N
  22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
    6 o; n  K) w$ B1 y7 @6 i) f5 J
  23.   G) ^6 l% C* ~, e1 Z: g
  24. /* 占空比 */) R) I6 u" G& A
  25. sConfig.Pulse = pulse;
    1 }& _, K' ?- X3 x- ^/ C4 E+ w
  26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)5 i% M" O% Q- }/ H+ E- a0 o0 s
  27. {$ [) @2 A8 a7 d* t7 E% d; X( c
  28.     Error_Handler(__FILE__, __LINE__);  v; e/ _2 y& M. D# @
  29. }
复制代码
8 S: f6 I" D" S* i
32.4.5 函数HAL_TIM_PWM_Start
" v! e' [! j% S; B3 F4 Z函数原型:
2 C1 [6 X& l" x7 X) L4 R( J. G
  1. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)( {% A5 B& q) E
  2. {, }3 f8 a! O2 c* D+ M' e9 _( ?/ ^
  3.   /* 检测参数 */
    : B9 T5 C# B4 O4 g, W  p' |5 I3 j
  4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));) ^6 t8 G/ ~+ L2 d: W

  5. 5 I8 Y4 T1 S  Q
  6.   /* 使能捕获比较通道 */
    3 e; x* [" }" d: Z8 {
  7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);! N3 @: C/ Q* k6 z

  8. - Y0 R1 X4 ^% f1 P* F" Q7 A
  9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  
    ( ]6 o8 P$ {) K; Z
  10.   {
    , x& o  z9 K5 a/ o6 K* T
  11.     /* 使能主输出 */
    - \6 ?: M, _6 h/ }$ A/ X: |
  12.     __HAL_TIM_MOE_ENABLE(htim);/ q$ Q$ A6 V; T; B9 n
  13.   }; u7 P4 z9 F6 }1 S) w2 G- l; J. ]
  14. 8 |2 |% o, x+ g
  15.   /* 使能定时器 */
    * ]1 W% D. f: p' s: G  [
  16.   __HAL_TIM_ENABLE(htim);
    ' Y  I3 S1 f7 Q. C) `7 e& p
  17. ) [" ^3 a& q  K) s1 ?
  18.   /* 返回状态*/; f0 {8 y0 s; o5 l  t1 O0 y! G- g. b2 G
  19.   return HAL_OK;! w) Y+ K& a$ n& v; I& [
  20. }
复制代码

( T( R& ^2 ^' e' D函数描述:0 x% R1 b3 C" F9 u' u5 Q

4 h0 N" [, D+ J, V3 A此函数用于启动PWM。! N8 [' _- [% }5 Q+ S

' k; n# A' v, r: ?函数参数:) z. k0 y) _9 I) P; p, Q2 P$ i9 W, r
( t5 ]2 y" h  ?( L/ K% U* T
  第1个参数是TIM_HandleTypeDef类型结构体指针变量,用于配置要初始化的参数。6 E" F: J! P# i4 R$ W; ^
  第2个参数是通道设置,支持以下参数:
- m7 a& V7 w( |: ^! GTIM_CHANNEL_1
0 [4 `1 |* s: ]( v% R
5 D  j4 T2 A4 @6 |* a& Q' STIM_CHANNEL_2+ N0 P" W4 N& q9 f- a9 G
& U% z: y7 C! J, p4 k
TIM_CHANNEL_38 ]7 T- R% Z, O) B. c
. U/ h/ w. s9 O, t% h0 }0 k( w
TIM_CHANNEL_4/ A( S+ r+ m# A/ }' |

) X% K9 y+ @, b, @  返回值,返回HAL_ERROR表示配置失败,HAL_OK表示配置成功,HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出。
: p( l5 K& B5 c. A  y使用举例:
$ X" i: `& T1 q8 U
) c# e# _  x  t4 W* T
  1. TIM_HandleTypeDef  TimHandle = {0};$ E* b8 d0 z# \, r* r" n7 X

  2. 1 x$ v5 U, R, V
  3. /*  PWM频率 = TIMxCLK / usPrescaler + 1)/usPeriod + 1)*/; C0 t  b7 u" |, Y9 Y
  4. TimHandle.Instance = TIM1;
    9 M4 N0 C% |+ C8 Y
  5. TimHandle.Init.Prescaler         = usPrescaler;
    . T% Q  f9 C  E" m$ F1 \
  6. TimHandle.Init.Period            = usPeriod;
    7 G% t" T. x) S
  7. TimHandle.Init.ClockDivision     = 0;4 y2 K1 F* ^* D( T+ B7 f1 _- `
  8. TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;% k$ K$ j, k- b: L" d# `
  9. TimHandle.Init.RepetitionCounter = 0;
    1 ]. @& |' m4 a* M* O/ s" m
  10. TimHandle.Init.AutoReloadPreload = 0;
    ! `" w) q( y4 [
  11. if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
    / p; A  J; a, V: c" z7 `& R
  12. {  ?; C+ h/ b: w( o
  13.     Error_Handler(__FILE__, __LINE__);! h( x1 U* Q. m6 l% Q
  14. }
    2 p- l7 S% d( Z3 h- @$ h0 X! ~, O/ M

  15. - Y2 o4 z% z& M; K# b- H8 |0 v
  16. /* 配置定时器PWM输出通道 */( c5 E# T. L5 M+ E$ n
  17. sConfig.OCMode       = TIM_OCMODE_PWM1;. W7 }0 X2 q! m3 \  c$ F2 D3 o
  18. sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
    7 S9 {: j7 \* Z" x6 f/ q
  19. sConfig.OCFastMode   = TIM_OCFAST_DISABLE;9 m- |8 }* y6 y
  20. sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
      `( R+ p% r& J/ [: A6 c8 q2 b
  21. sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;  g$ P6 R. X( J* _  F9 l( V
  22. sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;- v- T8 u5 r" _% s5 |, P. L
  23. . U) O; W, ?$ m7 H2 g4 I
  24. /* 占空比 */
    " D! [7 N: T- g% [9 }# `
  25. sConfig.Pulse = pulse;: M& w7 R& ^5 g. O
  26. if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
    / ^* d0 ~/ n) U& X* i9 z
  27. {
    8 x/ }) c9 n0 ^3 I* h+ F
  28.     Error_Handler(__FILE__, __LINE__);9 ?! P* D$ M! N2 k
  29. }
    1 D- f' x  g- E! ^0 S$ b% N
  30. ( z# j% L0 d& ~% C8 N6 o3 ?- r* r
  31. /* 启动PWM输出 */
      W' j5 U2 i3 m( Y$ r3 b# n0 C
  32. if (HAL_TIM_PWM_Start(&TimHandle, TimChannel[_ucChannel]) != HAL_OK)
    : ^4 g7 ]* B" S* r1 I0 _; M% W
  33. {% K* }( }) T1 B5 R
  34.         Error_Handler(__FILE__, __LINE__);/ S" Y" M! `0 H9 f6 B: ?( I
  35. }
复制代码

- G- g3 T4 b. q, v( s. h4 [32.4.6 函数HAL_TIM_IC_Init
; |6 [. T7 D. `1 m2 A' C函数原型:2 R$ g0 j6 Q! l, z! a$ K/ x

' q. L- |1 f% I$ U% P) q
  1. HAL_StatusTypeDef HAL_TIM_IC_Init(TIM_HandleTypeDef *htim)
    ' h; D( z: ^8 S# O2 e2 ?: i2 \! [
  2. {, A& L! T3 I# {: D6 I' v
  3.   /* 检测形参是否有效 */3 W( P8 ^* ^# d- v
  4.   if(htim == NULL)2 c3 O4 V; K3 m2 k; W
  5.   {% e7 l1 w1 Q. x9 Y3 v
  6.     return HAL_ERROR;! K( I$ q7 N/ R& v. L7 N
  7.   }$ H- b. r2 [7 b  |7 H! y
  8. $ G9 U+ b3 P7 e: F
  9.   /* 检测参数 */
    ' O$ Y& l& y4 Z- e2 A' N/ g
  10.   assert_param(IS_TIM_INSTANCE(htim->Instance));3 w, I0 z: w$ {
  11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    , p) C% n/ c" I; c5 L# X  K
  12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    / J) L$ |" ^# R9 f8 F
  13. % O3 _) |# k/ k3 C
  14.   if(htim->State == HAL_TIM_STATE_RESET)
    3 _1 t" Q) U- B: F
  15.   {
    & }2 ~* H) D" Z/ j4 V
  16. /* 默认取消锁 */
    . B  @: k( H& N4 ?+ P9 A* ]$ L
  17.     htim->Lock = HAL_UNLOCKED;
    # T' {) p5 y( h* y

  18. 0 U8 H* u- l% Q+ ~+ f6 k
  19.      /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */' M* C  b+ |% v
  20.     HAL_TIM_IC_MspInit(htim);
    3 c* K# {. x; [7 e; z( O5 y% ]( E
  21.   }
    / H1 o/ f* s! z9 |5 ~1 N

  22.   g4 K, L/ [: ~' _+ }, C
  23.   /* 设置定时器状态 */& o9 d9 E0 n3 ?, U
  24.   htim->State= HAL_TIM_STATE_BUSY; ' P- X8 w1 |; M: Y: J9 a$ m
  25. . Q: F  m; E$ q& G7 E: u2 j
  26.   /* 配置定时器为输入捕获模式 */  
    : J( k. h7 }+ V- W& _3 z) ?, H# Y
  27.   TIM_Base_SetConfig(htim->Instance, &htim->Init); 2 F" o- n9 [4 `' |9 D

  28. ) U. Z0 Y( n2 E" v1 r
  29.   /* 设置定时器状态 */( W! P- h! ]# [0 L# w
  30.   htim->State= HAL_TIM_STATE_READY;5 P4 c3 j) p& {, }; G" ~

  31. + E+ P0 ^# Z" X0 N/ C
  32.   return HAL_OK;4 D7 N9 }# l. S( p9 B; l: N3 O. y! O
  33. }
复制代码

$ ]2 m9 q8 d# }, W函数描述:
$ m# U/ B1 Z1 t; O3 I4 X
6 o0 |) o  l8 x, X* {此函数用于定时器输入捕获初始化。
* v; W) m/ ~5 ^  h$ K
  |. {; x5 g7 y) g2 ]2 P函数参数:
$ C2 j. I. _1 {( G# Z+ [: q* R" r7 d. r( Z  p7 |6 w* U2 p
  第1个参数是TIM_HandleTypeDef类型结构体指针变量,用于配置要初始化的参数。
9 y* r  {. x; O2 w2 ^5 R  返回值,返回HAL_ERROR表示配置失败,HAL_OK表示配置成功,HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出。
; v9 r' A. Z2 h3 S( i! V: h6 ]% L注意事项:. A( p9 V3 {( a" _  q

0 n7 H% _/ {4 |3 w) a5 `  }函数HAL_TIM_IC_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能,由于这个函数是弱定义的,允许用户在工程其它源文件里面重新实现此函数。当然,不限制一定要在此函数里面实现,也可以像早期的标准库那样,用户自己初始化即可,更灵活些。
5 `$ ], `+ S% F1 k& ~. n) R0 f如果形参htim的结构体成员gState没有做初始状态,这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。5 D$ g0 w; o0 m# T( K7 \. ]5 P
对于局部变量来说,这个参数就是一个随机值,如果是全局变量还好,一般MDK和IAR都会将全部变量初始化为0,而恰好这个HAL_TIM_STATE_RESET  = 0x00U。
4 B% E" B# }0 Q5 U
1 L9 A% c- F% k5 V' O9 ~9 f8 N解决办法有三:3 C& p( c$ Z- L' B$ w

! {( V3 _3 c" ?3 l" W3 w方法1:用户自己初始定时器和涉及到的GPIO等。
1 B0 q; Z8 V& `& P% s3 j, N* s4 k3 b2 W+ c
方法2:定义TIM_HandleTypeDef TimHandle为全局变量。2 h5 o, L* I  |2 w) Z6 x  R/ h3 Q

7 ?8 q& |$ X1 e方法3;下面的方法
0 F  ^; Z1 W1 s  o' f0 G2 g# c4 ^
& X2 d8 t- z8 k: ~
  1. if(HAL_TIM_IC_DeInit(&UartHandle) != HAL_OK)
    2 @) C! O# S: e8 s- T
  2. {4 O; H0 Q; b& I' L
  3.     Error_Handler();  o7 ~( ?! _4 D  I; ^, o+ y6 W3 W
  4. }  ; e/ r! ?4 O- U) j1 k
  5. if(HAL_TIM_IC_Init(&UartHandle) != HAL_OK)" ~) \( i" _' N' ~
  6. {/ o" s* v( O* c9 A
  7.     Error_Handler();
    ( \" M, x$ [: X& r; i
  8. }
复制代码
# I# U' e9 K. G# B" j, c3 u
32.4.7 函数HAL_TIM_IC_ConfigChannel
' B* L1 `9 P( X1 V  B函数原型:: z( K7 t: E9 x) t

& a) @* P: ^8 j1 n0 X* u' [
  1. HAL_StatusTypeDef HAL_TIM_IC_ConfigChannel(TIM_HandleTypeDef *htim, TIM_IC_InitTypeDef* sConfig, uint32_t Channel)
    9 y- Z! _' O: e; ~
  2. {
    % w1 J- _# Z; M. W8 x
  3.   /* 检查参数 */
    4 {9 z) B  z: J7 v$ }
  4.   assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
    , P( r) r7 I4 B# J7 M% e0 A+ e
  5.   assert_param(IS_TIM_IC_POLARITY(sConfig->ICPolarity));6 S# N& C3 b& [  S$ H
  6.   assert_param(IS_TIM_IC_SELECTION(sConfig->ICSelection));
    ; _% _$ N: \- n" z
  7.   assert_param(IS_TIM_IC_PRESCALER(sConfig->ICPrescaler));  P2 u7 r7 N8 }8 p- l
  8.   assert_param(IS_TIM_IC_FILTER(sConfig->ICFilter));
    0 Y1 y4 z+ P: q/ x4 H9 L" y; Y

  9. & N' h2 g8 p: @9 Z* D
  10.   /* 开锁 */  ) q) }/ X' W* S, @; }
  11.   __HAL_LOCK(htim);) I# O: b) k, D) W; c5 g. r

  12.   r) z' [+ I  M1 `1 w
  13.   htim->State = HAL_TIM_STATE_BUSY;
    $ W* @1 s) M2 K4 D
  14. ; J7 J; [  O: l  R' S
  15.   if (Channel == TIM_CHANNEL_1)& {* o. u& {8 W! J
  16.   {) ]% Q  m( m* e
  17.     /* 配置输入通道1 */! g0 u" o; x6 N& Q" \( {- z  @  S
  18.     TIM_TI1_SetConfig(htim->Instance,
    . a. S% a$ y! ?* K* `
  19.                sConfig->ICPolarity,+ U6 [1 _3 C$ a2 j' Y6 s$ g% h, C
  20.                sConfig->ICSelection,7 H+ y; w5 {" _8 C) T. ], m
  21.                sConfig->ICFilter);7 S% y5 h, R3 y8 T! ~5 a" U+ g/ `
  22. - g! k  L. T( w" \9 N( a# d8 o; c
  23.     /* 清零IC1PSC位 *// x9 y* ?$ J- \' B: y
  24.     htim->Instance->CCMR1 &= ~TIM_CCMR1_IC1PSC;" w3 S' [: U( \( O* E

  25. . y  {' u" l5 u0 \: ~. o, Z- X
  26.     /* 根据用户配置,设置分频 */
    * [9 q4 o; g9 K. n
  27.     htim->Instance->CCMR1 |= sConfig->ICPrescaler;
    ( y2 b7 \! j  y& ~! z, v% R
  28.   }5 P5 ~4 n" R. p7 |2 j8 y- ?
  29.   else if (Channel == TIM_CHANNEL_2)
    6 o! e7 P+ U. V/ e9 n
  30.   {) S' O6 z# C1 R; Y0 h: t2 {
  31. /* 省略 */; i6 C9 g& c; N2 |5 ?$ u
  32.   }
    $ B* `; W7 i: W3 P4 o- f3 b- t
  33.   else if (Channel == TIM_CHANNEL_3)
    & E) G5 |) X7 ~: W) r9 d% \0 [
  34.   {
    # {" n; G8 ~2 e! R  h
  35.      /* 省略 */
    ' X9 Y- Z, H5 r8 Q8 M4 F  F
  36.   }
    - T  V8 c, r/ \$ t
  37.   else
    - \+ [6 r" s1 F# \$ G$ {6 W
  38.   {1 k3 ~; ~) r5 r
  39.      /* 省略 */
    ! J7 a' M: N4 }% j) c# i8 [+ i0 ?
  40.   }0 L6 p/ {. Z0 F$ r
  41. ) h) `8 n4 G5 \& m: Z$ Y0 O
  42.   htim->State = HAL_TIM_STATE_READY;8 ], ]' F  [7 o0 s' `0 g+ j/ F6 X
  43. ) z5 A) z7 f/ J1 ]& L; z0 i
  44.   __HAL_UNLOCK(htim);  {9 r* ]" r+ `$ Y
  45. ! R7 A6 f8 ^1 n) h
  46.   return HAL_OK; ' B* y; w1 i, N: C
  47. }
复制代码
- _$ X: @) g; a. k% h+ g
函数描述:
7 H& F( h/ a0 y, R3 b* `- z. T7 G$ n6 O8 J: x6 H3 ]
此函数用于配置定时器的输入捕获通道。7 C+ N6 j/ @' V) Z
& r; N! d# i+ Z: H
函数参数:/ ~( y4 X) ]! ~. b
. q+ I* F8 M7 M& h. ^0 B/ a
  第1个参数是TIM_HandleTypeDef类型结构体指针变量,用于定时器基本参数配置+ o. {: e: v% @, @3 G
  第2个参数是TIM_IC_InitTypeDef类型结构体指定变量,用于定时器输出比较参数配置。7 G& }4 C7 |$ A$ r* |7 A, o
  第3个参数是通道设置,支持以下参数:
9 p( o" a* y# [6 v% V$ aTIM_CHANNEL_13 M3 G0 n2 u$ E. }7 v7 I$ Z+ W

9 E& g$ P% V- ~" s' |TIM_CHANNEL_2( Y2 t3 _/ V0 Q1 W2 p* W

8 z) v* U  m6 e( o/ y! B1 y5 \TIM_CHANNEL_37 \( G( x2 j$ I

- H3 g5 R- w* p% ~1 i. oTIM_CHANNEL_4
4 S! ^8 k3 f5 a; z* m- i
! C6 u4 f/ i0 b  返回值,返回HAL_ERROR表示配置失败,HAL_OK表示配置成功,HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出。
! ]( d/ ?+ m% L4 q" d6 ^
" Y- l+ N+ E% o; d6 w32.4.8 函数HAL_TIM_IC_Start_IT
4 j0 A0 f8 n5 f$ W+ S6 ]函数原型:
9 C  `+ Y$ o, Y8 l9 C5 x" N1 }3 P' `; v8 L+ {! e
  1. HAL_StatusTypeDef HAL_TIM_IC_Start_IT (TIM_HandleTypeDef *htim, uint32_t Channel)
    3 V6 a8 t0 X4 I2 v+ b- k! J
  2. {
    7 Q$ Q4 D) b- @8 a4 l) S2 R5 h, u  `
  3.   /* 检查参数 */: l8 J1 u# k( w5 T' e$ q4 u
  4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));, c3 c8 ~6 Z  N" P
  5. : `# o8 a* a% V$ e% N2 E7 F  |
  6.   switch (Channel)* V0 @9 A$ J9 x
  7.   {, W, E$ B# g7 D3 R6 v
  8.     case TIM_CHANNEL_1:7 B9 s" A9 X2 ^( w6 }1 a
  9.     {       / X0 J. n7 P0 f7 P; t* Z
  10.       /* 使能CC1(Capture/Compare 1)中断 */
    " i; _; [0 G+ I  ?8 o$ |
  11.       __HAL_TIM_ENABLE_IT(htim, TIM_IT_CC1);6 W/ U& L- q' @" J6 d2 r
  12.     }
    ! X6 `8 a$ u* R6 V$ T& h
  13.     break;' \+ Y1 Q' G# r, K5 V! c9 w
  14. ' Q- m3 ?" J# p$ p
  15.     case TIM_CHANNEL_2:
    2 ~# m0 a  Z0 i/ o* b
  16.     {7 \  [7 G3 m5 m. P% U8 h( ]2 l
  17.    /* 省略 */5 h& Z  G3 g3 j
  18.     }
    4 G$ F' {, \3 [5 F: q6 m
  19.     break;3 k  X5 L/ @  P: P0 ~, f; V

  20. 3 ]8 }1 L; V8 j4 b& g
  21.     case TIM_CHANNEL_3:/ b2 ]  ~( N0 L: c' n  p
  22.     {" W( m3 a  c( T/ f  H" d4 U/ `
  23.   /* 省略 */& V4 l! ?; P, Y" g3 \
  24.     }
    ) Q% D$ M& ]0 Z. C5 c
  25.     break;+ N2 W$ O7 M. B  R- Z" i
  26. 7 k6 k! t8 x3 o! \
  27.     case TIM_CHANNEL_4:
    ; E! J  C* t9 Y5 }3 N, G
  28.     {, O0 G' i, q7 d/ K7 k4 ]
  29.   /* 省略 */
    9 u) N( e: t! a* a( }
  30.     }8 Y) `# E' |' J3 B! ]1 S
  31.     break;: o2 q) G4 d* Y5 k
  32.   d& L. X$ H; j3 u: W; f0 H: G
  33.     default:
    7 I( n$ f2 `. b- ?# t
  34.     break;4 C: s/ S& B8 g) q7 h* U
  35.   }  
    ! `9 T. J& k; a2 C
  36.   /* 使能输入捕获通道 */& E6 b7 S; a- J, H; ?$ T. d
  37.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);3 J$ N' Y. T  u+ q6 ?" P9 G

  38. " X) l( x; J  k
  39.   /* 使能定时器 */# K. @( l, }" r( S& d
  40.   __HAL_TIM_ENABLE(htim);  
    ' s8 H% d! r( Q/ \1 ]3 T" T, b; e
  41.   K, _. Y0 z8 C* \/ }. Q
  42.   /* 返回状态 */+ n7 f+ t! K6 c% }* N! F* _$ l8 S
  43.   return HAL_OK;  1 A$ c# Y+ _* ]0 M- l/ K& V
  44. }
复制代码
% x' P" ^7 |. ~, P+ d
函数描述:. D5 y1 A! E) G# {( d2 b  R

4 ^% O3 I2 ]! ^, [此函数用于启动定时器输入捕获模式,采用定时器方式。
6 T, C: K- g. C$ y3 M- k$ H
" Y: V& u4 ^( w函数参数:0 a9 [  m0 f& d# |: S1 K, A
, ~4 t) q8 W: D
  第1个参数是TIM_HandleTypeDef类型结构体指针变量,用于配置要初始化的参数。
; L" ]6 h2 t& N- t  第2个参数是通道设置,支持以下参数:  ?( s8 ?3 t% J% W' g
TIM_CHANNEL_1+ p5 a) d+ C- K$ T
! h1 K8 X2 a3 |% f6 |1 ]
TIM_CHANNEL_2& @* h( ?) I3 K: r3 R) q0 d% U
$ \' c' I8 i, i# _, i9 }& }6 p: s
TIM_CHANNEL_38 v8 T7 P9 W1 c! j% x; e% t7 h8 Q( d5 @

5 M: a0 O# n. Q1 \- [TIM_CHANNEL_4
! Z( e# p% |' F
0 d( [) g+ D/ ~$ ]. e  返回值,返回HAL_ERROR表示配置失败,HAL_OK表示配置成功,HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出。
! u' i; Q( Y# M3 Y
. Z) U0 G& C( c6 L2 F* F32.4.9 函数HAL_TIM_OC_Init4 p- W6 n% x) @" d2 @2 p
函数原型:
& |  f9 q) `  e7 c0 \6 U9 J
7 S  v! ?3 @4 F
  1. HAL_StatusTypeDef HAL_TIM_OC_Init(TIM_HandleTypeDef* htim)0 ~9 k" d: s+ s! L* R* u1 s/ D
  2. {6 m# P/ J' o* `) a
  3.   /* 检测形参是否有效 Check */6 V4 U+ z% S  _! N1 D8 S( ]$ T
  4.   if(htim == NULL)
    2 M4 y; t6 T( h
  5.   {- D7 V2 w' ]# I* ^' m$ T; u
  6.     return HAL_ERROR;
    6 E$ G& a8 `& s3 s! M7 G( T$ m
  7.   }. t2 p- R5 t; Q9 E" S. |

  8.   i7 ^9 }4 j5 x' r3 l8 k8 R
  9.   /* 检查参数 */( _6 Q, j% l( R* j1 T$ n
  10.   assert_param(IS_TIM_INSTANCE(htim->Instance));6 J( q" |$ H5 [. K, [2 n
  11.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    * L4 o. \7 Q$ p, V& ~2 o0 D
  12.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    & P1 w. l. [! P

  13. ! g5 ]3 m5 @$ L5 v3 K& a1 Y
  14.   if(htim->State == HAL_TIM_STATE_RESET)
    : w1 @6 g! D% [; Q
  15.   {
      i. Q3 w- r' i' n( Y5 R
  16. /* 默认取消锁 */
    5 `. S9 Z$ O4 N0 f. B
  17.     htim->Lock = HAL_UNLOCKED;
    ( }( w+ v$ l: G# o1 ?- o7 ?
  18. , R2 T) m" z) W8 X, g) c' u: H
  19. /* 初始底层 : GPIO, CLOCK, NVIC 和 DMA */( K) G0 g+ }: m3 l- o% u5 x# \
  20.     HAL_TIM_OC_MspInit(htim);/ v8 N, h. P, j
  21.   }% s) {- i$ b( Y8 V4 L* T& V
  22. ) g8 h5 T. K4 Y5 n9 [+ p
  23.   /* 设置定时器状态Set the TIM state */  z2 p! G) f% i
  24.   htim->State= HAL_TIM_STATE_BUSY;5 P% o2 j( Z) E- m6 Z
  25. 8 M: r3 W# d: l1 l
  26.   /* 配置定时器为输出比较模式Init the base time for the Output Compare */  
    - \! U# b: S1 C
  27.   TIM_Base_SetConfig(htim->Instance,  &htim->Init);
    . [  ^1 T. Q& ~4 y  m4 S! S

  28. 5 T! z$ E6 W. U/ V1 g
  29.   /* 设置定时器状态 */7 \' d- w# {! n" \; w7 ^
  30.   htim->State= HAL_TIM_STATE_READY;) r( O8 z0 G1 A5 U" e, c- s

  31. 3 o) z4 ^+ @+ j- w, a4 w0 e
  32.   return HAL_OK;
    9 f: Q9 a; N2 ^; M" u" o
  33. }
复制代码

0 C. Y- U2 F0 e% ~9 V函数描述:
4 v0 r8 D. ~% [. G& `. F( y7 T; d4 o7 U, C  B+ W0 ^* h1 e; e7 e
此函数用于定时器输出比较初始化。, h" Z( [) ]6 p8 j/ ?3 B! E& y' g' |* r
9 Z; r' |8 C9 I) R' d+ L
函数参数:3 v" d8 j3 {, {$ z& i0 E# A
+ o$ S/ K0 \0 X5 g3 {6 R3 G- `3 }# X
  第1个参数是TIM_HandleTypeDef类型结构体指针变量,用于配置要初始化的参数。
) u9 _* x2 ?" h: \  返回值,返回HAL_ERROR表示配置失败,HAL_OK表示配置成功,HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出。- C: @2 f/ J& }) M% b9 b7 K
注意事项:
5 D( ~# x6 `8 ]/ a" X
( o' P4 i2 [8 p1 P$ m  x0 h/ f6 x函数HAL_TIM_OC_MspInit用于初始化定时器的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能,由于这个函数是弱定义的,允许用户在工程其它源文件里面重新实现此函数。当然,不限制一定要在此函数里面实现,也可以像早期的标准库那样,用户自己初始化即可,更灵活些。
# R, w/ x( M1 v! ]% B1 Z如果形参htim的结构体成员gState没有做初始状态,这个地方就是个坑。特别是用户搞了一个局部变量TIM_HandleTypeDef TimHandle。
! O+ k. B3 ~5 G# h1 V' ]! G# {) B% A对于局部变量来说,这个参数就是一个随机值,如果是全局变量还好,一般MDK和IAR都会将全部变量初始化为0,而恰好这个HAL_TIM_STATE_RESET  = 0x00U。& e% \  n+ I( L

) y4 M0 @( j8 i解决办法有三:
2 i% J& ~# c! h3 h0 ?/ k
- h1 d* Q2 _9 Q6 |: F方法1:用户自己初始定时器和涉及到的GPIO等。4 S4 l5 e5 r# ~# C2 Q' x
+ M  [0 M" N. r0 j! \6 D5 k
方法2:定义TIM_HandleTypeDef TimHandle为全局变量。
* l6 V4 C& Y3 q; `# Q) x; [$ E
1 P5 N9 g: r9 E& Z方法3;下面的方法4 e' O. w( W* j2 y, r4 _5 `5 Z
+ p9 X$ q- L! }8 H
  1. if(HAL_TIM_OC_DeInit(&UartHandle) != HAL_OK)
    6 I' n" _" A- V! |( v& ^! f
  2. {# S/ W8 ~5 w  }. s2 F/ `
  3.     Error_Handler();
    ) O3 x- l5 h7 T3 ^! L4 w/ s
  4. }  4 e! O3 @& E% ~
  5. if(HAL_TIM_OC_Init(&UartHandle) != HAL_OK)& b2 Y; ^" O& b/ x0 {& L! P/ ]  b
  6. {5 \# q7 }) F6 O/ F
  7.     Error_Handler();
    : W9 u4 t4 X* _5 e
  8. }
复制代码
6 L' M* D, o+ x/ i! x
32.4.10   函数HAL_TIM_OC_ConfigChannel
. `3 B0 g! _/ m函数原型:5 Q3 k1 ]# r3 I2 I$ m5 |

! I* I# a8 N$ r8 {3 G0 U) b3 l
  1. HAL_StatusTypeDef HAL_TIM_OC_ConfigChannel(TIM_HandleTypeDef *htim," k4 w- m) g5 Q+ O# `* i
  2.                                            TIM_OC_InitTypeDef* sConfig,: l* T" y; i) H& h7 y8 R6 e
  3.                                            uint32_t Channel)
    - A1 c% t# R" F! Y- v6 b) ~
  4. {  3 E/ z) S0 _% y' h) f  n0 s
  5.   /* Check the parameters */
    ! q7 V3 M" i/ @0 Q& m
  6.   assert_param(IS_TIM_CHANNELS(Channel)); 3 h3 H! T, X- f# e
  7.   assert_param(IS_TIM_OC_MODE(sConfig->OCMode));
      b, g! T( ~: ?9 L5 w/ Q) d
  8.   assert_param(IS_TIM_OC_POLARITY(sConfig->OCPolarity));
    ; @( u" i5 y& B, S9 C1 G' G6 R7 O! H3 L- H
  9. % z% {5 D  j5 K# u6 A
  10.   /* Process Locked */
    : X9 @% d" b. P9 }1 B
  11.   __HAL_LOCK(htim); 4 p  d! ?- x$ s1 d; s, h7 D

  12. * y3 @0 K) H2 t% v5 X/ x. k* ^
  13.   htim->State = HAL_TIM_STATE_BUSY;
    8 F' M" `" Q  x
  14. # e& t4 w+ A0 D1 ?) `0 K2 _; a2 I
  15.   switch (Channel)
    5 m' E- q' z; b$ ]- l% {
  16.   {9 \+ b1 G) w& e5 S" G8 E
  17.     case TIM_CHANNEL_1:
    ! p% k- G2 c$ i# @! O
  18.     {  |( M) q  m4 s# Q
  19.       /* 检测参数Check the parameters */$ N5 q" H* ]: r& L4 {9 `( m. O
  20.       assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));
      z( k8 {/ d& J: S$ s- m5 L) o

  21. # ^, l8 P2 M9 z( }! R
  22.      /* 配置定时器输出比较通道1 */
    + v- k% v9 B9 e5 i) L( D. b
  23.       TIM_OC1_SetConfig(htim->Instance, sConfig);
    8 z1 |( l' N! C& U
  24.     }+ u! T: B/ Z* q: s& y  K
  25.     break;( Q7 |0 E5 |- V5 X" E
  26.   c6 V% _6 i& N" _4 x1 O
  27.     case TIM_CHANNEL_2:
    6 h3 g4 c. _8 g
  28.     {
      _  e4 r* {% Y/ H5 e4 v  E9 w$ X
  29.       /* 省略 */
    - ^; w4 @) @5 ]$ I! V
  30.     }
    ! I9 T" e! R7 Z4 B  P! N
  31.     break;1 x7 H% v  w8 q7 C7 x/ w7 E# |, F

  32. ' I% `% y  m' Q
  33.     case TIM_CHANNEL_3:0 c! Z- p, }7 Y3 i2 L% L+ Z, \
  34.     {
    : O7 |- C/ Y' ~: ~# }
  35.       /* 省略 */, d/ T1 l1 ~* U% q1 `0 u% [
  36.     }7 ~- [) y& y  w% s* X
  37.     break;
    ; |! \* L" a6 M, n9 G. g' [
  38. 8 r5 ?% r& w. s: I
  39.     case TIM_CHANNEL_4:0 m) U7 F% U- w9 {) s) R
  40.     {
    ( T; i2 j) |1 B# M( ?3 _
  41.       /* 省略 */. ^' M: n  t2 ?6 o' O1 @' {
  42.     }9 _% e+ U) ]7 ~7 w1 [3 J
  43.     break;
    6 Z# z7 r6 v4 c# n; j) t

  44. 2 N5 z  h7 U! F3 z' i& F# h8 }
  45.     case TIM_CHANNEL_5:
    : {. w" `8 A, y
  46.     {
    7 d9 z" V# ]" l/ \% o
  47.       /* 省略 */
    # \- s  [  A6 x& F" x3 L
  48.     }
    ! B9 m; q0 i8 D% o+ R
  49.     break;% K* D, V; c( w. _3 S# ?
  50. 6 s: z+ o: T" ~
  51.     case TIM_CHANNEL_6:
    & q7 V& z# A1 z, i# k8 [
  52.     {3 H  H3 Y6 l( W6 m& O7 U; B
  53.       /* 省略 */
      l" h# N$ Y2 g
  54.     }+ g9 u; k+ _" Q" U/ D
  55.     break;
    : M! _% |+ c. P' U9 l# Y/ p. D- e0 X
  56. 6 P( p+ c" I7 F. ~  d; q
  57.     default:
    & p, A* a# P8 l/ n
  58.     break;    8 T7 c+ T* e5 V' l) G8 w
  59.   }
    7 n$ a; q& A: U" `* V+ D+ `

  60. ! Y6 u3 E5 P& q. s. e
  61.   htim->State = HAL_TIM_STATE_READY;% X" l) h1 g5 y( }
  62. : ]$ S6 {2 Y8 y8 \# `5 ?# x
  63.   __HAL_UNLOCK(htim);
      G, D+ g  N9 I9 c+ `
  64. * M5 D: p, [! r/ I
  65.   return HAL_OK;# _' j- H6 G- N. u- k: [8 y
  66. }
复制代码

% W9 B' G. S: v0 C/ r9 {! [1 [函数描述:
$ w/ L& _9 N! R( V7 u* I" ?# \% T, [" _
此函数用于初始化串口的基础特性和高级特性。
& W7 h0 i3 r* ^9 d6 n6 _( A
$ t4 P& g$ Y8 Q6 H; [( p函数参数:
2 j6 D  B7 t5 j# W) `; Q$ ^5 D# v# C7 h5 j+ u; S  Y, Q5 \* X5 H
  第1个参数是TIM_HandleTypeDef类型结构体指针变量,用于定时器基本参数配置。
+ X; P! ^4 ]  j1 G7 x5 ^  第2个参数是TIM_OC_InitTypeDef类型结构体指定变量,用于定时器输出比较参数配置。
3 k$ K  C  G  d. g( ^  U  第3个参数是通道设置,支持以下参数:
2 X6 g) P) N: G" dTIM_CHANNEL_1
1 u6 j2 L% K; q% T7 c
1 n* o! [6 V8 j* MTIM_CHANNEL_2* D; l8 t7 F; X( N
0 N) E. l! B6 y/ }. @, ^4 J$ R
TIM_CHANNEL_3* _; M) P0 |9 a) S
1 y. _* |9 }( H% W& m7 O
TIM_CHANNEL_4
  \) l# `1 t2 V( y& Z1 C' b/ x( l
* s  o& X% H1 |  V. JTIM_CHANNEL_5' U7 T4 f3 s5 f! d! @0 p. P

( X" ^! q9 D3 P$ S/ l1 r6 XTIM_CHANNEL_6+ P# E; e* C  S0 k

8 e$ Z& }2 F7 h$ N" a  返回值,返回HAL_ERROR表示配置失败,HAL_OK表示配置成功,HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出。4 m! A. @3 A9 y, k; z. `0 @! p

6 A+ i1 M% ]( }  w5 p/ z  O32.4.11   函数HAL_TIM_OC_Start! {4 |/ y. T* b  \' @* I
函数原型:: ]: E: c3 w9 P* ?" w- I, e4 n
9 \3 w4 O  m9 |
  1. HAL_StatusTypeDef HAL_TIM_OC_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
    . g+ p( B/ N. J( W9 o3 t1 K1 s
  2. {) f0 L+ |+ @3 o( H0 h: P! ?% o/ j
  3.   /* 检查参数 */
    3 [9 I# z7 w0 M6 p
  4.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));8 c$ `0 o0 i4 L, v# c7 V

  5. ' {# T$ G( }1 [7 L0 g
  6.   /* 使能输出比较通道 */* z6 r4 L& w+ s3 O
  7.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    6 Y) {5 p" i3 x2 Y" M1 s
  8. - t6 [! j# ^' F$ Q. n! Z
  9.   if(IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)  ) U* s8 T$ g. y; d
  10.   {
    - T8 }8 P6 u0 Z; P
  11.     /* 使能主输出 */1 e' X, ^: g5 C& {
  12.     __HAL_TIM_MOE_ENABLE(htim);1 i7 a! K4 D( e) m7 z* Z
  13.   }
    7 q$ v. z7 ?* d1 U* w# u1 H3 Z( D
  14. 4 p4 v0 i6 R( T5 r. f$ Z* l
  15.   /* 使能定时器 */$ v/ Q( w& P" i/ @2 a7 A
  16.   __HAL_TIM_ENABLE(htim);
    3 L5 u' E0 P, @( L5 V% H4 {
  17. 7 W( y6 w. X- l/ f7 d
  18.   /* 返回状态 */
    8 o/ F( u2 i: w* d& l
  19.   return HAL_OK;& l2 ~" N0 T( T
  20. }
复制代码

) k0 h( M. K  [3 x函数描述:8 n5 G$ E4 y! X2 ~% u% O

/ m6 `8 g% v/ @. f6 h此函数用于启动定时器输出比较模式。% O- K+ e  [6 Y+ G

1 j  _) ]2 ]: i7 J函数参数:
2 J- i* i, D% D% P+ d1 v0 \% h, ~* x( T0 E
  第1个参数是TIM_HandleTypeDef类型结构体指针变量,用于配置要初始化的参数。) Q( T; V2 L$ m" ^$ R
  第2个参数是通道设置,支持以下参数:
9 R; S3 g' \/ a# b7 L* ?5 GTIM_CHANNEL_12 m" c4 r2 Y$ F
3 y. y, e9 |- h' F$ y. k
TIM_CHANNEL_2
: w) {: V& w; h/ e+ L1 R% z/ S
3 H8 H: c% j" }  nTIM_CHANNEL_3# E: W0 L9 u1 z7 |* z  N3 I3 R" u
4 p. |. t) I  Z9 W( f( V
TIM_CHANNEL_4. G7 {) ]* ~6 h- k. J6 F

  \5 _/ @5 B' y+ q& }# ^  返回值,返回HAL_ERROR表示配置失败,HAL_OK表示配置成功,HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出。
/ b3 j+ |& }" K% _1 z  F# l6 s3 N, ^2 W1 l0 e& W
32.5 总结: v; U# b5 _4 f/ w- n6 U, A3 v
本章节就为大家讲解这么多,建议大家将GPIO的驱动源码结合参考手册中的寄存器通读一遍,对于我们后面章节的学习大有裨益。( h" B& F# X# K) [' m* C
! v& y/ }' h5 @6 h: a- y4 }2 k6 Y- S! ]
- S' j0 h/ T" A( \- r. V

2 t; s7 |3 c8 T1 I% v
赞 收藏 评论0 发布时间:2021-12-21 23:00

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版