基本计时功能
1 y; N5 Y: @8 Y# w+ w最简单的，定时器嘛，基本的定时器就是定时功能，简单来说就是TIMx->CNT会跟随着输入时钟的脉冲而计数。
' L9 x9 {+ h- O初始化定时器的参数，大家都好理解，因为TIM2的输入时钟是108Mhz，这里进行10800分频，输入频率为10K，重装载值设置为20K，每2秒溢出一次。
  q8 Y# S8 y/ Y在HAL_TIM_Base_Init的执行过程中，会先调用HAL_TIM_Base_MspInit再进行其他参数的配置,即先开时钟。

1. TIM_HandleTypeDef TIM2_Handler;
   
2. static void MX_TIM2_Init(void)
   
3. {
   
4.     TIM2_Handler.Instance = TIM2;
   . q: D5 h/ ?, E5 w& U
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;
   * V/ A# O. N$ g. K, S7 [
9. 
   5 Q$ `' D# [$ m4 h5 r8 f/ R8 V
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    , k# k# c  _3 t1 N
11.         HAL_TIM_Base_Start(&TIM2_Handler);
    0 n( C" Y2 n  _' X
12. }
    
13. 
    
14. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    * U9 c: c" P$ \$ {; j8 o% V
15. {
    
16.                 __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM3时钟  
    " z* b8 w1 u  F
17. }
    
18. 
    : E, t2 k7 ]; K$ A! I

复制代码

3 a: h4 L' i2 G8 O. g9 b3 G主函数中每秒打印一次定时器的值：

1.    while (1)
   + x" F0 A, c, O; R; ^9 m1 L) U$ e
2.     {
   
3.                 printf("cnt:%d\r\n",TIM2->CNT);
   4 b5 b2 }) U* [: P
4.         delay_ms(1000);
   
5.     }
   

复制代码

显示效果如下：

0 Z7 @5 X& \' X& W9 M/ \
6 k& |, ~8 u  I, H
定时器中断
& U$ L8 V# G- C! b) A通过HAL_TIM_Base_Start可以开启基本计时功能，但要实现定时器中断功能，就需要开启相应的标志位，即使用HAL_TIM_Base_Start_IT进行定时的开启；
在配置定时器之前，除了要开启时钟，还需要先设置中断优先级，和使能中断向量；
6 T( r4 F  Q8 {! K, P* i在定时器中断TIM2_IRQHandler服务函数中调用HAL库提供的定时器中断处理函数HAL_TIM_IRQHandler，解析到的定时器超时中断会自动跳转到HAL_TIM_PeriodElapsedCallback；
) R; p. ~% l3 u! _& D

1. TIM_HandleTypeDef TIM2_Handler;
   
2. static void MX_TIM2_Init(void)
   
3. {
   
4.     TIM2_Handler.Instance = TIM2;
   8 `0 @3 l' n8 a+ ^( ~$ _
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. 
   0 c6 ?; ^8 _" n! s- s& R& ]
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    
11.     //HAL_TIM_Base_Start(&TIM2_Handler);
    * @4 Z1 }! R1 B1 F2 z$ p/ d
12.         HAL_TIM_Base_Start_IT(&TIM2_Handler);
    
13. }
    4 C/ l; L# ^: d" R$ U4 R1 |+ X
14. 
    % u9 S- h0 p3 q, q; J5 D: P6 v% o
15. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    ! m  |& A1 O& {* g0 e
16. {
    
17.     __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM2时钟
    
18.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);  //设置中断优先级，抢占优先级1，子优先级3
    3 j( s# C" Z" k( v- A/ U4 n  I- A$ u
19.     HAL_NVIC_EnableIRQ(TIM2_IRQn);          //开启ITM2中断
    
20. }
    % g' b. Z( U$ x' P( n
21. 
    
22. void TIM2_IRQHandler(void)
    
23. {
    / o/ q# W5 K8 F
24.     HAL_TIM_IRQHandler(&TIM2_Handler);
    5 |# t* p1 ]' R, Q
25. }
    , a, K6 {5 c4 e$ N- L4 v6 o. m7 y4 U
26. 
    ' P) o$ c$ t% i2 g
27. 
    : `+ j5 y) T  ~( `/ p2 ^% S
28. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    ! S2 @9 Z9 u2 h" t
29. {
    % K$ O( }9 _" F/ y! o
30.     if (htim == (&TIM2_Handler))
    
31.     {
    
32.         printf("enter irq\r\n");
    % ]3 V. l% A' y3 T" N# N
33.     }
    6 u, l, d0 x. o2 i' F+ i
34. }
    
35. 
    

复制代码

  U: t  S5 z8 [) u* s0 O' g显示效果如下：
' y) K+ X; I1 h5 T0 f
) n5 r) {# m) F

  T2 @& T, p! {0 l/ u5 j/ i3 n; V% w9 \PWM输出
硬件PWM输出是不需要使用定时器中断的，但同样需要基本的定时参数配置，初始化也不再是使用HAL_TIM_Base_Init而是使用HAL_TIM_PWM_Init进行初始化了；
" s7 I( j; J  T9 K& a7 H配置完定时器为PWM模式，那么相应的输出通道也需要通过HAL_TIM_PWM_ConfigChannel进行配置；
; n0 S' i2 J; @6 w# W同样的启动也不是HAL_TIM_Base_Start或者HAL_TIM_Base_Start_IT了，而是HAL_TIM_PWM_Start了；

1. TIM_HandleTypeDef TIM2_Handler;
   
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   0 b0 }. Z* Z& ^( T. Y2 e, D
3. static void MX_TIM2_Init(void)
   
4. {
   ) m) T# K1 q# G/ ?9 i! }
5.     TIM2_Handler.Instance = TIM2;
   ( h9 Q% P2 P5 \1 V1 x& x( k
6.     TIM2_Handler.Init.Prescaler = 10800;
   
7.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   4 m1 i) N2 u- Y. h+ @# ^
8.     TIM2_Handler.Init.Period = 20000;
   
9.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   $ F7 |* f0 q' V: Y0 j
10.     HAL_TIM_PWM_Init(&TIM2_Handler);
    ( Y6 @% y5 q) }3 F, B1 C
11. 
    ' `" ^: b# S( Z! L  z
12.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    # C; g1 G+ F- {0 l) A; ~
13.     TIM2_CH2Handler.Pulse = 10000;
    
14.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    # l( s, m/ R9 S8 @/ Z
15.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    
16.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    ! J, p- V, Q5 F6 I* s+ Y
17. 
    
18.     HAL_TIM_PWM_Start(&TIM2_Handler, TIM_CHANNEL_2); //开启PWM通道2
    6 A/ O$ i1 U8 l! m' m
19. }
    7 j9 i. {3 D; v1 q1 E
20. 
    
21. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    
22. {
    
23.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
24.                
    2 D; `8 [0 M: y; h/ x) v
25.         __HAL_RCC_TIM2_CLK_ENABLE();           
    * d& J' |, A# i/ M. `
26.     __HAL_RCC_GPIOA_CLK_ENABLE();
    4 o& A6 Q! o7 [, J& ~
27.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    . ]  y* {: |/ c% l% h
28.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
29.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    ! V' v' I* V( W8 C7 t' p) Y
30.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    , ?0 ?  G( f4 `3 Y
31.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
      g) z' \( M5 J* C
32.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    # ~0 T; H5 }; r3 a. _
33. }
    0 g& J7 B: ^+ F8 S+ F

复制代码

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


; j/ I8 l$ O+ p" p2 x; _
: N" y: [% e7 T. S5 V3 g9 \PWM + 定时器溢出中断
我们都知道，PWM模式是在比较值处翻转，在溢出的时候再次翻转，而溢出的时候，我们也是可以产生中断的；所以同一个定时器，在这种定时时长和周期相同的时候，是可以即做硬件PWM输出，又做溢出中断的。
这里我们观察一下两种初始化函数：
1 y2 E6 p# L+ k9 E5 _5 |6 x

1. /**
   
2.   * @brief  Initializes the TIM Time base Unit according to the specified
   
3.   *         parameters in the TIM_HandleTypeDef and create the associated handle.
   
4.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   * C$ h7 M- u0 t+ F
5.   *                the configuration information for TIM module.
   : ^5 b5 C+ ~- N; g/ ~- W; a
6.   * @retval HAL status
   $ a7 I% s: f6 h6 b; C
7.   */
   . d5 g4 r. o" E7 D$ P5 _
8. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   0 v  A* B) m$ N3 y( i" W8 [: z& a: A
9. {
   # F1 Y# @- E6 g9 D0 i& ?6 k* J
10.   /* Check the TIM handle allocation */
    
11.   if(htim == NULL)
    0 e" S- @7 N9 h% ^! l3 f
12.   {
    3 k4 P4 ?0 k1 z
13.     return HAL_ERROR;
    + ?6 V+ E3 r8 o$ Z- [, T6 Q
14.   }
    
15.   
    6 L- {0 p8 S$ ?( Q! t
16.   /* Check the parameters */
    
17.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
18.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    ! k) h+ \# x9 ~$ B3 f. \% B0 a3 q
19.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    1 P# }; ]. H3 {" f1 b
20.   
    
21.   if(htim->State == HAL_TIM_STATE_RESET)
    . l1 e7 E2 V7 n% w0 z
22.   {  
    1 [& o% Z" u2 F( P. w
23.     /* Init the low level hardware : GPIO, CLOCK, NVIC */
    - N5 C6 K( o8 z
24.     HAL_TIM_Base_MspInit(htim);
    
25.   }
    
26.   
    
27.   /* Set the TIM state */
    
28.   htim->State= HAL_TIM_STATE_BUSY;
    % m. q4 C' I, N0 ], Q
29.   
    
30.   /* Set the Time Base configuration */
    7 ~! S4 j7 X& Y7 i2 G; W- |! v
31.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    ' [. e' \* ?4 m; [2 |) \
32.   
    + f' V5 W5 I! c9 {
33.   /* Initialize the TIM state*/
    
34.   htim->State= HAL_TIM_STATE_READY;
    
35.   
    * t$ [  N4 P  b0 P! h
36.   return HAL_OK;
    . ^& E) U  a& X/ v6 z
37. }
    
38. 
    . N' X2 ]  k% A7 v
39. 
    
40. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
    9 [% r" b( r$ B
41. {
    " l8 ^0 [3 k, b' O9 k* u! J
42.   /* Check the TIM handle allocation */
    ( B; u1 i9 l) i5 g
43.   if(htim == NULL)
    9 q# K" o) r; {( ~  \% j$ i# e
44.   {
    % Z# V8 p! ?2 |" p0 O
45.     return HAL_ERROR;
    ) ~! n5 @5 B$ p
46.   }
    % V3 v2 G6 F8 r" z7 Z
47. 
    
48.   /* Check the parameters */
    
49.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    ( L# \* }# W# B) c3 O" E
50.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    . [3 |* I2 Q) m  _% Z
51.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
52. 
    
53.   if(htim->State == HAL_TIM_STATE_RESET)
    
54.   {
    2 T- W( i6 n( q! a7 h  k; K6 t
55.     /* Allocate lock resource and initialize it */
    
56.     htim->Lock = HAL_UNLOCKED;  
    - v6 ~7 o* [: {, V+ X# E
57.     /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
    1 }6 _" Y6 c& }
58.     HAL_TIM_PWM_MspInit(htim);
    
59.   }
    0 w2 T& u7 ^0 S5 o
60. 
    ) {1 \9 y1 O* O* o# \, v! h9 f  K
61.   /* Set the TIM state */
    
62.   htim->State= HAL_TIM_STATE_BUSY;  
    1 }2 z5 @3 r/ z: P
63.   
    ; P; F% r5 v6 e1 O
64.   /* Init the base time for the PWM */  
    
65.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
66.    
    " o( h, X( D. z  n( w
67.   /* Initialize the TIM state*/
    
68.   htim->State= HAL_TIM_STATE_READY;
    
69.   
    
70.   return HAL_OK;
    
71. }  
    + k0 K! M8 S$ i( }

复制代码

两者除了底层的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，后面的一个就得不到执行了。
+ D* t) L; x! j$ Y/ P1 M! v( o0 F再来看启动代码：

1. /**
   
2.   * @brief  Starts the TIM Base generation.
   
3.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   - }+ e$ r9 p$ g9 [/ ]
4.   *                the configuration information for TIM module.
   . Y0 G9 u# j2 X% W% \
5.   * @retval HAL status
   - h9 w% z' `' H; `
6.   */
   
7. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   : S6 Z$ }' ^; u+ m$ e& O
8. {
   * N3 K! z' @9 a% x  c& p
9.   /* Check the parameters */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
11.   
    
12.   /* Set the TIM state */
    
13.   htim->State= HAL_TIM_STATE_BUSY;
    , \1 Z2 X' `9 {1 w8 x/ r
14.   
    
15.   /* Enable the Peripheral */
    ( r4 g+ I- P; r/ c8 B9 q" n
16.   __HAL_TIM_ENABLE(htim);
    
17.   
    
18.   /* Change the TIM state*/
    
19.   htim->State= HAL_TIM_STATE_READY;
    $ m" u- M  v$ t
20.   
    
21.   /* Return function status */
      Z: `. H3 K- Q6 B  }
22.   return HAL_OK;
    
23. }
    7 j$ J! ^  Y" t1 k% ?3 d
24. 
    5 v( B8 y9 k4 Q% N
25. 
    
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.
    1 h7 [) @. S% t. U5 g: t
30.   * @retval HAL status
    8 d- A9 Y0 Z" ?6 s: ^
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 */
    
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;
    : E% i' z. I0 d# @  h$ h
45. }
    
46. 
    
47. 
    3 ^) ^4 \8 ]" p5 `" w
48. /**
    3 i( s+ S* p9 i1 n/ R! ]
49.   * @brief  Starts the PWM signal generation.
    % K+ Z  v2 ^5 ^( a  N
50.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    
51.   *                the configuration information for TIM module.
    3 Q4 f! X3 s/ L" ?- T6 l. s! |& Q
52.   * @param  Channel: TIM Channels to be enabled.
    
53.   *          This parameter can be one of the following values:
    
54.   *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
    . S/ c4 V3 y7 m% U, @2 w1 K
55.   *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
    8 Z. {, o5 {5 e1 z8 M
56.   *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
    
57.   *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
    9 |- r" y8 u9 C  X6 V$ {
58.   * @retval HAL status
    * B& ]- _4 `4 H3 p$ g4 ~$ o
59.   */
    & Y4 @& v0 U$ ~3 q" s  O
60. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
    
61. {
      Q5 I" z8 o- u  {. o
62.   /* Check the parameters */
    
63.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
    $ E' V! b( D7 t. U. r6 d- E
64. 
    4 f7 a) D- [/ n2 ]( l' d0 M5 ~, n
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)  
    & T% P3 l7 A+ c% c3 r4 C
69.   {
    - B* M. b. J$ h/ G) x/ G
70.     /* Enable the main output */
    
71.     __HAL_TIM_MOE_ENABLE(htim);
    / G* h/ |: S- a
72.   }
    & h' `8 A: c3 ^& u# W
73.    
    
74.   /* Enable the Peripheral */
    
75.   __HAL_TIM_ENABLE(htim);
    
76.   
    
77.   /* Return function status */
    
78.   return HAL_OK;
    
79. }
    

复制代码

( [  e1 Q3 f2 W: n2 m9 B其中的核心代码分别是：
" b" B% M  b1 ]0 x; G* ^

1. __HAL_TIM_ENABLE(htim);
   2 h' V/ p' R& \

复制代码

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   
2.   __HAL_TIM_ENABLE(htim);
   % ~6 l% q0 ^5 a' Z4 h

复制代码

1.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   9 [4 F/ y4 W: t! K
2.   __HAL_TIM_ENABLE(htim);
   

复制代码

1 {, G  I2 d& I  m, L% c那么我们可以不用hal库提供给我们的启动函数，直接写三句话，就实现了定时器中断+PWM功能了。

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   
2.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
3.   __HAL_TIM_ENABLE(htim);
   ) l  {. C) }% g6 h

复制代码

% |- o- s3 A$ d7 g" F% b' m# L完整代码如下：

1. TIM_HandleTypeDef TIM2_Handler;
   / q. C1 i9 ]( h3 d6 K
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   ) w0 O0 ^% y) B2 U/ |/ F
3. 
   
4. 
   $ I- C5 q5 }# [" |' o# g. m7 O5 i
5. static void MX_TIM2_Init(void)
   
6. {
   0 m/ R! E$ _- o+ h% U5 V
7.     __HAL_RCC_TIM2_CLK_ENABLE();
   
8.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);
   
9.     HAL_NVIC_EnableIRQ(TIM2_IRQn);
   8 W; M. P" U2 R) H/ C
10. 
    0 N; d$ ?8 ^( z: f! ^4 s1 l& n
11.     TIM2_Handler.Instance = TIM2;
    ! y3 N: \- U4 C2 Q1 U
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;
    
16.    
    0 Q: s6 Y9 {: Q  `
17.     HAL_TIM_PWM_Init(&TIM2_Handler);
    
18. 
    ; h  @  j' K2 V( v; M
19.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    3 I& m. h6 K" T% t% w' A
20.     TIM2_CH2Handler.Pulse = 10000;
    , C$ y" S2 [: }6 X1 K7 Y/ j  T
21.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    6 R, n# p! I  `1 e0 {; E3 ?1 ?6 m6 G
22.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    
23.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    5 w* p, H3 v8 a+ q0 n
24. 
    2 H( j4 M0 N% j
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);
    
28. }
    ) S2 [- P4 b- R( D
29. 
      [/ U& F! k  Y5 c6 @$ E# H* Z; {
30. 
    * ?3 r1 @2 i, y
31. void TIM2_IRQHandler(void)
      q8 I  C0 l: b5 d5 ^. {- T2 u5 _
32. {
    
33.     HAL_TIM_IRQHandler(&TIM2_Handler);
    ! N( c1 M1 V5 y9 D
34. }
    3 [  e* e- K; d* j8 |& c
35. 
    2 C! J# y5 [5 _- ~
36. 
    
37. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
38. {
    
39.     if (htim == (&TIM2_Handler))
    1 O6 V+ U* m) l3 p, [5 o5 {$ K
40.     {
    
41.         printf("enter irq\r\n");
    - N6 p9 ?( C5 |! y5 L
42.     }
    
43. }
    % o" x! _  [1 e; ^
44. 
    % @: x  s" |7 W  s$ }' `2 Z
45. 
    : _4 s$ z: F; n: H+ g
46. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    
47. {
    
48.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    ; N$ t2 A; |( M! z' y
49. 
    
50.     __HAL_RCC_TIM2_CLK_ENABLE();
    
51.     __HAL_RCC_GPIOA_CLK_ENABLE();
    
52.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    
53.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    5 ^9 i3 k# a% ^2 N& j: s* s7 z
54.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
55.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
56.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    
57.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
58. }

复制代码

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