背景说明
先进先出队列（简称队列）是一种基于先进先出（FIFO）策略的集合类型。对于数据传输速度不同步的应用场景里，采用FIFO队列作为数据缓冲是十分有必要的。在单片机开发的项目中，笔者遇见应用FIFO缓冲的两个典型场景分别是串口数据收发与ADC高速采样。
' V$ j+ Q. r8 G# |% ?
' l. s0 B, ]' K8 OFIFO队列最重要的指标之一就是队列长度问题，因为队列长度是有限的，有可能被填满，这就涉及到该机制的丢弃原则。常见的一个丢弃原则叫做Tail Drop机制，简单地说就是该队列如果已经满了，那么后续进入的报文被丢弃。还有一种原则是覆盖机制，简单的说就是如果队列已经满了，那么后续进入的数据将覆盖最前面的数据，队列中的数据始终保持着最新。

两种机制有各自的应用场景，但当队列已满时，都有不可避免的数据丢失。因此，在硬件资源足够的前提下，可以适当增大队列的深度，提高读操作的速度，以尽量避免队列满的情况。本文设计的FIFO队列模型采用了覆盖机制，读者可以根据需要将它改成Tail Drop机制。
; w5 Y( a5 j* g1 i5 b& ?
7 @1 i* ^/ y: b9 f% P* r4 S% C8 f库源码
9 C: k; ~) [  U' Q% v  \/ a头文件

1. /*
   
2. * fifo.h
   7 N( C7 L4 C% a1 @7 s% h
3. *
   
4. *  Created on: 2020年9月18日
   
5. *      Author: Tao
   - M" ^1 q5 \. w  n& @
6. */
   
7. 
   6 X. i8 E2 F$ p
8. #ifndef SOURCE_ALWHALESLIB_SYSEXTEND_INC_FIFO_H_
   9 J/ P' b5 Y0 c6 s
9. #define SOURCE_ALWHALESLIB_SYSEXTEND_INC_FIFO_H_
   + ?# e' _$ J+ Q+ S1 A# k1 S
10. 
    
11. #include "stm32f4xx.h"
    ; I9 b1 f$ f; O6 ?1 }
12. #include "stm32f4xx_conf.h"
    
13. 
    
14. /**
    3 ]# r1 ?5 K2 H+ f) |- `
15. * 考虑到FIFO数据成员可能会是不同类型的数据，
    
16. * 因此在此处重命名一个数据类型，
    6 T) Y9 F- Y! o( [) g$ Y7 ]# y
17. * 并将此数据类型作为FIFO数据结构库的成员类型。
    
18. * 这么做的好处是可以方便的修改FIFO的成员数据类型。
      ~. t0 H: b  y- L, F
19. */
    
20. typedef uint16_t FIFO_DataType;
    ) R) I: D8 ~  q5 d. H' \, Q
21. 
    
22. typedef struct
    & U: C/ L1 P: X7 Q  H( t
23. {
    : v% Y2 \" X$ l% l: [) q" L; A
24.         uint32_t BufferSize;                                //数据缓存容量
    * i9 M3 p1 _  Q" l
25.         FIFO_DataType *Buffer;                                //数据缓存
    
26.         FIFO_DataType *Read_P;                                //读指针
    
27.         FIFO_DataType *Write_P;                                //写指针
    
28.         uint32_t DataCount;                                        //剩余数据量
    2 l6 J% ~+ X1 ~+ `; ^% B: K
29. } FIFO_Struct;
    
30. 
    
31. 
    
32. #define FIFO_DATA_NUM                1
    
33. #define FIFO_DATA_SIZE                10000
    ) |. k2 T+ ^7 r5 T5 |/ L
34. 
    
35. extern FIFO_Struct FIFO_Data[FIFO_DATA_NUM];
    : ^, F0 a+ a: X
36. 
    4 v8 f( }  i+ a7 Q2 D' I
37. void FIFO_Init(FIFO_Struct *FIFO_Data);
    ! B5 p5 k+ c( P
38. void FIFO_WriteData(FIFO_Struct *FIFO_Data,FIFO_DataType *Data, uint32_t length);
    
39. void FIFO_WriteOneData(FIFO_Struct *FIFO_Data,FIFO_DataType Data);
    
40. void FIFO_ReadData(FIFO_Struct *FIFO_Data,FIFO_DataType *Data, uint32_t length);
    
41. uint16_t FIFO_ReadOneData(FIFO_Struct *FIFO_Data);
    9 t* s3 `* r0 d7 M6 z7 s
42. uint8_t FIFO_IsDataFull(FIFO_Struct *FIFO_Data);
    
43. uint8_t FIFO_IsDataEmpty(FIFO_Struct *FIFO_Data);
    
44. uint32_t FIFO_GetDataCount(FIFO_Struct *FIFO_Data);
    
45. 
    
46. #endif /* SOURCE_ALWHALESLIB_SYSEXTEND_INC_FIFO_H_ */

复制代码

# h- O- W7 A* b7 R源文件
2 c+ w+ p: ]) s

1. /*
   # ^: M, Z, F% [, t
2. * fifo.c
   # G" [4 o2 g2 S3 P  L( p
3. *
   : a8 J& P$ J, E( q. v! \5 B
4. *  Created on: 2020年9月18日
   8 \. ]! N9 c* x; x' h4 b4 s5 C; o
5. *      Author: Tao
   & G7 P- A9 `- w! m
6. */
   " {/ M9 }) L' U$ ]
7. #include "fifo.h"
   ; a1 @! ~  |$ c; E( f! Y
8. 
   
9. static FIFO_DataType FIFO_DataBuffer[FIFO_DATA_NUM][FIFO_DATA_SIZE];
   & b. R* h; B* N6 q
10. 
    8 D& i9 q2 T* b+ |
11. FIFO_Struct FIFO_Data[FIFO_DATA_NUM] =
    : a/ `! z& y1 X9 N
12. {
    1 k' O7 N( c! m8 x  n7 ?
13.                 {
    3 z, l# s  F4 C( f
14.                                 .BufferSize = FIFO_DATA_SIZE,
    / F8 {( ], `' c$ ]
15.                                 .Buffer = FIFO_DataBuffer[0],
    * p' h, F5 ?" H; B
16.                 },
    / V8 P9 A3 c5 {7 Z0 B: c
17. };
    
18. 
    " o" R+ v0 h- B3 t
19. 
    , M9 C" e2 E, @. w* z1 {, }* a
20. /**
    4 }" T' u; B9 z
21. * @brief 初始化FIFO队列数据：清空数据、复位读写指针
    
22. */
    
23. void FIFO_Init(FIFO_Struct *FIFO_Data)
    : p, D0 E* A% b; Y+ D; T
24. {
    % y- [' k+ j4 g( f  d+ @
25.         FIFO_Data->DataCount = 0;
    
26.         FIFO_Data->Read_P = FIFO_Data->Buffer;
    
27.         FIFO_Data->Write_P = FIFO_Data->Buffer;
    
28. }
    
29. 
    ) ^; Z* Z2 K3 e! ^! O# L/ q2 s
30. 
    + M4 Z! E8 h+ R
31. /**
    1 I9 O1 r. x# m2 _1 c
32. * @brief 将数据写入FIFO队列，当数据超出缓冲区的大小时，停止写入数据
    
33. * @param FIFO_Data: 需要操作的FIFO队列数据指针
    ' |3 h& k, @$ b2 f3 M
34. * @param Data: 需要写入的数据指针
    9 v1 l- H3 R: y
35. * @param length: 需要写入的数据长度
    9 i8 v+ g. w1 X* f: ^- N
36. */
    
37. void FIFO_WriteData(FIFO_Struct *FIFO_Data,FIFO_DataType *Data, uint32_t length)
    
38. {
    
39.         //将数据依次写入到队列缓冲区
    9 F, F0 j) P8 d
40.         for(uint32_t index = 0; index < length; index++)
    
41.         {
    
42.                 //如果计数器大于等于缓冲容量
    & u7 |$ f  [/ c# l* m$ ?4 V" ^
43.                 if(FIFO_Data->DataCount > FIFO_Data->BufferSize -1)
    ) Y0 p0 o% Q4 d9 {4 G
44.                 {
    
45.                         //退出写数据
    ( N% m% ~& }4 \5 v+ j6 @
46.                         return;
    - n+ l. i& Y8 p) |# T
47.                 }
    
48. 
    
49.                 //写入一个数据
    
50.                 *FIFO_Data->Write_P = *Data;
    : Y3 A* ^' a  _* g
51.                 //写指针移动一位
    
52.                 FIFO_Data->Write_P++;
    
53.                 //数据缓存指针移动一位
    . P( y' L% V8 g3 ~( d/ x5 ~4 U
54.                 Data++;
    9 X. S$ A2 m" t! `. J, n) Q! x; b
55.                 //计数器自增1
    ( p" H/ H0 x0 Z) g2 Q
56.                 FIFO_Data->DataCount++;
    9 U2 N( w4 z1 L
57. 
      |3 m0 p6 N( Y: O% `3 Z$ Q+ M' r
58.                 //如果写指针已经到达缓冲区边界
    
59.                 if(FIFO_Data->Write_P >= FIFO_Data->Buffer + FIFO_Data->BufferSize)
    9 W* W" `+ o3 r. h8 v2 u# ^  m
60.                 {
    
61.                         //使写指针回到缓冲区起点
    3 H5 F6 ]8 ^' g  N7 p8 H
62.                         FIFO_Data->Write_P = FIFO_Data->Buffer;
    * h7 q, W% z7 Q. k( j
63.                 }
    
64.         }
    
65. }
    
66. 
    
67. 
    1 e# z# \, a4 W) R
68. /**
    
69. * @brief 向FIFO队列中写入一个数据
    
70. * @param FIFO_Data: 需要操作的FIFO队列数据指针
    
71. * @param Data: 要写入的数据
    0 y' G4 F% z( _+ }; x6 p
72. */
    9 o; Q: r0 p/ k- ?- v' M
73. void FIFO_WriteOneData(FIFO_Struct *FIFO_Data,FIFO_DataType Data)
    
74. {
    
75.         FIFO_WriteData(FIFO_Data, &Data, 1);
    % X6 o1 f  m- m5 |7 V. e
76. }
    & q  n, _' l6 S
77. 
    4 G' ^2 e! V% m" `' N! [6 D+ t
78. 
    
79. /**
    9 P# D8 e6 R# }; w, K' p
80. * @brief 将数据从FIFO队列中读出，当缓冲区为空时，停止读出数据
    
81. * @param FIFO_Data: 需要操作的FIFO队列数据指针
    
82. * @param Data: 用来存放读出数据的指针
    , I) u) X: h9 ~$ f* q3 a9 f
83. * @param length: 需要读出的数据长度
    2 \  u/ ?6 F# H; `! z, [
84. */
      B1 d- R$ d  S% q! D% [5 r: n! l
85. void FIFO_ReadData(FIFO_Struct *FIFO_Data,FIFO_DataType *Data, uint32_t length)
    4 p  }' @3 k2 @  \! h' H- n
86. {
    ) _1 P6 Y  J: x6 C
87.         //将缓冲区数据依次读出到Data数组中
    2 C" v7 q( |* c- p) i
88.         for(uint32_t index = 0; index < length; index++)
    0 G0 @$ K* Q5 k$ I
89.         {
    
90.                 //缓冲区数据计数器为0时
    5 C+ n/ G0 X, K6 l- {! ^/ V; W
91.                 if(FIFO_Data->DataCount == 0)
    
92.                 {
    
93.                         //退出读数据
    
94.                         return;
    
95.                 }
    
96. 
    
97.                 //如果数据计数器大于写指针减去缓冲区起始位置（说明写入的数据已经到达过缓冲区边界）
    
98.                 if(FIFO_Data->Write_P - FIFO_Data->Buffer < FIFO_Data->DataCount)
    # V8 n& I* |4 ~7 U5 r* j
99.                 {
    
100.                         //确定数据初始位置，并传递给读指针
     
101.                         FIFO_Data->Read_P = FIFO_Data->BufferSize - FIFO_Data->DataCount + FIFO_Data->Write_P;
     
102.                 }
     
103.                 //写入的数据还未到达过缓冲区边界
     
104.                 else
     0 e3 u+ B7 a# H6 t! h; E, ~9 {
105.                 {
     ( i5 Y* k8 s1 _3 y; t& t/ e
106.                         //确定数据初始位置，并传递给读指针
     
107.                         FIFO_Data->Read_P = FIFO_Data->Write_P - FIFO_Data->DataCount;
     
108.                 }
     
109. 
     
110.                 //读出一个数据
     
111.                 *Data = *FIFO_Data->Read_P;
     + N" C1 H( h! S1 G- e; J/ `
112.                 //读指针移动一位
     0 u; Q8 U8 m- a6 n" R& _
113.                 FIFO_Data->Read_P++;
     
114.                 //数据缓存指针移动一位
     3 {5 F7 }' `. f3 g& M
115.                 Data++;
     + h* {* T7 Y+ P2 b
116.                 //计数器自减1
     " I: r! K  d- \
117.                 FIFO_Data->DataCount--;
     
118. 
     5 v. W; f+ e. J& K6 i
119.                 //如果读指针已经到达缓冲区边界
     ! b3 x( \$ k* f- ?
120.                 if(FIFO_Data->Read_P >= FIFO_Data->Buffer + FIFO_Data->BufferSize)
     % i! ^( o' X6 C( T& L
121.                 {
     
122.                         //使读指针回到缓冲区起点
     
123.                         FIFO_Data->Read_P = FIFO_Data->Buffer;
     
124.                 }
     
125.         }
     
126. }
     
127. 
     
128. 
     - M; ~1 x- E" H; c; y
129. /**
     
130. * @brief 从FIFO队列中读出一个数据
     2 r1 l: W4 ~" {/ {; f7 L
131. * @param FIFO_Data: 需要操作的FIFO队列数据指针
     
132. * @retval 读出的数据
     4 L; `- E6 J( {
133. */
     ' O& g6 y+ j  T" [5 F
134. FIFO_DataType FIFO_ReadOneData(FIFO_Struct *FIFO_Data)
     
135. {
     " |: ?) N3 F7 G9 y. i6 \4 G
136.         FIFO_DataType tempData;
     9 w! }1 q( r" f
137. 
     
138.         FIFO_ReadData(FIFO_Data, &tempData, 1);
     % V: x; t6 c8 u: D3 u
139. 
     : t! P* O+ A9 t, q
140.         return tempData;
     : W& y( p9 }) w/ L4 S
141. }
     3 l  Q% A; i; X% f0 y
142. 
     
143. 
     2 b9 \6 g2 u9 K" ^
144. /**
     
145. * @brief 判断队列数据是否已满
     
146. * @param FIFO_Data: 需要操作的FIFO队列数据指针
     6 _8 ?2 ^- T" U/ B
147. * @retval 指示队列是否已满
     : {) W6 Q: y) c
148. *                 @arg 0: 队列未满
     
149. *                 @arg 1: 队列已满
     2 ]5 C* [, v- {, q) Q7 g) Q
150. */
     
151. uint8_t FIFO_IsDataFull(FIFO_Struct *FIFO_Data)
     
152. {
     - G6 z1 b9 j; N1 ]1 b- m3 t& u$ V
153.         if(FIFO_Data->DataCount >= FIFO_Data->BufferSize)
     . p' A$ ]- y% L
154.         {
     + e& }# }* @$ i( J
155.                 return 1;
     1 P+ R  h3 D4 _
156.         }
     5 G" T  ^; w# V7 O
157.         else
     ' a$ s3 B, ^' \0 P% n, t$ y2 G
158.         {
     % H6 \  @9 p. ~5 s" l: U
159.                 return 0;
     9 a  F# B, M- ^) o
160.         }
     2 ?5 k$ r* @' S$ K9 B
161. }
     
162. 
     
163. 
     0 D/ r  w; W* F
164. /**
     : u9 `, k1 D9 d
165. * @brief 判断队列数据是否为空
     ' B3 t- Z- Z* a
166. * @param FIFO_Data: 需要操作的FIFO队列数据指针
     4 w. p) M/ K  B
167. * @retval 指示队列是否为空
     " U! F1 J8 d7 J' t8 \
168. *                 @arg 0: 队列不空
     0 g9 H; t! N- T+ T
169. *                 @arg 1: 队列为空
     " z) F( x& n' C' F+ Y& ]2 t7 D
170. */
     4 y# {, |1 i! s7 p3 ?2 Y. P
171. uint8_t FIFO_IsDataEmpty(FIFO_Struct *FIFO_Data)
     
172. {
     7 h8 M/ L5 g5 y! d. n( J. ~/ a
173.         if(FIFO_Data->DataCount == 0)
     1 h" {9 Z& ]+ y$ T; B: R
174.         {
     # ~) n8 M$ T0 r- h. `4 [& C. x
175.                 return 1;
     
176.         }
     - Q0 ^- q" O; n
177.         else
     7 v! O6 n3 J5 m, N$ F1 H
178.         {
     
179.                 return 0;
     - q3 ]7 R# F# _! |9 n! n; X- W
180.         }
     + l7 J7 s# A* R1 I
181. }
     ( {" W' T' l9 b2 G7 O
182. 
       s/ h$ J) k/ U+ t% |
183. 
     7 t( a+ e5 o3 Q2 E# P( i
184. /**
     + |: T* m$ P6 r: d& J; C
185. * @brief 获取队列数据的数量
     
186. * @param FIFO_Data: 需要操作的FIFO队列数据指针
     $ B; y% ^: H6 F# |  y9 z8 E
187. * @retval 队列数据的数量
     
188. */
     * S. ^% @8 n1 a& r4 l) q
189. uint32_t FIFO_GetDataCount(FIFO_Struct *FIFO_Data)
     
190. {
     0 @& t' F! U3 y0 n
191.         return FIFO_Data->DataCount;
     ' H* r8 `. M$ c" O7 i1 J
192. }
     2 I! q+ a, B" E( S

复制代码

应用指南
- I1 o0 V7 x! t6 ^" S( w2 n声明并初始化FIFO队列数据
根据项目的需要可以选择声明一个FIFO数据类型的变量或者数组，并初始化。可以依次为每一个成员赋值以完成初始化，或者是为FIFO结构体类型变量分配缓存区后，通过void FIFO_Init(FIFO_Struct *FIFO_Data)来完成其他成员的初始化。

( L1 H, V1 u0 Z6 r7 l" I9 _

1. #define FIFO_DATA_NUM                2
   
2. #define FIFO_DATA_SIZE                10000
   6 q% P6 z. X8 a
3. 
   ' O- D2 {8 y; s# S
4. extern FIFO_Struct FIFO_Data[FIFO_DATA_NUM];
   ( _: I5 r7 X5 X  {6 `( H
5. 
   
6. FIFO_Struct FIFO_Data[FIFO_DATA_NUM] =
   
7. {
   
8.         {
   $ _7 f7 Z3 m" N, K
9.                 .BufferSize = FIFO_DATA_SIZE,
   " l8 r7 I$ E2 z! p9 @7 g+ X7 T
10.                 .Buffer = FIFO_DataBuffer[0],
    ! o! F' A1 K- m  N3 N4 j
11.         },
    6 M% m+ H( x/ r! s2 ^. V4 _
12.         {
    
13.                 .BufferSize = FIFO_DATA_SIZE,
    
14.                 .Buffer = FIFO_DataBuffer[1],
    
15.         },
    & i7 u, m1 l& Q0 h6 ~
16. };
    / I) g/ Y2 T0 P, p/ v
17. 
    ) p2 a0 k* g  R9 I9 k- p6 @3 g
18. void User_Init()
    " I' ?( i1 w1 S0 a
19. {
    
20.         /*省略无关代码*/
    $ ?/ H4 j$ c4 H: b5 l2 w$ E  ]
21.         FIFO_Init(&FIFO_Data[0]);
    
22.         FIFO_Init(&FIFO_Data[1]);
    ) N: e( v9 y) z; X
23.         /*省略无关代码*/
    
24. }
    ; d& ?$ R- K+ ^4 ?4 j' G8 f- A

复制代码

* P$ w/ s0 m4 `6 t( _& u: W在需要写入数据的地方
$ W0 |; b6 n" |根据写入数据的数量，可以选择调用void FIFO_WriteData(FIFO_Struct *FIFO_Data,FIFO_DataType *Data, uint32_t length)或者void FIFO_WriteOneData(FIFO_Struct *FIFO_Data,FIFO_DataType Data)。例如：
; P  i$ B* \* \1 T# j$ y6 C
. k! C& f- i" L; A; ]

1. /**
   ' H6 X0 _; m3 \2 O
2. * @brief 在外部中断14的服务函数中周期性的写入AD7606的高速采样数据
   6 g# a: A  l$ O* ?+ Z% Y4 t3 `/ U
3. */
   
4. void EXTI14Triggered()
   5 q% L% m% x7 b
5. {
   4 |( G6 O) o; k- q" _: ?
6.         if(User_StartDAQ != 0)
   
7.         {
   ; X7 y5 V+ l9 x7 T8 a
8.                 AD7606_RefreshData();
   
9.                 FIFO_WriteOneData(&FIFO_Data[0], AD7606_RawData[0]);
   7 a6 T/ v3 e! i) \6 T1 L- s1 d
10.         }
    $ p+ X- g" J  `. I  p- U% @
11. }

复制代码

6 q: {6 t5 i3 w: W在需要读出数据的地方
根据读出数据的数量，可以选择调用void FIFO_ReadData(FIFO_Struct *FIFO_Data,FIFO_DataType *Data, uint32_t length)或者uint16_t FIFO_ReadOneData(FIFO_Struct *FIFO_Data)。例如：

) H/ ]6 |! g" A! |5 ]8 K6 v

1. /**
   
2. * @brief This function is called by timer update interrupt handler, which will be executed periodically.
   1 B) E( l' J' A9 ]1 y( C2 i
3. */
   
4. void User_RefreshData()
   
5. {
   
6.         //注意SensorData数组顺序与ADS1115数据通道顺序不一致
   
7.         SensorData[0].value = ADS1115_Data[1];
   , o7 E" w! P6 Z0 t* z; N0 t0 S
8.         SensorData[1].value = ADS1115_Data[0];
   
9. 
   - F1 O% p: C3 c- e1 A
10.         //注意SensorData数组顺序与AD7606数据通道顺序不一致
    
11.         SensorData[2].value = (int16_t)AD7606_RawData[1]/32768.0*5000;
    
12.         SensorData[3].value = (int16_t)FIFO_ReadOneData(&FIFO_Data[0])/32768.0*5000;
    3 Y3 J# p; \* c6 n! F8 T
13. 
    . v6 r! p3 U* `/ b; F- f
14.         User_SetOutputCurrent();
    8 |8 H6 O1 [/ v& C1 J* P5 L  `
15.         User_RefreshSingalSwitch();
    0 {9 A) r6 S, h  [; `
16. }

复制代码

FIFO队列的数据类型
+ ^: q. _" R% [/ t4 F由于C语言不支持模板特性，因此采用typedef关键字重命名数据类型，并将此别名用作FIFO队列的数据成员类型。根据不同项目的不同需求，可以更改数据类型：

2 [- z- |- y  P8 k+ M

1. typedef float FIFO_DataType;

复制代码

5 V% m0 v9 Q' p- J7 V/ w( g
2 v: c1 O' d. w' g0 Y4 z