此篇博客记录的是自己通过CubeMX学习F7系列定时器功能的过程，献给有过标准库开发经验的同学。
- b9 m% f+ S. E, G; K8 X# _# J
& d" ~- o8 V+ v7 M+ I6 O9 O5 Z基本计时功能
9 y5 |- s9 B8 A+ y7 j' k$ k最简单的，定时器嘛，基本的定时器就是定时功能，简单来说就是TIMx->CNT会跟随着输入时钟的脉冲而计数。
1 D1 [+ Y: t0 |  U" c2 o初始化定时器的参数，大家都好理解，因为TIM2的输入时钟是108Mhz，这里进行10800分频，输入频率为10K，重装载值设置为20K，每2秒溢出一次。
* A) N$ ]* ?, B! |在HAL_TIM_Base_Init的执行过程中，会先调用HAL_TIM_Base_MspInit再进行其他参数的配置,即先开时钟。

( N1 \& V; d4 V* Z1 x# ]

1. TIM_HandleTypeDef TIM2_Handler;
   9 e1 }9 ]3 `: j! B' ^9 o) K
2. static void MX_TIM2_Init(void)
   
3. {
   
4.     TIM2_Handler.Instance = TIM2;
   
5.     TIM2_Handler.Init.Prescaler = 10800;
   3 }& h" H  W! K, Z6 A
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   : h7 t! {& j  j9 G, A  u
7.     TIM2_Handler.Init.Period = 20000;
   $ t, {: d# W& q, r% f
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   
9. 
   4 @  |# B/ D9 U+ g% c+ u, H% x9 \
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    
11.         HAL_TIM_Base_Start(&TIM2_Handler);
    
12. }
    
13. 
      \$ T7 J7 l& |7 S4 J$ B4 E9 z* O
14. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    
15. {
    8 \$ Q& @3 v; ~+ g$ f  Z& s
16.                 __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM3时钟  
    3 K0 M$ d' ?* ?9 b4 i
17. }

复制代码

主函数中每秒打印一次定时器的值：
+ m* y( k# V- g3 u1 n! L1 K

1.    while (1)
   & w4 P, Z& o! s  C4 D" [8 {
2.     {
   0 L3 K6 k# Z8 ?- S3 o" N* b1 x; e1 A
3.                 printf("cnt:%d\r\n",TIM2->CNT);
   
4.         delay_ms(1000);
   
5.     }

复制代码

6 P( J) X  F4 T5 x显示效果如下：
3 b% \3 q- K0 u  g0 U
% e; X) [. L' D

( a$ \' `# {  A' s$ c1 a
1 r1 T* z  x& A$ G% B+ n+ V  V定时器中断
# G$ v, @8 p, d7 u通过HAL_TIM_Base_Start可以开启基本计时功能，但要实现定时器中断功能，就需要开启相应的标志位，即使用HAL_TIM_Base_Start_IT进行定时的开启；
6 P) F" a3 V5 P在配置定时器之前，除了要开启时钟，还需要先设置中断优先级，和使能中断向量；
0 ~2 ]) t3 \9 V. v! D在定时器中断TIM2_IRQHandler服务函数中调用HAL库提供的定时器中断处理函数HAL_TIM_IRQHandler，解析到的定时器超时中断会自动跳转到HAL_TIM_PeriodElapsedCallback；
7 ~6 U+ Z# M7 W+ }  X) @  V

1. TIM_HandleTypeDef TIM2_Handler;
   # J" h! m! c( ]+ O
2. static void MX_TIM2_Init(void)
   
3. {
   . h# c( X+ \4 h+ v" P* j
4.     TIM2_Handler.Instance = TIM2;
   
5.     TIM2_Handler.Init.Prescaler = 10800;
   
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   % A8 {) S% `* L# W
7.     TIM2_Handler.Init.Period = 20000;
   , S3 ^! J* Z% d
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   
9. 
   
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    
11.     //HAL_TIM_Base_Start(&TIM2_Handler);
    & i3 ^2 C( B3 n- `( H  {- S2 r
12.         HAL_TIM_Base_Start_IT(&TIM2_Handler);
    6 o  _+ e' M9 z) P/ z% N
13. }
      J* i1 ^/ M+ y- Q5 `, ]2 ^' E8 O
14. 
    3 T9 Q; X9 x$ L; p8 N% ~  C
15. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    
16. {
    
17.     __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM2时钟
    ! c4 b0 Q& q5 I6 K2 H1 P( \  t* M
18.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);  //设置中断优先级，抢占优先级1，子优先级3
    % z. V7 y* L; c3 o
19.     HAL_NVIC_EnableIRQ(TIM2_IRQn);          //开启ITM2中断
    
20. }
    ) B" D1 K4 Q9 o4 v9 ~( o
21. 
    ; t- N# p, [! `. M0 I. E, e
22. void TIM2_IRQHandler(void)
    
23. {
    8 j" `, l& d4 ?8 j5 f$ K# Y
24.     HAL_TIM_IRQHandler(&TIM2_Handler);
    3 G, F- @7 C. }  a. W* G! _
25. }
    ! N2 g8 j7 w( h+ G- x8 B/ z
26. 
    
27. 
    1 d- D: G8 A9 t7 P
28. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    1 t) G% \  P& V2 d
29. {
    
30.     if (htim == (&TIM2_Handler))
    : G4 o" U9 Y# o3 C( _
31.     {
    
32.         printf("enter irq\r\n");
    + M7 N1 k6 c  ?2 q5 d$ ?/ t
33.     }
    * }& c2 X7 w6 j; B5 i& g
34. }
    : _2 j. I$ A* e: @1 Y

复制代码

+ n# G/ _0 C  o- {# J1 q显示效果如下：

3 K. H" ~4 J# @

/ ?2 [4 `: N' g3 t$ SPWM输出
8 w; i0 Y8 W3 p+ _硬件PWM输出是不需要使用定时器中断的，但同样需要基本的定时参数配置，初始化也不再是使用HAL_TIM_Base_Init而是使用HAL_TIM_PWM_Init进行初始化了；
* D% J( L3 H3 [/ b- e# A4 T$ P配置完定时器为PWM模式，那么相应的输出通道也需要通过HAL_TIM_PWM_ConfigChannel进行配置；
4 i* v0 ]6 g% b8 H$ o" Y+ ^1 ]同样的启动也不是HAL_TIM_Base_Start或者HAL_TIM_Base_Start_IT了，而是HAL_TIM_PWM_Start了；

1. TIM_HandleTypeDef TIM2_Handler;
     K0 f8 b- h  d! h* I& @
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   
3. static void MX_TIM2_Init(void)
   8 L: A# Q$ Q! e: f$ A
4. {
   
5.     TIM2_Handler.Instance = TIM2;
   
6.     TIM2_Handler.Init.Prescaler = 10800;
   9 w5 j0 L% W) U8 h7 b
7.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
     X& o" I$ L7 Y
8.     TIM2_Handler.Init.Period = 20000;
   
9.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   ) G( Q/ b+ [; j1 x1 d/ S# r
10.     HAL_TIM_PWM_Init(&TIM2_Handler);
    
11. 
    
12.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    
13.     TIM2_CH2Handler.Pulse = 10000;
    " o+ B/ G! [( Z  r, T
14.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    
15.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    & u- G1 I: C4 _8 b, m# k( e3 D) W
16.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    0 S7 p6 f9 o: p" y4 N9 ^! X
17. 
    5 e- u  L/ w  d  a
18.     HAL_TIM_PWM_Start(&TIM2_Handler, TIM_CHANNEL_2); //开启PWM通道2
    
19. }
    
20. 
    2 }7 R) p3 s: m* L6 ]( \  T" ?
21. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    
22. {
    
23.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    * B, G- ~# u/ V- A& A6 M
24.                
    $ K2 l) `) n- ^
25.         __HAL_RCC_TIM2_CLK_ENABLE();           
    
26.     __HAL_RCC_GPIOA_CLK_ENABLE();
    # I8 S% A5 M! D* n
27.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    8 L; g3 a( z5 G3 K! c6 y# H
28.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    4 T; b6 a& S: }3 J7 E' P
29.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    ' x" w( \5 p( G1 E5 o3 y, r
30.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    2 B& v5 N7 v0 R5 X: s5 T# g4 }
31.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    : [; J. E+ \* w0 V. f6 k/ i
32.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    " y4 O$ V; i. R, N0 z1 B, G9 O
33. }

复制代码

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

PWM + 定时器溢出中断
我们都知道，PWM模式是在比较值处翻转，在溢出的时候再次翻转，而溢出的时候，我们也是可以产生中断的；所以同一个定时器，在这种定时时长和周期相同的时候，是可以即做硬件PWM输出，又做溢出中断的。
这里我们观察一下两种初始化函数：
7 p+ h$ ]9 @4 H

1. /**
   ! k: [/ Z& k" [. _" ]% ^
2.   * @brief  Initializes the TIM Time base Unit according to the specified
   - |5 q' ^# L* C# n
3.   *         parameters in the TIM_HandleTypeDef and create the associated handle.
   5 E( U- \  c# [3 S& D
4.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   
5.   *                the configuration information for TIM module.
   
6.   * @retval HAL status
   # y8 ^" X, ?1 u1 \* T% C
7.   */
   % I7 y# e7 r3 J& U- C$ Y, [
8. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   
9. {
   
10.   /* Check the TIM handle allocation */
    
11.   if(htim == NULL)
    ) M8 }4 ]; F; J# ]. I( f" ?+ T
12.   {
    
13.     return HAL_ERROR;
    1 W" j& {$ g0 H8 x
14.   }
    
15. 
    - F4 ~$ `6 V+ R4 n' n. {( w; M$ ^' W
16.   /* Check the parameters */
    
17.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    / t* S! w% p% [- U- y0 i
18.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    
19.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    * v/ U' t7 ^$ v9 |; E
20. 
    
21.   if(htim->State == HAL_TIM_STATE_RESET)
    
22.   {  
    
23.     /* Init the low level hardware : GPIO, CLOCK, NVIC */
    1 I3 ]% n6 B# b9 B( O/ C, z5 s- x
24.     HAL_TIM_Base_MspInit(htim);
    
25.   }
    
26. 
    0 F; r9 W: Z/ p, e
27.   /* Set the TIM state */
    
28.   htim->State= HAL_TIM_STATE_BUSY;
    
29. 
    , l; f. v' S' f1 j1 ~9 X
30.   /* Set the Time Base configuration */
    ) f  ~2 g% w1 V  i* }* J; S0 }
31.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    - f5 h  `0 _# ^" F9 }& Z
32. 
      K" v. o. a0 G+ |: H
33.   /* Initialize the TIM state*/
    $ p' P; s) ?9 w9 T9 S% a& N
34.   htim->State= HAL_TIM_STATE_READY;
    ) K/ a6 [8 q9 A5 R; G( a
35. 
    
36.   return HAL_OK;
      z3 Y  V& [" }; i
37. }
    $ U$ I  Y5 K5 i, @9 M3 @2 i& C
38. 
    # D6 V) H. e) l" l
39. 
    
40. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
    
41. {
    / t1 S  I: i4 s+ N
42.   /* Check the TIM handle allocation */
    
43.   if(htim == NULL)
    
44.   {
    
45.     return HAL_ERROR;
    , D2 _+ h; s. S
46.   }
    
47. 
    
48.   /* Check the parameters */
    4 f6 L: b2 \, Z- O% u7 Q
49.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
50.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    
51.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
52. 
    ) I! E5 d2 \$ o3 l7 r7 T
53.   if(htim->State == HAL_TIM_STATE_RESET)
    5 M/ }4 J. l8 P
54.   {
    
55.     /* Allocate lock resource and initialize it */
    
56.     htim->Lock = HAL_UNLOCKED;  
    ( a8 S& e) E+ O# }/ T! _$ A- P
57.     /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
    ! G# Z- Y+ H" M
58.     HAL_TIM_PWM_MspInit(htim);
    
59.   }
    ! C) M) q  j/ T  o% j! z
60. 
    ! u9 f9 b- q- K' n
61.   /* Set the TIM state */
    3 @3 I' V, k1 s
62.   htim->State= HAL_TIM_STATE_BUSY;  
    
63. 
    
64.   /* Init the base time for the PWM */  
    4 v; \) z( v3 W' p+ y
65.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    6 p/ a; M% f7 P4 H( F2 {
66. 
    2 F4 e4 j6 ?& E1 ^! F: i
67.   /* Initialize the TIM state*/
    + C  z7 \3 T+ N  G5 ~% W" \" {
68.   htim->State= HAL_TIM_STATE_READY;
    
69. 
    ( c# @$ Q0 |: b  M
70.   return HAL_OK;
    
71. }  

复制代码

两者除了底层的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，后面的一个就得不到执行了。
+ `+ q; B/ y8 i7 g8 @$ z再来看启动代码：

1. /**
   3 ^* y. N+ a# C/ P* C( s6 b' k
2.   * @brief  Starts the TIM Base generation.
   
3.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   * G; N( w6 K. d' A- z% `
4.   *                the configuration information for TIM module.
   
5.   * @retval HAL status
   
6.   */
   / x2 ?+ v8 {% _* O5 T; [, m# q: z
7. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   1 D. K* n' j/ U( P* N
8. {
   
9.   /* Check the parameters */
   1 s+ M( r6 U3 Y! i
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    2 l- S, Q4 i# [& P' V) v4 h
11. 
    
12.   /* Set the TIM state */
    4 a% B- s& b& y: ~. B6 t# r" s
13.   htim->State= HAL_TIM_STATE_BUSY;
    . \- u" ~* d( q+ l5 ^. p
14. 
    
15.   /* Enable the Peripheral */
    
16.   __HAL_TIM_ENABLE(htim);
    ' v1 j5 a, u' z- m3 V- i9 T% f, L
17. 
    
18.   /* Change the TIM state*/
    / B3 M5 p+ e5 n7 c( r
19.   htim->State= HAL_TIM_STATE_READY;
    9 N2 ^" T  X  S6 {6 m0 E) Q. ~
20. 
    2 |$ r, e, n6 x% J: F, i$ w5 O8 R
21.   /* Return function status */
    # B( a9 I8 F) A, L0 m4 w
22.   return HAL_OK;
    
23. }
    
24. 
    
25. 
    . ~& T- E) k; A/ X2 o
26. /**
    
27.   * @brief  Starts the TIM Base generation in interrupt mode.
    . v- r0 d9 f. {( Y/ A" _
28.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    : `2 P; E# o. W  Z- S: D% |
29.   *                the configuration information for TIM module.
    
30.   * @retval HAL status
    6 a. y. c) r3 z& w) L  E
31.   */
    
32. HAL_StatusTypeDef HAL_TIM_Base_Start_IT(TIM_HandleTypeDef *htim)
    
33. {
    # {  h. l( {, w4 y  P2 j
34.   /* Check the parameters */
    
35.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    4 {- \- U7 w1 T
36. 
    6 D; W+ t* y. Q% o
37.   /* Enable the TIM Update interrupt */
    
38.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
    8 `& _% M# L: t/ Q
39. 
    
40.   /* Enable the Peripheral */
    
41.   __HAL_TIM_ENABLE(htim);
    , o1 V* Z+ Y+ ]% h" w
42. 
    
43.   /* Return function status */
    1 t* |2 @) M7 }! c) {
44.   return HAL_OK;
    
45. }
    / f- @. K) N4 P0 o1 K' {3 v* x
46. 
    
47. 
    3 D" ^& i  b7 U0 {+ Y7 m
48. /**
    
49.   * @brief  Starts the PWM signal generation.
    
50.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    / q; E& R) @& w0 Q+ N# q
51.   *                the configuration information for TIM module.
    2 Y5 a: g3 f6 h$ W" s) u
52.   * @param  Channel: TIM Channels to be enabled.
    
53.   *          This parameter can be one of the following values:
    # H4 U& o. a0 y$ r+ `5 e
54.   *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
    : t- U6 [- O' v$ s( Q6 C8 g7 g9 M# T
55.   *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
    
56.   *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
    $ g5 x: m; a7 L
57.   *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
    + D, ~' f& N* C2 w: F/ z7 i1 w
58.   * @retval HAL status
    1 z1 o1 X& S* Q# Z+ J( k2 w7 U
59.   */
    3 \7 P' ]( u7 F/ s; ]* H' F: }
60. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
    # |* ?3 h0 Z* w0 n
61. {
    
62.   /* Check the parameters */
    ) m; N# A# Z* M  n) g7 P
63.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
    $ E- v/ Z7 T8 x' L
64. 
    
65.   /* Enable the Capture compare channel */
    6 K+ [, t# e; e( ?
66.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
67. 
    
68.   if(IS_TIM_ADVANCED_INSTANCE(htim->Instance) != RESET)  
    
69.   {
    ( Y: e0 B" \) M/ p; a* o
70.     /* Enable the main output */
      b( z; [- }' T: [. c8 ?
71.     __HAL_TIM_MOE_ENABLE(htim);
    
72.   }
    
73. 
    + d2 \* R) e% a! r- X. F% P: z
74.   /* Enable the Peripheral */
    ; s, e$ V1 q2 |6 ~+ {- a
75.   __HAL_TIM_ENABLE(htim);
    
76. 
    
77.   /* Return function status */
    
78.   return HAL_OK;
    + k" W% D$ p, k. R9 E: Z* K6 @  L
79. }

复制代码

" J$ q% L) H/ Z7 s, ^0 Z2 E
其中的核心代码分别是：

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);
   
2.   __HAL_TIM_ENABLE(htim);

复制代码

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

2 T+ T- r* ^4 z$ {1 i7 S

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   
2.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   7 F/ M1 Z! J; M: c% b9 |# \
3.   __HAL_TIM_ENABLE(htim);

复制代码

6 U5 a; j, r. `; V完整代码如下：

1. TIM_HandleTypeDef TIM2_Handler;
   
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   
3. 
   ; @! z  q* p! |- j2 w
4. 
   
5. static void MX_TIM2_Init(void)
   , l. f, t! g5 c
6. {
   
7.     __HAL_RCC_TIM2_CLK_ENABLE();
   " O! ~/ v5 w! C
8.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);
   ' y! S4 M' }* F9 x8 H8 [6 s
9.     HAL_NVIC_EnableIRQ(TIM2_IRQn);
   + |0 ]8 t+ U: m. o) F, S. T3 O+ E8 H
10. 
    1 @7 V/ j9 C2 A5 b  H
11.     TIM2_Handler.Instance = TIM2;
    2 [( c4 f3 P+ e/ u6 g; B
12.     TIM2_Handler.Init.Prescaler = 10800;
    
13.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
    / B$ _, c# V3 t
14.     TIM2_Handler.Init.Period = 20000;
    9 L; s2 O7 r3 E  D. O1 D' ]
15.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    3 R4 t/ K3 n9 r+ V* g# d: [; y
16. 
    
17.     HAL_TIM_PWM_Init(&TIM2_Handler);
    . @5 K% H  D3 B& B' D. x) ?$ j1 d0 e: l
18. 
    
19.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    * j! s- M1 {' w- j! ?
20.     TIM2_CH2Handler.Pulse = 10000;
    " O9 q8 ~1 B4 m
21.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    
22.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    + G- i9 x5 b1 I0 v& `- c- _8 Q
23.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    4 l: i! r5 U- P2 u  @
24. 
    
25.     __HAL_TIM_ENABLE_IT(&TIM2_Handler, TIM_IT_UPDATE);
    ) i9 a$ c6 M  w) C( m
26.     TIM_CCxChannelCmd(TIM2_Handler.Instance, TIM_CHANNEL_2, TIM_CCx_ENABLE);
    
27.     __HAL_TIM_ENABLE(&TIM2_Handler);
    2 x/ P. w0 a$ [) Q% j7 M/ \
28. }
    $ T3 a5 P, G! l3 C  ]
29. 
    / B; x+ J) B* F, I$ X8 ]
30. 
    ! t3 o5 ?6 K9 M1 `1 e
31. void TIM2_IRQHandler(void)
    
32. {
    % A8 h0 D$ }4 [7 A
33.     HAL_TIM_IRQHandler(&TIM2_Handler);
    
34. }
    & f/ c$ u8 y1 ?0 ~1 z) |
35. 
    * R6 M! a7 k3 t% [' s( I6 ]
36. 
    . _  d9 o: q/ M# ?4 \
37. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
38. {
    
39.     if (htim == (&TIM2_Handler))
    
40.     {
    / I9 B- W9 m1 s7 Z/ d; n4 \0 a
41.         printf("enter irq\r\n");
    3 N  J6 E/ ^! v( @/ q8 r% Q
42.     }
    
43. }
    
44. 
    # E8 f# `+ |1 q8 b
45. 
    7 h) i! g1 t( j3 G4 W- Y
46. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
      |) k4 L* `- e& {3 B
47. {
    6 F4 s% H( ]1 I0 ?+ d
48.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    # z& I% L% B! F' Z
49. 
    0 K4 d- U# a. k& y
50.     __HAL_RCC_TIM2_CLK_ENABLE();
    & {* p5 D; U2 B( j3 c) o
51.     __HAL_RCC_GPIOA_CLK_ENABLE();
    6 N( q6 G0 u; \" Q$ ~
52.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    
53.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    - j. Z8 Q; q2 I  ~# ?3 \+ [
54.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    & i: V' E0 h1 y: ]. c$ N4 P
55.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
56.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    
57.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    4 O1 m- w9 L$ p' J9 j6 n
58. }
    9 u& C/ S# v9 M: z, u7 ~' M4 m! e

复制代码