此篇博客记录的是自己通过CubeMX学习F7系列定时器功能的过程，献给有过标准库开发经验的同学。
( A; f3 c: C7 b
8 |6 }0 \2 b7 }" c9 U基本计时功能
- s8 E* O+ c* X1 X. Q$ ]最简单的，定时器嘛，基本的定时器就是定时功能，简单来说就是TIMx->CNT会跟随着输入时钟的脉冲而计数。
初始化定时器的参数，大家都好理解，因为TIM2的输入时钟是108Mhz，这里进行10800分频，输入频率为10K，重装载值设置为20K，每2秒溢出一次。
在HAL_TIM_Base_Init的执行过程中，会先调用HAL_TIM_Base_MspInit再进行其他参数的配置,即先开时钟。
5 p! @- W1 R  }8 h$ s
$ D* K9 c/ C% M* s/ q

1. TIM_HandleTypeDef TIM2_Handler;
   . b/ S  n* L) X- A" [7 F
2. static void MX_TIM2_Init(void)
   1 _6 I% H' a  P: K/ W& \
3. {
   3 A6 o6 u& @4 l7 v  G) O' @
4.     TIM2_Handler.Instance = TIM2;
   
5.     TIM2_Handler.Init.Prescaler = 10800;
   4 y$ S, u9 B+ _' A5 [
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   9 m) H! H* V& ~) ^, E" I/ O9 i; y* x
7.     TIM2_Handler.Init.Period = 20000;
   
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   * x  q) ?$ g% x  T" a
9. 
   
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    7 a7 D" c4 u( D0 d3 t
11.         HAL_TIM_Base_Start(&TIM2_Handler);
    % Z' ~; l0 j' Y- A4 k7 i1 R
12. }
    
13. 
    
14. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    ; X. t! a6 J: `% V0 V( Q
15. {
    
16.                 __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM3时钟  
    6 y  _2 @7 a' a/ S+ M! u
17. }

复制代码

主函数中每秒打印一次定时器的值：

7 l$ J6 V$ a- X: t

1.    while (1)
   % d; ?4 n" J* @: c2 F' z; k5 L
2.     {
   5 L+ ?4 |4 t% ~# |! t
3.                 printf("cnt:%d\r\n",TIM2->CNT);
   
4.         delay_ms(1000);
   
5.     }

复制代码

显示效果如下：
/ q$ R; g$ ]- ^
& y9 S$ x( q  ?9 t) p- t

3 t/ d( y) T$ Z$ r定时器中断
- U( H$ U0 J' `5 }+ p( d3 E通过HAL_TIM_Base_Start可以开启基本计时功能，但要实现定时器中断功能，就需要开启相应的标志位，即使用HAL_TIM_Base_Start_IT进行定时的开启；
在配置定时器之前，除了要开启时钟，还需要先设置中断优先级，和使能中断向量；
在定时器中断TIM2_IRQHandler服务函数中调用HAL库提供的定时器中断处理函数HAL_TIM_IRQHandler，解析到的定时器超时中断会自动跳转到HAL_TIM_PeriodElapsedCallback；

1. TIM_HandleTypeDef TIM2_Handler;
   
2. static void MX_TIM2_Init(void)
   . \, Y! I5 i4 B& c* k
3. {
   2 M, ]5 E, c7 g  `
4.     TIM2_Handler.Instance = TIM2;
   
5.     TIM2_Handler.Init.Prescaler = 10800;
   : L0 ]( G( y' N! }' U
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
7.     TIM2_Handler.Init.Period = 20000;
   
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   $ p  j  q  g: X, i, H) x
9. 
   
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    5 R3 W* }3 T1 K9 v1 s1 v$ _
11.     //HAL_TIM_Base_Start(&TIM2_Handler);
    & ]4 m% G0 A* {
12.         HAL_TIM_Base_Start_IT(&TIM2_Handler);
    
13. }
    $ d  y! H8 w  f8 k, I$ _
14. 
    
15. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    - ?3 K9 [. G  b  O% l. C. n
16. {
    
17.     __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM2时钟
    + t7 A* W8 y2 G0 D+ Z" {
18.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);  //设置中断优先级，抢占优先级1，子优先级3
    7 R8 \& E4 C% T2 h
19.     HAL_NVIC_EnableIRQ(TIM2_IRQn);          //开启ITM2中断
    ; y+ n( O* X; ]. y; d; Y
20. }
    . g8 c! r, u) z
21. 
    
22. void TIM2_IRQHandler(void)
    
23. {
    
24.     HAL_TIM_IRQHandler(&TIM2_Handler);
    - ^& a' z% `# |6 t# v, f0 Y
25. }
    * K- P/ M& W$ R5 ^( d9 p; m' C
26. 
    ) B  D/ Y% {- S7 G
27. 
    ; f4 j. L! x7 O: q3 O/ W; S7 e4 U
28. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
29. {
    # @4 ^( i* j* m
30.     if (htim == (&TIM2_Handler))
    
31.     {
    
32.         printf("enter irq\r\n");
    
33.     }
    . X+ v3 [8 n7 _! J7 c
34. }
    

复制代码

显示效果如下：
& ?# {. x8 j5 ]6 v9 K1 o
7 A. Y/ k4 O9 t' Y, [1 H

PWM输出
4 v, [- I7 D+ o8 C硬件PWM输出是不需要使用定时器中断的，但同样需要基本的定时参数配置，初始化也不再是使用HAL_TIM_Base_Init而是使用HAL_TIM_PWM_Init进行初始化了；
9 [! i$ K; [7 f, C0 w+ n4 X: I配置完定时器为PWM模式，那么相应的输出通道也需要通过HAL_TIM_PWM_ConfigChannel进行配置；
同样的启动也不是HAL_TIM_Base_Start或者HAL_TIM_Base_Start_IT了，而是HAL_TIM_PWM_Start了；

% C9 J2 Q% [; @4 y9 }

1. TIM_HandleTypeDef TIM2_Handler;
   ' V; C# T; H, e0 ~2 v+ X
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   
3. static void MX_TIM2_Init(void)
   
4. {
   
5.     TIM2_Handler.Instance = TIM2;
   7 ~  y" i  d# @4 Q. B/ d7 V# P3 T. x
6.     TIM2_Handler.Init.Prescaler = 10800;
   / E, _! |( P7 ~$ Y; d
7.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
8.     TIM2_Handler.Init.Period = 20000;
   
9.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   % w% e! L0 J; j
10.     HAL_TIM_PWM_Init(&TIM2_Handler);
    . U$ L/ r( P& J# C8 Z
11. 
    
12.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    
13.     TIM2_CH2Handler.Pulse = 10000;
    
14.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    2 w6 F( @+ W( Q
15.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    
16.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    , j& Z+ o$ k( y( S% D: o7 o" p7 I
17. 
    
18.     HAL_TIM_PWM_Start(&TIM2_Handler, TIM_CHANNEL_2); //开启PWM通道2
      |" {! T4 M" W+ O
19. }
    ) ]$ m7 i' C- T5 B* p/ P9 q
20. 
    * s6 q3 x% m6 c9 A
21. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    
22. {
    
23.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
24.                
    
25.         __HAL_RCC_TIM2_CLK_ENABLE();           
    ' B4 Q7 z& p" t5 a6 f9 t' `2 l
26.     __HAL_RCC_GPIOA_CLK_ENABLE();
    
27.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    4 A: R# M5 @2 D# z. O+ b3 F5 b
28.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
29.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
30.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
31.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    " Y2 N! ]  }* }9 `
32.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    ) M& `8 v0 X% z) _) J
33. }

复制代码

6 C0 }3 i, }0 X' Z9 I  c
$ F/ h* M" S% h/ d" |0 j+ ^通过万用表可以发现PA1口的电压在0和3.3V中大概每秒变动一次（疫情期间在家学习，没有示波器真是太惨了……为了确定确实有PWM波形，只能出此下策了T_T），串口打印数据如下：

6 G2 x. ]$ C! O$ M) R7 W0 J

PWM + 定时器溢出中断
, _0 b6 l8 A; j- e" w我们都知道，PWM模式是在比较值处翻转，在溢出的时候再次翻转，而溢出的时候，我们也是可以产生中断的；所以同一个定时器，在这种定时时长和周期相同的时候，是可以即做硬件PWM输出，又做溢出中断的。
这里我们观察一下两种初始化函数：
9 ?  l  A6 ~( M

1. /**
   
2.   * @brief  Initializes the TIM Time base Unit according to the specified
   
3.   *         parameters in the TIM_HandleTypeDef and create the associated handle.
   1 H! e' H: ]( }
4.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   
5.   *                the configuration information for TIM module.
   ( \5 y* ~& A  s$ t. r4 m
6.   * @retval HAL status
   
7.   */
   
8. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   
9. {
   
10.   /* Check the TIM handle allocation */
    ( h3 U/ Z% \+ Z4 h( p' [2 C" }, S
11.   if(htim == NULL)
    
12.   {
    
13.     return HAL_ERROR;
    $ {4 t( a; ~" ^( r% k- r" g
14.   }
    + b- s6 u4 @0 b1 o& c
15. 
    - \+ A0 {- B4 B+ p" a
16.   /* Check the parameters */
    
17.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
18.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    # O  L; Q* J  h  {
19.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
20. 
    9 J3 g' O" w6 q0 v
21.   if(htim->State == HAL_TIM_STATE_RESET)
    6 \9 F5 ?9 I$ l+ y/ ]* T
22.   {  
    
23.     /* Init the low level hardware : GPIO, CLOCK, NVIC */
    # a) j+ k  h' u$ J
24.     HAL_TIM_Base_MspInit(htim);
    " C& o# m4 w' E3 E. `5 `. b
25.   }
    
26. 
    
27.   /* Set the TIM state */
    . K1 c: [. [5 d0 n) w/ V2 t
28.   htim->State= HAL_TIM_STATE_BUSY;
    
29. 
    & {6 s* M- l0 g& Y
30.   /* Set the Time Base configuration */
    , Y5 v* k; t1 d9 h
31.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    * F; Z+ a. n  P' {$ j& p, L6 x
32. 
    
33.   /* Initialize the TIM state*/
    
34.   htim->State= HAL_TIM_STATE_READY;
    7 h" X& {+ B  B+ L% a+ E  E. |
35. 
    : l9 k, ~1 I- R% N
36.   return HAL_OK;
    
37. }
    
38. 
    0 q2 L% S& |" x' F
39. 
    
40. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
    ! @& a% i8 a) N, }
41. {
    1 l3 X4 c0 _& |+ t: @) T& Y' E
42.   /* Check the TIM handle allocation */
    
43.   if(htim == NULL)
    
44.   {
    ) j# P2 c- P. z% ^  X6 G
45.     return HAL_ERROR;
    
46.   }
      R2 \4 q2 u0 c+ m: ~
47. 
    * U* i& l! ]( m" ~5 j) P: I: @
48.   /* Check the parameters */
    & l1 i2 @8 \' t7 D; R
49.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
50.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    1 e) A$ ?3 D5 b3 P0 a+ }/ O# p
51.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
52. 
    $ K/ _+ j  K4 E
53.   if(htim->State == HAL_TIM_STATE_RESET)
    
54.   {
    2 A8 Q3 |( |# t6 B  ^
55.     /* Allocate lock resource and initialize it */
    
56.     htim->Lock = HAL_UNLOCKED;  
    # A# D6 t0 U, {& y6 `
57.     /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
    
58.     HAL_TIM_PWM_MspInit(htim);
    
59.   }
    
60. 
    6 F' X6 d' T* ]  S' c! D
61.   /* Set the TIM state */
    
62.   htim->State= HAL_TIM_STATE_BUSY;  
    
63. 
    
64.   /* Init the base time for the PWM */  
    
65.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
66. 
    
67.   /* Initialize the TIM state*/
    & S( H7 h  O0 R: ~! k4 x
68.   htim->State= HAL_TIM_STATE_READY;
    6 R0 p% }; g1 S& b
69. 
    % o0 x5 g6 p- o, `  R( P
70.   return HAL_OK;
    6 m3 [6 g; L  E3 v" c
71. }  

复制代码

  [( x& J+ Y' A9 `3 h, Z两者除了底层的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，后面的一个就得不到执行了。
( E) V" L7 Y+ S4 w* w, `$ X5 _再来看启动代码：

# l: k- e! X. D* ?& E. H* F

1. /**
   # f# U  l+ v( @& w
2.   * @brief  Starts the TIM Base generation.
   
3.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
     B. e, `9 i) V: c
4.   *                the configuration information for TIM module.
   
5.   * @retval HAL status
   1 T2 ^/ l* S) v& ]/ ]  m, S
6.   */
   
7. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   ; S8 t& P7 L2 G- K) r5 ]' T
8. {
   
9.   /* Check the parameters */
   $ G; c+ `/ q8 a% M& N( r; [4 b: l8 ^
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    ) L$ v9 b/ S/ ^
11. 
    
12.   /* Set the TIM state */
    4 V/ b, Y# w  |# q$ P
13.   htim->State= HAL_TIM_STATE_BUSY;
    
14. 
    
15.   /* Enable the Peripheral */
    1 u. n7 o. O) c0 ~; W0 j# y! _
16.   __HAL_TIM_ENABLE(htim);
    
17. 
    ; t' n! @8 p( K4 k
18.   /* Change the TIM state*/
    3 P1 @+ x2 }, |+ B+ G6 |& z. c
19.   htim->State= HAL_TIM_STATE_READY;
    
20. 
    
21.   /* Return function status */
    ) H% N. T! w: n( h7 ]3 e4 r! T
22.   return HAL_OK;
    
23. }
    
24. 
    
25. 
    
26. /**
    
27.   * @brief  Starts the TIM Base generation in interrupt mode.
    
28.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    
29.   *                the configuration information for TIM module.
    0 N" `8 A$ J0 j# f
30.   * @retval HAL status
    , K9 n1 e' G' i0 o( Q. b+ {" s
31.   */
    
32. HAL_StatusTypeDef HAL_TIM_Base_Start_IT(TIM_HandleTypeDef *htim)
    
33. {
    
34.   /* Check the parameters */
    
35.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    $ p1 f/ u4 |7 I' q) C7 v
36. 
    : i$ ~& B5 x0 t6 j
37.   /* Enable the TIM Update interrupt */
    
38.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
    
39. 
    0 V- ?% R  M' J2 q( Q  J. Q
40.   /* Enable the Peripheral */
    7 z3 r6 V' [( \3 ]5 ^' L
41.   __HAL_TIM_ENABLE(htim);
    7 a, i8 T0 L" S& X) A
42. 
    : l0 |' K. D) n; c: }
43.   /* Return function status */
    
44.   return HAL_OK;
    
45. }
    
46. 
    , C, H# M( {. H/ }* U
47. 
    ! y' i4 h$ L1 [$ G7 z8 m. m
48. /**
    
49.   * @brief  Starts the PWM signal generation.
    
50.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    8 u2 v5 Y8 N, }# E
51.   *                the configuration information for TIM module.
    
52.   * @param  Channel: TIM Channels to be enabled.
    ( i1 l& [& h3 [; m
53.   *          This parameter can be one of the following values:
    9 l* B* I' U1 k
54.   *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
    
55.   *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
    & q* i  [0 t, Q/ D9 O, T2 O
56.   *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
    
57.   *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
    
58.   * @retval HAL status
    : K8 ]3 F& O6 _( d  F) p6 G# i
59.   */
    & m% Y/ b$ D3 E' X0 N
60. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
    1 e& t3 D; y) m" l9 P1 z
61. {
    
62.   /* Check the parameters */
    
63.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
    
64. 
    * R5 r0 b0 L( m8 X; g5 O8 o
65.   /* Enable the Capture compare channel */
    
66.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    6 s, b; r  D( ]" L; `" C1 l
67. 
    . z# Q2 V* B8 f1 `5 x
68.   if(IS_TIM_ADVANCED_INSTANCE(htim->Instance) != RESET)  
    
69.   {
    
70.     /* Enable the main output */
    2 y2 P% t* K) z- T  z/ I  j
71.     __HAL_TIM_MOE_ENABLE(htim);
    
72.   }
    4 h$ [8 r  e8 }4 g* d5 m* }
73. 
    8 t% z$ N$ f& W! ]5 o# G, x1 ~. p3 i0 g
74.   /* Enable the Peripheral */
    ' W& v- K7 v: t5 e9 {" F- F3 L
75.   __HAL_TIM_ENABLE(htim);
    
76. 
    5 C- M1 d3 x5 e
77.   /* Return function status */
    - W9 _% a0 ~' u7 T6 E
78.   return HAL_OK;
    * p) k5 N4 o, V1 @% C
79. }

复制代码

其中的核心代码分别是：

2 p7 j0 i1 |* f! C" S& s/ c

1. __HAL_TIM_ENABLE(htim);

复制代码

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   ! M: k1 D& f; A  p
2.   __HAL_TIM_ENABLE(htim);

复制代码

1.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
2.   __HAL_TIM_ENABLE(htim);

复制代码

那么我们可以不用hal库提供给我们的启动函数，直接写三句话，就实现了定时器中断+PWM功能了。
' J6 I; y$ _7 w5 h- |' K4 c

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   9 \) L( ?; j! v0 ^
2.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
3.   __HAL_TIM_ENABLE(htim);

复制代码

) f% }# q) l* V0 r! }完整代码如下：

) m$ q  \0 l9 y' B2 U

1. TIM_HandleTypeDef TIM2_Handler;
   
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   - i' I: b5 x5 H, a; e( B
3. 
   
4. 
   
5. static void MX_TIM2_Init(void)
     [0 C0 N# ^5 @+ J% X8 N1 R/ p
6. {
   - \- r+ `9 R$ c) `5 P+ H, a, P% O
7.     __HAL_RCC_TIM2_CLK_ENABLE();
   $ O) K9 f* h& a, J% Z0 L
8.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);
   & s( k) m, n3 ]+ I6 `. e$ P
9.     HAL_NVIC_EnableIRQ(TIM2_IRQn);
   3 p/ S) g% C4 `# z
10. 
    5 N: {# E( t7 T, j4 P9 Y1 n1 b; ?
11.     TIM2_Handler.Instance = TIM2;
    ( a) K' M" b  c6 h+ z' O
12.     TIM2_Handler.Init.Prescaler = 10800;
    ; `4 S8 e% f% g- {" Z
13.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
    9 \0 x! D0 k  L7 P! r( ]5 `
14.     TIM2_Handler.Init.Period = 20000;
    
15.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    
16. 
    , A& K, B& ?& \6 g$ M
17.     HAL_TIM_PWM_Init(&TIM2_Handler);
    
18. 
    
19.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    
20.     TIM2_CH2Handler.Pulse = 10000;
    ! h, R  ^% `  z5 x  l
21.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    0 z; B4 j6 [% |6 n! H# Z  i
22.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    + @4 f0 L% h/ T, r, R& }
23.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    
24. 
    
25.     __HAL_TIM_ENABLE_IT(&TIM2_Handler, TIM_IT_UPDATE);
    
26.     TIM_CCxChannelCmd(TIM2_Handler.Instance, TIM_CHANNEL_2, TIM_CCx_ENABLE);
    
27.     __HAL_TIM_ENABLE(&TIM2_Handler);
    
28. }
    
29. 
    
30. 
    & d5 ~3 ]4 X" j" B
31. void TIM2_IRQHandler(void)
    
32. {
    # s: f6 @0 ~& s, B0 y
33.     HAL_TIM_IRQHandler(&TIM2_Handler);
      F& w- t+ E& U4 v4 ]6 i9 ^
34. }
    
35. 
    1 L- F1 I/ Q1 H% k9 }
36. 
    , a' J; _( ?  r6 ^! c
37. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    2 O9 q3 W( S9 r
38. {
    
39.     if (htim == (&TIM2_Handler))
    
40.     {
    
41.         printf("enter irq\r\n");
    5 B. q  _9 z% c# J& y
42.     }
    
43. }
    
44. 
    ) w; x, F& S$ Y) V  X6 I
45. 
    
46. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    
47. {
    + l; H/ I& ^( h
48.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    9 F5 W) z( p4 }6 _2 G2 y7 O0 G
49. 
    $ @# ?, k( |) I& j6 }
50.     __HAL_RCC_TIM2_CLK_ENABLE();
      g% X1 j, g& `: @$ u2 v) f8 Q" C
51.     __HAL_RCC_GPIOA_CLK_ENABLE();
    ! q; ?; M3 `/ b! D/ Q* A. S
52.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    
53.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
54.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
55.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    & r* s5 j; g7 E$ B# X
56.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    . P2 a" p, H& m
57.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    $ `* \- a( Z$ @7 j3 @  r
58. }
    

复制代码

' c8 s7 ^3 c' I0 u8 w0 B