此篇博客记录的是自己通过CubeMX学习F7系列定时器功能的过程，献给有过标准库开发经验的同学。

基本计时功能
最简单的，定时器嘛，基本的定时器就是定时功能，简单来说就是TIMx->CNT会跟随着输入时钟的脉冲而计数。
初始化定时器的参数，大家都好理解，因为TIM2的输入时钟是108Mhz，这里进行10800分频，输入频率为10K，重装载值设置为20K，每2秒溢出一次。
在HAL_TIM_Base_Init的执行过程中，会先调用HAL_TIM_Base_MspInit再进行其他参数的配置,即先开时钟。
! B" ?  s5 Z! r+ o. I
  \) M& S4 A: m+ U: d

1. TIM_HandleTypeDef TIM2_Handler;
   
2. static void MX_TIM2_Init(void)
   5 Y/ O; B( v! N7 w' I6 B6 _! N
3. {
   1 y  w* t: h* S3 s2 ?4 R+ E
4.     TIM2_Handler.Instance = TIM2;
   
5.     TIM2_Handler.Init.Prescaler = 10800;
   3 W4 @: p% s- R, F& {! g  M" e, H
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
7.     TIM2_Handler.Init.Period = 20000;
   ) s0 z) f$ j. Z
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   7 o) \+ {1 W( V' u
9. 
   ( I, ?0 J, b. X" x
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    
11.         HAL_TIM_Base_Start(&TIM2_Handler);
    
12. }
    
13. 
    5 \& i. o: |- o5 Y" }
14. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    
15. {
    
16.                 __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM3时钟  
    1 [5 m: `: j" Z/ B6 L8 N( F
17. }

复制代码

" c! D9 O- l( k1 P4 e4 h# M主函数中每秒打印一次定时器的值：

6 A# Y$ `2 W/ A( D1 l/ o! d, t5 ^

1.    while (1)
   # \# ^4 H6 b+ N: ^4 V, ]
2.     {
     H1 ]- S9 s. b2 _: I
3.                 printf("cnt:%d\r\n",TIM2->CNT);
   
4.         delay_ms(1000);
   
5.     }

复制代码

1 G5 N& d. [$ B% D- f' B显示效果如下：
4 @: U; q; |) Z) `( ^

* T* Z+ L9 ?3 w! ?
+ [: j- k& z% ~+ _0 ^' O定时器中断
通过HAL_TIM_Base_Start可以开启基本计时功能，但要实现定时器中断功能，就需要开启相应的标志位，即使用HAL_TIM_Base_Start_IT进行定时的开启；
8 {; v4 r* i( Y$ e在配置定时器之前，除了要开启时钟，还需要先设置中断优先级，和使能中断向量；
8 x7 i( q+ w2 _& y: S& j在定时器中断TIM2_IRQHandler服务函数中调用HAL库提供的定时器中断处理函数HAL_TIM_IRQHandler，解析到的定时器超时中断会自动跳转到HAL_TIM_PeriodElapsedCallback；

" P/ s# e+ |- ~. q4 Y  K: B

1. TIM_HandleTypeDef TIM2_Handler;
   
2. static void MX_TIM2_Init(void)
   
3. {
   ; t& C: l) U: r5 S& M
4.     TIM2_Handler.Instance = TIM2;
   + D1 ~! N( N. h: w$ e
5.     TIM2_Handler.Init.Prescaler = 10800;
   : y/ `2 z9 V$ Q* `
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   4 x9 i1 u, a; U& O6 [0 X
7.     TIM2_Handler.Init.Period = 20000;
   7 L1 |' N2 G. z. N/ X
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   . P" [, K% ]/ p; e
9. 
   
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    
11.     //HAL_TIM_Base_Start(&TIM2_Handler);
    8 `' H, P6 G  }: Q* j' Q
12.         HAL_TIM_Base_Start_IT(&TIM2_Handler);
    
13. }
    1 S5 V) P( a3 f) }+ W9 O
14. 
    
15. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    , O# R- b& s: c  L. F
16. {
    # t. \1 u. J2 a1 [0 r
17.     __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM2时钟
    
18.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);  //设置中断优先级，抢占优先级1，子优先级3
    ( E# C. T( V2 {6 S
19.     HAL_NVIC_EnableIRQ(TIM2_IRQn);          //开启ITM2中断
    
20. }
    
21. 
    
22. void TIM2_IRQHandler(void)
    
23. {
    7 v2 g( }( s$ u# G7 Q# M- D) c
24.     HAL_TIM_IRQHandler(&TIM2_Handler);
    : X9 [7 @0 z3 C' ~) \  Q
25. }
    0 D' U6 A/ P! f8 ~9 \
26. 
    # \, J8 O( C% c
27. 
    
28. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    ' o) l  w2 X* s1 n% a& {
29. {
    / i( D* E- k+ v: I
30.     if (htim == (&TIM2_Handler))
    + w5 [2 D" n9 @8 g
31.     {
    
32.         printf("enter irq\r\n");
    " ^6 ^0 s& M) m) G0 s- q
33.     }
    
34. }
    

复制代码

& v4 X6 J5 ]  t1 T9 g. v* n/ H显示效果如下：

0 z. a/ O) \# ?/ g; ^4 E
, c8 R8 p3 B6 q0 |! CPWM输出
& d5 l7 K% v; J0 A+ W硬件PWM输出是不需要使用定时器中断的，但同样需要基本的定时参数配置，初始化也不再是使用HAL_TIM_Base_Init而是使用HAL_TIM_PWM_Init进行初始化了；
4 t# C/ x; y% g- r配置完定时器为PWM模式，那么相应的输出通道也需要通过HAL_TIM_PWM_ConfigChannel进行配置；
0 z( M0 l& p" V5 S, {2 H同样的启动也不是HAL_TIM_Base_Start或者HAL_TIM_Base_Start_IT了，而是HAL_TIM_PWM_Start了；

! P! ]# g& S- a6 Z* ?2 V

1. TIM_HandleTypeDef TIM2_Handler;
   
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   + U/ E3 V: p' B, f* b% S
3. static void MX_TIM2_Init(void)
   
4. {
   
5.     TIM2_Handler.Instance = TIM2;
     F- Z; K: T. o% f" @% M/ T* l8 i
6.     TIM2_Handler.Init.Prescaler = 10800;
   
7.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
8.     TIM2_Handler.Init.Period = 20000;
   
9.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   
10.     HAL_TIM_PWM_Init(&TIM2_Handler);
    - q9 ~0 S! c! t5 C. P
11. 
    
12.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    ( b/ p! _! A4 H+ U6 i
13.     TIM2_CH2Handler.Pulse = 10000;
    & E$ M) C0 p  ?* ^0 }
14.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    " y' t- L4 U0 u4 O
15.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    / t7 D$ ?/ ?# A$ X6 s- j2 ?6 j
16.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    
17. 
    
18.     HAL_TIM_PWM_Start(&TIM2_Handler, TIM_CHANNEL_2); //开启PWM通道2
    
19. }
    
20. 
    
21. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    1 @( m5 b- }* O9 f  g4 J5 o
22. {
    7 n3 h! c# N7 x2 \% Q/ P
23.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    # R( }  i  E! B* ~: y. i# \' Z
24.                
    
25.         __HAL_RCC_TIM2_CLK_ENABLE();           
    ) K5 I$ d( k/ I/ _1 i
26.     __HAL_RCC_GPIOA_CLK_ENABLE();
    ) F1 ?. M1 a4 I# p. L6 t
27.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    
28.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
29.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    ( Q5 [6 \7 |" K9 [  W
30.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    ( l$ O, b1 e: [4 c- ~" ^# H; B
31.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    
32.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
33. }

复制代码

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

: i0 P, G$ e$ L! O

6 q3 c1 K' X. _+ x5 mPWM + 定时器溢出中断
* K9 w. N. Q' f" Z( ]我们都知道，PWM模式是在比较值处翻转，在溢出的时候再次翻转，而溢出的时候，我们也是可以产生中断的；所以同一个定时器，在这种定时时长和周期相同的时候，是可以即做硬件PWM输出，又做溢出中断的。
这里我们观察一下两种初始化函数：

9 ]& y( y1 O. C8 X2 j- o6 P1 s7 D

1. /**
   1 x$ r" e5 s0 |! |3 J% J7 ^9 Y
2.   * @brief  Initializes the TIM Time base Unit according to the specified
   ; c; V9 q4 W: h; U' S  y% r
3.   *         parameters in the TIM_HandleTypeDef and create the associated handle.
   3 ~5 u) f2 P0 H( m: H% Z1 Y) c4 k
4.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   
5.   *                the configuration information for TIM module.
   * i  B. `9 d# u
6.   * @retval HAL status
   % _4 m/ r; _9 V) r" a& m! m& l
7.   */
   
8. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   % c0 m. Z$ s, M! X" A! v$ @
9. {
   , m0 d- Z, [3 z2 E
10.   /* Check the TIM handle allocation */
      M. D* V. B- q" M1 C8 x+ `9 s" E6 t
11.   if(htim == NULL)
    1 l+ c* K8 ^. J
12.   {
    ' U+ I9 R0 v; I9 }, }) E! B! z- k. E
13.     return HAL_ERROR;
    ' L# o! @) k6 T% d0 @
14.   }
    
15. 
      R3 _5 |/ O2 w" q& S, t6 v
16.   /* Check the parameters */
    7 a0 q: j. w3 f( Q4 [; Z  [
17.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    - W/ s- w8 B+ }7 ~6 M0 y" \
18.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    3 P- e' t" z  j" O# }) Y
19.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
20. 
    
21.   if(htim->State == HAL_TIM_STATE_RESET)
    0 b% d6 o( |, o; U& @9 \* s
22.   {  
    $ w) \6 _, V3 U
23.     /* Init the low level hardware : GPIO, CLOCK, NVIC */
    " i+ t; C! [4 v% H/ p
24.     HAL_TIM_Base_MspInit(htim);
    
25.   }
    " p5 `7 O9 i- H3 v7 F. B. H
26. 
      Z6 v3 a7 u- f) G  Y3 B; C" ~
27.   /* Set the TIM state */
    4 ~" P+ u7 s8 [
28.   htim->State= HAL_TIM_STATE_BUSY;
    - l- o' n4 j8 I% A7 V6 {; {3 C
29. 
    : w! Y9 V/ [% u% r0 s0 e
30.   /* Set the Time Base configuration */
    
31.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    / z- B  Q& J8 }1 D
32. 
    $ g- s3 u8 w+ E+ k, r0 j7 a1 W
33.   /* Initialize the TIM state*/
    
34.   htim->State= HAL_TIM_STATE_READY;
    " [: R% J# z; }3 y8 v( K
35. 
    
36.   return HAL_OK;
    
37. }
    
38. 
    
39. 
    
40. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
    ( U# U$ m. V( }( `4 k# _7 v+ W
41. {
    
42.   /* Check the TIM handle allocation */
    % ~  p: S6 a9 c" t9 S8 U" u
43.   if(htim == NULL)
    
44.   {
    
45.     return HAL_ERROR;
    4 Y) S) b$ H  {/ z* q( H( ^
46.   }
    ( a9 s% a# M" u3 R/ L* I
47. 
    
48.   /* Check the parameters */
    
49.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    6 B: U5 C1 S, q5 W+ [
50.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    
51.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    6 u! J7 y- s  I4 {/ r1 U* u4 o
52. 
    
53.   if(htim->State == HAL_TIM_STATE_RESET)
    % V6 m3 R* o8 \" ^: E! U4 w
54.   {
    / H9 q, K& d7 E  l5 L5 {% S& G& ~
55.     /* Allocate lock resource and initialize it */
    $ y& f. i! \# o+ V( {7 }
56.     htim->Lock = HAL_UNLOCKED;  
    % Q9 Y3 ]0 v! ]4 v* c
57.     /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
    ( U5 B. }  P. E0 R
58.     HAL_TIM_PWM_MspInit(htim);
    : H/ Z+ d' ?2 R& D% C' \. F
59.   }
    
60. 
    
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);
    & ~' }4 F2 C8 z% ^& K
66. 
    , h/ h& u* L4 G( C7 ~4 ~4 y
67.   /* Initialize the TIM state*/
    
68.   htim->State= HAL_TIM_STATE_READY;
    
69. 
    5 [/ B+ s9 Z9 q) ^) B6 n2 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，后面的一个就得不到执行了。
7 y$ e$ p5 \: @" k' q) X再来看启动代码：
: U& n' H" {1 _; S. N
( J- [: a) {+ G7 a$ }( `0 r* k" q

1. /**
   
2.   * @brief  Starts the TIM Base generation.
   - Z  |) F! K0 t1 t$ k% ]/ X$ `2 k% n
3.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
     [2 o  N2 D* L# m: E8 v2 x
4.   *                the configuration information for TIM module.
   ( V" M+ Z2 l6 [
5.   * @retval HAL status
   
6.   */
   
7. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
     \  I2 w; k+ y' W; \
8. {
   7 d# }1 a* \# A% R
9.   /* Check the parameters */
   1 o  K, P# o! b6 y7 J  D9 [- U: I
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    ' e# `6 o5 y% g6 p7 h( k' |
11. 
    5 h! U3 _2 ?6 l) H! J5 A: O
12.   /* Set the TIM state */
    8 G* K3 C1 |/ U7 ^
13.   htim->State= HAL_TIM_STATE_BUSY;
    ( G8 R4 l; {' R. T( L$ V
14. 
    5 ?' i; b: x% w# `2 |9 e
15.   /* Enable the Peripheral */
    & r" a1 V! h. W
16.   __HAL_TIM_ENABLE(htim);
    + m- |! U8 y/ T  O
17. 
    3 D* {& k6 k( i. X: D7 U4 \
18.   /* Change the TIM state*/
    + f  X- i$ }1 i+ Z
19.   htim->State= HAL_TIM_STATE_READY;
    ; K% f+ Z3 L  [4 c$ H7 O+ ]) M
20. 
    
21.   /* Return function status */
    
22.   return HAL_OK;
    
23. }
    5 a2 P/ S8 M  A
24. 
    # t  k; ]/ c- [  D
25. 
    
26. /**
    
27.   * @brief  Starts the TIM Base generation in interrupt mode.
    
28.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
      M6 x, L6 t" `$ Q7 H  _! C" D6 T
29.   *                the configuration information for TIM module.
    7 g- I6 t2 D' |) Z- Q3 I
30.   * @retval HAL status
    
31.   */
    " Q! {( c2 A6 q5 w/ J
32. HAL_StatusTypeDef HAL_TIM_Base_Start_IT(TIM_HandleTypeDef *htim)
    , q& q+ \2 A6 Y7 U
33. {
    
34.   /* Check the parameters */
    
35.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
36. 
    3 D" d5 j5 R% y; ~4 i7 \
37.   /* Enable the TIM Update interrupt */
    
38.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
    7 N2 B2 `% A( j+ V
39. 
    
40.   /* Enable the Peripheral */
    8 Y3 C/ ?) ?3 z: Q7 R
41.   __HAL_TIM_ENABLE(htim);
    4 K, t8 }5 X' \' R( J
42. 
      p% C& X* Z* j& `7 k6 W
43.   /* Return function status */
    
44.   return HAL_OK;
    % m  S# l1 `3 b. F
45. }
    
46. 
    2 b/ G  R# w* l
47. 
    
48. /**
    
49.   * @brief  Starts the PWM signal generation.
    
50.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    
51.   *                the configuration information for TIM module.
    % v. N' f( _: K1 a, c
52.   * @param  Channel: TIM Channels to be enabled.
    6 z" x# H: x' }# ?
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
    
56.   *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
    
57.   *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
    
58.   * @retval HAL status
    
59.   */
    
60. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
    
61. {
    1 a' Q. e0 ?, F" j# P2 z. F0 }
62.   /* Check the parameters */
    ) c7 p2 O6 j7 i" O6 r
63.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
    
64. 
    + d) A5 ^/ i4 j4 H
65.   /* Enable the Capture compare channel */
    
66.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
67. 
    8 X! q; V4 G  ~% i; _7 n$ n( a
68.   if(IS_TIM_ADVANCED_INSTANCE(htim->Instance) != RESET)  
    
69.   {
    
70.     /* Enable the main output */
    
71.     __HAL_TIM_MOE_ENABLE(htim);
    % }* Y& Q7 R- |$ ^2 i. g
72.   }
    $ ~5 S5 g0 W: w: ~
73. 
    " R8 F. l( @; D" O; F
74.   /* Enable the Peripheral */
    
75.   __HAL_TIM_ENABLE(htim);
    
76. 
    
77.   /* Return function status */
    
78.   return HAL_OK;
    
79. }

复制代码

( C. E4 {% T) ~其中的核心代码分别是：

1. __HAL_TIM_ENABLE(htim);

复制代码

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   ) `9 j" s9 v8 y4 u4 t8 p
2.   __HAL_TIM_ENABLE(htim);

复制代码

1.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
2.   __HAL_TIM_ENABLE(htim);

复制代码

那么我们可以不用hal库提供给我们的启动函数，直接写三句话，就实现了定时器中断+PWM功能了。

+ M2 K: M5 p/ q6 C/ D' S6 ~  x

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   
2.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   9 W  j$ e9 S! M7 {; [
3.   __HAL_TIM_ENABLE(htim);

复制代码

! v* v8 {# T% |2 s, V$ q完整代码如下：
$ A  y$ C# }1 r

1. TIM_HandleTypeDef TIM2_Handler;
   4 L1 R2 {3 s2 ]8 V
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   , T: c* O2 _  A4 y' h
3. 
   
4. 
   ; i& _! b6 J& y  f  T/ x; y
5. static void MX_TIM2_Init(void)
   
6. {
   ( w3 D2 @# _! }% G
7.     __HAL_RCC_TIM2_CLK_ENABLE();
   
8.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);
   / X( a2 e" H8 {4 k+ P+ |0 \" B. u
9.     HAL_NVIC_EnableIRQ(TIM2_IRQn);
   - a$ s0 ?4 Z; t# R
10. 
    
11.     TIM2_Handler.Instance = TIM2;
    
12.     TIM2_Handler.Init.Prescaler = 10800;
    & F$ p$ W$ I0 C! f# j* c) ?
13.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
    
14.     TIM2_Handler.Init.Period = 20000;
    
15.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    
16. 
    
17.     HAL_TIM_PWM_Init(&TIM2_Handler);
    2 o2 M8 S( p8 U
18. 
    
19.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    3 @) w- ^+ r$ Y8 x, C' E% B/ ~
20.     TIM2_CH2Handler.Pulse = 10000;
    1 M$ L. Q8 u  r' ?  f1 l% d
21.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    
22.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    
23.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    - M3 B4 e$ W/ y& }2 O
24. 
    # J) Q+ P7 {# p7 D; ~8 r* W, E. @
25.     __HAL_TIM_ENABLE_IT(&TIM2_Handler, TIM_IT_UPDATE);
    
26.     TIM_CCxChannelCmd(TIM2_Handler.Instance, TIM_CHANNEL_2, TIM_CCx_ENABLE);
    : p; T$ M* W" @7 o
27.     __HAL_TIM_ENABLE(&TIM2_Handler);
    5 \' P$ J+ M' c+ v# P3 S
28. }
    
29. 
    
30. 
    3 {4 w9 |% I( Z3 ~5 `8 R. r0 u
31. void TIM2_IRQHandler(void)
    & i, f: S6 `1 ]
32. {
    
33.     HAL_TIM_IRQHandler(&TIM2_Handler);
    $ J% J+ [" @7 W4 @, _
34. }
    " V6 A. ?5 {7 v' U. _
35. 
    
36. 
    
37. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    ' `" \6 d0 I3 s. v2 Q& @9 C
38. {
    ) @7 e1 k- L; e4 U
39.     if (htim == (&TIM2_Handler))
    
40.     {
    : C, o6 y. U1 I3 e
41.         printf("enter irq\r\n");
    
42.     }
      L6 R4 i' [" ?
43. }
    + T$ ?$ A# e6 V& N& ^5 s9 e7 r
44. 
    ! \0 e6 G# T* x0 u, F( F
45. 
    
46. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    
47. {
    ! B9 P7 K- X. t: {* p- A( T5 a
48.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    . Q+ Y8 x% q# m  ^: W2 ~+ k
49. 
    
50.     __HAL_RCC_TIM2_CLK_ENABLE();
    . d; y8 W2 X2 A
51.     __HAL_RCC_GPIOA_CLK_ENABLE();
    
52.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    7 f5 R& l7 H1 j
53.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
54.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    4 B2 J  c9 N  N2 p5 {2 w
55.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    : _- X/ J6 J* I+ I* r
56.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    % Z2 @# q) Q- |& n
57.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    % W, O* u+ r! P" a+ K& R
58. }
    1 h) g/ U" H9 a

复制代码

$ m$ Q& }) O, Z; ]7 s% @