此篇博客记录的是自己通过CubeMX学习F7系列定时器功能的过程，献给有过标准库开发经验的同学。
* H# e) q/ J- h/ A
. ^& z; z6 ^& f( ?; J  ^基本计时功能
/ g# L/ E9 L! J& [& g5 f/ p最简单的，定时器嘛，基本的定时器就是定时功能，简单来说就是TIMx->CNT会跟随着输入时钟的脉冲而计数。
8 b: L; a; @2 H& G# F6 C- \* |4 R初始化定时器的参数，大家都好理解，因为TIM2的输入时钟是108Mhz，这里进行10800分频，输入频率为10K，重装载值设置为20K，每2秒溢出一次。
' y; o% ~% [! p在HAL_TIM_Base_Init的执行过程中，会先调用HAL_TIM_Base_MspInit再进行其他参数的配置,即先开时钟。

) x8 ^0 T9 u' \5 v. Y; s

1. TIM_HandleTypeDef TIM2_Handler;
   6 k7 }! R6 d- t
2. static void MX_TIM2_Init(void)
   
3. {
   
4.     TIM2_Handler.Instance = TIM2;
   , F! e9 d$ y5 X6 B: }7 f
5.     TIM2_Handler.Init.Prescaler = 10800;
   
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
7.     TIM2_Handler.Init.Period = 20000;
   
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   
9. 
   
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    5 _# w: J  d0 B, E3 Z  W
11.         HAL_TIM_Base_Start(&TIM2_Handler);
    
12. }
      C0 X( u& @# k( ~
13. 
    
14. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    # t) [; M* a5 s- {0 [
15. {
    
16.                 __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM3时钟  
    
17. }

复制代码

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

1.    while (1)
   : u2 o3 I9 d& C: ?  z% Z* R, L% H: }
2.     {
   4 ^9 x  {3 Q; B) u8 S
3.                 printf("cnt:%d\r\n",TIM2->CNT);
   . X, G0 @3 S5 N5 ~
4.         delay_ms(1000);
   
5.     }

复制代码

8 j1 m2 p/ U) i显示效果如下：

" N2 H+ k* V  L

8 n- W, j2 N, N( u1 n; N5 q
) e7 f2 `, ^& |+ f定时器中断
通过HAL_TIM_Base_Start可以开启基本计时功能，但要实现定时器中断功能，就需要开启相应的标志位，即使用HAL_TIM_Base_Start_IT进行定时的开启；
8 ~* D* i; l" L" r) |+ b在配置定时器之前，除了要开启时钟，还需要先设置中断优先级，和使能中断向量；
- @% G! [; b8 W3 Z. D1 e  i" r1 E在定时器中断TIM2_IRQHandler服务函数中调用HAL库提供的定时器中断处理函数HAL_TIM_IRQHandler，解析到的定时器超时中断会自动跳转到HAL_TIM_PeriodElapsedCallback；

1. TIM_HandleTypeDef TIM2_Handler;
   
2. static void MX_TIM2_Init(void)
   
3. {
   
4.     TIM2_Handler.Instance = TIM2;
   6 p# z( t) e; L4 |
5.     TIM2_Handler.Init.Prescaler = 10800;
   
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
7.     TIM2_Handler.Init.Period = 20000;
   
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   
9. 
   ' J1 l9 ~3 V  f% X" r; S: |. Y# H
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    ! w0 g6 {0 N1 k7 Q5 p/ h1 x
11.     //HAL_TIM_Base_Start(&TIM2_Handler);
    
12.         HAL_TIM_Base_Start_IT(&TIM2_Handler);
    
13. }
    
14. 
    / Y3 a% |$ t4 z
15. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    
16. {
    3 R& U: ]8 E2 B
17.     __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM2时钟
    8 t% }/ D2 C7 }
18.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);  //设置中断优先级，抢占优先级1，子优先级3
    
19.     HAL_NVIC_EnableIRQ(TIM2_IRQn);          //开启ITM2中断
    ; m7 t' Q3 N3 @" Z. K' M
20. }
    
21. 
    
22. void TIM2_IRQHandler(void)
    
23. {
    
24.     HAL_TIM_IRQHandler(&TIM2_Handler);
    % f3 Q) ~" e3 [1 H# B6 U8 y
25. }
    
26. 
    - l8 o. \( o: c1 j. g
27. 
    
28. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
29. {
    
30.     if (htim == (&TIM2_Handler))
    
31.     {
    
32.         printf("enter irq\r\n");
    
33.     }
    
34. }
    

复制代码

显示效果如下：
5 X' e3 {' l  S3 W% b" l
2 {* e; ^' x9 E! m4 J% f

PWM输出
硬件PWM输出是不需要使用定时器中断的，但同样需要基本的定时参数配置，初始化也不再是使用HAL_TIM_Base_Init而是使用HAL_TIM_PWM_Init进行初始化了；
配置完定时器为PWM模式，那么相应的输出通道也需要通过HAL_TIM_PWM_ConfigChannel进行配置；
同样的启动也不是HAL_TIM_Base_Start或者HAL_TIM_Base_Start_IT了，而是HAL_TIM_PWM_Start了；
1 Q; l7 B  ], v

1. TIM_HandleTypeDef TIM2_Handler;
   3 p7 y3 [4 u7 ?
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   ' P  W9 U, Q5 @  Q% E
3. static void MX_TIM2_Init(void)
   
4. {
   & {4 y+ D: d" }0 H8 X" C4 l
5.     TIM2_Handler.Instance = TIM2;
   
6.     TIM2_Handler.Init.Prescaler = 10800;
   * U, D& y* j) X$ y/ _& p6 @7 w2 b: D
7.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   # A' {, \6 b$ E$ `
8.     TIM2_Handler.Init.Period = 20000;
   
9.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   6 A4 d, K0 @! z. g, [
10.     HAL_TIM_PWM_Init(&TIM2_Handler);
    ( ^# a& ?( {2 o' w
11. 
    
12.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    
13.     TIM2_CH2Handler.Pulse = 10000;
    
14.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    ' v* f0 j, m' w
15.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    - ^7 T) f0 S4 b% @4 y% `2 w
16.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    , v' T0 E4 V+ y+ d( d
17. 
    
18.     HAL_TIM_PWM_Start(&TIM2_Handler, TIM_CHANNEL_2); //开启PWM通道2
    
19. }
    & w/ J1 n$ u! E  r6 D# h1 \" f0 e
20. 
    
21. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    
22. {
    
23.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    ; r% ^7 P1 Z2 \+ y1 T
24.                
    
25.         __HAL_RCC_TIM2_CLK_ENABLE();           
    
26.     __HAL_RCC_GPIOA_CLK_ENABLE();
    
27.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    : V; j! Z# j0 c9 G/ N
28.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
29.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    - O; B7 ~' A0 r- i- t
30.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    , m5 c. Y2 F! b7 U$ y; ]
31.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    0 J9 G3 Z$ {1 v$ b  v/ M% D* Y
32.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    ( F& l  O3 ~+ N/ ?0 y
33. }

复制代码

通过万用表可以发现PA1口的电压在0和3.3V中大概每秒变动一次（疫情期间在家学习，没有示波器真是太惨了……为了确定确实有PWM波形，只能出此下策了T_T），串口打印数据如下：
3 w; n+ c! Y( v# W1 k
+ W: u" ~4 K  A3 e1 l. C

0 R. y) a) d# a2 n8 R. ^7 v
PWM + 定时器溢出中断
我们都知道，PWM模式是在比较值处翻转，在溢出的时候再次翻转，而溢出的时候，我们也是可以产生中断的；所以同一个定时器，在这种定时时长和周期相同的时候，是可以即做硬件PWM输出，又做溢出中断的。
这里我们观察一下两种初始化函数：
0 R6 [0 u! I: A* t2 t  W) e2 \8 M
9 [' a% w! [. o  j: I

1. /**
   . }  w! _% R- f3 e8 |/ r4 c- E- ?( f
2.   * @brief  Initializes the TIM Time base Unit according to the specified
   : y5 O" V, m6 _% l& N0 C: U
3.   *         parameters in the TIM_HandleTypeDef and create the associated handle.
   
4.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   , A6 G! E- n% [/ A3 h
5.   *                the configuration information for TIM module.
   ' p7 ], z  G1 ~7 @/ [
6.   * @retval HAL status
   
7.   */
   % o& \4 i0 S' i$ ~
8. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   
9. {
   % [  C, b( P( d8 r* q& W
10.   /* Check the TIM handle allocation */
    
11.   if(htim == NULL)
    ) E5 b" g$ z) m& a8 W8 n
12.   {
    
13.     return HAL_ERROR;
    2 y4 v' |% g0 {, R
14.   }
    
15. 
    : m  X4 N$ ?; i, s, D, i" O2 W
16.   /* Check the parameters */
    
17.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    * C( @0 ?  N& ?5 |$ M- {
18.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    * v' B- S- j7 v6 `: o" t
19.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
20. 
    6 E3 @2 e* F/ N
21.   if(htim->State == HAL_TIM_STATE_RESET)
    
22.   {  
    7 s  Z( @4 H. F6 E5 T3 k) L
23.     /* Init the low level hardware : GPIO, CLOCK, NVIC */
    ' r4 q) L( w! P0 O$ B: e2 R$ L
24.     HAL_TIM_Base_MspInit(htim);
    + q; {7 u1 u0 J' U& L. V
25.   }
    % a3 b  e5 U5 j) M
26. 
    
27.   /* Set the TIM state */
    
28.   htim->State= HAL_TIM_STATE_BUSY;
    * ^4 ]  f# V, U5 N" i$ [8 X
29. 
    - S- F: z* h; q% d
30.   /* Set the Time Base configuration */
    
31.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    / |+ w* C5 [4 v8 ]; @
32. 
    
33.   /* Initialize the TIM state*/
    ( M; g3 f7 i$ J- l$ T
34.   htim->State= HAL_TIM_STATE_READY;
    
35. 
    - u, E; ^, }2 K! G5 {$ T
36.   return HAL_OK;
    
37. }
    ) T! j* s9 M2 R' D; v, L
38. 
    
39. 
    . e8 m5 A2 h1 V2 k- ?
40. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
    ' K1 o/ n0 y' _, n" ?5 G
41. {
    
42.   /* Check the TIM handle allocation */
    3 V$ v* q" w3 G' B9 Z
43.   if(htim == NULL)
    
44.   {
    , Y" }' s5 C$ T6 e9 V% J: K
45.     return HAL_ERROR;
    7 F! ?5 t) b) \! f3 g
46.   }
    
47. 
    ) K2 `. F0 M% ~' Y' @
48.   /* Check the parameters */
    
49.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    $ L9 s$ o7 `$ |9 |2 l
50.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    ' g" S" k3 r, d7 w/ @0 e
51.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    4 k/ j) X" `: ~# q5 \8 D
52. 
    
53.   if(htim->State == HAL_TIM_STATE_RESET)
    
54.   {
    9 l$ S8 e* ^2 j' c/ l4 _0 g6 M6 R
55.     /* Allocate lock resource and initialize it */
    
56.     htim->Lock = HAL_UNLOCKED;  
    6 A* x  u( ^, B, H) ~( [2 B
57.     /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
    
58.     HAL_TIM_PWM_MspInit(htim);
    
59.   }
    % H6 i1 ]1 t9 \( ?& ?
60. 
    
61.   /* Set the TIM state */
    9 e' n0 u3 c' ^" k
62.   htim->State= HAL_TIM_STATE_BUSY;  
    9 G2 y+ r1 p/ E4 p5 |6 M
63. 
    
64.   /* Init the base time for the PWM */  
    4 @3 x6 p! w- ^, ^  M* G: o1 T
65.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
66. 
    6 f* f1 y  g% t4 N) x
67.   /* Initialize the TIM state*/
    
68.   htim->State= HAL_TIM_STATE_READY;
    
69. 
    , c% W6 N! B$ k
70.   return HAL_OK;
    
71. }  

复制代码

- _# Z3 V1 Y( X2 w5 s4 {两者除了底层的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，后面的一个就得不到执行了。
( n9 H; o7 j% }再来看启动代码：

$ r7 d0 Q! ^/ `$ h( O' K+ J

1. /**
   
2.   * @brief  Starts the TIM Base generation.
   
3.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   & F: k2 {" E. D/ G4 ~) t; V
4.   *                the configuration information for TIM module.
   ) _% `3 P& ?* s0 x5 k) ?  R# i9 U
5.   * @retval HAL status
   
6.   */
   0 R' ^* q  H* v. q& ?8 a6 ?7 \
7. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   4 a* Q! w4 E: B) p
8. {
   
9.   /* Check the parameters */
   ) c: X% ~7 o7 h* K
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    " @. ^5 Z' j/ M+ w, r
11. 
    
12.   /* Set the TIM state */
    
13.   htim->State= HAL_TIM_STATE_BUSY;
    
14. 
    ! f& p& @% ?+ }5 y+ T8 P$ B, Y
15.   /* Enable the Peripheral */
    " Y# ~3 J: Q& |& m; _
16.   __HAL_TIM_ENABLE(htim);
    3 |( W6 b  K# u7 y  P2 v6 O7 ^
17. 
    $ q2 p0 k, _/ ]8 R7 c
18.   /* Change the TIM state*/
    ' Q8 z# p+ p' h9 J! K! M0 j
19.   htim->State= HAL_TIM_STATE_READY;
    
20. 
    
21.   /* Return function status */
    9 B7 @4 A8 _; U, ~& w# [2 x
22.   return HAL_OK;
    
23. }
    . x& ?, a/ T- }( ^( U! W. b
24. 
    & y$ P! l5 e4 `1 T2 O5 J2 P
25. 
    
26. /**
    $ Q! f0 S) b: |6 M: B
27.   * @brief  Starts the TIM Base generation in interrupt mode.
    " Y- F+ v3 [+ g
28.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    & ?. |! J4 p+ j9 d3 h
29.   *                the configuration information for TIM module.
    ( R+ ^+ P, y! D3 A- V
30.   * @retval HAL status
    " R) _3 d" w! D1 S3 C
31.   */
    
32. HAL_StatusTypeDef HAL_TIM_Base_Start_IT(TIM_HandleTypeDef *htim)
    
33. {
      Q2 }/ ]- }# d7 B9 M6 w; r- k" q
34.   /* Check the parameters */
    
35.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
36. 
    
37.   /* Enable the TIM Update interrupt */
    
38.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
    
39. 
    
40.   /* Enable the Peripheral */
    # t( z' ]; y$ M' y9 n) C3 A
41.   __HAL_TIM_ENABLE(htim);
    
42. 
    * y1 G7 `; F7 D
43.   /* Return function status */
    5 J' [1 f7 }. L' g1 F1 e
44.   return HAL_OK;
    
45. }
    5 h( K: I  z  J. |( L: A
46. 
    6 G( l& z. X; L) z4 D$ |% W
47. 
    ) g3 B+ |/ P2 v4 w
48. /**
    : \9 I) z7 s8 M
49.   * @brief  Starts the PWM signal generation.
    8 B) H: ?" U+ a7 b+ a, [
50.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    
51.   *                the configuration information for TIM module.
    2 r  |' \. {+ k3 T" F& ?. e/ ]6 ?
52.   * @param  Channel: TIM Channels to be enabled.
    
53.   *          This parameter can be one of the following values:
    4 z# ^* V# [: p9 ~4 G( c
54.   *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
    
55.   *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
    
56.   *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
    $ o3 J* K) J0 B$ N
57.   *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
    3 j. \2 g5 H0 z, R# d; W) y
58.   * @retval HAL status
    
59.   */
    " a3 J# j3 ~3 I7 m6 v+ q3 l
60. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
    0 ~8 ^& V' B6 `* ^
61. {
    
62.   /* Check the parameters */
    
63.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
    
64. 
    6 l) v6 M- i' [' `. p% I* M
65.   /* Enable the Capture compare channel */
    * B* b1 L$ s+ x3 A5 z
66.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
67. 
    . f, A8 ^0 K7 q! _' y* A
68.   if(IS_TIM_ADVANCED_INSTANCE(htim->Instance) != RESET)  
    ! k2 T5 U5 ?' k  q$ B. @& ~
69.   {
    2 f3 `, c4 u( D; O7 K$ V3 p7 N  \
70.     /* Enable the main output */
    ( D% [6 J# A9 ?  C. I" q9 d
71.     __HAL_TIM_MOE_ENABLE(htim);
    3 M8 p; d  ]% H0 |$ V5 L
72.   }
    
73. 
    ' R$ r" t0 ^% p$ e+ E8 K: o
74.   /* Enable the Peripheral */
    0 s7 Q+ E9 y7 P* |& X! i
75.   __HAL_TIM_ENABLE(htim);
    
76. 
    
77.   /* Return function status */
    
78.   return HAL_OK;
    % h0 `; f, `" H
79. }

复制代码

其中的核心代码分别是：

3 ^0 s# [: U  w, L1 X

1. __HAL_TIM_ENABLE(htim);

复制代码

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   
2.   __HAL_TIM_ENABLE(htim);

复制代码

1.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   ' U& C! r5 {5 C8 }" p: g
2.   __HAL_TIM_ENABLE(htim);

复制代码

那么我们可以不用hal库提供给我们的启动函数，直接写三句话，就实现了定时器中断+PWM功能了。
* I' U5 x  n* w7 A
9 [( Z; L  ^. p/ M, B1 @9 V

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

复制代码

3 k0 i# J7 `, X9 v& i# s2 B( o完整代码如下：

- t, P9 A: t8 P, n

1. TIM_HandleTypeDef TIM2_Handler;
   2 Q- U. A8 w3 T2 }  E
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   
3. 
   % E. L: ^" y3 `) ]4 p8 S
4. 
   2 A' M0 ^: F/ r/ w
5. static void MX_TIM2_Init(void)
   - T4 r' q0 F  ~6 r  B: R% [
6. {
   
7.     __HAL_RCC_TIM2_CLK_ENABLE();
   7 Y* O/ \+ n! ~0 L" W* R/ h
8.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);
   
9.     HAL_NVIC_EnableIRQ(TIM2_IRQn);
   8 Z4 y* v5 h0 }! w3 P# {
10. 
    
11.     TIM2_Handler.Instance = TIM2;
    
12.     TIM2_Handler.Init.Prescaler = 10800;
    & i5 W" v- L2 Z4 K$ X4 J5 e
13.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
    
14.     TIM2_Handler.Init.Period = 20000;
    
15.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    
16. 
    9 b% y' C- S; Y2 U
17.     HAL_TIM_PWM_Init(&TIM2_Handler);
    
18. 
    
19.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    9 I, I: f; @* H% Z) J% t( J
20.     TIM2_CH2Handler.Pulse = 10000;
    
21.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    
22.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    " B, ~! w- f! b1 Z3 f! J1 ]5 W+ ]
23.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    * @9 N3 z$ T0 H5 }# L, L
24. 
    7 U' Z3 a4 n9 \3 N/ K
25.     __HAL_TIM_ENABLE_IT(&TIM2_Handler, TIM_IT_UPDATE);
    
26.     TIM_CCxChannelCmd(TIM2_Handler.Instance, TIM_CHANNEL_2, TIM_CCx_ENABLE);
    # D4 i% g5 X6 ~& n2 |5 O% Z0 h- n7 ]
27.     __HAL_TIM_ENABLE(&TIM2_Handler);
    
28. }
    ( P$ @' e3 m- L! j/ h
29. 
    
30. 
    2 z' i4 i# L$ U# E5 d6 T/ w
31. void TIM2_IRQHandler(void)
      L  }8 b( F& q
32. {
    
33.     HAL_TIM_IRQHandler(&TIM2_Handler);
    & P; c( i" o% @! q: q
34. }
    . ^$ L2 v: h) r
35. 
    
36. 
    
37. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    & l: z$ B7 y- L4 [) i( c
38. {
    ) x! z' r% _+ E  d/ C
39.     if (htim == (&TIM2_Handler))
    
40.     {
    ( p! b9 o3 N+ O
41.         printf("enter irq\r\n");
    
42.     }
    % ~7 |2 B3 S' s: g( d' {
43. }
    
44. 
    
45. 
    % }) n1 ~" O' ]. I3 ]
46. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    
47. {
    % o- e1 P. u/ L* A2 ^# `: h
48.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    6 V' |' ?8 W4 i1 F. H; g& H8 l0 [1 p
49. 
    ' `7 z* \$ z8 @; T, F1 D- @
50.     __HAL_RCC_TIM2_CLK_ENABLE();
    % x  H' G9 p. d
51.     __HAL_RCC_GPIOA_CLK_ENABLE();
    - m! v" y/ _" P+ d9 \% }: M
52.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    ' ^) M) e# {; }) d5 s
53.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    / L8 R1 o' N+ X: T
54.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    ' q' k9 Y& d5 E- w+ Q; N9 R7 d  }
55.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    : p. D- f  V4 x' k
56.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    + o) J% W3 b, f
57.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
58. }
    

复制代码

. I" u* P- H% L5 z/ f: H
' b" Q7 w8 W" P  K9 Q