前言
本文章主要介绍多任务系统中的的不可重入函数的用法和如何避免出错。

1. 可重入函数与不可重入函数的区别
0 B) S5 J& w9 Q. C& l: U   在多任务环境中，可重入函数可以由多于一个的任务并发使用，而不用担心数据错误。这个函数可以在执行的任何时刻中断它。
  V# d! T( {8 p  [$ l9 h   不可重入函数由于使用了一些系统资源，比如全局变量等，不能被很多任务所共享，除非能确保函数的互斥性。
1）可重入函数：
9 o6 p5 k8 E* m3 v3 v1 {* W4 H0 x不返回指向静态数据的指针。
使用本地数据。
; M, U. Z! q& R; I2 V3 Z如果必须访问全局变量，记住利用互斥信号量来保护全局变量。
9 A6 ~9 R( a$ |) z3 x, B1 H绝不调用任何不可重入函数。
2）不可重入函数：
# k6 x" i" A% J* U& i函数中使用了静态变量。
函数返回静态变量。
& \; g3 x5 c9 {% E7 s/ [函数中调用了不可重入函数。
函数体内使用了静态的数据结构；
9 i4 K# _$ x$ a函数体内调用了 malloc()或者 free()函数；
$ A  E$ y) L) D函数体内调用了其他标准 I/O 函数。
$ q& K. M) c; M7 ^+ q
7 ^( a1 O" A3 z! L总的来说，如果一个函数在重入条件下使用了未受保护的共享的资源，那么它是不可重入的。

7 _% x5 j. V% x% [9 q7 J2 a2. 不可重入函数的一次错误应用示例，造成 I2C Master 端收到的数据无法正确解析。
! i3 M- x8 p6 ?4 U. e8 R6 e: h# P这个产品使用的 MCU 为 STM32F411，是作为 Sensor hub 使用的，做为 I2C 的 Master 端，总线上挂了好几个传感器，如加速度、陀螺仪、光感应等。并且同时采用定时方式和中断方式通过 I2C 总线读取 sensor 上数据的。
& r0 H  n6 L7 F( d! P


客户产品功能是在实时操作系统上实现的，属于多任务系统。在中断处理函数中会调用 I2C_Read(…)函数，而I2C_Read(…)函数中又调用了 HAL_I2C_Master_Receive_IT(…)函数。

函数代码在示例程序中的位置如下：
% J; d1 [& d1 [# }…\stm32cubef4\STM32Cube_FW_F4_V1.6.0\Drivers\STM32F4xx_HAL_Driver\Src 的 stm32f4xx_hal_i2c.c
" F4 v' L) E. sstm32f4xx_hal_i2c.c 文件中有一段 I2C slave 接收程序，具体代码如下：
3 B9 t9 y( j! i6 @, Y6 W2 \

1. /**
   
2. /**
   8 ^5 U" [- p# Q" e4 @' P7 l+ F
3. 
   
4. * @brief Receive in master mode an amount of data in no-blocking mode with Interrupt
   $ \( i% D3 c" c; V: M9 k# z* a* B
5. * @param hi2c: pointer to a I2C_HandleTypeDef structure that contains
   
6. * the configuration information for I2C module
     w$ H+ e5 k6 W1 }" {
7. * @param DevAddress: Target device address
   
8. * @param pData: Pointer to data buffer
   
9. * @param Size: Amount of data to be sent
   
10. * @retval HAL status
    
11.   */ */
    
12.   */
    4 u; ^- ]6 x* I) o6 j( O
13.   HAL_StatusTypeDef HAL_I2C_Master_Receive_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress,
    4 I+ T5 O# s' u0 L0 m1 u' ~
14.   uint8_t *pData, uint16_t Size)
    4 c& h5 C* v3 I7 J3 p  o
15.   {
    " q# S7 P% J+ r$ _
16.   if(hi2c->State == HAL_I2C_STATE_READY)
    
17.   {
    
18.   if((pData == NULL) || (Size == 0))
    / y% t0 W3 z+ S' C
19.   {
    7 X! \' I; ?9 Q. `! ~9 H" z
20.   return HAL_ERROR;
    
21.   }
    3 Z" A# `3 V4 Y: u4 V& ^
22.   /* Wait until BUSY flag is reset */
    
23.   if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_BUSY, SET, I2C_TIMEOUT_BUSY_FLAG) !=
    1 R9 o+ V0 F8 {9 x, J
24.   HAL_OK)
    
25.   {
    
26.   return HAL_BUSY;
    7 N/ B7 _$ u! A' b
27.   }
    
28.   /* Process Locked */
    # U; v" C: h3 v( K% C8 p
29.   主控 STM32F411
    
30.   sensorhub
    
31.   Sensor1
    ) n( G6 h" `+ s; r
32.   Sensor2
    
33.   Sensor3
    
34.   Sensor4
    + g* V8 R/ [, j1 I5 J, Z
35.   __HAL_LOCK(hi2c);
    
36. 
    
37. /* Disable Pos */
    6 v8 d: \2 Y7 T. o
38. hi2c->Instance->CR1 &= ~I2C_CR1_POS;
    . H/ P4 [/ D3 P9 U
39. hi2c->State = HAL_I2C_STATE_BUSY_RX;
    
40. hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
    
41. hi2c->pBuffPtr = pData;
    
42. hi2c->XferSize = Size;
    
43. hi2c->XferCount = Size;
    ! J0 Q# l% V/ E5 J
44. /* Send Slave Address */
    
45. if(I2C_MasterRequestRead(hi2c, DevAddress, I2C_TIMEOUT_FLAG) != HAL_OK)
    
46. {
    
47. if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
    ; O1 g/ s9 `$ S; E, Z! y! X0 e
48. {
    ) ]; H) R- x2 N: T/ R
49. /* Process Unlocked */
    
50. __HAL_UNLOCK(hi2c);
    $ P) }# W; V$ p2 {4 W% k
51. return HAL_ERROR;
    ! W( u2 f# N# H- [# R
52. }
    . t! H2 t& u* a
53. else
    , _( S, g6 d7 D- v/ ]3 r
54. {
    
55. /* Process Unlocked */
    
56. __HAL_UNLOCK(hi2c);
    - d3 D' i" A; |+ Q& }- s
57. return HAL_TIMEOUT;
    
58. }
    
59. }
    
60. if(hi2c->XferCount == 1)
    
61. {
    % j0 u. a. c6 j2 T/ v1 M* A
62. /* Disable Acknowledge */
    
63. hi2c->Instance->CR1 &= ~I2C_CR1_ACK;
    4 y# E. g; N) y! h- d/ m  f9 n
64. /* Clear ADDR flag */
    : q" V' X2 z  o
65. __HAL_I2C_CLEAR_ADDRFLAG(hi2c);
    ! N& P$ ~. i: f
66. /* Generate Stop */
    # M/ u3 R# a- q3 L5 y! U0 o6 q
67. hi2c->Instance->CR1 |= I2C_CR1_STOP;
    
68. }
    7 G8 _9 ]6 `2 B% p
69. else if(hi2c->XferCount == 2)
    0 l# `2 Y) d) f# j
70. {
    2 W. Z6 C  w& I7 Y0 B
71. /* Disable Acknowledge */
    
72. hi2c->Instance->CR1 &= ~I2C_CR1_ACK;
    : c' i# R$ z2 k* F2 ~8 V
73. /* Enable Pos */
    ) t) L$ |0 m1 e! M
74. hi2c->Instance->CR1 |= I2C_CR1_POS;
    
75. /* Clear ADDR flag */
    
76. __HAL_I2C_CLEAR_ADDRFLAG(hi2c);
    - y7 T& a& Z4 \. v- H
77. }
    ! E/ x/ ?( F8 D0 X
78. else
    % r6 Y2 B5 a- E" h* B- ^( n
79. {
    " }* ^6 B, r" v$ N" y' _
80. /* Enable Acknowledge */
    
81. hi2c->Instance->CR1 |= I2C_CR1_ACK;
    
82. /* Clear ADDR flag */
    
83. __HAL_I2C_CLEAR_ADDRFLAG(hi2c);
    
84. }
    / H- O) W" w4 Z. I4 r0 n- z
85. /* Process Unlocked */
    
86. __HAL_UNLOCK(hi2c);
    $ D$ d+ L: Q) O$ P0 N
87. /* Note : The I2C interrupts must be enabled after unlocking current process
    2 X2 C" h& p: y! f: K, W
88. to avoid the risk of I2C interrupt handle execution before current
    9 k) J; H1 {: L& w; w
89. process unlock */
    " H3 S% w. L  G3 v* {
90. /* Enable EVT, BUF and ERR interrupt */
    : q1 e; _' _* q- Y
91. __HAL_I2C_ENABLE_IT(hi2c, I2C_IT_EVT | I2C_IT_BUF | I2C_IT_ERR);
    
92. return HAL_OK;
    
93. } */
    
94. else
    
95. {
    5 a7 W& T3 Q0 J* v$ I: Z' H6 p
96. return HAL_BUSY;
    
97. }
    
98. }

复制代码

上面程序中通过下面指令对硬件端口进行加锁：
5 Q$ I" z0 D3 Q$ X% W__HAL_LOCK(hi2c);
__HAL_UNLOCK(hi2c);
. B# v2 Y) `" z4 v6 k# t) }% G初步看来多任务系统中好像是安全的，但实际应用中并非如此（客户的不可重入函数调用了这个 I2C 函数），下面用图例来说明：
+ U0 d- I% h1 K+ Z! [
: n; y, M/ S  L* n: |% o, O1 O8 C

" z3 v; `7 |9 j& ~4 L上图中”t”为时间轴，”T1”时间发生 sensor 1 中断并调用 I2C_Read(…),在 I2C_Read(…)函数中会调用HAL_I2C_Master_Receive_IT（…）函数，在调用 HAL_I2C_Master_Receive_IT（…）函数之前已经进行了传参，即：Addr=0x1A0，Size=3，Buf 指向 buffer1 的地址。

- p# V: w" s5 U/ z当程序运行到”T2”时又来了一个 sensor 2 中断，调用 I2C_Read(…)函数，在调用 HAL_I2C_Master_Receive_IT（…）函数之前已经传参完成。此时的 I2C 地址，Size 等的值如下：
Addr=0x1B0，Size=5，Buf 指向 buffer1 的地址。
' a8 m2 R$ ?+ O- k) `由于 HAL_I2C_Master_Receive_IT（…）程序有加锁，和判断 busy 状况，当程序判断到总线 busy 时或是有加锁时跳出HAL_I2C_Master_Receive_IT（…）函数；但此时的 I2C 地址，buffer 地址， Size 都已经是 Sensor2 对应的值了。然后程序进入 ”T3“。
Sensor2 中断返回时会把 sensor2 的 Size 值 5 赋给 hi2c->XferSize，因此后面的 I2C 通讯中的值如下：
* r3 M4 `' Y$ d6 j% P5 U6 y: dAddr=0x1A0（sensor1 value）
Buf 指向 buffer1（sensor1 value）
Size=5（sensor2 value）
因此程序处理中会出错。

* M9 f' ?! Y0 y0 `$ W; f6 }$ v& S3.上面的问题解决方法：
" w+ i) d+ @( d/ A上面多任务系统的 I2C 处理程序中出现了不可重入函数的多次调用问题，主要是 I2C_Read(…)为不可重入函数，但对它进行了多次调用，使变量更改。
下面的办法可以解决多次调用问题，既对调用 I2C_Read(…)的动作加锁，使第二个 I2C 中断发生后不进行传参动作，如下图所示：
9 o! o, Z  R$ f! J( _. V



" I" g3 t# |2 q7 R& M/ Y: T也可以使用信号量方式处理。如下图：

4 [/ P4 X/ g' o4 m7 [

! k- W1 z: w  @2 _8 [
4. 程序占用资源后要防止死锁发生

' V  {% \# h6 @/ w上面 I2C 程序处理中要注意不要发生死锁，假设在 I2C_Read(…) 函数里有一条指令是对 I2C 端口的状态进行判断，如 busy状态，如果程序一直在等待中，就很容易发生死锁，下面图示是程序发生死锁的情况：
, b$ e& c3 u3 K$ F, b


7 h, [1 ~5 N* o+ c& |7 L在上面程序中需要增加超时跳出机制来防止死锁。
; u0 Z, M  g7 \( [7 s, b& e( \
5.总结
8 H/ |, v+ a1 {/ X0 P在多任务系统中，在使用函数时要了解函数的可重入性，对待有信号量或是加互斥锁的函数要防止死锁的发生。通讯程序比如 I2C， UART 等最好增加超时跳出机制。
! g/ c4 V% |5 s2 d+ m! m
  m7 j' j  O+ e1 D