基本计时功能
1 W4 G! C4 F, Q5 ]最简单的，定时器嘛，基本的定时器就是定时功能，简单来说就是TIMx->CNT会跟随着输入时钟的脉冲而计数。
初始化定时器的参数，大家都好理解，因为TIM2的输入时钟是108Mhz，这里进行10800分频，输入频率为10K，重装载值设置为20K，每2秒溢出一次。
在HAL_TIM_Base_Init的执行过程中，会先调用HAL_TIM_Base_MspInit再进行其他参数的配置,即先开时钟。
9 a9 T/ A, z, Q  i( ~, Q

1. TIM_HandleTypeDef TIM2_Handler;
   
2. static void MX_TIM2_Init(void)
   
3. {
   
4.     TIM2_Handler.Instance = TIM2;
   
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);
    
11.         HAL_TIM_Base_Start(&TIM2_Handler);
    8 w* k5 u% D) q+ C4 N. g6 Y
12. }
    4 w. D: Q: U3 S* i
13. 
    ( ]2 v/ C' l5 Q, z
14. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    ' p4 e/ @) O7 R% W
15. {
    
16.                 __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM3时钟  
    
17. }
    
18. 
    

复制代码

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

1.    while (1)
   " o! @+ U- ]1 Y  _2 s5 T+ J
2.     {
   
3.                 printf("cnt:%d\r\n",TIM2->CNT);
   
4.         delay_ms(1000);
   
5.     }
   1 l+ c; E9 `& b" i1 _2 W6 S

复制代码

显示效果如下：

9 d6 v& c- k0 R6 U

定时器中断
5 v& n& ?& P+ _" O通过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)
   . p9 n. G  c7 U& m- X" r, F
3. {
   
4.     TIM2_Handler.Instance = TIM2;
   
5.     TIM2_Handler.Init.Prescaler = 10800;
   4 |+ j! K& H1 @) x
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);
    
11.     //HAL_TIM_Base_Start(&TIM2_Handler);
    
12.         HAL_TIM_Base_Start_IT(&TIM2_Handler);
    
13. }
    " d2 P4 C$ {# s, \
14. 
    3 O% I9 |5 X" U' o+ P: h
15. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    
16. {
    * m, E% @0 C6 ?* I7 a
17.     __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM2时钟
      J- s* {& n, {% E& a# S
18.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);  //设置中断优先级，抢占优先级1，子优先级3
    4 w- y* E' ~/ F
19.     HAL_NVIC_EnableIRQ(TIM2_IRQn);          //开启ITM2中断
    / G% N7 M; S# M
20. }
    / r2 ~3 }7 q2 R2 d0 u* @; c. b
21. 
    
22. void TIM2_IRQHandler(void)
    
23. {
    
24.     HAL_TIM_IRQHandler(&TIM2_Handler);
    8 ^! e3 c- q! F
25. }
    
26. 
    ; K- i' C2 B3 x8 E+ D
27. 
    8 K. m: t1 |: W/ _
28. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
29. {
    1 U1 G: t/ T' O( ~' _
30.     if (htim == (&TIM2_Handler))
    
31.     {
    % f! k7 f* w6 G: X  ?
32.         printf("enter irq\r\n");
      y7 a& S6 T; y) r6 ~9 K
33.     }
    2 N; {1 N5 \# ~/ O* L5 F0 o: K
34. }
    
35. 
    

复制代码

显示效果如下：
- q& y) {$ t. h% R8 o6 Z
7 k; d8 C) S' z# y/ I% W( X% X

& z- z4 M9 K  W6 H( lPWM输出
硬件PWM输出是不需要使用定时器中断的，但同样需要基本的定时参数配置，初始化也不再是使用HAL_TIM_Base_Init而是使用HAL_TIM_PWM_Init进行初始化了；
配置完定时器为PWM模式，那么相应的输出通道也需要通过HAL_TIM_PWM_ConfigChannel进行配置；
9 b, X. h6 z) t3 `  a同样的启动也不是HAL_TIM_Base_Start或者HAL_TIM_Base_Start_IT了，而是HAL_TIM_PWM_Start了；
  A& x# s4 y8 ^: B8 k9 r$ i; {1 b

1. TIM_HandleTypeDef TIM2_Handler;
   
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   5 M3 l$ h: p9 @9 ?& ]! {
3. static void MX_TIM2_Init(void)
   ) M" E: E$ j' E' R/ ]* `
4. {
   , d# ]  S. C6 Q  ^
5.     TIM2_Handler.Instance = TIM2;
   8 A% @5 d4 V; ]( x% d' I
6.     TIM2_Handler.Init.Prescaler = 10800;
   
7.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   , o1 L( ]' C$ U5 N0 Q4 S1 x3 j
8.     TIM2_Handler.Init.Period = 20000;
   
9.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   " p% a( n+ j# B' P5 ?. H
10.     HAL_TIM_PWM_Init(&TIM2_Handler);
    
11. 
    & s; t2 @) R* q  F
12.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    " w4 O, y. S+ v; R( m. h
13.     TIM2_CH2Handler.Pulse = 10000;
    
14.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    
15.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    - ^% B+ ]* c- D- w# T1 I# `
16.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    : J% w7 d7 Y* M, Q2 K2 {
17. 
    ; F3 i1 v$ ]5 ~7 c: s1 X
18.     HAL_TIM_PWM_Start(&TIM2_Handler, TIM_CHANNEL_2); //开启PWM通道2
    
19. }
    
20. 
    
21. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    $ ^5 B0 T! u1 j3 H$ I5 j, r' c
22. {
    
23.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
24.                
    . [' b3 S: t8 T. b( J: C8 r1 z- C. b
25.         __HAL_RCC_TIM2_CLK_ENABLE();           
    
26.     __HAL_RCC_GPIOA_CLK_ENABLE();
    0 `$ m0 q9 P1 L! h9 ~5 t
27.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    
28.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    & y0 A0 k/ l# d7 d* _, z8 [5 x3 e
29.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    ; @3 F; S) @9 m3 j
30.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    ( p4 s; d3 ~9 k, C8 e  o$ j- L( K
31.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    
32.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
33. }
    

复制代码

通过万用表可以发现PA1口的电压在0和3.3V中大概每秒变动一次（疫情期间在家学习，没有示波器真是太惨了……为了确定确实有PWM波形，只能出此下策了T_T），串口打印数据如下：
, T& I3 @; u1 L/ w
0 U9 T: j; f$ _/ K2 X3 l6 g0 J* e

9 w) P, c. y! f7 O* uPWM + 定时器溢出中断
- G" z' R: @3 b" s- f我们都知道，PWM模式是在比较值处翻转，在溢出的时候再次翻转，而溢出的时候，我们也是可以产生中断的；所以同一个定时器，在这种定时时长和周期相同的时候，是可以即做硬件PWM输出，又做溢出中断的。
+ }6 k2 U" ~& B* Y# i这里我们观察一下两种初始化函数：
( L# J' B6 W8 X( P

1. /**
   8 W* a5 q3 ~' a7 c
2.   * @brief  Initializes the TIM Time base Unit according to the specified
   : Q1 V/ f# E3 c+ U+ |
3.   *         parameters in the TIM_HandleTypeDef and create the associated handle.
   3 q  @' f5 a/ G7 n
4.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   
5.   *                the configuration information for TIM module.
   
6.   * @retval HAL status
   ( F6 W% P' |- X4 X. f3 d6 }) @
7.   */
   
8. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   4 K4 G) N. ]) k
9. {
   % G4 b4 U* }+ p
10.   /* Check the TIM handle allocation */
    1 `/ g* q, \8 k3 I7 a, s
11.   if(htim == NULL)
    ' Z# B6 b1 @6 R9 X
12.   {
    % D4 }  W% |6 I. _9 e0 ]
13.     return HAL_ERROR;
    
14.   }
    ( @; \4 B+ z2 H! o1 _
15.   
    
16.   /* Check the parameters */
    
17.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
18.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    
19.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    0 c7 z, f- c- h4 l) |2 {
20.   
    
21.   if(htim->State == HAL_TIM_STATE_RESET)
    ' E! h) \) {7 F. ?5 s  o
22.   {  
    
23.     /* Init the low level hardware : GPIO, CLOCK, NVIC */
    
24.     HAL_TIM_Base_MspInit(htim);
    
25.   }
    
26.   
    ( f, p( {) Y6 E' n- z
27.   /* Set the TIM state */
    8 O( \, y# L4 o2 o8 w& q3 @
28.   htim->State= HAL_TIM_STATE_BUSY;
    * X1 y. J- p* L1 z( r
29.   
    
30.   /* Set the Time Base configuration */
    
31.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    " ^/ t6 h2 e3 a. f7 P8 c
32.   
    
33.   /* Initialize the TIM state*/
    6 j; X! q5 F% y, s/ {7 q$ o7 l
34.   htim->State= HAL_TIM_STATE_READY;
    ) U  M9 r, L2 n+ j3 n9 ~' r
35.   
    ' V/ |9 r; ^) L5 ]- Y# H8 [
36.   return HAL_OK;
    + u9 L! d. p  s4 Z" k) B) E( e
37. }
    
38. 
    - g5 c+ L- R0 q3 [9 N: J
39. 
    
40. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
      S9 T3 t) K8 A
41. {
    
42.   /* Check the TIM handle allocation */
    
43.   if(htim == NULL)
    
44.   {
    
45.     return HAL_ERROR;
    - J! H  J; I1 Z! u2 n& ?: J
46.   }
    , w  {2 n) {! q
47. 
    
48.   /* Check the parameters */
    ! E9 J! J3 l8 @/ x( G. ^$ J: Y, Q
49.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    " s% C8 `, |( D
50.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    
51.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    - g* g6 \8 t* F2 a' E7 T
52. 
    
53.   if(htim->State == HAL_TIM_STATE_RESET)
    
54.   {
    : C# U4 b. W  @2 S1 ?* M/ v) W' C
55.     /* Allocate lock resource and initialize it */
    1 w" n/ U1 [; p( W
56.     htim->Lock = HAL_UNLOCKED;  
    & q+ z# M. T0 Y; r
57.     /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
    ! `- L& ~# s+ O; x
58.     HAL_TIM_PWM_MspInit(htim);
    
59.   }
    
60. 
    * x7 C' q; }; ^$ }# o' {5 q" a; L4 M
61.   /* Set the TIM state */
    # Z# T4 Y+ F  ?0 U0 b8 u
62.   htim->State= HAL_TIM_STATE_BUSY;  
    " H8 f% Y& t: A9 `. G; P. S: W
63.   
    
64.   /* Init the base time for the PWM */  
    ) x) g( t3 s( V! Z% p. g! i. {0 Z0 P
65.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    7 d3 b: }% l2 ^+ H1 A
66.    
    
67.   /* Initialize the TIM state*/
    + L) G% C9 e7 Z( t6 M) l  _! V1 I
68.   htim->State= HAL_TIM_STATE_READY;
    
69.   
    & I" Y% T  q1 Q$ Y7 {% k
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，后面的一个就得不到执行了。
再来看启动代码：

1. /**
   : A0 _( J1 J5 M3 r9 E
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.
     C) n9 `/ N) E. T+ T
5.   * @retval HAL status
   " k6 h! f& ?9 ]2 w& a  l$ G
6.   */
   
7. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   1 p9 z! e7 a2 U
8. {
   
9.   /* Check the parameters */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    . a4 Y+ a5 Z: Q& r9 P: a
11.   
    ) g4 }* v$ _: U8 H; M* m9 C$ }
12.   /* Set the TIM state */
    , Z6 c1 h8 N, e- X. a9 v
13.   htim->State= HAL_TIM_STATE_BUSY;
    
14.   
    , I7 r1 y3 T  n+ k8 |& s8 x' o
15.   /* Enable the Peripheral */
    
16.   __HAL_TIM_ENABLE(htim);
    + I' U* x1 R6 r' {5 a
17.   
    
18.   /* Change the TIM state*/
    
19.   htim->State= HAL_TIM_STATE_READY;
    4 ~' l- X5 W0 f# ~% |1 W
20.   
    
21.   /* Return function status */
    
22.   return HAL_OK;
    
23. }
    
24. 
    
25. 
    # o! b* I# m7 P
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.
    7 q2 l* I8 [6 L% ?
30.   * @retval HAL status
    / M/ a7 K/ h8 u4 ~  |( a
31.   */
    5 o; z. B) i9 a2 n. p, h+ G
32. HAL_StatusTypeDef HAL_TIM_Base_Start_IT(TIM_HandleTypeDef *htim)
    ( j+ L5 A4 X) S2 {  l
33. {
    
34.   /* Check the parameters */
    
35.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
36.   
    ! S9 Y- F; G/ O, h* Y3 w
37.   /* Enable the TIM Update interrupt */
    ; i1 |) e: @0 P7 F$ _6 I7 W
38.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
    , p$ M3 H' v$ M2 ]0 \4 A' p
39.       
    
40.   /* Enable the Peripheral */
    * I5 a$ A, |" h+ @  f- H* X- R
41.   __HAL_TIM_ENABLE(htim);
    
42.       
    
43.   /* Return function status */
    
44.   return HAL_OK;
    ! D( B9 A8 t# X1 ~% v
45. }
    
46. 
    
47. 
    
48. /**
    
49.   * @brief  Starts the PWM signal generation.
    
50.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    ( a8 u7 R0 b) d! a' y7 v
51.   *                the configuration information for TIM module.
    
52.   * @param  Channel: TIM Channels to be enabled.
    $ R1 o! I" p) F3 H) t+ l
53.   *          This parameter can be one of the following values:
    1 ?0 [$ O! o- O  ^, R
54.   *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
    " b, a$ k$ i. R6 j5 l7 f% x2 u
55.   *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
    
56.   *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
    + \4 y2 a' ^1 o0 b  E# f2 \
57.   *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
    
58.   * @retval HAL status
    
59.   */
    ' G5 l; l& }3 @7 j8 a; g6 x
60. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
    . D5 A* q- l0 y1 g4 m) k* Z$ Q$ g
61. {
    ) A: {! N( B- u6 W7 F% f
62.   /* Check the parameters */
    4 M+ [* p0 k0 ?2 C  ?: Y
63.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
    9 x- v( h, w! Z1 j2 s2 {
64. 
    
65.   /* Enable the Capture compare channel */
    3 |9 J. S5 a: }
66.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
67.   
    0 C: w  c) y$ v2 L! S3 o* W3 u
68.   if(IS_TIM_ADVANCED_INSTANCE(htim->Instance) != RESET)  
    7 |5 X* \) R" B6 W% C
69.   {
    
70.     /* Enable the main output */
    
71.     __HAL_TIM_MOE_ENABLE(htim);
    ( T' k/ z  T- ~% Q
72.   }
    ! i: B0 H* X4 t$ e
73.    
    ) U! o/ r% e' S, a
74.   /* Enable the Peripheral */
    " C, V9 O; J3 z7 C2 m, E
75.   __HAL_TIM_ENABLE(htim);
    
76.   
    
77.   /* Return function status */
    
78.   return HAL_OK;
    ! Z' m9 R0 `3 N+ J9 l1 x6 m
79. }
    

复制代码

其中的核心代码分别是：
% o: C( \8 e: A/ V7 G. Z6 C( i

1. __HAL_TIM_ENABLE(htim);
   : W2 f; m+ Q8 N

复制代码

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   5 X; z" T0 t: G( v& z  q' |
2.   __HAL_TIM_ENABLE(htim);
   & H+ |- @  G9 m7 }- Z2 B

复制代码

1.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
2.   __HAL_TIM_ENABLE(htim);
   ( y/ e3 u7 w; Q% G

复制代码

  H& i$ Q2 j. T2 V0 X那么我们可以不用hal库提供给我们的启动函数，直接写三句话，就实现了定时器中断+PWM功能了。
7 [3 {5 g! w7 g

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   3 [8 M+ [/ p4 h* ?
2.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
3.   __HAL_TIM_ENABLE(htim);
   

复制代码

& r$ _' N* k; P完整代码如下：
& M5 {1 I7 D4 [/ R4 X/ e

1. TIM_HandleTypeDef TIM2_Handler;
   # N( q5 K! w: X6 M) C: B
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   ( m- G) _* p# a- y" @
3. 
   
4. 
   0 p: ~1 d5 w/ |; J$ K
5. static void MX_TIM2_Init(void)
   
6. {
   
7.     __HAL_RCC_TIM2_CLK_ENABLE();
   
8.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);
   
9.     HAL_NVIC_EnableIRQ(TIM2_IRQn);
   - B3 B) Z) p, g% E! e
10. 
    4 b/ f" @4 L% b5 k& y; o/ R* j1 x5 U
11.     TIM2_Handler.Instance = TIM2;
    & X* B4 l1 `! T0 X  C; F7 _7 `. M, Q
12.     TIM2_Handler.Init.Prescaler = 10800;
    ! J" I8 R$ @: B2 U: @
13.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
    2 X$ n& J! w9 O4 }% E
14.     TIM2_Handler.Init.Period = 20000;
    0 a& H' \4 P5 @
15.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    
16.    
    
17.     HAL_TIM_PWM_Init(&TIM2_Handler);
    
18. 
    
19.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
      n# \* G. D/ S
20.     TIM2_CH2Handler.Pulse = 10000;
    
21.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    , B$ r6 ~: O  {4 l2 b6 O/ V- \9 k, G0 g
22.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    ! {) v0 t/ q' j6 I7 w  ~
23.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    
24. 
    
25.     __HAL_TIM_ENABLE_IT(&TIM2_Handler, TIM_IT_UPDATE);
    # s1 P- E  t2 @  R
26.     TIM_CCxChannelCmd(TIM2_Handler.Instance, TIM_CHANNEL_2, TIM_CCx_ENABLE);
    6 E% G5 O4 j5 g- l% F* o- b
27.     __HAL_TIM_ENABLE(&TIM2_Handler);
    6 g2 Z; d, R& m+ N1 d
28. }
    
29. 
    7 v; k! r4 m; x% f! B" c2 e; c
30. 
    - s$ o7 T" F. t! ]
31. void TIM2_IRQHandler(void)
    
32. {
    . x3 J7 B! Q6 S/ @9 a" C
33.     HAL_TIM_IRQHandler(&TIM2_Handler);
    
34. }
    
35. 
    
36. 
    
37. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
38. {
    4 d1 d  V; `9 V* B
39.     if (htim == (&TIM2_Handler))
    " U- s: B% ^/ N  z7 d  x$ u
40.     {
    . ]  T/ z, \5 p9 N
41.         printf("enter irq\r\n");
    
42.     }
    ) z8 Y' U0 L; g
43. }
    
44. 
    
45. 
    2 }2 \( y5 q: d" [
46. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    
47. {
    
48.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    / I* Y4 k0 |5 E* o( j& p
49. 
    
50.     __HAL_RCC_TIM2_CLK_ENABLE();
    0 k4 r$ j7 e' {1 G( l+ U. F, R
51.     __HAL_RCC_GPIOA_CLK_ENABLE();
    2 ]3 u, X3 U( m
52.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    
53.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    * r- r  g7 U: t# W, I
54.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
55.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
56.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    6 J; `' X# J; E7 F. b2 C3 c
57.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
58. }

复制代码

————————————————
版权声明：小盼你最萌哒
  w$ M5 _- K2 D
7 m  O/ C6 d- _/ d6 R: u4 Y+ l0 K