此篇博客记录的是自己通过CubeMX学习F7系列定时器功能的过程，献给有过标准库开发经验的同学。
" G" ?# o# ?0 Z* {( C5 H% x
基本计时功能
. C/ l' W) g& P3 S( h最简单的，定时器嘛，基本的定时器就是定时功能，简单来说就是TIMx->CNT会跟随着输入时钟的脉冲而计数。
- \8 R' i7 k0 c  k6 k0 A* _初始化定时器的参数，大家都好理解，因为TIM2的输入时钟是108Mhz，这里进行10800分频，输入频率为10K，重装载值设置为20K，每2秒溢出一次。
在HAL_TIM_Base_Init的执行过程中，会先调用HAL_TIM_Base_MspInit再进行其他参数的配置,即先开时钟。
1 q& }  r. q+ J& `8 m
7 S: v* s9 ~7 p3 I" F6 {) U: Y: a

1. TIM_HandleTypeDef TIM2_Handler;
   ' p( A3 G, y1 q' H0 J
2. static void MX_TIM2_Init(void)
   
3. {
   
4.     TIM2_Handler.Instance = TIM2;
   ! d. ?+ y- H$ n5 V- J: I3 B7 ^
5.     TIM2_Handler.Init.Prescaler = 10800;
   - E' h" g9 M* o1 p+ M( Y3 }
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
7.     TIM2_Handler.Init.Period = 20000;
   . r9 y  P/ O7 {: G0 O, t0 b  s
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
     q* A! p$ s( u5 F* c
9. 
   
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    2 V) a+ }. ~3 j1 T4 c+ O/ H
11.         HAL_TIM_Base_Start(&TIM2_Handler);
    
12. }
    
13. 
    
14. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    0 Z; {4 Z5 B% `/ @' V' T
15. {
    , {) H2 W7 N4 E
16.                 __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM3时钟  
    $ e1 |5 @( y) @; @6 K( }
17. }

复制代码

$ R' S, E8 m0 ?9 z, w主函数中每秒打印一次定时器的值：
8 a# Q) T# Z+ P7 t2 Y" W& \
: {0 t" U  F. P, K" S# Q" @

1.    while (1)
   . _1 y* }! v9 d2 K2 Z8 i
2.     {
   , @1 V" z3 G6 y# v% ^) @+ ?
3.                 printf("cnt:%d\r\n",TIM2->CNT);
   
4.         delay_ms(1000);
   * w' j! S1 o- J' ?6 |
5.     }

复制代码

% M  D8 ]0 X* t显示效果如下：
' Q# Q' d% g+ h' A% g

8 e. D; i6 _; }7 ^: r$ i2 m3 F
' z6 e( ]9 \3 K" ~0 q定时器中断
通过HAL_TIM_Base_Start可以开启基本计时功能，但要实现定时器中断功能，就需要开启相应的标志位，即使用HAL_TIM_Base_Start_IT进行定时的开启；
& M8 s9 Y0 t- L- J: A% r在配置定时器之前，除了要开启时钟，还需要先设置中断优先级，和使能中断向量；
在定时器中断TIM2_IRQHandler服务函数中调用HAL库提供的定时器中断处理函数HAL_TIM_IRQHandler，解析到的定时器超时中断会自动跳转到HAL_TIM_PeriodElapsedCallback；
9 r4 ]' q: {/ Q0 o3 M$ u5 W; v
# O% I& Q* N& @) s& d! ?

1. TIM_HandleTypeDef TIM2_Handler;
   
2. static void MX_TIM2_Init(void)
   % X  E; A5 [& X- V
3. {
   / @% @9 B) w; d' D" w7 n
4.     TIM2_Handler.Instance = TIM2;
   
5.     TIM2_Handler.Init.Prescaler = 10800;
   ( c, c9 [, v6 F; |8 ?
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
7.     TIM2_Handler.Init.Period = 20000;
   
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   + V7 d) W5 p  k, F7 @5 x
9. 
   ) _: u# D$ e; w7 d% U* }0 b
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    $ |# [' z0 O, F# R# E+ {# w) I  z
11.     //HAL_TIM_Base_Start(&TIM2_Handler);
    5 o4 y! h# U' D- `: R/ Y, E
12.         HAL_TIM_Base_Start_IT(&TIM2_Handler);
    0 v& f3 |2 i$ l9 Q6 M1 |. U( I1 U
13. }
    
14. 
    6 v' }9 A$ o& n# i0 o8 e. S
15. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    
16. {
    2 j7 N5 T/ ^0 a6 c6 f( |( k# p
17.     __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM2时钟
    
18.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);  //设置中断优先级，抢占优先级1，子优先级3
    
19.     HAL_NVIC_EnableIRQ(TIM2_IRQn);          //开启ITM2中断
    
20. }
    
21. 
    2 g% _2 C, k1 y
22. void TIM2_IRQHandler(void)
    ( S* W( h- f0 A/ U2 X7 D
23. {
    * l7 I5 d" O1 A# l; Y+ a+ |5 z
24.     HAL_TIM_IRQHandler(&TIM2_Handler);
    
25. }
    ( k* m# c. \" U+ X0 K3 N
26. 
    3 i) A6 I, e8 ?( r
27. 
    
28. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    " F' ]' K1 j: E2 j3 E2 M
29. {
    " y: q# A3 [/ E! F
30.     if (htim == (&TIM2_Handler))
    
31.     {
    ) R3 z; a) C6 s" ]$ I, D9 g4 D
32.         printf("enter irq\r\n");
    
33.     }
    ( d' g0 _1 c% O/ w! r
34. }
    $ C; P3 K! o. I7 D- h) m0 g1 Z

复制代码

显示效果如下：
/ q+ v8 B& R. e4 \4 j2 |: u
8 c1 p; K# i3 ^

PWM输出
) q1 p1 y; `  f7 `" [硬件PWM输出是不需要使用定时器中断的，但同样需要基本的定时参数配置，初始化也不再是使用HAL_TIM_Base_Init而是使用HAL_TIM_PWM_Init进行初始化了；
8 `6 F7 o+ p, [8 V配置完定时器为PWM模式，那么相应的输出通道也需要通过HAL_TIM_PWM_ConfigChannel进行配置；
同样的启动也不是HAL_TIM_Base_Start或者HAL_TIM_Base_Start_IT了，而是HAL_TIM_PWM_Start了；
3 k. [5 w  L8 b3 H( W2 R

1. TIM_HandleTypeDef TIM2_Handler;
   
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   
3. static void MX_TIM2_Init(void)
   
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;
   0 e3 J7 U' n; T- g7 z
9.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   - u; F) G: W% L) O; Q
10.     HAL_TIM_PWM_Init(&TIM2_Handler);
    
11. 
    + M% f# G2 |/ p+ n1 E, Y5 m
12.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    ; E: H! l! ~6 U- w( a# D4 @
13.     TIM2_CH2Handler.Pulse = 10000;
    ( B+ |- a5 P9 a* u0 G
14.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    9 W9 N; k! F4 ?- k5 j+ R
15.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    
16.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    " l2 }- h, J9 \9 C
17. 
    " o! D  h+ m2 [( ~8 U" n4 D6 ?
18.     HAL_TIM_PWM_Start(&TIM2_Handler, TIM_CHANNEL_2); //开启PWM通道2
    3 [  E1 ]$ p. S3 H9 T1 l3 F" w
19. }
    
20. 
    3 R4 a' X$ d* J/ H
21. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    1 |1 E, {2 ~& P) ^2 ~; T' M
22. {
    ; c  J) W. H8 E: O2 E5 d6 D
23.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    3 \# \& @0 [) V; z( A0 ]
24.                
    
25.         __HAL_RCC_TIM2_CLK_ENABLE();           
    
26.     __HAL_RCC_GPIOA_CLK_ENABLE();
    
27.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    
28.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
29.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
30.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
31.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    
32.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
33. }

复制代码

$ F$ m0 d, m. e8 N2 D通过万用表可以发现PA1口的电压在0和3.3V中大概每秒变动一次（疫情期间在家学习，没有示波器真是太惨了……为了确定确实有PWM波形，只能出此下策了T_T），串口打印数据如下：
: _0 ^" I. f4 ?- S

( r) i7 a. Q4 Z8 I/ P; Q4 [. N
) l1 {, f' U, D( C0 [: {PWM + 定时器溢出中断
- O8 t% g" p) A2 G我们都知道，PWM模式是在比较值处翻转，在溢出的时候再次翻转，而溢出的时候，我们也是可以产生中断的；所以同一个定时器，在这种定时时长和周期相同的时候，是可以即做硬件PWM输出，又做溢出中断的。
7 h8 c$ l" M& X4 }* j9 D这里我们观察一下两种初始化函数：

8 c* z, A6 U; L% E  t% k

1. /**
   7 E1 q. t/ u2 ^% D$ h# H& H3 O
2.   * @brief  Initializes the TIM Time base Unit according to the specified
   ! p% {. f2 ~) X9 l& O5 W' Z: ?# D
3.   *         parameters in the TIM_HandleTypeDef and create the associated handle.
   
4.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   . H$ F& ?8 _& X, j1 K+ Z+ x9 o
5.   *                the configuration information for TIM module.
   8 Y9 I3 Y& G. S9 r% }8 W5 ?
6.   * @retval HAL status
   0 @- }1 g% s: C
7.   */
   ' f- g0 ?/ t5 G' E
8. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   
9. {
   3 n# Z* _. U% P4 V; A! K: B/ C
10.   /* Check the TIM handle allocation */
    
11.   if(htim == NULL)
    , \7 E$ L% Q) g+ _
12.   {
    
13.     return HAL_ERROR;
    ; r% N" V% G/ w# X9 P3 ^* ^
14.   }
    
15. 
    
16.   /* Check the parameters */
    
17.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
18.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    / E5 L! t  X2 _% L7 H1 O3 x
19.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
20. 
    
21.   if(htim->State == HAL_TIM_STATE_RESET)
    - L1 ^$ k" i' Q, y% U5 K$ u
22.   {  
    
23.     /* Init the low level hardware : GPIO, CLOCK, NVIC */
    
24.     HAL_TIM_Base_MspInit(htim);
    
25.   }
    
26. 
    
27.   /* Set the TIM state */
    
28.   htim->State= HAL_TIM_STATE_BUSY;
    
29. 
    
30.   /* Set the Time Base configuration */
    
31.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    * W! c. T7 ~5 N" h0 C% F, h: A
32. 
    * g" a1 ^+ |7 @
33.   /* Initialize the TIM state*/
    
34.   htim->State= HAL_TIM_STATE_READY;
    
35. 
    
36.   return HAL_OK;
    
37. }
    1 q' s4 }5 p8 O5 C  T
38. 
    3 q( G% b7 {. w7 _3 a, \
39. 
    & s8 w. X' ]6 A. t
40. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
    6 o; F8 a2 k  ~! c3 V( A+ P! ~
41. {
    4 g# i* r5 }5 D2 u4 h
42.   /* Check the TIM handle allocation */
    ; G- H9 M7 |: I( y
43.   if(htim == NULL)
    
44.   {
    / x! ?# Z8 Y3 c' \* O, _0 K1 q
45.     return HAL_ERROR;
    1 I7 W, b  T5 C
46.   }
    * U8 r; B: T  q: q( r- X! C' R+ Q& J
47. 
    
48.   /* Check the parameters */
    - N$ k- M. I: f+ Q' n6 Y6 x5 z  v
49.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    ) v) `  Z2 e: }9 s: ]2 u( |' W
50.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    
51.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    
52. 
    " r, X8 W) _. R2 P! c3 w
53.   if(htim->State == HAL_TIM_STATE_RESET)
    # r% v5 [5 D' U2 f/ l( }
54.   {
    9 M+ K# Q1 {$ S8 {
55.     /* Allocate lock resource and initialize it */
    6 h( c( s4 M4 H
56.     htim->Lock = HAL_UNLOCKED;  
    
57.     /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
    . c! c: I! q$ l- [8 @  }
58.     HAL_TIM_PWM_MspInit(htim);
    " T! h& `# W5 Y4 A: C: ?, m9 f2 n) L
59.   }
    
60. 
    
61.   /* Set the TIM state */
    
62.   htim->State= HAL_TIM_STATE_BUSY;  
    8 t/ }) c  I6 I8 }' g- j) A+ D7 J
63. 
    , m2 V* x0 ?. ~7 s) B) U
64.   /* Init the base time for the PWM */  
    4 Y$ t( }7 u) W  A4 R
65.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    
66. 
    $ r" Q  z5 X; t) c& X
67.   /* Initialize the TIM state*/
    
68.   htim->State= HAL_TIM_STATE_READY;
    
69. 
    4 _% P  b+ c! e0 r- \$ F! h
70.   return HAL_OK;
    
71. }  

复制代码

3 }; {6 H, ?' h8 x两者除了底层的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. /**
   ( m7 F/ d  Y0 A' o9 R
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.
   / B% x6 m- J, R: g7 S
5.   * @retval HAL status
   
6.   */
   8 q) I+ T& g) R2 N9 Y7 E  K
7. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   
8. {
   
9.   /* Check the parameters */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    ) a) f  C8 f* ^6 g1 k
11. 
    
12.   /* Set the TIM state */
    ' G/ q5 a' q- Q1 q
13.   htim->State= HAL_TIM_STATE_BUSY;
    # P3 {+ a" \1 I  M6 [
14. 
    
15.   /* Enable the Peripheral */
    # `2 h) E4 u; P9 ^2 y$ M
16.   __HAL_TIM_ENABLE(htim);
    
17. 
    4 j% m; W- E1 G6 a
18.   /* Change the TIM state*/
    4 X2 a; g, a  D9 k! X) o
19.   htim->State= HAL_TIM_STATE_READY;
    ( v/ j0 @) K4 X1 a0 l& B- k
20. 
    
21.   /* Return function status */
    3 U/ \1 o$ R, P) T: W' _
22.   return HAL_OK;
    ' ?4 k1 ]: Z1 o9 N, B
23. }
    9 `- |! @: ?9 z7 v
24. 
    
25. 
    : j, {: V; T% {3 Z) x% |# K& p
26. /**
    
27.   * @brief  Starts the TIM Base generation in interrupt mode.
    $ h: }+ ]  a% @. |
28.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    
29.   *                the configuration information for TIM module.
    ( G. P5 \& k9 W* H
30.   * @retval HAL status
    ! l# @3 `, O; E' `# Y% I+ a3 B& j
31.   */
    : O" e9 }6 R1 ]0 i! q, P! b" B
32. HAL_StatusTypeDef HAL_TIM_Base_Start_IT(TIM_HandleTypeDef *htim)
    4 c& y3 H; T* C! O, }  v: z
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! |2 X6 D7 r) H5 V* H
45. }
    + I3 u% i; z; N* F) I7 w
46. 
    
47. 
    
48. /**
    
49.   * @brief  Starts the PWM signal generation.
      y% J. ^0 C/ g* g: s& I
50.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    1 E0 s6 l8 v/ g  h  \7 j9 O9 ?
51.   *                the configuration information for TIM module.
    
52.   * @param  Channel: TIM Channels to be enabled.
    : Z0 e( F: t$ x) F
53.   *          This parameter can be one of the following values:
    
54.   *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
    : g/ F5 t5 {. H3 h6 c+ O
55.   *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
    . R( g  d' Z7 ?# y! B
56.   *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
    
57.   *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
    7 a( B6 K3 R: N4 {% ?6 X
58.   * @retval HAL status
    : ]1 ?9 d- K- a1 h; h
59.   */
    ; F5 q2 _6 \  C- ^+ ]9 }
60. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
    6 [+ }2 x/ S+ V
61. {
    / ~3 n7 t# T0 D6 h$ u0 f3 L7 @$ k
62.   /* Check the parameters */
    
63.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
    & E' ^0 A& C# a
64. 
    
65.   /* Enable the Capture compare channel */
    
66.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
67. 
    ! H' f& B3 _0 O9 G, x0 b( K' h
68.   if(IS_TIM_ADVANCED_INSTANCE(htim->Instance) != RESET)  
    ' Z# [( x' X& U0 p" F) I
69.   {
    - y" j& Y! Q; k. d# ~
70.     /* Enable the main output */
    
71.     __HAL_TIM_MOE_ENABLE(htim);
    
72.   }
    - v# E- N- P2 @. `8 H3 e: U$ I
73. 
    
74.   /* Enable the Peripheral */
    
75.   __HAL_TIM_ENABLE(htim);
    
76. 
    
77.   /* Return function status */
    
78.   return HAL_OK;
    
79. }

复制代码

7 k- N# ~3 M' V- N# s" T
其中的核心代码分别是：
+ R$ k/ z7 p# [
+ V7 V) E: S# w& H* s( ]3 n

1. __HAL_TIM_ENABLE(htim);

复制代码

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   % x* F* L4 H' x/ T( d
2.   __HAL_TIM_ENABLE(htim);

复制代码

1.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   ' A. ^+ ^& {- Q8 w
2.   __HAL_TIM_ENABLE(htim);

复制代码

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

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   : C* M. S3 ~+ T' G$ P4 H! _% U
2.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   
3.   __HAL_TIM_ENABLE(htim);

复制代码

- ~9 k2 S: r7 V4 m( Q$ J8 N完整代码如下：

1. TIM_HandleTypeDef TIM2_Handler;
   ' V! i2 |7 q/ \1 t4 W9 g" ^$ j
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   " t2 Q/ A, E. O0 ?% ?
3. 
   " a- ~1 o, d8 M/ d5 a9 s9 B
4. 
   $ {9 I( k: D& o: ~# ]2 v
5. static void MX_TIM2_Init(void)
   
6. {
   9 j1 n4 @* G* O! X
7.     __HAL_RCC_TIM2_CLK_ENABLE();
   
8.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);
   
9.     HAL_NVIC_EnableIRQ(TIM2_IRQn);
   
10. 
    ; ]3 `& @/ s" T
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;
    
15.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    ' S9 ]9 U* b% H
16. 
    
17.     HAL_TIM_PWM_Init(&TIM2_Handler);
    
18. 
    
19.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    
20.     TIM2_CH2Handler.Pulse = 10000;
    
21.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    $ d/ k! u8 j% U8 x0 J
22.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    
23.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    
24. 
    
25.     __HAL_TIM_ENABLE_IT(&TIM2_Handler, TIM_IT_UPDATE);
    ' j3 i- ?, \. I. }8 V* r; J
26.     TIM_CCxChannelCmd(TIM2_Handler.Instance, TIM_CHANNEL_2, TIM_CCx_ENABLE);
    ) q2 X, e7 n  h& f
27.     __HAL_TIM_ENABLE(&TIM2_Handler);
      x2 m$ S/ f2 z/ k& E
28. }
    : Z* i  Z. |1 m  Y8 _8 U
29. 
    4 C  d) c( x- e3 h
30. 
    ) O6 `1 g; x& o/ p1 V
31. void TIM2_IRQHandler(void)
    3 w- h4 `' F+ I
32. {
    : f# p9 a# _  e1 w
33.     HAL_TIM_IRQHandler(&TIM2_Handler);
    
34. }
    " L" |+ D% u( [; {5 w
35. 
    * M8 g5 q$ \$ z: a  E7 N* Q
36. 
    1 x" I5 y* g  {. F: x
37. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
38. {
    - _( N/ Z, ]; f/ U0 L
39.     if (htim == (&TIM2_Handler))
    
40.     {
    
41.         printf("enter irq\r\n");
    
42.     }
    
43. }
    6 V# E+ u4 S  b$ Q+ @" A1 P
44. 
    ; `5 H/ [" j' U, E2 |$ Y
45. 
    
46. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    
47. {
    - `( g2 U5 b+ d: J* x5 k! o1 E- G
48.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
49. 
    
50.     __HAL_RCC_TIM2_CLK_ENABLE();
    
51.     __HAL_RCC_GPIOA_CLK_ENABLE();
    
52.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    , n2 R1 U9 n- s7 ~
53.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    3 s, l4 M9 Y6 j
54.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
55.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    , U  A( A" |# h# W
56.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    
57.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    ; {' }( R( j/ ^" Y$ Z8 T6 p( I
58. }
    

复制代码