1）STM32F0有多个定时器，对应多个IRQn

1. TIM1_BRK_UP_TRG_COM_IRQn    = 13,     /*!< TIM1 Break, Update, Trigger and Commutation Interrupt           */
   8 A: x0 p- V( Z# z8 D% [
2.   TIM1_CC_IRQn                = 14,     /*!< TIM1 Capture Compare Interrupt                                  */
   
3.   TIM3_IRQn                   = 16,     /*!< TIM3 global Interrupt                                           */
   
4.   TIM6_IRQn                   = 17,     /*!< TIM6 global Interrupt                                           */
   " R: R3 R8 r/ x8 z0 X3 E, N
5.   TIM14_IRQn                  = 19,     /*!< TIM14 global Interrupt                                          */
   . [! |5 e, T% f
6.   TIM15_IRQn                  = 20,     /*!< TIM15 global Interrupt                                          */
   & U1 C# \0 ^6 y# K# @/ w
7.   TIM16_IRQn                  = 21,     /*!< TIM16 global Interrupt                                          */
   
8.   TIM17_IRQn                  = 22,     /*!< TIM17 global Interrupt                                          */

复制代码

2）通常每个IRQn对应一个zho中断函数
/ g4 C* r) X' m# u. U1 [

1. /**
   
2.   * @brief  This function handles TIM14 global interrupt request.
   ' g6 ^) p% k' R
3.   * @param  None
   2 d: v& _4 S, d# @* \
4.   * @retval None
   
5.   */
   + A  H( }( l0 _- p' T
6. void TIM14_IRQHandler(void)
   - v- O5 t9 _" Z( a& T' X4 X
7. {
   , u) l2 J$ s5 h
8.   HAL_TIM_IRQHandler(&Input_Handle);
   & M1 a9 h9 E" L7 L
9. }

复制代码

9 @' b6 [/ J& c3 }" a3 [: V3）中断函数里通常会调用HAL_TIM_IRQHandler(&Input_Handle);这个函数来区分是哪一种中断

! q9 \# C2 O, \1 @

1. /**
   
2.   * @brief  This function handles TIM interrupts requests.
   1 t3 Z* c1 ]; q8 ^9 X) R
3.   * @param  htim TIM  handle
   & d- @+ L/ A8 ?7 G+ I# B. H% Y
4.   * @retval None
   " {6 M" m7 ?8 L' }- x& \
5.   */
   
6. void HAL_TIM_IRQHandler(TIM_HandleTypeDef *htim)
   
7. {
   
8.   /* Capture compare 1 event */
   . T( E! k% L. \' n) F. Y
9.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC1) != RESET)
   
10.   {
    
11.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC1) !=RESET)
    3 I  N3 I* P; ~
12.     {
    3 C+ G6 k% v7 t' T3 z2 I
13.       {
    
14.         __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC1);
    9 ~0 J# F' ~' `; I# m
15.         htim->Channel = HAL_TIM_ACTIVE_CHANNEL_1;
    ' Q, e8 W' g7 }! s) j4 |: K
16. 
    ' o5 R( d% R+ u- a, Y5 ~
17.         /* Input capture event */
    
18.         if((htim->Instance->CCMR1 & TIM_CCMR1_CC1S) != 0x00U)
    3 g* B+ A6 C- |- c* I0 o4 h" }3 }
19.         {
    
20.           HAL_TIM_IC_CaptureCallback(htim);
    
21.         }
    * N5 {# G3 n* ^
22.         /* Output compare event */
    
23.         else
    : O; s8 z/ L0 K
24.         {
    
25.           HAL_TIM_OC_DelayElapsedCallback(htim);
    
26.           HAL_TIM_PWM_PulseFinishedCallback(htim);
    
27.         }
    
28.         htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;
    2 |9 z! j; ?) S! [$ O. t$ d8 n0 Q/ l
29.       }
    
30.     }
    ; _( K0 {, G/ x4 c* m# \2 ^0 B
31.   }
    
32.   /* Capture compare 2 event */
    4 l2 X2 o' _$ Y6 Y9 E
33.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC2) != RESET)
    
34.   {
      l& ]3 i3 o, a( i; G
35.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC2) !=RESET)
      Z; L9 N0 q. P2 |( M
36.     {
      E( B5 k+ D  K6 d
37.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC2);
    7 o1 z# J: F+ d+ P( P
38.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_2;
    9 Z; ]3 l& Y& a6 T5 i) j
39.       /* Input capture event */
    . y- @1 D4 W' S) @/ K
40.       if((htim->Instance->CCMR1 & TIM_CCMR1_CC2S) != 0x00U)
    
41.       {
    
42.         HAL_TIM_IC_CaptureCallback(htim);
    
43.       }
    6 e7 U  @6 a$ e$ i; g: {  K7 [
44.       /* Output compare event */
    . n8 g  p( f. M$ F; s& N
45.       else
    ; c3 p/ _" W1 I
46.       {
    # ]4 I$ j0 t. y" A3 `$ ], r
47.         HAL_TIM_OC_DelayElapsedCallback(htim);
    
48.         HAL_TIM_PWM_PulseFinishedCallback(htim);
    
49.       }
    . n; r9 |) }  G' e$ Q2 U
50.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;
    ; |+ t( }, t) Z2 T, {) ~% q
51.     }
    
52.   }
    
53.   /* Capture compare 3 event */
    
54.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC3) != RESET)
    1 q8 V7 k2 m9 N  M- P( ~
55.   {
    
56.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC3) !=RESET)
    
57.     {
    
58.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC3);
    
59.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_3;
    
60.       /* Input capture event */
    % _) t0 u9 U; v
61.       if((htim->Instance->CCMR2 & TIM_CCMR2_CC3S) != 0x00U)
    
62.       {
    
63.         HAL_TIM_IC_CaptureCallback(htim);
    - r+ M! @8 A3 \: E
64.       }
    
65.       /* Output compare event */
    9 q0 B- R$ @& H$ t
66.       else
    
67.       {
    : l- I9 E' J  l: t
68.         HAL_TIM_OC_DelayElapsedCallback(htim);
    % E. f. f& ^3 _2 a
69.         HAL_TIM_PWM_PulseFinishedCallback(htim);
    
70.       }
    
71.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;
    1 ^* ?2 Z8 T/ |* M
72.     }
    
73.   }
    - z3 t# |# _& E$ i( {
74.   /* Capture compare 4 event */
    
75.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC4) != RESET)
    # Z% i- Z% V/ r8 o0 v! ~$ H- v: m# d
76.   {
    
77.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC4) !=RESET)
    
78.     {
    
79.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC4);
    
80.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_4;
    
81.       /* Input capture event */
    : L; O& P" S3 e3 j" N  P
82.       if((htim->Instance->CCMR2 & TIM_CCMR2_CC4S) != 0x00U)
    8 R6 O- F, v" ]' G& }/ G3 u
83.       {
    , u# Y% k3 d3 q" j% \  Q2 }) b% K
84.         HAL_TIM_IC_CaptureCallback(htim);
    
85.       }
    
86.       /* Output compare event */
    - m8 @5 d& A# e# Y) R/ I
87.       else
    
88.       {
    3 l1 F8 T% }/ Q
89.         HAL_TIM_OC_DelayElapsedCallback(htim);
    
90.         HAL_TIM_PWM_PulseFinishedCallback(htim);
    ' p5 \) @, |# e  u
91.       }
    ! G2 {( U6 D$ O% d0 ]+ [
92.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;
    ' {8 s3 E. i* O8 f3 ?1 p
93.     }
    . e1 g( O; h3 V7 w" T
94.   }
    
95.   /* TIM Update event */
    # i1 D) X7 n) O
96.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_UPDATE) != RESET)
    
97.   {
    
98.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_UPDATE) !=RESET)
    3 d$ K4 A/ K( Y# |. c9 }
99.     {
    
100.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_UPDATE);
     
101.       HAL_TIM_PeriodElapsedCallback(htim);
     + Y2 [- U, L3 A7 m: b+ \
102.     }
     , Q: m% J# n: d/ m
103.   }
     
104.   /* TIM Break input event */
     
105.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_BREAK) != RESET)
     . A6 L3 W1 v1 Y3 Y- S$ [3 q1 ?: [
106.   {
     
107.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_BREAK) !=RESET)
     
108.     {
     
109.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_BREAK);
     ! t" ^' k1 x9 E
110.       HAL_TIMEx_BreakCallback(htim);
     . }& q0 z! u3 s) @4 t$ a' }
111.     }
     ) u: e) Y, P6 l  t4 G& ^: a" H
112.   }
     
113.   /* TIM Trigger detection event */
     8 \; q; ?: O( D
114.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_TRIGGER) != RESET)
     $ x, ]) i8 a& r+ B; W
115.   {
     
116.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_TRIGGER) !=RESET)
     5 w' E0 }3 @5 W$ k  M4 d0 [
117.     {
     , r1 y: e# a3 }" x" R. R
118.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_TRIGGER);
     
119.       HAL_TIM_TriggerCallback(htim);
     
120.     }
     ( a# i, A6 s) _" M2 d4 I
121.   }
     
122.   /* TIM commutation event */
     1 V! \+ L2 C. S& N' h/ g0 K
123.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_COM) != RESET)
     
124.   {
     
125.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_COM) !=RESET)
     
126.     {
     
127.       __HAL_TIM_CLEAR_IT(htim, TIM_FLAG_COM);
     . V$ t+ g* v! F. |& V
128.       HAL_TIMEx_CommutationCallback(htim);
     1 t4 t. b4 E- s6 `$ y
129.     }
     
130.   }
     9 N/ h. q2 R3 @4 k- z2 m
131. }

复制代码

) @% P  P' \5 T0 m4）在这个函数里根据不同的中断，调用不同的回调函数，像最基本的计时中断，调用HAL_TIM_PeriodElapsedCallback(htim);
, J, ]( {$ @6 ]" k! s8 o$ Q
1 G- A+ H2 F$ z) M$ a8 j5）问题来了：当我的程序需要用多个di开始定时器时，而且有相同的中断。开始我以为可以在

1. HAL_TIM_IRQHandler(&Input_Handle);后面写自己的处理代码
   
2. 
   4 o; m( y6 ]( c; y' @
3. void TIM14_IRQHandler(void)
   
4. {
   
5.   HAL_TIM_IRQHandler(&Input_Handle);
   
6. 
   
7. //其他处理代码
   ; e4 J' C( v! `/ ?
8. }

复制代码

6）但是，在使用Freemodbus的时候FreeModbus用到的定时器在HAL_TIM_PeriodElapsedCallback(htim)中执行了TIMERExpiredISR();这个函数。
5 m( V8 O+ q6 b  K/ r- ~) C
7）当我用到另一个别的定时器的的时候，因为我在HAL_TIM_PeriodElapsedCallback(htim)这个函数里没有区分是哪个定时器产生的中断，所以当其他定时器产生中断时也顺便执行了属于FreeModbus的这个TIMERExpiredISR();处理函数。

8）这样就导致了一个奇怪的xian现象：只有我一启动别的定时器。主机Modbus Poll的时候就会出现Timeout的情况。
; o& r' j! P. T; @% k; W' k* Y
* O0 [4 ^" ?# \' i在HAL_TIM_PeriodElapsedCallback(htim)中区分zh中断来源之后，问题就解决了。
7 Z/ I4 `$ u1 h& w6 J
9）ken坑啊，都怪对库的执行sh顺序不了解。
7 h, j2 Q% k5 P