基本计时功能
最简单的，定时器嘛，基本的定时器就是定时功能，简单来说就是TIMx->CNT会跟随着输入时钟的脉冲而计数。
初始化定时器的参数，大家都好理解，因为TIM2的输入时钟是108Mhz，这里进行10800分频，输入频率为10K，重装载值设置为20K，每2秒溢出一次。
在HAL_TIM_Base_Init的执行过程中，会先调用HAL_TIM_Base_MspInit再进行其他参数的配置,即先开时钟。
7 A1 N8 l- C) w9 D, R

1. TIM_HandleTypeDef TIM2_Handler;
   4 U- u& q& g/ Y7 N" L  T6 C
2. static void MX_TIM2_Init(void)
   4 w+ l0 s2 J: I7 I: I% N1 E
3. {
   
4.     TIM2_Handler.Instance = TIM2;
   % p. i, a' s4 [! b6 p4 @
5.     TIM2_Handler.Init.Prescaler = 10800;
   
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   / j# x7 C1 D8 X: G9 C' W
7.     TIM2_Handler.Init.Period = 20000;
   1 H( R1 b6 a/ m0 _* Z
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   
9. 
   
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    6 o, Z( U; r; ?. w' E$ h3 @
11.         HAL_TIM_Base_Start(&TIM2_Handler);
    5 r. S! m1 ~. m! }( `
12. }
    # I1 I) b% Y. s  D5 @3 \  s" S  H
13. 
    - E8 H% Y4 E. G3 o$ L; d
14. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
      g- v  [5 e+ F1 [0 w, `* w1 A3 q
15. {
    " g$ T  ~+ U) M
16.                 __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM3时钟  
    1 L6 G+ r% H2 S
17. }
    
18. 
    ' ?& K1 w) E5 F

复制代码

' A% W3 i# x: S/ T主函数中每秒打印一次定时器的值：
4 \. C- Q7 }+ [* r. |% k+ M( l5 `$ q

1.    while (1)
   
2.     {
   
3.                 printf("cnt:%d\r\n",TIM2->CNT);
   ! ]0 i% b  B4 u- k( H( w7 N9 {; c
4.         delay_ms(1000);
   ; _* {! X. F; V3 c3 r" E! I
5.     }
   ' K* T; j8 ^7 e4 c

复制代码

显示效果如下：

# H' `3 y0 \. |: ?4 H# L9 \5 _* }$ ?

定时器中断
, W4 {* |) O5 s( J. X" g7 ~通过HAL_TIM_Base_Start可以开启基本计时功能，但要实现定时器中断功能，就需要开启相应的标志位，即使用HAL_TIM_Base_Start_IT进行定时的开启；
+ }( ^2 R6 n6 J) E在配置定时器之前，除了要开启时钟，还需要先设置中断优先级，和使能中断向量；
在定时器中断TIM2_IRQHandler服务函数中调用HAL库提供的定时器中断处理函数HAL_TIM_IRQHandler，解析到的定时器超时中断会自动跳转到HAL_TIM_PeriodElapsedCallback；
- J7 h( W; e8 P$ I9 m, S5 G, q

1. TIM_HandleTypeDef TIM2_Handler;
   , F. G" x# j1 S7 M2 n, \0 b' i0 a
2. static void MX_TIM2_Init(void)
   
3. {
   * ]# |  Z& p  Z0 a. n
4.     TIM2_Handler.Instance = TIM2;
   
5.     TIM2_Handler.Init.Prescaler = 10800;
   * q9 g2 i! n2 \) N- Z7 P" E
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
7.     TIM2_Handler.Init.Period = 20000;
   
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   , K& i2 g  N. W5 C' p) g, }' Z
9. 
   1 q1 Q+ E- P9 T; L0 e  w
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    
11.     //HAL_TIM_Base_Start(&TIM2_Handler);
    ) q3 ]4 p; y* z3 T" K$ \6 V& F
12.         HAL_TIM_Base_Start_IT(&TIM2_Handler);
    
13. }
    
14. 
    * K, r; @7 `) D* W9 q6 V/ u7 M
15. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    0 g% l( L( W9 o9 x
16. {
    
17.     __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM2时钟
    
18.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);  //设置中断优先级，抢占优先级1，子优先级3
    
19.     HAL_NVIC_EnableIRQ(TIM2_IRQn);          //开启ITM2中断
    1 @% L6 U% H) u  ~. u: {5 A
20. }
    
21. 
    
22. void TIM2_IRQHandler(void)
    
23. {
    * E/ e; T/ n) {2 `. a
24.     HAL_TIM_IRQHandler(&TIM2_Handler);
    
25. }
    
26. 
    
27. 
    
28. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
29. {
    1 `# w" W0 \& w& j# t) P
30.     if (htim == (&TIM2_Handler))
    ! x8 E; B  x3 }
31.     {
    
32.         printf("enter irq\r\n");
    
33.     }
    " ^; b! w' u: D" n' I8 q+ M
34. }
    4 |5 n6 |5 H' v( x- D' K5 a
35. 
    - ^1 m8 g( D( G9 O

复制代码

0 }, p: I2 T1 r; _' v* H显示效果如下：
( n  x5 J- b0 Q1 i8 b2 H7 t0 A3 x
: J2 O$ `7 P& `+ r
  z% z% v+ F! z1 M( ~! u! |
; {; V/ \" ?: O! l$ d' JPWM输出
硬件PWM输出是不需要使用定时器中断的，但同样需要基本的定时参数配置，初始化也不再是使用HAL_TIM_Base_Init而是使用HAL_TIM_PWM_Init进行初始化了；
配置完定时器为PWM模式，那么相应的输出通道也需要通过HAL_TIM_PWM_ConfigChannel进行配置；
. f5 D# R) O# k( C4 ]同样的启动也不是HAL_TIM_Base_Start或者HAL_TIM_Base_Start_IT了，而是HAL_TIM_PWM_Start了；
/ o9 _0 P& w" g6 a2 }/ ]

1. TIM_HandleTypeDef TIM2_Handler;
   
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   4 Z$ T( ^$ d6 B% y1 N5 A' Z
3. static void MX_TIM2_Init(void)
   
4. {
   
5.     TIM2_Handler.Instance = TIM2;
   
6.     TIM2_Handler.Init.Prescaler = 10800;
   
7.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
8.     TIM2_Handler.Init.Period = 20000;
   
9.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
     z( B% O3 y2 [6 n
10.     HAL_TIM_PWM_Init(&TIM2_Handler);
    & _7 m5 r! P# Q! T3 Q9 [1 x
11. 
    
12.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    
13.     TIM2_CH2Handler.Pulse = 10000;
    
14.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    
15.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    % a1 p. z4 S& K. t0 y4 |) z
16.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    1 s- a: k6 d1 y+ [- j$ L
17. 
    
18.     HAL_TIM_PWM_Start(&TIM2_Handler, TIM_CHANNEL_2); //开启PWM通道2
    4 S2 H7 I' v1 d* l8 w
19. }
    
20. 
    
21. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    
22. {
    
23.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
24.                
    7 M4 l& U& [4 ?" I$ i$ b1 o4 Y
25.         __HAL_RCC_TIM2_CLK_ENABLE();           
    
26.     __HAL_RCC_GPIOA_CLK_ENABLE();
    
27.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    
28.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    8 E) }8 T6 B& s+ D' Q& }" o! z
29.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
30.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
      Q( |4 Z3 t, o0 c  q
31.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    $ [" [; Z. C% b; ~; ]3 k6 _8 n& n
32.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    " w0 a& Y8 Z) L! o
33. }
    

复制代码

$ t5 p0 u8 Z; j通过万用表可以发现PA1口的电压在0和3.3V中大概每秒变动一次（疫情期间在家学习，没有示波器真是太惨了……为了确定确实有PWM波形，只能出此下策了T_T），串口打印数据如下：

$ m1 C/ V- r4 D, L/ _
8 O. V: b- C0 d/ j" F; U
PWM + 定时器溢出中断
我们都知道，PWM模式是在比较值处翻转，在溢出的时候再次翻转，而溢出的时候，我们也是可以产生中断的；所以同一个定时器，在这种定时时长和周期相同的时候，是可以即做硬件PWM输出，又做溢出中断的。
这里我们观察一下两种初始化函数：
2 z7 q' m/ x. @' w3 }( H+ t0 P

1. /**
   
2.   * @brief  Initializes the TIM Time base Unit according to the specified
   
3.   *         parameters in the TIM_HandleTypeDef and create the associated handle.
   
4.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   
5.   *                the configuration information for TIM module.
   5 u+ V/ J- R" _# v
6.   * @retval HAL status
   ! E! ]1 k( c! d* {7 u# _
7.   */
   8 Y6 f/ D9 l3 j  I* }( m
8. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   
9. {
   . d0 R3 ]1 l5 A9 t
10.   /* Check the TIM handle allocation */
    
11.   if(htim == NULL)
    & M4 O' V  b4 j5 N& \1 B
12.   {
    
13.     return HAL_ERROR;
    
14.   }
    ; {0 Q% D5 U. d
15.   
    $ C+ A( w5 g! N! P
16.   /* Check the parameters */
    
17.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
18.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    7 W- X- b1 @* N6 b0 ~( c
19.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
20.   
    , ~) s! n7 r0 q" K7 D- u" h
21.   if(htim->State == HAL_TIM_STATE_RESET)
    2 q; F& l- H! g2 _
22.   {  
    ) O  b! w: m$ y" t; P, }
23.     /* Init the low level hardware : GPIO, CLOCK, NVIC */
    
24.     HAL_TIM_Base_MspInit(htim);
    ' n3 C6 K1 r" g$ O( g( {
25.   }
    & d' N' d( D9 @# ]+ R5 \  b
26.   
      p; D$ @, m; y4 A+ K' e
27.   /* Set the TIM state */
    
28.   htim->State= HAL_TIM_STATE_BUSY;
    
29.   
    4 H$ f. v9 {# h
30.   /* Set the Time Base configuration */
    6 L' ?# u/ J& j+ x2 Q: f. j
31.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    & H5 t' n5 G9 O- l/ J
32.   
    * v( y: i" @7 H; M% M7 S5 y
33.   /* Initialize the TIM state*/
    
34.   htim->State= HAL_TIM_STATE_READY;
    , {& p: r% K& N" R0 t
35.   
    & H6 R& I* x& n& o) V5 w# o
36.   return HAL_OK;
    
37. }
    
38. 
    
39. 
    
40. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
    
41. {
    * Q/ y6 _8 K! L/ l* i2 b) g9 m9 I4 e
42.   /* Check the TIM handle allocation */
    
43.   if(htim == NULL)
    3 W: v8 T* q' Z: k. p4 u) F
44.   {
    * }" N( p) g" B* X- n: D0 d0 q
45.     return HAL_ERROR;
    
46.   }
    ) `+ W! D  m3 B9 y( c+ v
47. 
    
48.   /* Check the parameters */
    , f* B# Q' h8 @9 `
49.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    9 U) O" i5 l5 m: j- X. h
50.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    
51.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
52. 
    % ~1 P9 u8 F0 v) {7 V
53.   if(htim->State == HAL_TIM_STATE_RESET)
    0 G; H  m+ j: n( z8 Q: l
54.   {
    
55.     /* Allocate lock resource and initialize it */
    ' [' v% U; v: G
56.     htim->Lock = HAL_UNLOCKED;  
    
57.     /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
    # e) L$ k9 r7 k% S% w
58.     HAL_TIM_PWM_MspInit(htim);
    8 d4 u3 L- c! h6 T0 g9 W
59.   }
    
60. 
    . f7 Q) J3 m2 d
61.   /* Set the TIM state */
    , q! D& P# x! @
62.   htim->State= HAL_TIM_STATE_BUSY;  
    : U* K/ P) Q, L" z. E( \
63.   
    $ O8 g: ~. Z$ e! [1 k4 V) c' C$ b: Z3 E
64.   /* Init the base time for the PWM */  
    % I: g( R/ U3 P
65.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    8 P5 Q. K8 m& J2 b/ ]% E
66.    
    ; m! ^/ y6 b+ w. v" D" J
67.   /* Initialize the TIM state*/
    ) P$ D/ J! _: e6 Y
68.   htim->State= HAL_TIM_STATE_READY;
    : c) K, H# v1 v* w
69.   
    + b  g/ x% h5 y- H( U% L# V
70.   return HAL_OK;
    
71. }  
    

复制代码

/ N  r- @) \4 Y8 g( L( l& [. v. Q2 y两者除了底层的HAL_TIM_Base_MspInit和HAL_TIM_PWM_MspInit，其他地方一模一样，所以我们随便调用一个初始化就可以了，但是要注意，我们在HAL_TIM_Base_MspInit里配置了NVIC，在HAL_TIM_PWM_MspInit里配置了GPIO，所以只调用一个的话，必须手动把底层的粘贴到另一个函数里去，如果是想两个都调用一次，这里就需要考虑htim->State这个变量了，因为在调用了一次之后，其值就从HAL_TIM_STATE_RESET变成了HAL_TIM_STATE_READY，后面的一个就得不到执行了。
1 y% R  T, P3 t# A) ~再来看启动代码：
9 g8 S( q4 ~& i1 R  }

1. /**
   ' k' S" @' T% N9 N5 L( w
2.   * @brief  Starts the TIM Base generation.
   
3.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   
4.   *                the configuration information for TIM module.
   ; d9 d8 e4 S9 d1 F
5.   * @retval HAL status
   * H9 I7 d+ K9 b* T& N. p% L' z
6.   */
   + k' U( p$ \# ]' e7 b" J, p8 c
7. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   . q, \$ ?/ [+ u3 J; O
8. {
   ' _( B* z) \" ?
9.   /* Check the parameters */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    : R3 O; R  n0 a' @5 R* [
11.   
    
12.   /* Set the TIM state */
    7 y2 O$ N. t* Z5 C4 j( B
13.   htim->State= HAL_TIM_STATE_BUSY;
    2 g! Z: w! I& A, W4 G6 j
14.   
    7 o$ _  f5 C8 O( Q/ @8 G" }, N# b
15.   /* Enable the Peripheral */
    
16.   __HAL_TIM_ENABLE(htim);
      v0 b6 A. w+ Q2 c- i, n2 l) y/ P) ~
17.   
    
18.   /* Change the TIM state*/
    
19.   htim->State= HAL_TIM_STATE_READY;
    
20.   
    / j2 {& g% y( B1 c; `
21.   /* Return function status */
    
22.   return HAL_OK;
    . n% @6 W- X# k; f
23. }
    
24. 
    
25. 
    + x  L7 I$ r4 ^) W$ n
26. /**
    
27.   * @brief  Starts the TIM Base generation in interrupt mode.
    5 Y7 M* h: t9 @' W# y+ w  l6 G+ D  F
28.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    
29.   *                the configuration information for TIM module.
    7 }$ q* f8 |  Q  F; c$ R
30.   * @retval HAL status
    2 [; y8 @( F' i% q- @2 {' Z) P
31.   */
    4 x4 a" J/ J, F( z! }2 \" z2 U
32. HAL_StatusTypeDef HAL_TIM_Base_Start_IT(TIM_HandleTypeDef *htim)
    $ Q, a/ f% t& }
33. {
    
34.   /* Check the parameters */
    
35.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
36.   
    8 E- w/ {, p. q* z3 d
37.   /* Enable the TIM Update interrupt */
    
38.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
    
39.       
    
40.   /* Enable the Peripheral */
    
41.   __HAL_TIM_ENABLE(htim);
    . @7 I  F( m9 `( }1 y3 x
42.       
    - Y  ^# A5 d. `+ F5 Q% |7 A: ~
43.   /* Return function status */
    5 j# X! s# O  y9 S- S6 p% v
44.   return HAL_OK;
    8 e4 h* R2 l- Q$ v" e/ L! `9 c
45. }
    
46. 
    " s- m* n# M9 e, s% _/ c; v, e
47. 
    4 I7 H  Q- ^' ^5 u! l3 @
48. /**
    
49.   * @brief  Starts the PWM signal generation.
    
50.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    - y. b% m+ f. N+ }
51.   *                the configuration information for TIM module.
    " ]8 t$ n, B* M" a) M2 I
52.   * @param  Channel: TIM Channels to be enabled.
    
53.   *          This parameter can be one of the following values:
    
54.   *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
    + V% h, n3 b& L9 h7 L0 I  L6 E) F7 {
55.   *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
    8 ^1 g8 K0 f0 W$ W
56.   *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
    4 j: u' f4 I! k
57.   *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
    
58.   * @retval HAL status
    
59.   */
    
60. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
      I# o' ^' `7 M' r+ m
61. {
    
62.   /* Check the parameters */
    
63.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
    
64. 
    0 k# H" A$ _, A+ T
65.   /* Enable the Capture compare channel */
    
66.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
67.   
    4 b1 i+ w; e8 g2 Z
68.   if(IS_TIM_ADVANCED_INSTANCE(htim->Instance) != RESET)  
    
69.   {
    ( w+ _% \! z; a; S( x8 l1 D
70.     /* Enable the main output */
    
71.     __HAL_TIM_MOE_ENABLE(htim);
    
72.   }
    
73.    
    
74.   /* Enable the Peripheral */
    
75.   __HAL_TIM_ENABLE(htim);
    - `; U  k7 S; f6 W+ r
76.   
    
77.   /* Return function status */
    5 o6 w. j; u: m
78.   return HAL_OK;
    
79. }
    

复制代码

' y  S4 Q! k6 t: s- Y其中的核心代码分别是：
6 j. M& t5 y( }- c! m6 _

1. __HAL_TIM_ENABLE(htim);
   

复制代码

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   ' X6 Z0 U. M7 u; n& \5 q
2.   __HAL_TIM_ENABLE(htim);
   

复制代码

1.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   + D9 J" j, B4 J& }: U, V
2.   __HAL_TIM_ENABLE(htim);
   ( G6 d2 g" v& ~( p/ W  o# ^4 e

复制代码

那么我们可以不用hal库提供给我们的启动函数，直接写三句话，就实现了定时器中断+PWM功能了。

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   
2.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
3.   __HAL_TIM_ENABLE(htim);
   . f( H; X5 n& ~4 y

复制代码

, h: O& t7 K6 o完整代码如下：

1. TIM_HandleTypeDef TIM2_Handler;
   
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   , t) K+ ?8 p6 p3 K5 s5 I
3. 
   
4. 
   * ^- s# [, D+ r
5. static void MX_TIM2_Init(void)
   
6. {
   9 N5 q) U" _1 z: a; z  X- {* h* H
7.     __HAL_RCC_TIM2_CLK_ENABLE();
   5 r+ t+ I& u  d' \# ]5 S
8.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);
   
9.     HAL_NVIC_EnableIRQ(TIM2_IRQn);
   
10. 
    1 p) z" ]" W. X8 }4 C9 `
11.     TIM2_Handler.Instance = TIM2;
    
12.     TIM2_Handler.Init.Prescaler = 10800;
    , ~0 H  e, e' l2 q
13.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
    9 X" \( p( }0 c9 L
14.     TIM2_Handler.Init.Period = 20000;
    
15.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    + t1 X9 @/ N  q6 l1 y0 a# k' F
16.    
    
17.     HAL_TIM_PWM_Init(&TIM2_Handler);
    5 M  e# Y) T6 Z# V! U* T
18. 
    
19.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    
20.     TIM2_CH2Handler.Pulse = 10000;
    / \/ U3 R& |* T8 Y
21.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    
22.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    
23.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    : C- a  i6 E+ J8 g% N, K* ]) S$ g& x- w
24. 
    ) I$ w7 l; c" W' y
25.     __HAL_TIM_ENABLE_IT(&TIM2_Handler, TIM_IT_UPDATE);
    . Y' [. y' J% C9 o, @
26.     TIM_CCxChannelCmd(TIM2_Handler.Instance, TIM_CHANNEL_2, TIM_CCx_ENABLE);
    8 H; S- S$ g1 H* `6 _% t* y9 [3 g
27.     __HAL_TIM_ENABLE(&TIM2_Handler);
    
28. }
    / G' ~  J7 Z: ]/ E
29. 
    
30. 
    7 F7 Q* P! A( Z/ Q4 x' B
31. void TIM2_IRQHandler(void)
    . O, T  F$ Z# x( @/ i+ S, f9 b! p
32. {
    8 B: S+ b, b& t7 M. x0 U6 u- t  z4 D
33.     HAL_TIM_IRQHandler(&TIM2_Handler);
    * k+ k9 w  A! o  h* Y
34. }
    
35. 
    
36. 
      F, x2 I: \& j. w" ~
37. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    - s% ^* {( P1 R2 s
38. {
    5 Y, T1 M8 @1 F/ c; }
39.     if (htim == (&TIM2_Handler))
    ' }$ V0 t" c' s6 X
40.     {
    9 q; d7 K3 J# F2 e7 w1 b3 @) k
41.         printf("enter irq\r\n");
    
42.     }
    
43. }
    
44. 
      I4 j" B( Y" {* w
45. 
    ' G9 V$ G6 B2 c8 H0 E# J
46. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    ) I3 ]1 n2 x7 }. C8 f; o3 Z' {( D
47. {
    
48.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    ( U/ B  y0 S4 J/ N( y/ M
49. 
    0 ]  v3 H6 I- ]# U
50.     __HAL_RCC_TIM2_CLK_ENABLE();
    
51.     __HAL_RCC_GPIOA_CLK_ENABLE();
    
52.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    9 Z1 z: }6 [# a' v
53.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
54.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
55.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
56.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    " J/ [/ \" q$ O
57.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    ; G( j* m" B! i. N& \
58. }

复制代码

————————————————
: i6 |7 w; w" W" ~' O* P版权声明：小盼你最萌哒