基本计时功能
6 s' ?+ O4 d2 k  }- V# H最简单的，定时器嘛，基本的定时器就是定时功能，简单来说就是TIMx->CNT会跟随着输入时钟的脉冲而计数。
初始化定时器的参数，大家都好理解，因为TIM2的输入时钟是108Mhz，这里进行10800分频，输入频率为10K，重装载值设置为20K，每2秒溢出一次。
在HAL_TIM_Base_Init的执行过程中，会先调用HAL_TIM_Base_MspInit再进行其他参数的配置,即先开时钟。
: s' M* Z+ u8 H$ T

1. TIM_HandleTypeDef TIM2_Handler;
   & ~# I7 ?, p3 q- \' a' w
2. static void MX_TIM2_Init(void)
   
3. {
   
4.     TIM2_Handler.Instance = TIM2;
   & J( _+ u2 C9 \& `5 M3 z
5.     TIM2_Handler.Init.Prescaler = 10800;
   
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   ' d. f5 |2 I  N( }+ V# e1 N
7.     TIM2_Handler.Init.Period = 20000;
   
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   
9. 
   1 u) U7 [# n! ^# \. O
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    
11.         HAL_TIM_Base_Start(&TIM2_Handler);
    
12. }
    ! _8 T  Y1 p% c; l- H  R4 x
13. 
    
14. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    
15. {
    
16.                 __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM3时钟  
    ! W) `4 w3 O; J$ ~) I( d
17. }
    
18. 
    

复制代码

主函数中每秒打印一次定时器的值：
+ i7 l4 @& ]/ G' `2 Q$ _" p

1.    while (1)
   
2.     {
   
3.                 printf("cnt:%d\r\n",TIM2->CNT);
   
4.         delay_ms(1000);
   7 ?1 r9 F  b- ?$ j
5.     }
   

复制代码

显示效果如下：


8 q: X6 a1 W" W, m' w0 h7 ]1 F- n
定时器中断
通过HAL_TIM_Base_Start可以开启基本计时功能，但要实现定时器中断功能，就需要开启相应的标志位，即使用HAL_TIM_Base_Start_IT进行定时的开启；
在配置定时器之前，除了要开启时钟，还需要先设置中断优先级，和使能中断向量；
在定时器中断TIM2_IRQHandler服务函数中调用HAL库提供的定时器中断处理函数HAL_TIM_IRQHandler，解析到的定时器超时中断会自动跳转到HAL_TIM_PeriodElapsedCallback；
$ E1 r; b' k' ?5 ?7 d

1. TIM_HandleTypeDef TIM2_Handler;
   1 Q" c9 _4 D3 k. _+ \& q' V9 _
2. static void MX_TIM2_Init(void)
   % l& K* T' S# {# i& k( K& w
3. {
   . Q+ V3 d5 F. D$ ?
4.     TIM2_Handler.Instance = TIM2;
   
5.     TIM2_Handler.Init.Prescaler = 10800;
   
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   ( R& D0 a8 d" w
7.     TIM2_Handler.Init.Period = 20000;
   
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   8 I; O/ |% v7 Z
9. 
   
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    3 ~; f. i, f+ J. J
11.     //HAL_TIM_Base_Start(&TIM2_Handler);
    
12.         HAL_TIM_Base_Start_IT(&TIM2_Handler);
    ' A' _0 a; I9 `$ O) O4 V
13. }
    7 _# T3 E8 G0 g1 b& T9 p  ?. q
14. 
    2 G% W! n% E; \" j: O7 e* P
15. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    4 m. p& Y1 S& V0 d8 Y7 ]
16. {
    
17.     __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM2时钟
    
18.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);  //设置中断优先级，抢占优先级1，子优先级3
    $ k7 \$ d5 W% E+ z4 j. t
19.     HAL_NVIC_EnableIRQ(TIM2_IRQn);          //开启ITM2中断
    
20. }
    2 t7 L) {1 \' k6 k1 G
21. 
    
22. void TIM2_IRQHandler(void)
    
23. {
    
24.     HAL_TIM_IRQHandler(&TIM2_Handler);
    3 p: Z3 i" I+ r) L6 F0 s$ G
25. }
    
26. 
    ) i3 f: {+ J+ K7 L7 H
27. 
    , c3 B3 r! b) l) ~5 L
28. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
29. {
    ; X; W: y7 P5 g! ^
30.     if (htim == (&TIM2_Handler))
    
31.     {
    $ S$ v( E8 ^+ k/ c* K" Y
32.         printf("enter irq\r\n");
    ' S6 r& T5 F+ O8 J
33.     }
    
34. }
    
35. 
    # p8 }2 E8 Q' B$ r& P' [- f- E6 |9 R

复制代码

/ ?  I: n4 w+ n7 J- \* Q& d$ ?) ?. o显示效果如下：
( \& Z. Z2 b$ i# u% v

  S' L+ I# A' T: G8 U
PWM输出
硬件PWM输出是不需要使用定时器中断的，但同样需要基本的定时参数配置，初始化也不再是使用HAL_TIM_Base_Init而是使用HAL_TIM_PWM_Init进行初始化了；
0 i# Z" {5 N/ P) `4 S* c配置完定时器为PWM模式，那么相应的输出通道也需要通过HAL_TIM_PWM_ConfigChannel进行配置；
0 a. `( _; ~2 s( C: o/ O* ^同样的启动也不是HAL_TIM_Base_Start或者HAL_TIM_Base_Start_IT了，而是HAL_TIM_PWM_Start了；

1. TIM_HandleTypeDef TIM2_Handler;
   8 i- n/ \7 |$ x' b
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   " A: ?3 Q! H7 `
3. static void MX_TIM2_Init(void)
   ( G9 {9 I5 I" n. w/ _# I( P( _
4. {
   
5.     TIM2_Handler.Instance = TIM2;
   
6.     TIM2_Handler.Init.Prescaler = 10800;
   
7.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
8.     TIM2_Handler.Init.Period = 20000;
   + r6 m& p1 p/ E( [" G! ^
9.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   
10.     HAL_TIM_PWM_Init(&TIM2_Handler);
    
11. 
    
12.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    " X; v0 L/ V7 L
13.     TIM2_CH2Handler.Pulse = 10000;
    
14.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    
15.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    
16.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    
17. 
    , |; G9 L0 J/ r. u2 \
18.     HAL_TIM_PWM_Start(&TIM2_Handler, TIM_CHANNEL_2); //开启PWM通道2
    , J- b7 T9 S' x/ U  \" z  j
19. }
    * j7 R  v. w, Z% j! m0 f- [% d& B
20. 
    
21. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    
22. {
    
23.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    5 q1 c5 m2 c" c! S# N; b5 s
24.                
    1 T3 q' d& \6 k/ H0 m6 y! m5 k
25.         __HAL_RCC_TIM2_CLK_ENABLE();           
    
26.     __HAL_RCC_GPIOA_CLK_ENABLE();
    1 T9 C: N! v+ k5 s; j/ k
27.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    . ?# d: _! o% c4 Z/ E
28.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    ; W8 `; k4 n9 `3 R8 P
29.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    % b/ z: Y: {9 B; U7 Q* q! i% u
30.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
31.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    ; L8 C, Q( \4 o" S  M/ z/ t* |( o
32.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    ) s, g1 x9 D/ q. u
33. }
    

复制代码

通过万用表可以发现PA1口的电压在0和3.3V中大概每秒变动一次（疫情期间在家学习，没有示波器真是太惨了……为了确定确实有PWM波形，只能出此下策了T_T），串口打印数据如下：
2 m9 d. U: ], t+ i( q' V" }3 _

+ D7 v; \4 c; S% W0 M; I6 Q4 P# i
  {8 R. B- D7 q2 s# m# Y8 _% hPWM + 定时器溢出中断
我们都知道，PWM模式是在比较值处翻转，在溢出的时候再次翻转，而溢出的时候，我们也是可以产生中断的；所以同一个定时器，在这种定时时长和周期相同的时候，是可以即做硬件PWM输出，又做溢出中断的。
1 S5 ^5 W" d, h# Z这里我们观察一下两种初始化函数：

1. /**
   
2.   * @brief  Initializes the TIM Time base Unit according to the specified
   8 j. z& {/ `, G* O
3.   *         parameters in the TIM_HandleTypeDef and create the associated handle.
   
4.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   1 P) m8 D5 K) q0 j) H4 l
5.   *                the configuration information for TIM module.
   
6.   * @retval HAL status
   ; q0 K: K2 S: n
7.   */
   + w, O% l" C" G7 [5 r0 ?! |
8. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   
9. {
   * Q( Z/ ~& |; A
10.   /* Check the TIM handle allocation */
    6 e' S* S8 R: O# D4 C$ N
11.   if(htim == NULL)
    " h8 n1 J3 s& D/ V+ T  J9 B% C
12.   {
    * @+ b( k7 j) s! J- m
13.     return HAL_ERROR;
    ) U# p6 j1 K) v! W
14.   }
    , I) W3 p0 J9 D
15.   
    
16.   /* Check the parameters */
    
17.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    $ {; ~3 t- ]6 R4 `
18.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    # j: u7 E/ `6 I2 m" O: I
19.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
20.   
    8 G( Q& U) h6 l2 d% h
21.   if(htim->State == HAL_TIM_STATE_RESET)
    0 u5 U* ]5 @! W
22.   {  
    
23.     /* Init the low level hardware : GPIO, CLOCK, NVIC */
    
24.     HAL_TIM_Base_MspInit(htim);
    3 e( ~. b" D; E+ Y  S
25.   }
    
26.   
    
27.   /* Set the TIM state */
    
28.   htim->State= HAL_TIM_STATE_BUSY;
    - m, U- A0 j% w7 N* e8 C( n( K% v6 ^
29.   
    ; r: b$ y6 j5 j( P2 B8 z# r
30.   /* Set the Time Base configuration */
    0 v: d( m3 }$ T( o  L& Z
31.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    0 S3 ]) g% p/ _0 I  K- I
32.   
    
33.   /* Initialize the TIM state*/
    
34.   htim->State= HAL_TIM_STATE_READY;
    2 b% Z, s8 w$ v+ ^0 m; R, \
35.   
    ( k9 w; B! W4 ~& P; g$ ?. i
36.   return HAL_OK;
    
37. }
    . o* C( ~4 b( m0 g
38. 
    
39. 
    
40. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
    - i3 q# O1 T3 w
41. {
    1 K5 S3 |: M' c5 O0 h$ m1 }
42.   /* Check the TIM handle allocation */
    ) Y6 q8 Y# ]: ^" t$ I1 ]) S7 R
43.   if(htim == NULL)
    
44.   {
    
45.     return HAL_ERROR;
    " u; J# ^& }' o1 q
46.   }
    
47. 
    
48.   /* Check the parameters */
    
49.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    1 k" p9 M' u! k& G2 U8 ~7 m( K" J
50.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    5 W$ g% b$ v8 y2 _3 W; Z7 q7 t
51.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    + B) e) z, u# J  J, a
52. 
    ( A: Y8 h' ]* [( g% V! o
53.   if(htim->State == HAL_TIM_STATE_RESET)
    % v% m- @# W) D
54.   {
    
55.     /* Allocate lock resource and initialize it */
    
56.     htim->Lock = HAL_UNLOCKED;  
    2 U/ o& |1 ]2 ], ~9 @, i" }
57.     /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
    
58.     HAL_TIM_PWM_MspInit(htim);
    * G1 p" X, f' j" G, j
59.   }
    2 R3 l% l- v% \1 {, r
60. 
    
61.   /* Set the TIM state */
    ( u: N+ B6 U$ G
62.   htim->State= HAL_TIM_STATE_BUSY;  
    6 y" s& S( {6 M. E1 S
63.   
    
64.   /* Init the base time for the PWM */  
    
65.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    ! E5 @# Z# m/ x1 L; C
66.    
    - C6 y4 \5 b  W" o0 @7 Q
67.   /* Initialize the TIM state*/
    5 X" C% ?* K- V" P2 B6 a! u& Y: G
68.   htim->State= HAL_TIM_STATE_READY;
    
69.   
    
70.   return HAL_OK;
    # G0 ~/ X5 X6 y3 ]8 D
71. }  
    $ B$ S/ N; {" _. N* m" h# H

复制代码

两者除了底层的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，后面的一个就得不到执行了。
  r3 K2 D* E  \/ y- p; J2 B再来看启动代码：
7 z8 O% u: R5 m# s: l+ h

1. /**
   
2.   * @brief  Starts the TIM Base generation.
   3 Q9 t* ]% W  G. W) n, Z
3.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   7 p- x$ G  u  f0 [4 h7 T, J. c$ S
4.   *                the configuration information for TIM module.
   
5.   * @retval HAL status
   - l) `$ n/ N9 x8 q0 A2 j# f
6.   */
   $ Y, F' E* S" m" `6 Y
7. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   
8. {
   % z) ]: g8 w  I" |
9.   /* Check the parameters */
   ( k# S, B9 o: ^7 U7 z3 H  @* w4 t
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    + E; n1 T' i  [2 [" _$ s. ~+ Y
11.   
    2 ~9 X4 M, L9 B9 f1 M! m3 E
12.   /* Set the TIM state */
    3 }' J' X3 o8 U% i& F4 W6 Y
13.   htim->State= HAL_TIM_STATE_BUSY;
    " Y5 k: T6 a7 z& f2 v2 {8 o
14.   
    8 Q: r* x2 p1 r4 G& g; O
15.   /* Enable the Peripheral */
    
16.   __HAL_TIM_ENABLE(htim);
    
17.   
    
18.   /* Change the TIM state*/
    
19.   htim->State= HAL_TIM_STATE_READY;
    & c9 ]! o/ `) C9 B
20.   
    % I& _/ y: f/ Z$ q
21.   /* Return function status */
    - E' h1 G8 G* O3 r
22.   return HAL_OK;
    4 ?% S# x5 R. O, K6 n
23. }
    0 E" k' Y; P* }. Q. d
24. 
    
25. 
    / U: I( D9 ?8 b. D0 t
26. /**
    
27.   * @brief  Starts the TIM Base generation in interrupt mode.
    
28.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    , g, L  |% `$ ^, z1 g
29.   *                the configuration information for TIM module.
    ; C) Q# G) F! F2 z+ _6 {
30.   * @retval HAL status
    # B# j6 }7 {8 [
31.   */
    5 ]% [8 e+ R8 |0 H  L. W9 F6 r
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.   
    " E: D6 X5 o3 C* E
37.   /* Enable the TIM Update interrupt */
    
38.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
    # c4 [4 \: i' v  [! Q( L' \* r: h6 ?
39.       
    6 l8 v8 Q5 V9 O% T8 T5 w& _
40.   /* Enable the Peripheral */
    
41.   __HAL_TIM_ENABLE(htim);
    9 v1 [* u: L( q' Y
42.       
    
43.   /* Return function status */
    $ _! M* B6 x3 Q' v. R$ j# N
44.   return HAL_OK;
    ; E( K  S3 ^1 G: O# [$ {% l& G
45. }
    7 c4 e( ]( m+ M2 p
46. 
    1 o- K2 x  u$ n6 R' p1 Y
47. 
      I( b- j! x+ p2 w+ r; L  P
48. /**
    
49.   * @brief  Starts the PWM signal generation.
    ) }+ T* I7 s2 u$ [9 ~  c
50.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    % |/ w2 }! J6 V; Q( ]& e
51.   *                the configuration information for TIM module.
    
52.   * @param  Channel: TIM Channels to be enabled.
    $ E" `0 |' |: j" F' c: s0 G
53.   *          This parameter can be one of the following values:
    8 p% u, }3 N, V0 R" o) q
54.   *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
    $ p+ o; a2 |' `# b! M) S
55.   *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
    
56.   *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
    ) h# A- R/ F' d" p  a: v! i
57.   *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
    4 ?$ y0 w' k5 j9 W% ]2 z1 j7 W" _; r
58.   * @retval HAL status
    2 W" [1 e, t4 `
59.   */
    
60. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
    
61. {
    6 A. Y. M5 n% P" q2 W7 ~
62.   /* Check the parameters */
    " j- l1 h, }5 f! {; }$ w2 W5 @: q
63.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
      r) k# [; N# G8 g
64. 
    
65.   /* Enable the Capture compare channel */
    7 Z* K& U, {; Q( W. R: N8 l
66.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
67.   
    
68.   if(IS_TIM_ADVANCED_INSTANCE(htim->Instance) != RESET)  
    / u4 ^+ m7 h; X2 r! f, m# d2 V6 m
69.   {
    
70.     /* Enable the main output */
    
71.     __HAL_TIM_MOE_ENABLE(htim);
    
72.   }
    ; n$ D) z* Y! h7 S
73.    
    + W1 E8 D2 z  y% f$ y
74.   /* Enable the Peripheral */
    9 p* n% h7 ]( B" m+ x: n  r
75.   __HAL_TIM_ENABLE(htim);
    
76.   
    
77.   /* Return function status */
    
78.   return HAL_OK;
    
79. }
    

复制代码

其中的核心代码分别是：
, M, v$ k; D+ q5 i  L

1. __HAL_TIM_ENABLE(htim);
   

复制代码

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   8 w: L" L7 G+ r9 \& G2 K
2.   __HAL_TIM_ENABLE(htim);
   . S: }# s3 T* p$ N& _8 z/ A+ C

复制代码

1.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
2.   __HAL_TIM_ENABLE(htim);
     c" t! N5 J7 B: }5 U

复制代码

! f0 ~3 F( y9 ^1 X, i那么我们可以不用hal库提供给我们的启动函数，直接写三句话，就实现了定时器中断+PWM功能了。
' k4 K5 {! H& d( e5 |  E

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   
2.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   * Q6 A8 Y' {7 C9 L
3.   __HAL_TIM_ENABLE(htim);
   

复制代码

完整代码如下：

1. TIM_HandleTypeDef TIM2_Handler;
   
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   
3. 
   
4. 
   $ c" Q; ^" L& I/ y- F4 K5 S
5. static void MX_TIM2_Init(void)
   $ F0 A2 Y2 S  g
6. {
   
7.     __HAL_RCC_TIM2_CLK_ENABLE();
   
8.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);
   
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;
    & O" S# C8 F3 z& U
15.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    
16.    
    3 k9 o# g0 |' `9 s9 U1 P# L
17.     HAL_TIM_PWM_Init(&TIM2_Handler);
    # W$ E7 R3 H, c1 q6 N
18. 
    
19.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    - G3 Q% K9 u2 F! |, r% S
20.     TIM2_CH2Handler.Pulse = 10000;
    
21.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    
22.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    . ~" ^2 l- @1 z' J5 W: @
23.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    , _" h) G; q% h- W6 S
24. 
    
25.     __HAL_TIM_ENABLE_IT(&TIM2_Handler, TIM_IT_UPDATE);
    8 T* ]& n* L% u) c
26.     TIM_CCxChannelCmd(TIM2_Handler.Instance, TIM_CHANNEL_2, TIM_CCx_ENABLE);
    
27.     __HAL_TIM_ENABLE(&TIM2_Handler);
    # ?, Q: T' ^4 f4 N8 q* X" s
28. }
    
29. 
    
30. 
    
31. void TIM2_IRQHandler(void)
    ! F! N8 Q/ ]+ E' b! l5 K
32. {
    1 ?& }1 a+ v* v5 X6 W) ]
33.     HAL_TIM_IRQHandler(&TIM2_Handler);
    4 Y* V, i% D, M! F8 G) O6 _0 d
34. }
    7 n" a! B4 Y6 a0 a) M( v
35. 
    
36. 
    
37. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    4 f, }9 G  j7 b. s3 F
38. {
    
39.     if (htim == (&TIM2_Handler))
    
40.     {
    8 g# d. F  T6 g0 Y( B/ ^
41.         printf("enter irq\r\n");
    . V: x8 z6 {) C' P1 f
42.     }
    
43. }
    
44. 
    
45. 
    8 D0 Z! M) y+ ^9 W" ^
46. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    # _, D) I  J  u& K/ q& b/ d) i
47. {
    
48.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
49. 
    
50.     __HAL_RCC_TIM2_CLK_ENABLE();
    
51.     __HAL_RCC_GPIOA_CLK_ENABLE();
    . ~( |# G- q" B8 a& ^
52.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    
53.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    ' S1 C' ^6 H% a9 j. x
54.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
55.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    * a- ^$ o2 s. L6 P' ~
56.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    
57.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
58. }

复制代码

————————————————
版权声明：小盼你最萌哒


! M% w3 O! b) P% ^4 R9 S4 Q