先看一段代码：

1. while (1)
   . ]$ K. I" _) K; `/ c* i2 u
2.   {
   
3. if(EXTI_Sign ==1)
   % x$ g1 ~6 d) e: i( t( i
4.            {
   0 a5 t& k$ g1 f6 Z
5. HAL_Delay(Period);
   2 Y1 |3 p  o+ V8 v/ n' S
6. 
   
7. HAL_NVIC_EnableIRQ(EXTI2_3_IRQn);
   
8. 
   
9. HAL_NVIC_EnableIRQ(EXTI2_3_IRQn);
   / i: w% X' L7 f6 R8 J  i% G) v
10. 
    ) b& \, J. {& V( Y' Y, \' v% ?8 _! C
11. EXTI_Sign =0;
    
12.      。。。。。。
    ( d5 C0 m! w$ e' ]/ P) I6 P
13. }
    
14. }

复制代码

有人使用STM32G0系列的芯片开发产品，有段功能测试验证代码如上所示，相同的函数必须调用2次才能正常运行，调用2次倒也罢了，关键是必须！颇为纳闷。

这里开启了PA3的外部中断功能，上下沿均可触发。PA3接收外来报警信号，类似于烟感报警器。报警信号是一串脉冲信号，报警信号过来时存在多次抖动问题。客户想了个方法消抖，只要报警端口有电平变化就触发中断然后把中断Disable，并设置报警标志再回到主程序。

主程序里识别到报警有效标志后延时几分钟再Enable刚才Disable掉的外部中断。但是，他发现再次使能外部中断时需要连续两次调用使能中断的代码才可以响应新的报警信号。

$ e8 U' ?: F: i. S

下面MX_GPIO_Init(void)是经CubeMx配置后自动生成的，里面有EXTI相关NVIC配置。相关代码如下：

1. static void MX_GPIO_Init(void)
   
2. 
   7 `' ?- K4 K  M0 O6 v+ W- _7 b% z1 D
3. {
   
4. 
   5 Z* J/ E. x4 u8 v
5.   GPIO_InitTypeDef GPIO_InitStruct = {0};
   * l6 J5 s! P5 u: b2 R' A
6. 
   
7. /* GPIO Ports Clock Enable */
   5 |; {6 K( }+ W
8. 
   
9.   __HAL_RCC_GPIOA_CLK_ENABLE();
   
10. 
    : Y- X' d- V/ T3 k
11.   __HAL_RCC_GPIOB_CLK_ENABLE();
    2 O+ y5 i% A3 e! |$ z7 @5 H% |
12. 
    , f1 _7 O3 D0 ^# E( ?% u5 ]
13.     。。。。。。
    
14. 
    0 B0 y! D+ l( y( }
15. /*Configure GPIO pin : PA3 */
    
16. 
    
17.   GPIO_InitStruct.Pin = GPIO_PIN_3;
    * j4 D! o4 ]% |5 P! Y3 e
18. 
    ) a, H, K  w. b( r; m: X
19.   GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;
    
20. 
    & O6 ]) F  g" ~# r8 f; A
21.   GPIO_InitStruct.Pull = GPIO_PULLUP;
    8 D. N" M9 `- F
22. 
    
23.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
24. /* EXTI interrupt init*/
    7 |8 f% O* q3 k$ j& Y) w
25. 
    ! z3 K+ t' _9 L: _
26.   HAL_NVIC_SetPriority(EXTI2_3_IRQn, 0, 0);
    
27. 
    
28.   HAL_NVIC_EnableIRQ(EXTI2_3_IRQn);
    + I1 G& Z" a) K
29. 
    2 U6 i) E$ D1 C: S& Q6 S2 _, p
30. }
    
31. 
    
32. 
    / _0 q' g! T; n, n3 k
33. 基于上沿触发的中断服务程序如下[基于下沿触发的此处省略】：
    
34. EXTI ISR（）：
    
35. {
    
36. __HAL_GPIO_EXTI_CLEAR_RISING_IT(GPIO_PIN_3); //清中断申请标志；
    . }/ ^) }% p* _+ K, o6 O
37. 
    / q' [' H# c3 q4 [& e  t! c
38. HAL_NVIC_DisableIRQ(EXTI2_3_IRQn);//关闭中断响应
    
39. 
    
40. EXIT_Sign=1;//表示收到报警信号
    8 Z9 v8 \& b. v" G7 L! Z, i: W% J
41. }
    
42. 
    
43. 主循环代码像下面书写才能让程序正常运行：【略去了其它代码】
    & R5 ^+ ^8 T! L# n. L
44. 
    
45. while (1)
    
46.   {
    
47.     if(EXTI_Sign ==1)
    & t$ \  E% y, Y* v
48.     {
    
49.     HAL_Delay(Period);
    
50. 
    
51.     MX_GPIO_Init();//客户无意中发现加这句有用
    & L1 s, }  s( I4 `. a  C9 L9 V
52. 
    
53.    HAL_NVIC_EnableIRQ(EXTI2_3_IRQn);
    
54. 
    ; H& N) B: P/ }/ Q5 ?" |
55.    EXTI_Sign =0;
    
56.     。。。。。。
    ! y/ X% A9 R5 m+ D5 V
57.     }
    6 X6 n. B8 e0 j1 o0 ?, r* e9 V$ h6 G
58. }

复制代码

& P$ y! c" d. ^& M7 [# p' a

现在的疑问是在EXTI中断服务程序运行HAL_NVIC_DisableIRQ(EXTI2_3_IRQn)后，到主循环代码里再次使能外部中断时，为何还要额外运行一次MX_GPIO_Init()函数才能让程序正常运行。最终发现运行该函数的实质就是将HAL_NVIC_EnableIRQ(EXTI2_3_IRQn)多运行一次。

0 K; }: @& P5 W

换句话说，上面的主循环代码要改成下面样子才可以让程序正常运行：

1. while (1)
   
2. 
   
3. {
   
4. 
   
5. if(EXTI_Sign ==1)
   ) ~  w9 M' |# |; Z7 u5 x1 c
6. 
   4 z/ ~9 d. ^3 D* h
7.    {  //报警有效，即发生过报警时，代码进到这里。
   1 M: _( K. @, W$ K5 b
8. 
   
9.    HAL_Delay(Period);
   ( d7 m/ X+ k2 W1 M
10. 
    
11.    HAL_NVIC_EnableIRQ(EXTI2_3_IRQn);//1
    
12. 
    
13.    HAL_NVIC_EnableIRQ(EXTI2_3_IRQn);//2
    
14. 
    ' Q$ q3 R# u; a5 j# G3 r) Z
15.    EXTI_Sign =0; //清除报警标志，准备监测新的警情
    
16. 
    . o$ T4 f2 l6 w5 C
17.     。。。。。。
    
18. 
    0 m7 c  P6 _" p( M7 K. e
19.     }
    . b% }& ~" g- O4 r
20. 
    
21. }

复制代码

说到底，问题就是主循环里为何要两次重复运行HAL_NVIC_EnableIRQ(EXTI2_3_IRQn)函数后才能响应新的报警信号呢？

可以肯定，理论上讲，开启某个中断响应无须2次运行相关函数。我们来一起找找原因。为了便于查看代码，我把中断服务程序和主程序代码截图放在一起。

' L) {7 Q! [6 m5 l" _

& O7 q* @, C- @, e' v

2 L/ J$ J: |4 \' H. y1 H4 g+ G

在中断服务程序里就是清除中断请求标志，关闭PA3的外部中断响应，并设置警情标志EXTI_Sign为1。

. h8 E" i) B- L1 h

这里有没有问题呢？

: t# h% f3 s. D" l

他使用的HAL_NVIC_EnableIRQ(EXTI2_3_IRQn)函数，关闭的是内核对该中断请求的响应，尽管他刚才在进中断时做外部中断请求标志的清零，但并不能保证他这个清零操作之后不会再产生外部中断请求。事实上，结合目前的使用场景，由于报警信号是一串跳变脉冲，即使一进中断就先做了个中断请求标志的清零，在中断退出甚至还未完全退出时大概率还会产生新的中断请求，但又由于他在中断服务程序里把中断响应关闭了，中断不能得到及时响应，请求只能悬着【Pending】跟随程序来到主循环。

主循环代码首先检查报警标志是否生效，生效则进入循环体，先静静地歇会儿【HAL_Delay(Period)】，让刚才的报警信号完全消停下来，然后再调用第一个HAL_NVIC_EnableIRQ(EXTI2_3_IRQn)函数打开中断响应。这下可好，刚才候着的中断请求得到响应机会了，则马上去执行中断服务程序。这次在中断服务程序里的操作跟上次完全一样，即在中断服务程序里，又调用中断响应关闭函数，做了跟刚才主循环里第一个HAL_NVIC_EnableIRQ(EXTI2_3_IRQn)函数完全相反的功能。即到这个点的时候，中断响应被关闭了。

+ M# L/ x# h2 i6 R0 p# ]

如果中断返回后没有使用第2句HAL_NVIC_EnableIRQ(EXTI2_3_IRQn)函数打开中断响应，而只是执行那句清零报警标志然后退出循环体。由于中断响应已经关闭，不管外部怎么报警都不会得到响应，报警标志也就永远不会被置1，这样主循环体也进不了内循环来开启中断响应。

如果有了第2句HAL_NVIC_EnableIRQ(EXTI2_3_IRQn)函数在循环体内，它就可以扭转刚才在中断服务程序里关闭外部中断响应的局面，即把它扳回来。这样的话功能上至少能正常运转了。

原因基本就大致这么回事。基于现有代码写法，如何破除这个连写2次的搞法呢。其实，我们只需要在主循环体内开启外部中断响应的函数前，延时等待函数之后加上对相关中断请求标志位的清零即可解决当前困惑。

% G3 \6 K% n6 V: t# C

比如像下面这样【其中DSB是个数据同步隔离指令，保障它前面的指令执行完毕后才执行它后面的】,在主循环内开启中断响应前，先做中断请求标志的清零。

1. while (1)
   
2. 
   $ D* n9 r& L( }2 Y+ P
3. {
   
4. 
   & ]5 d: ?5 B" z& x
5.   if(EXTI_Sign ==1)
   / E$ Y4 z5 C* z& h
6. 
   
7.     {
   : ?: t: [* {3 t5 |/ L" ]. N7 K
8. 
   
9.       HAL_Delay(Period);
   
10. 
    8 l6 [% \  \7 z2 y
11. __HAL_GPIO_EXTI_CLEAR_RISING_IT(GPIO_PIN_3);                      __HAL_GPIO_EXTI_CLEAR_FALLING_IT(GPIO_PIN_3);
    
12. 
    
13.     __DSB();
    
14. 
    % ?* Z7 t* |. e& A
15.     HAL_NVIC_EnableIRQ(EXTI2_3_IRQn);
    
16. 
    
17.    EXTI_Sign=0;
    
18. 
    
19.         。。。。。。
    
20. 
    
21.     }
    
22. 
    
23. }

复制代码

, {, J* D6 z# H# R0 K/ O$ T3 y" w

转载自：Miler

如有侵权请联系删除
) f' U, P% E; E1 }" D! X  l