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

1. TIM1_BRK_UP_TRG_COM_IRQn    = 13,     /*!< TIM1 Break, Update, Trigger and Commutation Interrupt           */
   ' `) m- c. |, ^( w
2.   TIM1_CC_IRQn                = 14,     /*!< TIM1 Capture Compare Interrupt                                  */
   7 x4 z2 N. U  T
3.   TIM3_IRQn                   = 16,     /*!< TIM3 global Interrupt                                           */
   . r! s5 H. N$ n6 b5 d
4.   TIM6_IRQn                   = 17,     /*!< TIM6 global Interrupt                                           */
   0 C6 w( W9 s9 a/ g( f
5.   TIM14_IRQn                  = 19,     /*!< TIM14 global Interrupt                                          */
   . R; [0 h, {* ]' H8 J
6.   TIM15_IRQn                  = 20,     /*!< TIM15 global Interrupt                                          */
   7 T4 d$ f$ ]9 e) V
7.   TIM16_IRQn                  = 21,     /*!< TIM16 global Interrupt                                          */
   ) {* N1 {# }0 P9 K" T: S- d
8.   TIM17_IRQn                  = 22,     /*!< TIM17 global Interrupt                                          */

复制代码

( [, [- [6 N0 S* y. t; a4 y2）通常每个IRQn对应一个zho中断函数
. u! A7 z, V- w( k8 I

1. /**
   % e; e8 d; O9 ~& ]* l2 ?
2.   * @brief  This function handles TIM14 global interrupt request.
   
3.   * @param  None
   # I/ L/ f6 }7 J3 Q
4.   * @retval None
   9 F3 y! D3 v; Y) l5 Y
5.   */
   ' H& i/ T5 Q$ f* U, ?% H7 z
6. void TIM14_IRQHandler(void)
   $ v1 M' @: V+ I& t6 W$ Q
7. {
     S4 `* q; ?% R0 z) d: i
8.   HAL_TIM_IRQHandler(&Input_Handle);
   9 u# H- w1 K6 ~2 f* j' H4 ^
9. }

复制代码

3）中断函数里通常会调用HAL_TIM_IRQHandler(&Input_Handle);这个函数来区分是哪一种中断

: @  C* p( v; m# R

1. /**
   
2.   * @brief  This function handles TIM interrupts requests.
   $ q5 v. r9 X, s4 m
3.   * @param  htim TIM  handle
   
4.   * @retval None
   
5.   */
   
6. void HAL_TIM_IRQHandler(TIM_HandleTypeDef *htim)
   9 e( A) U+ o% S3 ?% S
7. {
   
8.   /* Capture compare 1 event */
   - f* h+ R$ |* g( T" C
9.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC1) != RESET)
   ; F+ J" ^: P, G
10.   {
    
11.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC1) !=RESET)
    + R% a0 u! J( ?( Y
12.     {
    
13.       {
    ) j" O, r0 @& j& ^( o* \4 z2 t
14.         __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC1);
    $ w7 P4 m% W5 e0 r8 {' X" s+ d1 |  `
15.         htim->Channel = HAL_TIM_ACTIVE_CHANNEL_1;
    
16. 
    
17.         /* Input capture event */
    2 f# s& ?& ^3 u4 u
18.         if((htim->Instance->CCMR1 & TIM_CCMR1_CC1S) != 0x00U)
    9 W. m6 g* L8 V6 K4 i
19.         {
    
20.           HAL_TIM_IC_CaptureCallback(htim);
    8 p& I5 Q, ?" e- p/ s
21.         }
    
22.         /* Output compare event */
    5 r- L% u5 ^9 u% p
23.         else
    ( x+ `6 \/ F* ^; ^6 m
24.         {
    , n4 R/ F" c7 b) h" d, p+ D& W
25.           HAL_TIM_OC_DelayElapsedCallback(htim);
    7 F! u' G: K+ ?& d& c* Y: g0 S
26.           HAL_TIM_PWM_PulseFinishedCallback(htim);
    . z$ G  K5 }) L" Y
27.         }
    9 \* E, D; ]# Z9 I- {0 V
28.         htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;
    
29.       }
    ( n! j9 z% y! A& M. U2 D- E
30.     }
    * u; N3 B! U0 N
31.   }
    
32.   /* Capture compare 2 event */
    ! u/ W2 F8 M5 F
33.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC2) != RESET)
    & q0 s4 e6 n$ E1 R4 \3 G4 H# a! b# e8 J
34.   {
    
35.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC2) !=RESET)
    " V/ E9 Y! `5 `2 N1 V: {8 T9 L
36.     {
    9 K2 @  ~& e% ]( q
37.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC2);
    3 [  |2 a8 o) Q. o# e+ r( {
38.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_2;
    . F$ b1 A2 H1 i3 d/ R  @3 s/ }' _& _
39.       /* Input capture event */
    - F: C- u/ A. g/ j3 L0 J& C
40.       if((htim->Instance->CCMR1 & TIM_CCMR1_CC2S) != 0x00U)
    0 O) N) V8 Y' u3 f9 C, W
41.       {
    
42.         HAL_TIM_IC_CaptureCallback(htim);
    # ?% O+ D9 \8 c/ Y9 i
43.       }
    5 y& ^* c0 u; \( \+ _& y6 P
44.       /* Output compare event */
    # C: c& g( I. L+ |
45.       else
    : l+ _9 {7 q! J5 z$ e/ v6 n
46.       {
    2 Y8 A; T8 D( p* I, R: E$ D1 M
47.         HAL_TIM_OC_DelayElapsedCallback(htim);
    * g) H9 F  k( U; D, Q* ^1 L
48.         HAL_TIM_PWM_PulseFinishedCallback(htim);
    
49.       }
    ( E% z. j- f2 b# w7 L" E
50.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;
    
51.     }
    
52.   }
    9 R) Q7 Y: {  h$ q% ]
53.   /* Capture compare 3 event */
    
54.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC3) != RESET)
    ' c& u7 _5 p* s- a- l9 D
55.   {
    
56.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC3) !=RESET)
    
57.     {
    
58.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC3);
    , @& v4 |4 n4 a: k/ [
59.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_3;
    2 r: W4 [6 `1 G" X8 X) t
60.       /* Input capture event */
    
61.       if((htim->Instance->CCMR2 & TIM_CCMR2_CC3S) != 0x00U)
    7 \* s% _! ^1 I2 P7 @
62.       {
    
63.         HAL_TIM_IC_CaptureCallback(htim);
    & z4 d2 M; f) }- ~3 T4 U
64.       }
    
65.       /* Output compare event */
    
66.       else
    ( P  H/ n& a7 l" I3 B
67.       {
    
68.         HAL_TIM_OC_DelayElapsedCallback(htim);
    $ G( S: T/ ^+ v9 x1 w
69.         HAL_TIM_PWM_PulseFinishedCallback(htim);
    
70.       }
    ) ?9 H0 B  m) N; Z# J' A1 R
71.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;
    
72.     }
    6 ^% l; C/ K- q6 Y
73.   }
    
74.   /* Capture compare 4 event */
    
75.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC4) != RESET)
    
76.   {
    $ F: O; z8 w  Z" \  L
77.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC4) !=RESET)
    
78.     {
    . k) Q' }3 V1 F' R7 z" ^
79.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC4);
    
80.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_4;
    7 I0 B! G1 B' y. v+ F3 Y3 C% n
81.       /* Input capture event */
    1 O0 a* G6 p4 N. H/ o
82.       if((htim->Instance->CCMR2 & TIM_CCMR2_CC4S) != 0x00U)
    2 b0 r" S; H  c/ Y
83.       {
    / L9 s. U6 j% {( G( t  P2 }* R
84.         HAL_TIM_IC_CaptureCallback(htim);
    
85.       }
    $ w- T, j/ T; R
86.       /* Output compare event */
    
87.       else
    
88.       {
    / t3 \! X% p7 ?1 e: s& g
89.         HAL_TIM_OC_DelayElapsedCallback(htim);
    
90.         HAL_TIM_PWM_PulseFinishedCallback(htim);
    
91.       }
    
92.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;
    
93.     }
    * K9 O+ O7 D+ ]: I
94.   }
    
95.   /* TIM Update event */
    
96.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_UPDATE) != RESET)
    " z3 L% W- _" K4 {
97.   {
    
98.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_UPDATE) !=RESET)
    + [1 T/ R+ q8 x& q' i! M% X
99.     {
    0 Z+ V" h: u; B( V
100.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_UPDATE);
     
101.       HAL_TIM_PeriodElapsedCallback(htim);
     ! Q7 W: {7 l% t& Y
102.     }
     
103.   }
     ' B# d! a8 j) s6 l" K. K4 M
104.   /* TIM Break input event */
     
105.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_BREAK) != RESET)
     ! u+ V7 z/ t( q$ B+ M1 X
106.   {
     
107.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_BREAK) !=RESET)
     2 p8 ^; U' ~- C9 k: T+ `, }
108.     {
     
109.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_BREAK);
     
110.       HAL_TIMEx_BreakCallback(htim);
     1 I! w' F: \3 Y3 |4 J! \1 ?  K
111.     }
     3 W1 |3 M- O2 W' @- l
112.   }
     & ]" ^* p( `/ v  l7 O  j8 o* _0 @
113.   /* TIM Trigger detection event */
     % \. ]5 y2 ~; c  S- H& m- N
114.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_TRIGGER) != RESET)
     
115.   {
     
116.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_TRIGGER) !=RESET)
     
117.     {
     
118.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_TRIGGER);
     
119.       HAL_TIM_TriggerCallback(htim);
     
120.     }
     1 ^2 B0 \8 _2 |  N9 ]6 D% ^
121.   }
     
122.   /* TIM commutation event */
       a! F7 ~+ }! A! Q% T
123.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_COM) != RESET)
     
124.   {
     1 w7 `' M4 h2 N+ x2 R3 V
125.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_COM) !=RESET)
     
126.     {
     ' ~8 ]+ e% Q5 y
127.       __HAL_TIM_CLEAR_IT(htim, TIM_FLAG_COM);
     " n3 O9 k1 z  B4 y/ k
128.       HAL_TIMEx_CommutationCallback(htim);
     ) I8 t/ l4 ?  o; u& w9 w% _. \5 T5 a
129.     }
     
130.   }
     
131. }

复制代码

/ h3 H; t  ]$ X$ e. }4 H! }4）在这个函数里根据不同的中断，调用不同的回调函数，像最基本的计时中断，调用HAL_TIM_PeriodElapsedCallback(htim);
: _8 I( E* y3 S. M$ A1 |
5）问题来了：当我的程序需要用多个di开始定时器时，而且有相同的中断。开始我以为可以在

1. HAL_TIM_IRQHandler(&Input_Handle);后面写自己的处理代码
   
2. 
   
3. void TIM14_IRQHandler(void)
   . u1 w% l! g# C; v: }0 b
4. {
   8 g1 j* L. H8 [% K: P
5.   HAL_TIM_IRQHandler(&Input_Handle);
   5 Z  y) D( ^  c5 Q! C
6. 
   
7. //其他处理代码
   * r$ s6 w) U) _
8. }

复制代码

. t- |5 X3 U5 s( W& g2 V6）但是，在使用Freemodbus的时候FreeModbus用到的定时器在HAL_TIM_PeriodElapsedCallback(htim)中执行了TIMERExpiredISR();这个函数。

, c' s2 L' M9 m2 Q- [7）当我用到另一个别的定时器的的时候，因为我在HAL_TIM_PeriodElapsedCallback(htim)这个函数里没有区分是哪个定时器产生的中断，所以当其他定时器产生中断时也顺便执行了属于FreeModbus的这个TIMERExpiredISR();处理函数。
! Z. R) [9 h# t
8）这样就导致了一个奇怪的xian现象：只有我一启动别的定时器。主机Modbus Poll的时候就会出现Timeout的情况。
, J8 g7 i/ o+ |! A
在HAL_TIM_PeriodElapsedCallback(htim)中区分zh中断来源之后，问题就解决了。

& m2 o/ W/ N# D! q% ]- K9）ken坑啊，都怪对库的执行sh顺序不了解。
- @3 e, J# O& Z' L8 A; k- `/ W
% M8 n/ V+ d2 G) X& L& |