1）STM32F0有多个定时器，对应多个IRQn
+ S7 v( w  t! G0 y+ D: Y1 c

1. TIM1_BRK_UP_TRG_COM_IRQn    = 13,     /*!< TIM1 Break, Update, Trigger and Commutation Interrupt           */
   2 P5 U9 g, U( F$ T1 ?  i
2.   TIM1_CC_IRQn                = 14,     /*!< TIM1 Capture Compare Interrupt                                  */
   2 s+ o) A6 \. {% e: }) d# @5 @
3.   TIM3_IRQn                   = 16,     /*!< TIM3 global Interrupt                                           */
   1 Q9 e7 m/ b& j# s  K. z& L2 M3 w4 G1 w
4.   TIM6_IRQn                   = 17,     /*!< TIM6 global Interrupt                                           */
   
5.   TIM14_IRQn                  = 19,     /*!< TIM14 global Interrupt                                          */
   / y" P- Y8 s# q* N* \. [1 ]( B6 @
6.   TIM15_IRQn                  = 20,     /*!< TIM15 global Interrupt                                          */
   4 @6 t$ e1 g9 b, C
7.   TIM16_IRQn                  = 21,     /*!< TIM16 global Interrupt                                          */
   
8.   TIM17_IRQn                  = 22,     /*!< TIM17 global Interrupt                                          */

复制代码

9 X. c6 `; Y* }+ x* C+ F2）通常每个IRQn对应一个zho中断函数

1. /**
   
2.   * @brief  This function handles TIM14 global interrupt request.
   / Z/ M5 z3 f9 i% A3 N& v3 @- L
3.   * @param  None
   
4.   * @retval None
   
5.   */
   
6. void TIM14_IRQHandler(void)
   
7. {
   
8.   HAL_TIM_IRQHandler(&Input_Handle);
   1 D8 f5 ~  z* j# I4 m% d
9. }

复制代码

3）中断函数里通常会调用HAL_TIM_IRQHandler(&Input_Handle);这个函数来区分是哪一种中断
1 W# `" m" o: O; v8 o
$ |* t8 M, D( D

1. /**
     [% ~8 M4 ~3 H
2.   * @brief  This function handles TIM interrupts requests.
   1 k8 {' e* D  ?" j, _# x6 B
3.   * @param  htim TIM  handle
   * G9 v9 c# p! }9 g$ Y
4.   * @retval None
   
5.   */
   ; n3 H$ T/ V8 S9 w' \
6. void HAL_TIM_IRQHandler(TIM_HandleTypeDef *htim)
   
7. {
   
8.   /* Capture compare 1 event */
   
9.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC1) != RESET)
   
10.   {
    , U' t) l- z8 p4 l$ Y
11.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC1) !=RESET)
    
12.     {
    3 o( ~0 n3 S. q  m, x& \
13.       {
    
14.         __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC1);
    & ?" z: {+ c4 d" d+ J7 U
15.         htim->Channel = HAL_TIM_ACTIVE_CHANNEL_1;
    ! q1 J/ v3 o0 b% n/ D. A  k
16. 
    : R: X0 K7 s, t
17.         /* Input capture event */
    $ \( C' C. x$ q: i( ?! A0 k
18.         if((htim->Instance->CCMR1 & TIM_CCMR1_CC1S) != 0x00U)
    - {1 ]- u' {/ ^/ A7 g
19.         {
    , p: W" U% f% }% N
20.           HAL_TIM_IC_CaptureCallback(htim);
    ! N$ R& w! r8 G% p& S( K5 e& x
21.         }
    
22.         /* Output compare event */
    + S, Q, S8 z; a; A
23.         else
    
24.         {
    8 R( I+ d) P. u2 ?& \1 \+ j
25.           HAL_TIM_OC_DelayElapsedCallback(htim);
    ' I6 T  C, i4 x$ `0 h3 `
26.           HAL_TIM_PWM_PulseFinishedCallback(htim);
    0 S% s' J0 j0 d- ]) g# B
27.         }
    8 q# P. }# E5 l& J6 U5 r5 O# _
28.         htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;
    , I8 m' c; R& M$ i; x
29.       }
    4 |& H. J0 I+ ]
30.     }
    2 C; E3 e- f! N6 I+ a, p
31.   }
    . S6 j& T% }  \( v  V& r
32.   /* Capture compare 2 event */
    
33.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC2) != RESET)
    $ c1 X  y2 ?0 W% t3 O! a
34.   {
    
35.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC2) !=RESET)
    # l# M7 U3 n3 y. b& h
36.     {
      U2 G4 T+ d) u2 F8 A- ^5 t
37.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC2);
    % V3 L! ^) J) @) q5 ]7 Y1 ?% C
38.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_2;
    
39.       /* Input capture event */
    
40.       if((htim->Instance->CCMR1 & TIM_CCMR1_CC2S) != 0x00U)
    + ^0 V  H$ c. U  @( l. e
41.       {
    
42.         HAL_TIM_IC_CaptureCallback(htim);
    & ]$ l/ k: j' `9 Y- P$ y1 L0 q& h
43.       }
    
44.       /* Output compare event */
      R( R+ o( u) s7 ]6 _
45.       else
    ' b9 D0 W; `4 {% V$ v8 V$ i( C
46.       {
    
47.         HAL_TIM_OC_DelayElapsedCallback(htim);
    # Z/ V& U) G' \( s
48.         HAL_TIM_PWM_PulseFinishedCallback(htim);
    
49.       }
    % Z5 H- t$ t& d; v( Z7 h+ I
50.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;
    
51.     }
    - s: ~9 B! a, `0 m. P; C6 ~
52.   }
    
53.   /* Capture compare 3 event */
    * @0 b- ?; j& H& v; e7 M/ Z$ b
54.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC3) != RESET)
    
55.   {
    4 ?! s+ D; o0 F% y
56.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC3) !=RESET)
    ( b+ \# r8 a+ e3 H
57.     {
    
58.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC3);
    8 p7 X' M% [# q9 C7 G) S
59.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_3;
    1 \( S$ C. K" A4 I
60.       /* Input capture event */
    
61.       if((htim->Instance->CCMR2 & TIM_CCMR2_CC3S) != 0x00U)
    9 P2 v1 t1 ^; N& M; d" Q' C$ _. u
62.       {
    
63.         HAL_TIM_IC_CaptureCallback(htim);
    - y  A9 O; `: j& n* ?: C
64.       }
    # Y$ ~' i0 [1 Q1 u
65.       /* Output compare event */
    
66.       else
    # ^, z8 _1 a. ^$ t, p. k1 J5 o
67.       {
    9 I4 V$ R; p1 C1 O4 l& L
68.         HAL_TIM_OC_DelayElapsedCallback(htim);
    
69.         HAL_TIM_PWM_PulseFinishedCallback(htim);
    
70.       }
    
71.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;
    ; U5 P: E# Q) p( |5 \& B& q
72.     }
    
73.   }
    # [- K1 D  h1 z2 g
74.   /* Capture compare 4 event */
    ) h; E7 t4 \  r' `2 a  `
75.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC4) != RESET)
    * h; W7 e6 q# O2 N# w
76.   {
    + m: r* X' D7 {8 a0 y$ z6 A# _4 K
77.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC4) !=RESET)
    
78.     {
    : Q7 @! C8 ^4 P9 |2 r$ a5 k( R
79.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC4);
    ! U3 z8 N* J9 ]2 ]
80.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_4;
    
81.       /* Input capture event */
    4 j2 c7 C4 n# X
82.       if((htim->Instance->CCMR2 & TIM_CCMR2_CC4S) != 0x00U)
    * B4 C: s& l  D$ ~
83.       {
    
84.         HAL_TIM_IC_CaptureCallback(htim);
    ) `, |0 }/ o! C/ H
85.       }
    , U$ }$ y7 K) H' O- o9 V
86.       /* Output compare event */
    4 k- z6 l/ H4 o
87.       else
    
88.       {
    1 |! H, x. ]# u/ f
89.         HAL_TIM_OC_DelayElapsedCallback(htim);
    
90.         HAL_TIM_PWM_PulseFinishedCallback(htim);
    - z2 l( j) A; g) ]( P
91.       }
    8 ]3 e3 t0 f" j' B: {* a
92.       htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;
    . s% J1 N: [+ R4 W" }" l
93.     }
    
94.   }
    + v1 e+ f' M% |6 X0 q$ v( M% m
95.   /* TIM Update event */
    $ P  g# p% z7 Z) ~
96.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_UPDATE) != RESET)
    
97.   {
    
98.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_UPDATE) !=RESET)
    
99.     {
    
100.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_UPDATE);
     
101.       HAL_TIM_PeriodElapsedCallback(htim);
     1 j7 Y' Z+ J  p! W( H1 L
102.     }
     - y! u. ?) x2 K2 e
103.   }
     
104.   /* TIM Break input event */
     / |3 [1 X+ ^6 s( o9 _
105.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_BREAK) != RESET)
     " o: h4 c% b) P  ]3 ?2 B
106.   {
     
107.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_BREAK) !=RESET)
     
108.     {
     , [3 m. {/ Y  X7 i1 z
109.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_BREAK);
     2 [! D+ u7 x4 t3 R
110.       HAL_TIMEx_BreakCallback(htim);
     ' N) Y- i4 i. K: W
111.     }
     
112.   }
     ( c; ~/ ]2 v4 x& ~9 W- w, [
113.   /* TIM Trigger detection event */
     
114.   if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_TRIGGER) != RESET)
     
115.   {
     - E3 R- H' R' L2 L5 m; i
116.     if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_TRIGGER) !=RESET)
     
117.     {
     % M$ K/ S. }! s2 \4 t
118.       __HAL_TIM_CLEAR_IT(htim, TIM_IT_TRIGGER);
     * \8 {& f6 t1 \8 [2 w  j
119.       HAL_TIM_TriggerCallback(htim);
     ! I  E5 U6 V# [+ a* V; U" H
120.     }
     0 |/ z2 p' l# B* k, _) q
121.   }
     ( z6 ?- l' |$ q6 M) v
122.   /* TIM commutation event */
     ! ?5 M! u6 K# Q4 z+ E' n
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.     {
     $ J# N5 S. l9 O6 J  R' u
127.       __HAL_TIM_CLEAR_IT(htim, TIM_FLAG_COM);
     * ^8 Q( i: ?* B) `* t! j
128.       HAL_TIMEx_CommutationCallback(htim);
     
129.     }
     : w/ B" ]8 Y8 d# U& J
130.   }
     
131. }

复制代码

! F$ e. T: u$ U4）在这个函数里根据不同的中断，调用不同的回调函数，像最基本的计时中断，调用HAL_TIM_PeriodElapsedCallback(htim);
' }  ^! }; w% l/ C  {4 s
- J$ n) |4 J- Q6 {5）问题来了：当我的程序需要用多个di开始定时器时，而且有相同的中断。开始我以为可以在

1. HAL_TIM_IRQHandler(&Input_Handle);后面写自己的处理代码
   4 K4 z" E' `4 S- m1 a+ z, k1 `( {
2. 
   ( h+ S5 `1 o& r2 g) B' ]4 k+ r
3. void TIM14_IRQHandler(void)
   
4. {
   , ~% l, `" A& Q
5.   HAL_TIM_IRQHandler(&Input_Handle);
   . @4 d7 v/ A" H* ?  l( ~
6. 
   3 w  c+ g, {; d0 e
7. //其他处理代码
   
8. }

复制代码

6）但是，在使用Freemodbus的时候FreeModbus用到的定时器在HAL_TIM_PeriodElapsedCallback(htim)中执行了TIMERExpiredISR();这个函数。
1 L. [! o9 g  _. y
7）当我用到另一个别的定时器的的时候，因为我在HAL_TIM_PeriodElapsedCallback(htim)这个函数里没有区分是哪个定时器产生的中断，所以当其他定时器产生中断时也顺便执行了属于FreeModbus的这个TIMERExpiredISR();处理函数。
' J3 h5 L: d, [& Q: I; ], K
3 e4 B2 u3 T! n: b& d8）这样就导致了一个奇怪的xian现象：只有我一启动别的定时器。主机Modbus Poll的时候就会出现Timeout的情况。
/ T$ W6 {1 N# C' A: M  n7 u
" F' D# U/ {% G6 y' y) G在HAL_TIM_PeriodElapsedCallback(htim)中区分zh中断来源之后，问题就解决了。
. R) x) u6 U+ |3 Z
0 P! V+ _$ T& g3 }9）ken坑啊，都怪对库的执行sh顺序不了解。