此篇博客记录的是自己通过CubeMX学习F7系列定时器功能的过程，献给有过标准库开发经验的同学。
1 T0 U; O! w+ S2 T( y$ W( A
基本计时功能
, A9 {- m5 g3 v0 o; ~2 @) t7 d" O最简单的，定时器嘛，基本的定时器就是定时功能，简单来说就是TIMx->CNT会跟随着输入时钟的脉冲而计数。
2 o9 n, T) m6 }) l3 T* u初始化定时器的参数，大家都好理解，因为TIM2的输入时钟是108Mhz，这里进行10800分频，输入频率为10K，重装载值设置为20K，每2秒溢出一次。
在HAL_TIM_Base_Init的执行过程中，会先调用HAL_TIM_Base_MspInit再进行其他参数的配置,即先开时钟。

* f8 K" F0 M6 ?

1. TIM_HandleTypeDef TIM2_Handler;
   1 j# f3 U" s1 [2 l
2. static void MX_TIM2_Init(void)
   , I- j+ c4 j9 ?/ b
3. {
   
4.     TIM2_Handler.Instance = TIM2;
   # a$ I! i5 V+ O: t
5.     TIM2_Handler.Init.Prescaler = 10800;
   2 {8 W/ F" E6 l: ]8 `. v$ f/ G
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
7.     TIM2_Handler.Init.Period = 20000;
   - ?, I! q# j( p4 q
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   ! E: B3 [9 h4 @1 w; z2 {
9. 
   ( P8 Z/ X* r6 a- |1 [
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    
11.         HAL_TIM_Base_Start(&TIM2_Handler);
    4 ~  c9 c8 y) z3 ~5 G; W' f
12. }
    1 S/ G% _- N3 U* ~2 ~) l* D
13. 
    
14. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    1 d$ E! j" R7 V* c' e% ?1 r! ^
15. {
    5 q5 \; r  ~' v5 c- A
16.                 __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM3时钟  
    
17. }

复制代码

5 L; H8 ~" o3 U+ `! T  o5 d主函数中每秒打印一次定时器的值：

; {6 C% @* O/ v+ k7 M, c

1.    while (1)
   
2.     {
   ( z/ p+ A5 J; x- b" g, f. J4 f& q; O
3.                 printf("cnt:%d\r\n",TIM2->CNT);
   
4.         delay_ms(1000);
   % n4 \" I; e& t) w/ A% i' Q
5.     }

复制代码

显示效果如下：
8 |) n( c& f  w% p) ]5 C6 G

% v2 C9 D, y9 V3 e- D! l5 ^
定时器中断
通过HAL_TIM_Base_Start可以开启基本计时功能，但要实现定时器中断功能，就需要开启相应的标志位，即使用HAL_TIM_Base_Start_IT进行定时的开启；
在配置定时器之前，除了要开启时钟，还需要先设置中断优先级，和使能中断向量；
2 m/ p$ F# ^" u! I在定时器中断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;
   5 u3 ]) R& U! a0 s9 c* \# u
5.     TIM2_Handler.Init.Prescaler = 10800;
   , J3 m; I2 `9 {) N0 h
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);
    9 c% X( `; b/ j1 B; |
11.     //HAL_TIM_Base_Start(&TIM2_Handler);
    4 v* {4 X, ]. ^+ r1 C8 H& p
12.         HAL_TIM_Base_Start_IT(&TIM2_Handler);
    
13. }
    
14. 
    
15. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    $ V1 Y1 `. j/ ^5 j. Q' \, d6 B
16. {
    
17.     __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM2时钟
    ! b) v& B# C. `& N5 D
18.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);  //设置中断优先级，抢占优先级1，子优先级3
    
19.     HAL_NVIC_EnableIRQ(TIM2_IRQn);          //开启ITM2中断
    
20. }
      M+ x/ V6 I+ M3 c# H. r1 h
21. 
    
22. void TIM2_IRQHandler(void)
    
23. {
    
24.     HAL_TIM_IRQHandler(&TIM2_Handler);
    
25. }
    
26. 
    * S8 n# _* K+ U* X, _
27. 
    3 w: M2 O! ~, b1 [! `$ N
28. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
29. {
    
30.     if (htim == (&TIM2_Handler))
    : w% J$ r. Q2 |2 g0 `$ y& M6 O
31.     {
    ' l: Q% [( C, z, P% C- D( u
32.         printf("enter irq\r\n");
    
33.     }
    0 u7 m$ F/ g2 `) @& {+ @
34. }
    

复制代码

显示效果如下：
% X8 E- ?7 |; l) A- ~" i+ r
& O# P2 J# Y  _

: ?& g0 h9 z7 a2 [
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了；

+ r6 s- f0 ~' a0 B

1. TIM_HandleTypeDef TIM2_Handler;
   5 I- U9 Z  J# l/ ~1 |% s. Z2 T
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   
3. static void MX_TIM2_Init(void)
   ! h5 k  z" j0 Y: M
4. {
   
5.     TIM2_Handler.Instance = TIM2;
   
6.     TIM2_Handler.Init.Prescaler = 10800;
   2 S1 J+ I# V/ H
7.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
8.     TIM2_Handler.Init.Period = 20000;
   2 k4 r0 n$ d0 T. O; T; b& U
9.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   $ S# m: G3 A8 Y) D" I; M
10.     HAL_TIM_PWM_Init(&TIM2_Handler);
    ; q) I2 Q, |7 O" W1 i+ ?% n6 e
11. 
    
12.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    
13.     TIM2_CH2Handler.Pulse = 10000;
    - X' `, W, P+ N) n8 n+ e% |( W& u
14.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    ) e" u* v/ R" \6 r+ C
15.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    7 g' F2 H+ k' n- L
16.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    $ D7 N- L+ l) d7 Q. p' B3 x; Y
17. 
    
18.     HAL_TIM_PWM_Start(&TIM2_Handler, TIM_CHANNEL_2); //开启PWM通道2
    % Z7 `& ]) N. y0 p1 V4 [
19. }
    : H: k1 \4 G: E8 S3 E8 S1 Q
20. 
    1 Z8 U0 e4 y) a; q+ R# L
21. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    5 ?2 h- J# [: t/ f; w  b" R
22. {
    . b1 }9 V0 A5 G
23.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    ( K" T) O+ c& |) b+ m
24.                
    
25.         __HAL_RCC_TIM2_CLK_ENABLE();           
    / m+ r( N) H. k" T4 Y3 M4 L: ~
26.     __HAL_RCC_GPIOA_CLK_ENABLE();
    6 z; s& k8 z+ V- @
27.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    - s' o$ t& c& [/ i9 c
28.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    % i5 q- k& q+ S( p) J& f
29.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
30.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    + M7 m! h) V, p8 V
31.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    * r" B2 c9 h$ s$ d8 s% d& ?
32.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
33. }

复制代码

$ H9 `' u! j6 X  M2 `: Z
6 N2 Y$ M. J. R& L4 t2 }8 k通过万用表可以发现PA1口的电压在0和3.3V中大概每秒变动一次（疫情期间在家学习，没有示波器真是太惨了……为了确定确实有PWM波形，只能出此下策了T_T），串口打印数据如下：

% p2 N  A% G# ^& S( O

& V% H4 N- \& w3 I7 L
PWM + 定时器溢出中断
我们都知道，PWM模式是在比较值处翻转，在溢出的时候再次翻转，而溢出的时候，我们也是可以产生中断的；所以同一个定时器，在这种定时时长和周期相同的时候，是可以即做硬件PWM输出，又做溢出中断的。
这里我们观察一下两种初始化函数：

1 z% |& h  N1 t

1. /**
   
2.   * @brief  Initializes the TIM Time base Unit according to the specified
   % T; @7 R  Y7 G, h
3.   *         parameters in the TIM_HandleTypeDef and create the associated handle.
   # M4 o' a7 Y+ y  d5 W
4.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   5 c. w  i6 I2 M- M9 g
5.   *                the configuration information for TIM module.
   
6.   * @retval HAL status
   
7.   */
   
8. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   
9. {
     O: T/ P" V. r8 t( u
10.   /* Check the TIM handle allocation */
    
11.   if(htim == NULL)
    
12.   {
    3 `4 B2 E, F( [0 w. M& Q
13.     return HAL_ERROR;
    
14.   }
    
15. 
    
16.   /* Check the parameters */
    
17.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    3 l: c4 j- w' d) S/ C2 I# e2 g
18.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    / g8 Q- F  K9 x, b  k
19.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
20. 
    ( d7 M3 [7 V2 f6 O3 j
21.   if(htim->State == HAL_TIM_STATE_RESET)
    
22.   {  
    
23.     /* Init the low level hardware : GPIO, CLOCK, NVIC */
    4 j. i% q- Y5 |9 [; k+ b" E
24.     HAL_TIM_Base_MspInit(htim);
    
25.   }
    
26. 
    2 d2 g: H; I" L1 B
27.   /* Set the TIM state */
    & T* {# U2 P7 _3 |7 D0 K
28.   htim->State= HAL_TIM_STATE_BUSY;
    
29. 
    
30.   /* Set the Time Base configuration */
    . F* @6 ?2 e& K, T; g
31.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    6 @' c. G) L" K# b  l
32. 
    
33.   /* Initialize the TIM state*/
    * F$ H  A" @9 t/ P8 q
34.   htim->State= HAL_TIM_STATE_READY;
    5 m% m( l( H1 Z+ E9 b( H# T, @  y/ ?
35. 
    
36.   return HAL_OK;
    1 ?- t' S/ {% h$ j
37. }
    
38. 
    
39. 
    % b6 v  B, E! ~7 w4 J) S# y' e
40. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
    0 z) @( X9 K: q
41. {
    
42.   /* Check the TIM handle allocation */
    
43.   if(htim == NULL)
    , ~! w& r( Z: e. G6 C/ v: z: B/ l, u
44.   {
    
45.     return HAL_ERROR;
    
46.   }
    
47. 
    
48.   /* Check the parameters */
    7 l& Z4 _/ k, ^& A! x& T0 X
49.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    7 G# z8 k: X8 U
50.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    
51.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    8 `& Z( z5 t5 q/ K4 o& B( W
52. 
    
53.   if(htim->State == HAL_TIM_STATE_RESET)
    
54.   {
    
55.     /* Allocate lock resource and initialize it */
    
56.     htim->Lock = HAL_UNLOCKED;  
    
57.     /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
    5 y& z7 o1 N4 x8 Y$ }4 Z6 Y
58.     HAL_TIM_PWM_MspInit(htim);
    4 G* P! v! S! L$ _9 s1 y* q0 I
59.   }
    
60. 
    
61.   /* Set the TIM state */
    4 F* a- S6 k  p; W1 X4 S& M
62.   htim->State= HAL_TIM_STATE_BUSY;  
    # r& M3 s" l5 [3 ]
63. 
    
64.   /* Init the base time for the PWM */  
    ' t/ R! o: C: V- o
65.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
66. 
    ( N. f1 g! o% S, a& \
67.   /* Initialize the TIM state*/
    
68.   htim->State= HAL_TIM_STATE_READY;
    
69. 
    + a$ C1 ~9 s* q$ b2 _, v- z
70.   return HAL_OK;
    7 k, E0 ]3 d* A6 B7 O: T
71. }  

复制代码

- s- W9 u+ Q, g6 B# k  g! {两者除了底层的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，后面的一个就得不到执行了。
再来看启动代码：

9 u. H& k3 i! n

1. /**
   
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.
   
5.   * @retval HAL status
   2 Q; G! j* P! O" W5 P3 P% X
6.   */
   
7. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   1 \0 B! f" O3 [5 j
8. {
   
9.   /* Check the parameters */
   / J/ H/ c/ B9 y/ a; p" G
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    . u' x. \) n* N6 t  Y! G
11. 
    + p2 e6 ^. a4 d. I
12.   /* Set the TIM state */
    
13.   htim->State= HAL_TIM_STATE_BUSY;
    
14. 
    
15.   /* Enable the Peripheral */
    
16.   __HAL_TIM_ENABLE(htim);
    
17. 
    
18.   /* Change the TIM state*/
    
19.   htim->State= HAL_TIM_STATE_READY;
    
20. 
    
21.   /* Return function status */
    
22.   return HAL_OK;
    7 g* Z  Y' w0 }; \' b! k
23. }
    3 F$ ^0 R- L" v5 x9 t% k4 p
24. 
    
25. 
    
26. /**
    
27.   * @brief  Starts the TIM Base generation in interrupt mode.
    ) G. _* i5 J2 M- k5 u- g
28.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    
29.   *                the configuration information for TIM module.
    2 H& w" C, A9 W9 H6 J4 p8 u
30.   * @retval HAL status
    8 {0 v" V' P6 k9 L  P: L* O
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));
    
36. 
    
37.   /* Enable the TIM Update interrupt */
    6 W$ I/ R  Y. s6 r9 @/ X
38.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
    
39. 
    
40.   /* Enable the Peripheral */
    
41.   __HAL_TIM_ENABLE(htim);
    
42. 
    
43.   /* Return function status */
    
44.   return HAL_OK;
    & i7 j  i/ _( E$ Z: {6 n! X4 v
45. }
    % w* o- H7 y' O  s, F
46. 
    # u5 R9 m9 {& x: M$ L
47. 
    
48. /**
    2 L7 p. |" F# ^, D
49.   * @brief  Starts the PWM signal generation.
    * I; M4 e, [! X/ Z5 u) T1 s: |
50.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    3 H, E/ x- d; D% Y& Y( O+ u) W
51.   *                the configuration information for TIM module.
    ) u) V; B& c% [* s" \1 G& j
52.   * @param  Channel: TIM Channels to be enabled.
    $ \/ p0 `3 f$ W
53.   *          This parameter can be one of the following values:
    - x  D6 V. |) o, O0 L& m' y: H
54.   *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
    * J4 T5 O; p5 c: E. |: \  Y
55.   *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
    / T: T4 j4 w& g4 b/ [8 W) B
56.   *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
    
57.   *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
    2 d, z. l( g0 ^3 s1 t5 M3 r
58.   * @retval HAL status
    ) G" S) ?2 A' U0 L0 A0 Y
59.   */
    4 G. p/ |! h7 @# n' h. ~$ z' L
60. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
    7 Z/ H8 g! W7 A8 L9 h, E) y
61. {
    
62.   /* Check the parameters */
    
63.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
    1 Z& {2 u8 ~/ q
64. 
    
65.   /* Enable the Capture compare channel */
    
66.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
67. 
    
68.   if(IS_TIM_ADVANCED_INSTANCE(htim->Instance) != RESET)  
    
69.   {
    
70.     /* Enable the main output */
    
71.     __HAL_TIM_MOE_ENABLE(htim);
    6 S! e1 j! Y3 z: F" ?1 F
72.   }
    ( o2 T% U  |( e- ]4 Y; ?
73. 
    , j, d3 i9 Q% ^* L/ Q0 @
74.   /* Enable the Peripheral */
    8 b$ v6 k/ @3 D9 r( w, `
75.   __HAL_TIM_ENABLE(htim);
    
76. 
    
77.   /* Return function status */
    
78.   return HAL_OK;
    
79. }

复制代码

其中的核心代码分别是：

0 p9 U- _: g9 v5 {) ?0 i/ L6 q8 n3 ]

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功能了。

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   
2.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   * X! u6 ^1 y: [9 N
3.   __HAL_TIM_ENABLE(htim);

复制代码

完整代码如下：
. a" O2 Z: [8 H" p3 x

1. TIM_HandleTypeDef TIM2_Handler;
   2 W; C. \- K1 N+ u5 P8 r, |
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   & _& p( d5 ^6 ]4 b
3. 
   
4. 
   
5. static void MX_TIM2_Init(void)
   4 _! w5 z: ~! Y% l
6. {
   
7.     __HAL_RCC_TIM2_CLK_ENABLE();
   9 `4 }' S! ^; b7 n% i5 Z$ J& r
8.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);
   0 E. ?  n6 w2 ?
9.     HAL_NVIC_EnableIRQ(TIM2_IRQn);
   
10. 
    
11.     TIM2_Handler.Instance = TIM2;
    
12.     TIM2_Handler.Init.Prescaler = 10800;
    
13.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
    
14.     TIM2_Handler.Init.Period = 20000;
    . ?1 @2 e: X$ G
15.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    
16. 
    0 N, ?2 T) j& E: n. f
17.     HAL_TIM_PWM_Init(&TIM2_Handler);
    ) p/ s8 k# k, C. B+ k
18. 
    + s0 O- i# T. L7 R& Y- @
19.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    
20.     TIM2_CH2Handler.Pulse = 10000;
    0 E5 q5 |  P8 U6 F; z) D
21.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    ( |7 T" I$ W0 j4 @* [
22.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    4 ~- l1 Y* |8 [+ q
23.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    
24. 
    9 X& N; Z$ U4 |3 u5 v5 K
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);
    ' T* u0 g2 q# w2 e, U8 r* k
28. }
    
29. 
    % R2 S- H  R  I  ?! R
30. 
    : r( z9 F( l% C! `2 g" |9 r
31. void TIM2_IRQHandler(void)
    9 j' s  K" m7 w3 ?
32. {
    6 a6 ~0 Z6 o- ?
33.     HAL_TIM_IRQHandler(&TIM2_Handler);
    ( E/ \7 `. W& N
34. }
    
35. 
    ; h8 k& j; Y6 u$ ]2 z, j1 X
36. 
    ; u. z0 P: Q! @7 N8 d( ^- @5 n
37. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
38. {
    7 P% ], q, B8 i
39.     if (htim == (&TIM2_Handler))
    
40.     {
    
41.         printf("enter irq\r\n");
    3 x9 M- H1 `6 h* C& W
42.     }
    6 Z0 @! R3 Z9 Z% t: V3 o, r3 a' Y
43. }
    & _! c8 a- ]8 E! b7 g9 q
44. 
    
45. 
    # ?6 [) H) m. U9 K$ F# P/ P
46. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    
47. {
    . }* I. H, Q9 H! d+ O
48.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
49. 
    1 D, _0 t) L3 K1 u7 E2 x
50.     __HAL_RCC_TIM2_CLK_ENABLE();
    3 h$ `6 T0 o# \% X
51.     __HAL_RCC_GPIOA_CLK_ENABLE();
    
52.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    $ m% U5 |) n2 ~+ I0 C& \8 y+ c% N
53.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    7 N( Z4 P7 K0 j5 t2 q" o- ]
54.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
55.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    " ~, |6 @# _+ d
56.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    ! F, F# S1 v* ^
57.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    # h6 [. w4 w% K3 W
58. }
    

复制代码