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

1. TIM_HandleTypeDef TIM2_Handler;
   
2. static void MX_TIM2_Init(void)
   
3. {
   6 E7 s+ Q" U% f0 q) X) Z& r
4.     TIM2_Handler.Instance = TIM2;
   7 r( F4 X0 L& X& O8 u
5.     TIM2_Handler.Init.Prescaler = 10800;
   : H$ i: @1 r" C2 d3 S
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
7.     TIM2_Handler.Init.Period = 20000;
   
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   
9. 
   ! u3 e  _+ ?9 U: I+ @
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    
11.         HAL_TIM_Base_Start(&TIM2_Handler);
    # N. E6 n4 m' W8 Z& M0 N
12. }
    
13. 
    
14. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    
15. {
    
16.                 __HAL_RCC_TIM2_CLK_ENABLE();            //使能TIM3时钟  
    ! G  c6 [% O+ g6 ]7 Y
17. }
    ) L* W& ?7 B/ X9 g4 U4 y
18. 
      o% P: Q& V7 S- P  @. S

复制代码

& q  a% M9 V# d主函数中每秒打印一次定时器的值：

1.    while (1)
   - }6 j6 d: K$ l2 n; L3 \
2.     {
   
3.                 printf("cnt:%d\r\n",TIM2->CNT);
   
4.         delay_ms(1000);
   4 ?: {2 e- ?; {, d* m: z
5.     }
   4 ]! w4 C5 n7 B) {

复制代码

显示效果如下：
# L8 E1 U8 l# R+ Q8 ?. w3 \4 Y


8 Y6 w8 X# l; N定时器中断
6 R- s! L7 B! j' y5 j通过HAL_TIM_Base_Start可以开启基本计时功能，但要实现定时器中断功能，就需要开启相应的标志位，即使用HAL_TIM_Base_Start_IT进行定时的开启；
* x2 `: j# p/ W. s- P4 F在配置定时器之前，除了要开启时钟，还需要先设置中断优先级，和使能中断向量；
在定时器中断TIM2_IRQHandler服务函数中调用HAL库提供的定时器中断处理函数HAL_TIM_IRQHandler，解析到的定时器超时中断会自动跳转到HAL_TIM_PeriodElapsedCallback；
+ }/ \( g( F' f

1. TIM_HandleTypeDef TIM2_Handler;
   
2. static void MX_TIM2_Init(void)
   
3. {
     K+ U0 h; j& Q: {% [' g* m
4.     TIM2_Handler.Instance = TIM2;
   
5.     TIM2_Handler.Init.Prescaler = 10800;
   . s, ^% ?8 _6 w. }4 R9 [* ?9 i# _. ]
6.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   
7.     TIM2_Handler.Init.Period = 20000;
   
8.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   
9. 
   ' g6 `' m- Q& K4 n4 @9 _
10.     HAL_TIM_Base_Init(&TIM2_Handler);
    
11.     //HAL_TIM_Base_Start(&TIM2_Handler);
    
12.         HAL_TIM_Base_Start_IT(&TIM2_Handler);
    1 }; R) ?: O1 R7 V9 t9 _
13. }
    9 X: ]# N) K4 H# s' f5 `
14. 
    
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
    
19.     HAL_NVIC_EnableIRQ(TIM2_IRQn);          //开启ITM2中断
    - j2 y1 u' y% |( z& e5 {
20. }
    - t! d  G3 s% K8 l0 a: w( f8 l
21. 
    
22. void TIM2_IRQHandler(void)
    
23. {
    
24.     HAL_TIM_IRQHandler(&TIM2_Handler);
    % T0 B( f" v) `3 q4 u
25. }
    
26. 
    ; L+ Y3 ]6 \8 f: X
27. 
    $ A8 _: J/ c# G5 Y& g. C# k
28. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
29. {
    
30.     if (htim == (&TIM2_Handler))
    : ?6 [- t$ j) `! R& `- _5 B1 I
31.     {
    $ e% o7 L; Z/ s# S& D2 u
32.         printf("enter irq\r\n");
    
33.     }
    
34. }
    
35. 
    1 I/ P* e  G( A- `+ R+ L8 r

复制代码

0 K" J) ~9 g( A8 ~, r2 R显示效果如下：
. L$ W: J0 k- Z' t3 _+ F) f
9 V, G  _# W. S5 a' M7 p3 j

% y/ g8 l/ c" u0 APWM输出
硬件PWM输出是不需要使用定时器中断的，但同样需要基本的定时参数配置，初始化也不再是使用HAL_TIM_Base_Init而是使用HAL_TIM_PWM_Init进行初始化了；
5 k9 m* Y; x& E6 |7 Z$ ?5 y配置完定时器为PWM模式，那么相应的输出通道也需要通过HAL_TIM_PWM_ConfigChannel进行配置；
# w; `) L3 z1 u+ P* a同样的启动也不是HAL_TIM_Base_Start或者HAL_TIM_Base_Start_IT了，而是HAL_TIM_PWM_Start了；

1. TIM_HandleTypeDef TIM2_Handler;
   " N: W$ p! ]' E% E2 S- r
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   / i5 G) @3 ^! g  }1 S0 t) @
3. static void MX_TIM2_Init(void)
   2 o) Z/ T. d* E' T
4. {
   
5.     TIM2_Handler.Instance = TIM2;
   
6.     TIM2_Handler.Init.Prescaler = 10800;
   
7.     TIM2_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
   & S) T! d' I" F6 d
8.     TIM2_Handler.Init.Period = 20000;
   ; f/ E6 W0 g" q- O! ~
9.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   
10.     HAL_TIM_PWM_Init(&TIM2_Handler);
    3 ?; J% b2 A8 k: p) i, w
11. 
    
12.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    4 n0 G1 @2 w; o8 O9 l7 {
13.     TIM2_CH2Handler.Pulse = 10000;
    1 W( w2 o* K4 r4 I
14.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    / J1 K. ~+ X2 {: e& v. [8 d- y
15.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    
16.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    - q! A- t9 `1 ~- F$ z
17. 
    
18.     HAL_TIM_PWM_Start(&TIM2_Handler, TIM_CHANNEL_2); //开启PWM通道2
    
19. }
    
20. 
      I1 q1 F" c% N6 L2 N" f
21. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    3 f( Q) u3 z2 k
22. {
    ; l* s+ w# d- H
23.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    2 z) z# j; o+ [2 _6 ]6 P
24.                
    0 P6 `% K/ o( |/ r7 O% Z& \$ S
25.         __HAL_RCC_TIM2_CLK_ENABLE();           
    " Y1 M8 R3 u7 x% a
26.     __HAL_RCC_GPIOA_CLK_ENABLE();
    , @) k, @' I( ]' ]3 j
27.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    
28.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    ' n( w0 u7 J9 z4 O8 D: S$ H
29.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
30.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    / z( I7 f- |. U- ]
31.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    
32.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
33. }
    

复制代码

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

' z' z$ e% q/ |6 D1 r
PWM + 定时器溢出中断
我们都知道，PWM模式是在比较值处翻转，在溢出的时候再次翻转，而溢出的时候，我们也是可以产生中断的；所以同一个定时器，在这种定时时长和周期相同的时候，是可以即做硬件PWM输出，又做溢出中断的。
6 n$ v% J. C6 T8 L, B这里我们观察一下两种初始化函数：

1. /**
   
2.   * @brief  Initializes the TIM Time base Unit according to the specified
   : Q1 y! x  E8 t& U4 Y
3.   *         parameters in the TIM_HandleTypeDef and create the associated handle.
   5 Z3 y" o7 i# Q$ ]# v4 h
4.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   
5.   *                the configuration information for TIM module.
   9 u( w/ V; {$ @( Y8 {/ W2 I
6.   * @retval HAL status
   0 w) _0 n+ }$ b2 P
7.   */
   
8. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
   
9. {
     Y) Z; A0 s  m
10.   /* Check the TIM handle allocation */
    2 Z4 {/ ^0 L; Y6 a8 A5 o. N
11.   if(htim == NULL)
    
12.   {
    # K6 O! Y  e% @
13.     return HAL_ERROR;
    
14.   }
      u6 o4 t* t! K6 B3 F
15.   
    
16.   /* Check the parameters */
    
17.   assert_param(IS_TIM_INSTANCE(htim->Instance));
      l6 `& `" s1 Q3 S: O# I5 q4 X
18.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    
19.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    5 s/ j% C6 F1 ]5 d8 x8 ]* a
20.   
      C1 U+ V& @9 ?' G1 a
21.   if(htim->State == HAL_TIM_STATE_RESET)
    
22.   {  
    - ]1 f" `: e) [
23.     /* Init the low level hardware : GPIO, CLOCK, NVIC */
    
24.     HAL_TIM_Base_MspInit(htim);
    : T1 }4 Y. f  ?# i3 k  }' B- q8 P
25.   }
    
26.   
    
27.   /* Set the TIM state */
    % X) w8 R! u, T' Y& w
28.   htim->State= HAL_TIM_STATE_BUSY;
    % t! r  t7 \$ t. R3 c5 J7 x0 S1 r5 }$ Z
29.   
      f/ A: W% g# }( d8 _" v
30.   /* Set the Time Base configuration */
    % v! p' F7 r4 `* S" P! H+ a
31.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    6 y0 Q! N+ N) R& W6 y1 U0 L
32.   
    * o5 x/ X( N( }% r% W: k0 H/ {7 e! {# \
33.   /* Initialize the TIM state*/
    8 d' _% ]% ]9 \- O
34.   htim->State= HAL_TIM_STATE_READY;
    
35.   
    / x  `# a, P+ c) `, z9 A
36.   return HAL_OK;
    
37. }
    
38. 
    
39. 
    
40. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
    
41. {
    
42.   /* Check the TIM handle allocation */
    
43.   if(htim == NULL)
    ) u& _+ e+ t2 c& B! e
44.   {
    
45.     return HAL_ERROR;
    : }- H( {' t; N# D! f
46.   }
    
47. 
    
48.   /* Check the parameters */
    ( I! w2 ~1 s* x$ `
49.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    
50.   assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
    : |/ L5 x6 Z- A6 n: E
51.   assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
    " g8 K8 U) `+ t2 I" T% k' z
52. 
    
53.   if(htim->State == HAL_TIM_STATE_RESET)
    6 A; \' {' l% F- V
54.   {
    : l, ?# l6 \# F  R) ~
55.     /* Allocate lock resource and initialize it */
    
56.     htim->Lock = HAL_UNLOCKED;  
    . i+ d: F& A6 _9 ?* W' f
57.     /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
    
58.     HAL_TIM_PWM_MspInit(htim);
    3 G- z9 `) g+ j1 G
59.   }
    1 I, w3 I2 f" x/ w$ j0 _" h
60. 
    # y0 ?+ W/ l7 S) l8 Z, u! [4 v
61.   /* Set the TIM state */
    
62.   htim->State= HAL_TIM_STATE_BUSY;  
    
63.   
    % F- K0 \1 L% z# @- y4 Y
64.   /* Init the base time for the PWM */  
    
65.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    % y* X/ r% n+ K* T3 S
66.    
    
67.   /* Initialize the TIM state*/
    # M; I& A, N. ^/ m) H$ j; d& J* |
68.   htim->State= HAL_TIM_STATE_READY;
    
69.   
    9 T- f* w- D" A0 z! f
70.   return HAL_OK;
    
71. }  
    9 x& t9 g* _! g7 S

复制代码

6 L5 _, U) f# _$ d/ D" S两者除了底层的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，后面的一个就得不到执行了。
- f4 l; i' T/ K' q: U再来看启动代码：
- \0 A. C& T" K) K/ k

1. /**
   7 c; p. y  J* _! J; }
2.   * @brief  Starts the TIM Base generation.
   
3.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
   0 n& T0 ~5 z) ^8 L5 Y" e
4.   *                the configuration information for TIM module.
   
5.   * @retval HAL status
   3 e* I3 y. {% ], K& _. {* J9 v9 J
6.   */
   & B3 E5 l+ N; n) \- {
7. HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim)
   
8. {
   
9.   /* Check the parameters */
   
10.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    $ ^* S  x  s7 L0 ^! a% k& J
11.   
    
12.   /* Set the TIM state */
    
13.   htim->State= HAL_TIM_STATE_BUSY;
    4 J( ]2 E3 w0 _/ j
14.   
    
15.   /* Enable the Peripheral */
      h2 t. ~; p4 X, o3 l; O$ J
16.   __HAL_TIM_ENABLE(htim);
    " D' \7 [. [, ^. G0 X' p2 R
17.   
    
18.   /* Change the TIM state*/
    
19.   htim->State= HAL_TIM_STATE_READY;
    / }; A5 q: z( D9 c, {% l) Y
20.   
      d9 ^5 w, g5 t( O1 l. a. h- g
21.   /* Return function status */
    
22.   return HAL_OK;
    
23. }
    7 O, i. K: V; Q: q" J4 F  J
24. 
    
25. 
    
26. /**
    , u) Z1 t; F! R
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.
    2 W/ B7 n1 x- T' v! ]8 s
30.   * @retval HAL status
    ' b$ j% Z) L, A6 ^  R
31.   */
    5 u7 y3 l+ J( f9 U0 t* W
32. HAL_StatusTypeDef HAL_TIM_Base_Start_IT(TIM_HandleTypeDef *htim)
    4 o; z& q+ e+ \: t' O
33. {
    ' s" r1 M+ S0 X# N, q" P
34.   /* Check the parameters */
    
35.   assert_param(IS_TIM_INSTANCE(htim->Instance));
    + D6 b4 X6 x* G! h/ Q
36.   
    5 e$ t/ W% X9 U0 ?
37.   /* Enable the TIM Update interrupt */
    7 E0 I; V" E0 Q$ c
38.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
    " y+ j3 c) X0 H4 D: F
39.       
    ) N% L: k+ m/ D5 y4 L/ L" _0 s" x
40.   /* Enable the Peripheral */
    
41.   __HAL_TIM_ENABLE(htim);
    - G% i% ~5 A5 s/ a2 a) ]5 I9 S0 C5 R8 ]
42.       
    0 h3 }; [  _# G; v" J5 D5 A
43.   /* Return function status */
    6 o9 ^/ J2 v- Z" E$ _  O# a
44.   return HAL_OK;
    
45. }
    
46. 
    # G; Q0 }0 f# n" i5 y
47. 
    
48. /**
    1 ?/ Z8 I8 p2 N/ X
49.   * @brief  Starts the PWM signal generation.
    " i6 ?3 l# }' J0 N8 e) F, K
50.   * @param  htim: pointer to a TIM_HandleTypeDef structure that contains
    % q! o  v: j4 R( A5 q' y! O
51.   *                the configuration information for TIM module.
    
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
    
55.   *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
    - A2 U6 b# h6 y' G
56.   *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
    4 G( R  t* ?6 f5 d) Z* ?: \
57.   *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
    
58.   * @retval HAL status
    $ X3 [. H/ N8 b- z! r9 }
59.   */
    
60. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
    , l6 e+ Z4 T7 z! R$ t- b  L
61. {
    1 |+ R) k6 X% U* J# F% g
62.   /* Check the parameters */
    - P( M& v# y: n+ Q( n  m
63.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
    
64. 
    
65.   /* Enable the Capture compare channel */
    & C, T( N/ [3 u2 ~+ _' i
66.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    
67.   
    
68.   if(IS_TIM_ADVANCED_INSTANCE(htim->Instance) != RESET)  
    % M+ w$ N' f4 U5 i1 S7 o$ s" ~
69.   {
    ' p* Z- J9 n* o5 }: p
70.     /* Enable the main output */
    
71.     __HAL_TIM_MOE_ENABLE(htim);
    4 Y0 y, s% M, h; i0 @' {
72.   }
    ' H; K2 J' w( K  t6 I* b* O, e
73.    
    ' [5 Y$ E. T* M" \! L
74.   /* Enable the Peripheral */
    
75.   __HAL_TIM_ENABLE(htim);
    & t9 j$ i# Z1 b& l
76.   
    5 x$ m7 G- I6 X: w9 l# O+ m
77.   /* Return function status */
    ' a  g9 o2 X7 Y0 G: U+ h
78.   return HAL_OK;
    ) y/ H* n1 l- i- v6 t, L
79. }
    . }+ q1 r' }1 V; f$ _

复制代码

6 c9 N, m. z& a3 b$ k. E, l其中的核心代码分别是：

1. __HAL_TIM_ENABLE(htim);
   $ J  w% O$ [+ v- D8 T3 b4 v

复制代码

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   7 N7 w- e0 Z" X: G* a2 ^1 l6 M
2.   __HAL_TIM_ENABLE(htim);
   

复制代码

1.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   + {5 b, t% a' F5 r0 s
2.   __HAL_TIM_ENABLE(htim);
   

复制代码

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

1.   __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
   5 Z; Y' z6 S* M
2.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
   / `3 }( c% B  y8 W3 v' O0 r7 A5 U. G
3.   __HAL_TIM_ENABLE(htim);
   + j  D' z5 f: L; K- ?

复制代码

7 \, U4 {( I( U/ K8 y$ L完整代码如下：
& M; k4 Z( _. U8 X% r$ ^  `

1. TIM_HandleTypeDef TIM2_Handler;
   
2. TIM_OC_InitTypeDef TIM2_CH2Handler;
   
3. 
   
4. 
   $ @9 A- S2 _+ C  q/ J: o7 |
5. static void MX_TIM2_Init(void)
   
6. {
   
7.     __HAL_RCC_TIM2_CLK_ENABLE();
   % t. w% _6 I2 s% e  C3 X
8.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 3);
   $ G# Y- d- F) N' K& r
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;
    # w* j! B- m+ N* M% |
14.     TIM2_Handler.Init.Period = 20000;
    
15.     TIM2_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    
16.    
    
17.     HAL_TIM_PWM_Init(&TIM2_Handler);
    2 j" T: D9 [# h
18. 
    
19.     TIM2_CH2Handler.OCMode = TIM_OCMODE_PWM1;
    
20.     TIM2_CH2Handler.Pulse = 10000;
    
21.     TIM2_CH2Handler.OCPolarity = TIM_OCPOLARITY_HIGH;
    & k* [2 \7 t0 f2 A
22.     TIM2_CH2Handler.OCFastMode = TIM_OCFAST_DISABLE;
    
23.     HAL_TIM_PWM_ConfigChannel(&TIM2_Handler, &TIM2_CH2Handler, TIM_CHANNEL_2) ;
    
24. 
    7 d$ {( t/ \& T  C7 U! i
25.     __HAL_TIM_ENABLE_IT(&TIM2_Handler, TIM_IT_UPDATE);
    
26.     TIM_CCxChannelCmd(TIM2_Handler.Instance, TIM_CHANNEL_2, TIM_CCx_ENABLE);
    7 Y$ S% c: B9 A2 I
27.     __HAL_TIM_ENABLE(&TIM2_Handler);
    $ M/ q& y& u4 L! O. E1 I
28. }
    
29. 
    
30. 
    
31. void TIM2_IRQHandler(void)
    
32. {
    7 d- N* ?% M2 A5 z3 r- ]& O" `
33.     HAL_TIM_IRQHandler(&TIM2_Handler);
    0 N3 v# b( b. U% u
34. }
    6 Y( C  m. E+ c; J
35. 
    
36. 
    0 S& ?- q  H- C% }/ q6 J
37. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    * e) j" f" y8 b$ @, d# G& Y
38. {
    # v# ?3 _8 [0 T8 |7 t' {* G  ?( f
39.     if (htim == (&TIM2_Handler))
    
40.     {
    
41.         printf("enter irq\r\n");
    
42.     }
      w: ^3 C& s) X3 ^, _2 d0 u( h8 C* i, X
43. }
    4 |0 Y  w' i4 M3 |, G) s4 v( v
44. 
    , S% v/ u* f: [, j5 f
45. 
    
46. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    
47. {
    - A! A" @- d$ q* q7 l2 [
48.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
49. 
    2 u* t* i# S% K2 Z# J/ \
50.     __HAL_RCC_TIM2_CLK_ENABLE();
    
51.     __HAL_RCC_GPIOA_CLK_ENABLE();
    , o, L1 S: D5 e8 b; k3 Q& ~5 I
52.     GPIO_InitStruct.Pin = GPIO_PIN_1;
    
53.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    0 w/ L" Q" R3 c, o. y0 o
54.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    $ H! C' g- L  _; p; `) G
55.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    $ S1 i1 r- f8 k( s, \6 o3 ^% [! h
56.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    2 d$ M2 ?5 h5 x) J& B" S. _
57.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
      _) R! U0 c( J* `3 [$ X$ d+ L
58. }

复制代码

————————————————
) V. D) ~  B& o! W# P9 _版权声明：小盼你最萌哒
& C! j1 z( g0 O: D( P# d

' r9 p6 `2 \, J