基本计时功能
最简单的，定时器嘛，基本的定时器就是定时功能，简单来说就是TIMx->CNT会跟随着输入时钟的脉冲而计数。
2 Y  ?/ ~- m" p" t; y初始化定时器的参数，大家都好理解，因为TIM2的输入时钟是108Mhz，这里进行10800分频，输入频率为10K，重装载值设置为20K，每2秒溢出一次。
在HAL_TIM_Base_Init的执行过程中，会先调用HAL_TIM_Base_MspInit再进行其他参数的配置,即先开时钟。
9 l. K4 v- H1 v$ ]3 ^

1. TIM_HandleTypeDef TIM2_Handler;
   
2. static void MX_TIM2_Init(void)
   / z/ T/ d8 W4 {4 C
3. {
   
4.     TIM2_Handler.Instance = TIM2;
   " N  P/ ?5 N+ Z! V/ r
5.     TIM2_Handler.Init.Prescaler = 10800;
     a2 ]2 |# a& Z- L/ j
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
7.     TIM2_Handler.Init.Period = 20000;
   , y8 ]8 c( [% L% Q& I
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   , @4 F" E7 y* M! j2 Y
9. 
   
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    8 y3 o# {+ i9 E' Q
11.         HAL_TIM_Base_Start(&TIM2_Handler);
    6 D1 G" v( M  N: J0 L$ M  A/ F
12. }
    7 _7 l: M" W- X
13. 
    
14. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    ' @; W  X9 n2 s/ v2 r7 [& U; |6 m
15. {
    ! u7 e# o4 y- `7 Y% X
16.                 __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM3时钟  
    % j( ^- Y; ^* A# \( I
17. }
    / y9 }8 A* `. O# |# v; z* g
18. 
    , F$ o$ k- u! |9 T! k4 e

复制代码

  X; D, k% r: P& b/ E主函数中每秒打印一次定时器的值：
. G4 y  b; \7 A. I' v: Z6 n

1.    while (1)
   6 A2 b( a6 D3 }8 J
2.     {
   & r3 i; s. B; g3 W$ g  Z
3.                 printf("cnt:%d\r\n",TIM2->CNT);
   
4.         delay_ms(1000);
   
5.     }
   

复制代码

显示效果如下：


+ Z3 i$ ]& V& h# Y7 k- N( [
定时器中断
0 y+ ^: _6 B5 w8 R通过HAL_TIM_Base_Start可以开启基本计时功能，但要实现定时器中断功能，就需要开启相应的标志位，即使用HAL_TIM_Base_Start_IT进行定时的开启；
3 [* c% m" B& c4 s7 ~" j在配置定时器之前，除了要开启时钟，还需要先设置中断优先级，和使能中断向量；
在定时器中断TIM2_IRQHandler服务函数中调用HAL库提供的定时器中断处理函数HAL_TIM_IRQHandler，解析到的定时器超时中断会自动跳转到HAL_TIM_PeriodElapsedCallback；
0 h1 p+ y2 ^) }+ A

1. TIM_HandleTypeDef TIM2_Handler;
   0 p  ?) {- z! A, B$ @4 R
2. static void MX_TIM2_Init(void)
   
3. {
   / A. E( N& X: P0 ~9 V4 V
4.     TIM2_Handler.Instance = TIM2;
   
5.     TIM2_Handler.Init.Prescaler = 10800;
   
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   & h7 M* A$ |0 S& g; N+ R
7.     TIM2_Handler.Init.Period = 20000;
   0 G3 g* ~3 Z, x. F
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   . F( ?! I. B3 g8 j- Z
9. 
   ) C( v' d' M, P
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    . S) x# p' i" a' o8 N
11.     //HAL_TIM_Base_Start(&TIM2_Handler);
    ( ^% z0 S8 n" `+ T; \+ k3 j
12.         HAL_TIM_Base_Start_IT(&TIM2_Handler);
    ' D. F+ Z9 e0 Z: C
13. }
    # E1 V3 g5 M* [( X( W& Z9 Z* I
14. 
    ' a% K' c  x7 F: i' d% C1 ?
15. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    
16. {
    
17.     __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM2时钟
    
18.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);  //设置中断优先级，抢占优先级1，子优先级3
    8 l2 T1 A2 ]! L  H) P% v8 d
19.     HAL_NVIC_EnableIRQ(TIM2_IRQn);          //开启ITM2中断
    
20. }
    
21. 
    - G8 c) o; O9 @
22. void TIM2_IRQHandler(void)
    
23. {
    % b9 j' p$ x0 s# D% B
24.     HAL_TIM_IRQHandler(&TIM2_Handler);
    
25. }
    $ @) ^: h  r0 y3 H- V4 [9 _
26. 
    ! j4 H3 u! |0 q; g& D  V, v% x+ p( N
27. 
    2 }! F' h4 w' f" w2 d
28. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
29. {
    
30.     if (htim == (&TIM2_Handler))
    
31.     {
    1 N2 Z- a9 c) K
32.         printf("enter irq\r\n");
    
33.     }
    
34. }
    4 D% d- u6 \* A) r7 Z, s+ e
35. 
    

复制代码

( ^# x; u; [& u. ?* j: i显示效果如下：



PWM输出
硬件PWM输出是不需要使用定时器中断的，但同样需要基本的定时参数配置，初始化也不再是使用HAL_TIM_Base_Init而是使用HAL_TIM_PWM_Init进行初始化了；
配置完定时器为PWM模式，那么相应的输出通道也需要通过HAL_TIM_PWM_ConfigChannel进行配置；
  [$ t5 Q& j- q  P5 J7 f3 s, C- l同样的启动也不是HAL_TIM_Base_Start或者HAL_TIM_Base_Start_IT了，而是HAL_TIM_PWM_Start了；

1. TIM_HandleTypeDef TIM2_Handler;
   
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   
3. static void MX_TIM2_Init(void)
   
4. {
   
5.     TIM2_Handler.Instance = TIM2;
   . H9 v6 C# ?: |- a6 j8 d
6.     TIM2_Handler.Init.Prescaler = 10800;
   
7.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
8.     TIM2_Handler.Init.Period = 20000;
   $ J; }- e' {3 u2 k
9.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   
10.     HAL_TIM_PWM_Init(&TIM2_Handler);
    ) J$ o0 F6 f$ s$ S! d) i0 S) ?. r! @
11. 
    
12.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    
13.     TIM2_CH2Handler.Pulse = 10000;
    
14.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    " ?8 n% J7 y$ _+ a( t' p
15.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    
16.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
      ^2 {  y+ U, h& F
17. 
    , F( m" ?3 Q; Q$ s% T
18.     HAL_TIM_PWM_Start(&TIM2_Handler, TIM_CHANNEL_2); //开启PWM通道2
    " L0 w1 u& L( K# E# O/ B" P  R
19. }
    5 j+ k% G0 u5 F
20. 
    
21. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    % {1 A6 a/ p1 N% T
22. {
    
23.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
24.                
    
25.         __HAL_RCC_TIM2_CLK_ENABLE();           
    
26.     __HAL_RCC_GPIOA_CLK_ENABLE();
    6 w  |3 B: F& J! R
27.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    
28.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    8 c2 _. }& g; n* l8 d
29.     GPIO_InitStruct.Pull = GPIO_NOPULL;
      s+ W1 T  @4 d; w- N
30.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    ) O3 y) |! O# y' U  I
31.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    
32.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    * }4 u; b) n6 ^. B* \
33. }
    

复制代码

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


8 f) W2 ?4 ~$ h$ y
PWM + 定时器溢出中断
我们都知道，PWM模式是在比较值处翻转，在溢出的时候再次翻转，而溢出的时候，我们也是可以产生中断的；所以同一个定时器，在这种定时时长和周期相同的时候，是可以即做硬件PWM输出，又做溢出中断的。
5 @2 O6 @+ I7 q7 u; }这里我们观察一下两种初始化函数：
+ l/ G( w, t5 J8 Q$ ~6 U

1. /**
   0 Y0 C2 p% ~( a( k* P, o( [& h
2.   * @brief  Initializes the TIM Time base Unit according to the specified
   - l" G+ S& o) {4 k9 k( k( D( x
3.   *         parameters in the TIM_HandleTypeDef and create the associated handle.
   # H  o1 L3 G$ D/ v2 a5 o% e
4.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   . N" j: _; Y7 o2 E. Q# R7 ]# d
5.   *                the configuration information for TIM module.
   9 Y1 E& Q0 E- Y# b$ b8 l$ `
6.   * @retval HAL status
   " N  H$ Z+ x" V4 j1 P
7.   */
   
8. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   $ ?5 o  n$ L3 e) v7 c' p
9. {
   # }% F5 q7 T% g3 E% K6 F: u7 X
10.   /* Check the TIM handle allocation */
    
11.   if(htim == NULL)
    
12.   {
    ( U! C) X% Z3 Y2 E6 N& Y2 [
13.     return HAL_ERROR;
    
14.   }
    ) I- F. L* P9 b
15.   
    
16.   /* Check the parameters */
    
17.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    7 E) y! h6 Q6 Q/ r4 l1 L3 n5 l+ R
18.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    
19.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
20.   
    " r# M0 S# I6 \  F' L9 [: G3 c; N
21.   if(htim->State == HAL_TIM_STATE_RESET)
    
22.   {  
    
23.     /* Init the low level hardware : GPIO, CLOCK, NVIC */
    9 \  a* \! H% V, n. d+ P$ P* p5 `
24.     HAL_TIM_Base_MspInit(htim);
    % S6 l) G/ T: I( H# X) C
25.   }
    
26.   
    
27.   /* Set the TIM state */
    4 s$ G: h( o+ `! F$ Q" F! n
28.   htim->State= HAL_TIM_STATE_BUSY;
    ; u1 S  g; n  \0 t4 |$ ?+ b% f
29.   
    
30.   /* Set the Time Base configuration */
    * s, M1 L+ ~  Q6 R' D/ W
31.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    0 n2 [+ B( g* d! R
32.   
    : g+ i4 g  d7 t, \& |) L
33.   /* Initialize the TIM state*/
      L# i$ `7 g7 c3 \+ M6 T1 _
34.   htim->State= HAL_TIM_STATE_READY;
    9 \/ C2 U1 _) g! ~8 [% y
35.   
    5 y; `* ~+ p, k, _7 C/ s
36.   return HAL_OK;
    * r6 C- d2 Y7 F: Y8 R; c# b$ c
37. }
    , \/ H& Y5 y2 i. Z6 p
38. 
    8 M/ `  G  M/ S& |8 L+ }
39. 
    
40. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
    
41. {
    
42.   /* Check the TIM handle allocation */
    8 g! e4 P- ]* j5 K5 h) V* s7 o+ K
43.   if(htim == NULL)
    
44.   {
    
45.     return HAL_ERROR;
    $ \* |, P: q6 i( \
46.   }
    ; ~! [' R* @# l& @* l0 Z; D
47. 
    
48.   /* Check the parameters */
    7 @! |2 d( s6 \, U
49.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    ; b" Y6 r: {% v6 j4 v. `
50.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    ) l, r# K# z; w& k1 @
51.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    : Z+ n4 E. \3 P
52. 
    
53.   if(htim->State == HAL_TIM_STATE_RESET)
    ) T0 D0 |: U& }# ?) h" L
54.   {
    + t, v0 A* ?9 [7 y6 z/ Y& e
55.     /* Allocate lock resource and initialize it */
    
56.     htim->Lock = HAL_UNLOCKED;  
    
57.     /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
    
58.     HAL_TIM_PWM_MspInit(htim);
    
59.   }
    
60. 
    / y, l/ ?8 j  @7 {& q7 I0 C  U
61.   /* Set the TIM state */
    
62.   htim->State= HAL_TIM_STATE_BUSY;  
    
63.   
    
64.   /* Init the base time for the PWM */  
    
65.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
66.    
    " b& V( X, I) P3 J
67.   /* Initialize the TIM state*/
    
68.   htim->State= HAL_TIM_STATE_READY;
    3 e, |1 H  ?2 z6 M, i
69.   
    6 T- C" W, Z5 Z& o% Z/ J4 Q) k
70.   return HAL_OK;
    5 y$ g0 E5 }5 F( A
71. }  
    

复制代码

( M1 C$ u( L8 F两者除了底层的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，后面的一个就得不到执行了。
; F! c; L5 @7 F1 g* y; ]. g再来看启动代码：
' H; p7 n- ^% N7 W+ x* J" K3 l- u

1. /**
   # |  V2 u8 I' w9 E* P
2.   * @brief  Starts the TIM Base generation.
   
3.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   # W/ n: v. ~0 b3 I7 r  a2 ^8 J! u6 L
4.   *                the configuration information for TIM module.
   0 r9 p+ C6 {. Q$ r8 ~( Q
5.   * @retval HAL status
   
6.   */
   ; s6 j5 A! }9 @3 @% T
7. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   
8. {
   
9.   /* Check the parameters */
   ' ^, L4 O2 K5 Z* d" }3 Q
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
11.   
    3 ^, n; m: T( D/ e" ^5 G
12.   /* Set the TIM state */
    
13.   htim->State= HAL_TIM_STATE_BUSY;
    
14.   
    ' x3 e* B; C! k
15.   /* Enable the Peripheral */
    ! p  \; D8 n( c( H5 r2 V: y
16.   __HAL_TIM_ENABLE(htim);
    
17.   
    
18.   /* Change the TIM state*/
    
19.   htim->State= HAL_TIM_STATE_READY;
    
20.   
    
21.   /* Return function status */
      H4 O/ w( j4 `, I' b9 K
22.   return HAL_OK;
    
23. }
    
24. 
    
25. 
    
26. /**
    ' x  z+ z9 U" N6 p
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.
    
30.   * @retval HAL status
    
31.   */
    1 _& u2 v1 N& r5 x3 H
32. HAL_StatusTypeDef HAL_TIM_Base_Start_IT(TIM_HandleTypeDef *htim)
    0 b; b# b) [( |( A: H
33. {
    1 A. Z  g4 U# ^' A" y6 ^, r/ B. ~- Q6 M
34.   /* Check the parameters */
    8 ^+ z  ~# R6 z* Z
35.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    ! S2 {  t: N' w6 _& P
36.   
    , T' V- V, n% F* O# S
37.   /* Enable the TIM Update interrupt */
    
38.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
    
39.       
    1 Z. D: s/ B; s0 A
40.   /* Enable the Peripheral */
    " n1 U! r3 c0 A8 M3 Y& c
41.   __HAL_TIM_ENABLE(htim);
    & L2 z0 q& _9 Q* D) X, o9 M  m' e. g. v
42.       
    
43.   /* Return function status */
    
44.   return HAL_OK;
    ) }9 b* i/ Y- q2 O
45. }
    % G- Y- V( w/ \5 ], O
46. 
    6 x9 S- z- a% A+ N  p! A/ M
47. 
    
48. /**
    
49.   * @brief  Starts the PWM signal generation.
    / c; h; Z0 B$ ]1 g2 j8 E: l% y; A
50.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    & C- ?( o/ f" g9 w" H
51.   *                the configuration information for TIM module.
    
52.   * @param  Channel: TIM Channels to be enabled.
    " n" l" S1 n4 T* [
53.   *          This parameter can be one of the following values:
    
54.   *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
    
55.   *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
    / c. c" J" |+ ^' m
56.   *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
    
57.   *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
    ; l8 G; W$ j) |2 q$ ^( l
58.   * @retval HAL status
    ) d2 r% ?8 D# k% e: j
59.   */
    9 m1 u; t4 g( i$ Q* V- p2 o
60. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
    + J$ T% p9 l9 A
61. {
    
62.   /* Check the parameters */
    
63.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
    ' o# C, L9 v4 [+ o, j, E2 ~
64. 
    
65.   /* Enable the Capture compare channel */
    
66.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
67.   
    ) Z3 B  `" L; Q4 `7 t
68.   if(IS_TIM_ADVANCED_INSTANCE(htim->Instance) != RESET)  
    5 g1 o! ?, n: ]: ]5 O, [
69.   {
    
70.     /* Enable the main output */
    - O! n) M% u# n
71.     __HAL_TIM_MOE_ENABLE(htim);
    
72.   }
    
73.    
    
74.   /* Enable the Peripheral */
    " L. i4 I6 r% D
75.   __HAL_TIM_ENABLE(htim);
    
76.   
    
77.   /* Return function status */
    ! @4 f' C. R% S  x: T, i
78.   return HAL_OK;
    . s( c# a( l. Q/ O& t* K4 ]- N, @
79. }
    

复制代码

) i( k' p5 g- L8 N( Y其中的核心代码分别是：
5 X( M6 a0 h$ |/ B  D% f

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);
   0 i4 S: i  f) w0 J* }; r! ~5 _

复制代码

, c8 s! ?8 u+ ?' `8 @  q那么我们可以不用hal库提供给我们的启动函数，直接写三句话，就实现了定时器中断+PWM功能了。
1 \1 D- j5 {6 c- @2 z. `

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   5 X. g4 g$ v! K' u& N  R' O
2.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
3.   __HAL_TIM_ENABLE(htim);
   

复制代码

完整代码如下：
8 i8 ^  {/ A: O' O! O

1. TIM_HandleTypeDef TIM2_Handler;
   1 U6 w/ a% L, ^! @1 N7 p- V& \/ K
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   
3. 
   
4. 
   
5. static void MX_TIM2_Init(void)
   + w. I/ ~2 G/ B4 n9 F
6. {
   
7.     __HAL_RCC_TIM2_CLK_ENABLE();
   1 K( [' y- w* H$ P
8.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);
   
9.     HAL_NVIC_EnableIRQ(TIM2_IRQn);
   / V2 c9 u7 G9 a2 H/ m) s
10. 
    
11.     TIM2_Handler.Instance = TIM2;
    5 b5 {; M, |, Y$ q# x: C( D
12.     TIM2_Handler.Init.Prescaler = 10800;
    
13.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
    
14.     TIM2_Handler.Init.Period = 20000;
    
15.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    1 @4 g& p+ R/ u( L6 J
16.    
    + }$ P- r: Z7 q& A. |  r
17.     HAL_TIM_PWM_Init(&TIM2_Handler);
    
18. 
    - S7 P6 s! J  U$ N- Y) H
19.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    
20.     TIM2_CH2Handler.Pulse = 10000;
    1 a- D  O, k( T- v: D5 p
21.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    - u0 v& Z; a' [  X
22.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    ( N6 R, |. P+ S+ u$ }/ |4 f
23.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    ! x% `& {# p, d; Z, G
24. 
    
25.     __HAL_TIM_ENABLE_IT(&TIM2_Handler, TIM_IT_UPDATE);
    2 z# Q4 ~: _( U; g/ m
26.     TIM_CCxChannelCmd(TIM2_Handler.Instance, TIM_CHANNEL_2, TIM_CCx_ENABLE);
    
27.     __HAL_TIM_ENABLE(&TIM2_Handler);
    
28. }
    
29. 
    
30. 
    
31. void TIM2_IRQHandler(void)
    
32. {
      _3 Q# }6 ^5 I+ H; n( X  O
33.     HAL_TIM_IRQHandler(&TIM2_Handler);
    % K$ g4 b; J) Y' l
34. }
    : I1 I  [; @9 b( N7 j0 J
35. 
    
36. 
    
37. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
38. {
    
39.     if (htim == (&TIM2_Handler))
    ; @4 k1 {" P# p! h) M" [/ }
40.     {
    ) Z/ C2 D6 v' S# _8 L" S) ?; `3 p
41.         printf("enter irq\r\n");
    
42.     }
    0 g. A3 x$ M5 `
43. }
    ' `/ P6 G" x1 S; f
44. 
    * ]1 K5 G, R  S
45. 
    6 ~. @2 ^, F& R
46. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    
47. {
    
48.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
49. 
    " V; Q0 {0 t/ l  M: e8 D
50.     __HAL_RCC_TIM2_CLK_ENABLE();
    / M) E% W2 @/ B8 V" \9 s
51.     __HAL_RCC_GPIOA_CLK_ENABLE();
    
52.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    1 a; a+ j. ]* H5 ]2 @
53.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
54.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    2 @) v5 v" ]  v/ P' O5 C0 ]5 P* i
55.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
      h. n# s" p, o' S: p7 A* S* F
56.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    0 t* {! C4 K0 B' I' [0 |
57.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
58. }

复制代码

————————————————
版权声明：小盼你最萌哒
7 E! i% O$ y. A2 Y7 W