2 n$ j8 x) @' N7 x6 }& R7 L" r

模仿kfifo实现的环形缓冲区

) ?4 v) G. F) ?6 `" ~, X1 }$ O% B+ k
# k' W" W0 I7 H7 H) \转载来源：模仿kfifo实现的环形缓冲区

3 |; j; k, v! u6 ]' _  T- ]
9 {7 `( q1 b) g2 e0 `' Y% f- pGitHub仓库：http://github.com/XinLiGitHub/RingBuffer
PS：博文不再更新，后续更新会在GitHub仓库进行。

( s  V# s" }% o% ?0 l5 I    模仿kfifo实现的环形缓冲区。程序中涉及到环形缓冲区的概念，详细介绍见维基百科[Circular buffer](http://en.wikipedia.org/wiki/Circular_buffer)。

4 \$ {5 v+ n7 U3 t7 `, J! `1，开发环境
      1，操作系统：Windows 10 专业版
/ h/ h. O3 o/ H2 N4 _2 J      2，IDE：Visual Studio 2015 专业版

2，程序源码
      RingBuffer.h文件
5 Q4 W! _4 k9 X9 q7 L

1. /**
   8 R! m8 d1 n8 |5 }$ U. u+ }# {
2.   ******************************************************************************
   2 y1 J: w$ k2 A- |  ?
3.   * @file    RingBuffer.h
   
4.   * @author  XinLi
   
5.   * @version v1.0
   2 M) L- X9 `6 I8 ?2 E9 q- C
6.   * @date    15-January-2018
   
7.   * @brief   Header file for RingBuffer.c module.
   
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    7 v" @/ \0 q, z/ g
14.   * it under the terms of the GNU General Public License as published by
    % s% L! Z" h. @; `4 U5 n- B$ V9 A
15.   * the Free Software Foundation, either version 3 of the License, or
    1 s$ Z* v6 ]7 u" `' R" h! b
16.   * (at your option) any later version.
    3 h5 q5 S6 N8 X% E8 A( q+ a4 K
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    6 m& w& a  w0 L: i: I
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    8 P& ~: ]& F  x  P9 Z% m  n0 ~
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    ( O9 ^& a; w* \) g+ ?5 m% f! Q
21.   * GNU General Public License for more details.
    8 `* B. J0 e, j( s
22.   *
    7 a$ d+ {% r1 f
23.   * You should have received a copy of the GNU General Public License
    
24.   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
25.   *
    ) z4 n/ [3 v! u+ K: x+ }
26.   ******************************************************************************
    3 E! y: A( o2 `; b
27.   */
    
28. 
      J; [: l6 ^) X0 T, ^  e
29. #ifndef __RINGBUFFER_H
    ! Y1 P! W! q6 R5 q. r
30. #define __RINGBUFFER_H
    
31. 
    & F7 s# B% s* w& k6 e
32. #ifdef __cplusplus
    
33. extern "C" {
    & ]7 _( G/ U. A) N
34. #endif
    
35. 
    8 E9 r2 n  n: P9 A' Q2 b
36. /* Header includes -----------------------------------------------------------*/
    ) R3 t( n) E! \$ C7 i( ?/ t! G! F& x
37. #include <stdint.h>
    
38. #include <stdbool.h>
    
39. 
    , y" ]6 J8 a: Z3 A
40. /* Macro definitions ---------------------------------------------------------*/
    : c* O+ F6 C# E2 q6 }3 Q
41. #define RING_BUFFER_MALLOC(size)  malloc(size)
    4 e) t# v6 I* G  P+ \* T8 }
42. #define RING_BUFFER_FREE(block)   free(block)
    ) X6 ^% `9 U" @9 x3 c8 g& x
43. 
    & Y( L# e/ s% i/ K' Q; ]) L
44. /* Type definitions ----------------------------------------------------------*/
    + W2 N0 I. R, ?+ R0 p
45. typedef struct
    5 `1 G2 ^  A- h; f- h
46. {
    3 S, V1 L2 R7 t9 ^: d4 o+ e$ C
47.   uint8_t *buffer;
    ) d! r$ D) ?  U  b# R
48.   uint32_t size;
    
49.   uint32_t in;
    , ], n  e9 ^/ n' Z9 J7 R
50.   uint32_t out;
    9 Q1 j( n0 z0 x! y0 b
51. }RingBuffer;
    : [7 t- _1 W/ \& `! W
52. 
    ' F+ w8 D' j/ c: i
53. /* Variable declarations -----------------------------------------------------*/
    1 ^" i, Z/ G( o, K' x2 M0 y0 `3 Z) u
54. /* Variable definitions ------------------------------------------------------*/
    
55. /* Function declarations -----------------------------------------------------*/
    
56. RingBuffer *RingBuffer_Malloc(uint32_t size);
    
57. void RingBuffer_Free(RingBuffer *fifo);
    : ~! \" v* J5 x$ Y" `
58. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len);
    
59. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len);
    
60. 
    ; z9 Y8 D, c0 W& L
61. /* Function definitions ------------------------------------------------------*/
    1 N% y" S" e. d5 q5 d
62. 
    
63. /**
    + ~4 N" q* c9 P  {
64.   * @brief  Removes the entire FIFO contents.
    
65.   * @param  [in] fifo: The fifo to be emptied.
    ! ^! _# J, s# \8 z' _7 @  o& e1 u
66.   * @return None.
    6 I2 E& n4 m  F) D
67.   */
    - z1 j3 X( c  N& G' k: Q: j% M
68. static inline void RingBuffer_Reset(RingBuffer *fifo)
    - T9 K# a" v+ }+ a2 {0 M2 A- J
69. {
    $ e+ @% K4 c& U2 `& ]9 w1 h4 X# F
70.   fifo->in = fifo->out = 0;
    
71. }
    - ^% o0 A+ e7 y" w0 N
72. 
    
73. /**
    
74.   * @brief  Returns the size of the FIFO in bytes.
    
75.   * @param  [in] fifo: The fifo to be used.
    
76.   * @return The size of the FIFO.
    
77.   */
    
78. static inline uint32_t RingBuffer_Size(RingBuffer *fifo)
    * q1 n3 \3 K, D: r2 T  c9 j5 n
79. {
    7 W' K+ v4 o& h5 O) U
80.   return fifo->size;
    
81. }
    5 f. s+ E0 [' U1 _5 [
82. 
    
83. /**
      I7 y* ^/ v% g. U+ e( U- x0 `
84.   * @brief  Returns the number of used bytes in the FIFO.
    1 f8 g1 G( X' w. J( S
85.   * @param  [in] fifo: The fifo to be used.
    ( ^; @7 G4 t# \- y+ g8 ~$ _$ Y: M+ F
86.   * @return The number of used bytes.
    : D5 P' _7 f: E
87.   */
    
88. static inline uint32_t RingBuffer_Len(RingBuffer *fifo)
    # H. t' v) t1 m# n: X, z/ p
89. {
    
90.   return fifo->in - fifo->out;
    / X/ S5 X9 t* e3 |: F  @7 T
91. }
    
92. 
    0 R% P, n/ x6 R, }
93. /**
    3 u5 f) ~. n5 Z
94.   * @brief  Returns the number of bytes available in the FIFO.
    
95.   * @param  [in] fifo: The fifo to be used.
    
96.   * @return The number of bytes available.
    
97.   */
    
98. static inline uint32_t RingBuffer_Avail(RingBuffer *fifo)
    % [6 m" S( U8 g* n+ c; J( e9 y- A
99. {
    ( g/ e" i% V* o. _' }, G
100.   return RingBuffer_Size(fifo) - RingBuffer_Len(fifo);
     & P% M4 t6 e* ?, ^7 H
101. }
     ! _, L: S& h5 L1 X
102. 
     - V$ U5 u" \8 \( a3 P
103. /**
     9 C" @8 a) D# L0 D' E
104.   * @brief  Is the FIFO empty?
     
105.   * @param  [in] fifo: The fifo to be used.
     
106.   * @retval true:      Yes.
     ; D, l, p3 X/ I1 v1 G2 i
107.   * @retval false:     No.
     : g6 T3 }4 b$ {
108.   */
     . p( m! n1 y7 @( X
109. static inline bool RingBuffer_IsEmpty(RingBuffer *fifo)
     
110. {
     8 U. a" x2 ?0 U9 U
111.   return RingBuffer_Len(fifo) == 0;
     0 A" [- N8 b+ a1 V8 ~9 z
112. }
     * c! u+ j& W, ^- g- t. f
113. 
     
114. /**
     
115.   * @brief  Is the FIFO full?
     
116.   * @param  [in] fifo: The fifo to be used.
     2 U/ H2 m& `* L& [0 U
117.   * @retval true:      Yes.
     
118.   * @retval false:     No.
     
119.   */
       ?* d* F" k, h
120. static inline bool RingBuffer_IsFull(RingBuffer *fifo)
     : \! D+ ?; ?$ P* [4 i
121. {
     
122.   return RingBuffer_Avail(fifo) == 0;
     6 {6 P9 z+ O6 F; j
123. }
     1 X+ m) V7 d% W  v
124. 
     
125. #ifdef __cplusplus
     # L  b$ C6 {/ q
126. }
     , ?9 D& \5 \! T# a3 E# {
127. #endif
     : m0 ~; Y, }/ e* ~* ?
128. 
     8 k3 T+ z( x3 W( W& z
129. #endif /* __RINGBUFFER_H */
     

复制代码

/ V" e; B$ k) c; W7 z/ S      RingBuffer.c文件
! }1 t/ J! c: D( \# I. L

1. /**
   
2.   ******************************************************************************
   8 z9 \2 e' X- c3 E! N
3.   * @file    RingBuffer.c
   
4.   * @author  XinLi
   
5.   * @version v1.0
   ) [5 |9 |% L0 b6 E2 x* \) k
6.   * @date    15-January-2018
   
7.   * @brief   Ring buffer module source file.
   
8.   ******************************************************************************
   
9.   * @attention
   : \- R* j/ G$ P% A) R# S! C  n
10.   *
    - _6 P2 C  g# Q: G& i& H" t
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    * H! f. }( ]1 W3 e. @' \
13.   * This program is free software: you can redistribute it and/or modify
    
14.   * it under the terms of the GNU General Public License as published by
    ' Z$ i* E- y% {& L! |  ^# z/ k$ H
15.   * the Free Software Foundation, either version 3 of the License, or
    - J4 s& u' F# a$ @0 Q2 R
16.   * (at your option) any later version.
    
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    7 c& O7 \  h: e  G0 a/ W: H7 p# u
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    
22.   *
    * C! X* D) Z6 j
23.   * You should have received a copy of the GNU General Public License
    
24.   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
    - Q' @) l6 L) ^1 f5 S* `& B4 U
25.   *
    
26.   ******************************************************************************
    
27.   */
    ( N2 h) P. @+ Y8 R) b2 Y2 V
28. 
    7 i* W' Z3 A* [
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "RingBuffer.h"
    
31. #include <stdlib.h>
    
32. #include <string.h>
    
33. 
    
34. /* Macro definitions ---------------------------------------------------------*/
    2 K8 U* T$ Z: b* t! {, W+ m
35. /* Type definitions ----------------------------------------------------------*/
    9 B. G/ e2 {+ L4 k# T
36. /* Variable declarations -----------------------------------------------------*/
    
37. /* Variable definitions ------------------------------------------------------*/
    
38. /* Function declarations -----------------------------------------------------*/
    ; K7 u8 \9 T" h' Q+ W
39. static bool is_power_of_2(uint32_t x);
      x5 o( P/ N' t7 z4 o7 `
40. static uint32_t roundup_pow_of_two(uint32_t x);
    
41. 
    , z1 `) L% H. o! ~/ C  S
42. /* Function definitions ------------------------------------------------------*/
    ( i# }  k1 Y  Y/ Z6 P  |/ `  N
43. 
    
44. /**
    ; o0 N/ d2 o! ]3 u
45.   * @brief  Allocates a new FIFO and its internal buffer.
    / y3 k- P/ o+ E& A6 p8 I$ X! T
46.   * @param  [in] size: The size of the internal buffer to be allocated.
    
47.   * @note   The size will be rounded-up to a power of 2.
    / J% n# w/ b; G4 b
48.   * @return RingBuffer pointer.
    
49.   */
      s' c5 Z7 Z; r% h
50. RingBuffer *RingBuffer_Malloc(uint32_t size)
    
51. {
    
52.   RingBuffer *fifo = RING_BUFFER_MALLOC(sizeof(RingBuffer));
    
53. 
    ( Q4 w; b! Q$ v" I) q6 C9 M
54.   if(fifo != NULL)
    
55.   {
    8 b) G! x6 j2 u- n
56.     if(is_power_of_2(size) != true)
    
57.     {
    5 ^# }. \0 Z: v$ I" U( k/ L# `$ e
58.       if(size > 0x80000000UL)
    
59.       {
    
60.         RING_BUFFER_FREE(fifo);
    ; T0 J6 J) C5 E" C7 G7 g4 L
61.         fifo = NULL;
    : k$ \2 N3 g( u! z/ `$ N! }
62.         return fifo;
    
63.       }
    0 K- `$ o2 O* ?0 Z/ ?; h
64. 
    
65.       size = roundup_pow_of_two(size);
    . h% S) e0 f! p
66.     }
    # M6 q( ]8 x% s/ U
67. 
    
68.     fifo->size   = size;
    3 A) h( {) [3 h: U
69.     fifo->in     = 0;
    6 n6 G, S+ Z) b: J/ w
70.     fifo->out    = 0;
    - e2 c# j; ^4 S- f& y% M4 ~
71.     fifo->buffer = RING_BUFFER_MALLOC(fifo->size);
    ! p% s# D; M$ J. z0 w9 W0 s  x
72. 
    ( A- w3 s, L. g
73.     if(fifo->buffer == NULL)
    . ^5 j4 A% S* r
74.     {
    - g/ c, R7 _: ?, R" d: g
75.       RING_BUFFER_FREE(fifo);
    8 v4 k: F3 o  k# ?9 [* {
76.       fifo = NULL;
    & A1 L3 b0 R" k' Z! J& C# {0 R4 U
77.       return fifo;
    , r7 I' k4 Q/ v2 E( A* r
78.     }
    7 m9 j/ N) T( Z5 K+ _1 b
79.   }
    ( u: N: F$ H5 X1 H0 I# O- H9 e
80. 
    2 L  I: m' {- G* u$ M7 ~
81.   return fifo;
    
82. }
    
83. 
    : ?5 r# j% Z0 P5 B3 c
84. /**
    . n7 n: I$ ]3 i) S, P6 L( x, l
85.   * @brief  Frees the FIFO.
    
86.   * @param  [in] fifo: The fifo to be freed.
    
87.   * @return None.
    
88.   */
    . B9 P4 v* D& t4 S$ E& p9 u2 T
89. void RingBuffer_Free(RingBuffer *fifo)
    - J$ |5 d2 Y. H" b' O" E  S) o
90. {
    2 e4 U3 F& S( X: i, @+ [
91.   RING_BUFFER_FREE(fifo->buffer);
    & R8 A+ o$ h, X
92.   RING_BUFFER_FREE(fifo);
    & s- b, D( B' F9 W8 P0 Q' K+ P1 l
93.   fifo = NULL;
    , h7 @. g7 s  v
94. }
    
95. 
    
96. /**
    
97.   * @brief  Puts some data into the FIFO.
    
98.   * @param  [in] fifo: The fifo to be used.
    
99.   * @param  [in] in:   The data to be added.
    . _% N/ d5 O2 n# ~6 Q6 ]3 ?) v
100.   * @param  [in] len:  The length of the data to be added.
     6 N$ o! r- e* o6 g! M
101.   * @return The number of bytes copied.
     # K( O5 R& v' z
102.   * @note   This function copies at most @len bytes from the @in into
     # i- j; t, D3 H9 C. v" D/ ~% X
103.   *         the FIFO depending on the free space, and returns the number
     - j& ]- m* \& W2 t
104.   *         of bytes copied.
     ' V+ S$ \) n, |2 ?. s* N, x
105.   */
     * K! q3 U( s, b6 W& j: F
106. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len)
     
107. {
     
108.   len = min(len, RingBuffer_Avail(fifo));
     2 ?4 L0 z) l) z% }: `" o9 C- X% t* J
109. 
     
110.   /* First put the data starting from fifo->in to buffer end. */
     
111.   uint32_t l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));
     + \7 i1 ^8 S* u# G" k+ M6 F
112.   memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), in, l);
     ) i8 u2 j7 Y. g6 O0 {+ a: ~
113. 
     + Q1 `2 S9 ?  l9 k1 }# D% z
114.   /* Then put the rest (if any) at the beginning of the buffer. */
     . y* y% W0 T1 X( w
115.   memcpy(fifo->buffer, (uint8_t *)in + l, len - l);
     9 Z9 X. x- Z8 ^
116. 
     
117.   fifo->in += len;
     6 f% y: u- Z/ b4 T( p
118. 
     
119.   return len;
     4 C! }, p4 J- O/ }- ~  a& v
120. }
     
121. 
     + X" r- p: h; G1 o
122. /**
     ; ?( s5 G/ ~6 B4 `2 Y; K
123.   * @brief  Gets some data from the FIFO.
     4 a, w) e* P! J8 j3 z7 E. @( z
124.   * @param  [in] fifo: The fifo to be used.
     
125.   * @param  [in] out:  Where the data must be copied.
     
126.   * @param  [in] len:  The size of the destination buffer.
     
127.   * @return The number of copied bytes.
     
128.   * @note   This function copies at most @len bytes from the FIFO into
     0 u1 a; ?( @7 O4 P2 p
129.   *         the @out and returns the number of copied bytes.
     
130.   */
     
131. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len)
     
132. {
     
133.   len = min(len, RingBuffer_Len(fifo));
     
134. 
     4 `. Y+ s, B- ^2 `0 z8 C
135.   /* First get the data from fifo->out until the end of the buffer. */
     
136.   uint32_t l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
     0 f1 T9 H+ d: i8 a% ]1 S
137.   memcpy(out, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
     6 Y- O1 U+ F- |1 c
138. 
     * Z* {6 g+ u5 v$ @2 C" P# f0 V
139.   /* Then get the rest (if any) from the beginning of the buffer. */
     
140.   memcpy((uint8_t *)out + l, fifo->buffer, len - l);
     5 T$ ^. ~. e5 t/ n1 ?9 Z5 x
141. 
     ' D" H% o# G6 _* L
142.   fifo->out += len;
     
143. 
     
144.   return len;
     4 B  Z& Y/ P% f7 K+ H$ W- |
145. }
     
146. 
     
147. /**
     
148.   * @brief  Determine whether some value is a power of two.
     # m) p9 b- p: Y' \- O
149.   * @param  [in] x: The number to be confirmed.
     . C, ^$ f% G. v  e4 j  [
150.   * @retval true:   Yes.
     
151.   * @retval false:  No.
     0 r0 E8 n, s- ~
152.   * @note   Where zero is not considered a power of two.
     5 M( D& d6 Q, q  z3 o. a; s
153.   */
     3 N* o: I" i  ]7 e. m7 @
154. static bool is_power_of_2(uint32_t x)
     % k" j1 T% N, w% K4 ~0 `
155. {
     : m  Y1 X' j. B6 h$ w+ A6 T
156.   return (x != 0) && ((x & (x - 1)) == 0);
     8 r- n! Q' u) P% ^' s8 {) ?5 D
157. }
     + j& Q+ o0 ^% S
158. 
     8 W' \6 U+ b( X/ B2 f
159. /**
     $ M0 H4 ~) g; F
160.   * @brief  Round the given value up to nearest power of two.
       q# _$ c0 o; W+ n
161.   * @param  [in] x: The number to be converted.
     
162.   * @return The power of two.
     
163.   */
     
164. static uint32_t roundup_pow_of_two(uint32_t x)
     $ a, U* u- k% ~2 \5 c6 D) b1 j
165. {
     3 P/ `/ u4 H& ?1 O- K
166.   uint32_t b = 0;
     
167. 
     7 B) C- j1 e% p4 h/ F5 D
168.   for(int i = 0; i < 32; i++)
     2 D9 x  I! G2 `1 g- ^. d
169.   {
     ; N. k" Y. W- m% Y
170.     b = 1UL << i;
     4 N- j. D; ^" R" @
171. 
     
172.     if(x <= b)
     7 B: [  U% m. M6 ^
173.     {
     - Q+ z3 r# C+ m7 C9 Z# |
174.       break;
     + l* m- h& U# B8 O
175.     }
     
176.   }
     3 G6 t4 h9 d/ X. Z9 @) K0 z
177. 
     
178.   return b;
     $ x/ a" R% t1 r& ?( H
179. }
     / Q, I5 o: L) O) j  H* [

复制代码

0 E/ H6 }3 K) q2 L5 E1 [; \      main.c文件
& x# N3 w% |" w/ t, c8 I1 ~: s

1. /**
   
2.   ******************************************************************************
   ; j0 L' P. ?& ]2 u0 U' I5 k" a% }
3.   * @file    main.c
   6 e; r, H4 h7 e$ }( ]. ?
4.   * @author  XinLi
   ; Y* o9 j$ V; k5 F+ @3 q3 e8 U
5.   * @version v1.0
   2 L+ I; V+ I& ~2 X" m8 i
6.   * @date    15-January-2018
   , y7 d2 |% k6 R' h
7.   * @brief   Main program body.
   0 I8 E$ T7 S9 X
8.   ******************************************************************************
   
9.   * @attention
   4 I5 ~( Q( ?5 C
10.   *
    * h# x  J' X! e1 N1 z
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    8 E% @% S- U% S1 q( z& @1 ]
13.   * This program is free software: you can redistribute it and/or modify
    * v% [. T& c  ?. g
14.   * it under the terms of the GNU General Public License as published by
    
15.   * the Free Software Foundation, either version 3 of the License, or
    $ {8 o3 L5 A4 c  G9 x, B% n/ y2 a  ~
16.   * (at your option) any later version.
    
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    2 w$ |8 R+ V* o, I3 S
21.   * GNU General Public License for more details.
    
22.   *
    
23.   * You should have received a copy of the GNU General Public License
    
24.   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
25.   *
    0 g% ^5 N  Z$ r/ b
26.   ******************************************************************************
    
27.   */
    ( ^0 R; |0 A! [: J% k5 v4 L' X
28. 
    9 F8 ^2 v2 ?3 J7 x
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "RingBuffer.h"
    
31. #include <stdio.h>
    $ D- H: q+ ]6 r
32. #include <windows.h>
    
33. 
    4 k! ^9 J! K- Z1 S
34. /* Macro definitions ---------------------------------------------------------*/
    
35. /* Type definitions ----------------------------------------------------------*/
    
36. /* Variable declarations -----------------------------------------------------*/
    
37. /* Variable definitions ------------------------------------------------------*/
    
38. /* Function declarations -----------------------------------------------------*/
    # B/ x) e5 ?& a' Z' d9 g7 k5 I
39. /* Function definitions ------------------------------------------------------*/
    
40. 
    % q/ S8 L2 \& a# j7 P
41. /**
    ' Q3 A2 \' S* ^1 E& o" K
42.   * @brief  Main program.
    1 {" k& [' W6 w% j0 f- e6 r
43.   * @param  None.
    
44.   * @return None.
    
45.   */
    
46. int main(void)
    : R8 Q, A; q8 t; l7 t
47. {
    
48.   uint8_t data[256] = {0};
    
49. 
    
50.   for(int i = 0; i < sizeof(data); i++)
    
51.   {
    
52.     data[i] = i;
    
53.   }
    % V- t6 Y/ x% i1 |6 m6 a
54. 
    & D5 d7 V9 i% t9 E4 ^8 c& ~/ ?  C
55.   RingBuffer *fifo = RingBuffer_Malloc(sizeof(data));
    
56. 
    
57.   if(fifo != NULL)
    
58.   {
    ' N+ t  d* u& m2 {  a: b) n4 m
59.     printf("FIFO创建成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
    - K/ s( i) C4 d3 F* o) j" i' a
60.            RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
    
61. 
    3 w$ i8 K9 ]; `5 I9 n
62.     if(RingBuffer_IsFull(fifo) == true)
    
63.     {
    
64.       printf("FIFO满了！！！\n");
    
65.     }
    
66.     else
    
67.     {
    
68.       printf("FIFO没满！！！\n");
    ' N* S4 }1 V2 k3 r/ w
69.     }
    
70. 
    ) o* ~$ `3 L9 H
71.     if(RingBuffer_IsEmpty(fifo) == true)
      h$ g# ^% P' u
72.     {
    5 ?7 s/ r' u  H3 Q  t1 N, `
73.       printf("FIFO空了！！！\n");
    
74.     }
    
75.     else
    * }7 x+ p* `" p& C- g$ ^9 ~
76.     {
    4 B/ b* H( d  i2 {6 \! `5 M7 Y& ~5 F
77.       printf("FIFO没空！！！\n");
    " S( r, k; J+ \
78.     }
    9 w6 H5 W/ N! U% ]2 K1 M& _
79. 
    
80.     printf("\n");
    ) N2 a+ b2 B+ ]) k/ e
81. 
    ! ~7 M5 `7 @8 E; m5 p
82.     for(;;)
    
83.     {
    8 `" `  m6 X2 Z& E/ F
84.       {
    
85.         if(RingBuffer_In(fifo, data, sizeof(data) / 2) > 0)
    , v  B8 l" D8 E6 p. \  C" Q; P
86.         {
    
87.           printf("FIFO写入成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
    
88.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
    
89.         }
    4 y( q; l: F# Z7 c- u  {+ s
90.         else
    
91.         {
      j8 h  O' ~/ F$ a7 F
92.           printf("FIFO写入失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
    
93.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
    
94.         }
    % O" O% n+ U( w6 S
95. 
    
96.         if(RingBuffer_IsFull(fifo) == true)
    % k( E) }2 E5 k  ^
97.         {
    2 @7 q+ x4 K4 B  }2 W! Y# O
98.           printf("FIFO满了！！！\n");
    ( m* F# _( k, n8 u8 a  b/ g6 r
99.         }
    / n' _2 ^1 D0 R) {
100.         else
     
101.         {
     
102.           printf("FIFO没满！！！\n");
     % [& `) k  B+ L6 s
103.         }
     $ N) e3 C8 n: E- I: W1 r# F9 W: [, z
104. 
     % w8 I8 M2 t% x; F+ {
105.         if(RingBuffer_IsEmpty(fifo) == true)
     
106.         {
     # B/ d( |6 t7 D: A4 {2 ?+ n
107.           printf("FIFO空了！！！\n");
     ! ?3 C" J# ?, L5 i) ]0 y( [2 M
108.         }
     + r! E% _4 ^1 V0 F, Z
109.         else
     9 n' G* {/ x+ n( D, b6 m6 t7 x+ T
110.         {
     
111.           printf("FIFO没空！！！\n");
     
112.         }
     
113.       }
     
114. 
     
115.       printf("\n");
     4 J! P! L7 k" m1 n! [: E7 w
116. 
     . {; Z- ^8 n7 b: d+ U
117.       {
     
118.         uint8_t rdata[64] = {0};
     - `  |$ {* F5 z  M' v# K, @1 b
119.         uint8_t len       = RingBuffer_Out(fifo, rdata, sizeof(rdata));
     : j2 {1 x# h4 G1 v/ W
120. 
     
121.         if(len > 0)
     " _& Y- i+ P) n1 ]
122.         {
     $ d) r/ i, n* r
123.           printf("从FIFO中读出的数据，长度：%d\n", len);
     
124. 
     
125.           for(int i = 0; i < len; i++)
     , }: A3 ?+ m  @" _3 q
126.           {
     
127.             printf("%d ", rdata[i]);
     8 ]. v3 o0 M" r  J1 F1 Z3 m- H
128.           }
     & w& C+ `) r3 ^$ G& f: K7 X
129. 
     
130.           printf("\n");
     
131. 
     
132.           printf("FIFO读取成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     # ^' J& j  q* M1 @
133.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     7 f' S$ L6 X4 S7 v$ x6 k
134.         }
     
135.         else
     * r# A2 S) a: J
136.         {
     ' \* D* O9 D, a6 ~
137.           printf("FIFO读取失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
138.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
139.         }
     
140. 
     
141.         if(RingBuffer_IsFull(fifo) == true)
     9 H* z  I- ~& z" T2 J2 I2 T
142.         {
     ' S% g2 G" L- U4 Z- [3 x
143.           printf("FIFO满了！！！\n");
     
144.         }
     
145.         else
     + P6 d1 \& \& {0 h
146.         {
     
147.           printf("FIFO没满！！！\n");
     
148.         }
     ! W4 g& M8 x) r
149. 
     # Y6 I: @; Z+ k/ Y6 v5 I
150.         if(RingBuffer_IsEmpty(fifo) == true)
     * z& o( ~4 B: q) N& U3 E
151.         {
     
152.           printf("FIFO空了！！！\n");
     
153.         }
     * I% w6 M2 D8 ?% E$ a% q) D
154.         else
     
155.         {
     
156.           printf("FIFO没空！！！\n");
     3 E, d2 N4 s3 @
157.         }
     * p% W0 z! k+ T: z5 k/ K6 O
158.       }
     
159. 
     5 U: y, g  _( |( |+ o* `
160.       printf("\n");
     
161. 
     
162.       {
     
163.         RingBuffer_Reset(fifo);
     
164.         printf("FIFO清空成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
165.                RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
166. 
     & x9 ?1 T# t2 E+ l. e# y; r
167.         if(RingBuffer_IsFull(fifo) == true)
     * x( Z# L/ U% O  [$ d- ~( \$ F) V
168.         {
     
169.           printf("FIFO满了！！！\n");
     
170.         }
     
171.         else
     
172.         {
     
173.           printf("FIFO没满！！！\n");
     3 n6 j/ w0 O% R  o1 v6 [
174.         }
     
175. 
     6 }8 f2 v9 p/ P1 D# I$ _
176.         if(RingBuffer_IsEmpty(fifo) == true)
     
177.         {
     
178.           printf("FIFO空了！！！\n");
     3 P1 s; O3 P/ f: s8 z/ U
179.         }
     " A/ m) q; b% ?/ c0 ?9 f
180.         else
     
181.         {
     
182.           printf("FIFO没空！！！\n");
     
183.         }
     ) f9 y. M7 w; h; X
184.       }
     
185. 
     
186.       printf("\n");
     , _. X, A9 p3 R4 S* @8 `& }. b/ r3 B
187. 
     
188.       {
     / ]% K8 a2 l: G5 j
189.         if(RingBuffer_In(fifo, data, sizeof(data)) > 0)
     
190.         {
     # z& h6 V2 W. B9 Y1 a
191.           printf("FIFO写入成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     7 |1 o0 V* B5 y1 }1 A3 m8 `+ @# t
192.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
193.         }
     
194.         else
     
195.         {
     * N! N. P  L- \9 ?/ `
196.           printf("FIFO写入失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     0 I# H* b( f% }) w: L1 r. H7 z" }& |
197.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
198.         }
     
199. 
     ' q1 x8 h) {/ q& g
200.         if(RingBuffer_IsFull(fifo) == true)
     
201.         {
     8 k7 z4 V3 t6 y% S: M5 i2 i
202.           printf("FIFO满了！！！\n");
     ( ^3 x8 z7 Z+ h- O$ S, Q
203.         }
     + s' W# z/ X7 i" I; X
204.         else
     , [3 K) h+ n9 m: F: {9 C
205.         {
     
206.           printf("FIFO没满！！！\n");
     
207.         }
     ! y) [; c& K% c3 v
208. 
     
209.         if(RingBuffer_IsEmpty(fifo) == true)
     
210.         {
     
211.           printf("FIFO空了！！！\n");
     ' o+ ]4 s$ r- }
212.         }
     
213.         else
     8 H% V7 M4 g0 W2 }% O- W
214.         {
     $ }  L  ]/ y; \8 A8 H$ n7 O
215.           printf("FIFO没空！！！\n");
     , O! {* [0 Y, E) w
216.         }
     
217.       }
     
218. 
       R( R! Z3 O( ?, Z0 R' h1 z" t
219.       printf("\n");
     3 e9 ^& }5 g3 v2 s* e( g8 t
220. 
     ) t1 m& _6 t: o' G$ A! G
221.       {
     5 w) a0 B9 I1 Q, _- h
222.         if(RingBuffer_In(fifo, data, sizeof(data)) > 0)
     
223.         {
     
224.           printf("FIFO写入成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
225.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
226.         }
     $ m1 {: _0 U6 s+ V# y9 b2 ]
227.         else
     
228.         {
     " h" P, L9 e/ L$ ^- J* r' x: j! Z
229.           printf("FIFO写入失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     2 `6 X2 L! m8 b
230.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
231.         }
     ! Z  o+ H  r6 ^6 c2 C1 z
232. 
     
233.         if(RingBuffer_IsFull(fifo) == true)
     
234.         {
     5 G2 U5 p/ B9 @* l" i0 ~8 u
235.           printf("FIFO满了！！！\n");
     
236.         }
     0 t2 ]1 n/ X6 f
237.         else
       w" g% ~, K" x  N4 J% c: W8 H
238.         {
     1 y3 J3 Z. B# [/ h6 m! T. y
239.           printf("FIFO没满！！！\n");
     
240.         }
     
241. 
     6 Z0 ^! _/ U5 ?9 ^( i
242.         if(RingBuffer_IsEmpty(fifo) == true)
     ' U  W2 F) f# e+ K' I  W
243.         {
     
244.           printf("FIFO空了！！！\n");
     / C' N4 H' ?: q( ~
245.         }
     
246.         else
     
247.         {
     9 d% V$ H+ ~8 e3 N" h! W2 w  w
248.           printf("FIFO没空！！！\n");
     
249.         }
     
250.       }
     
251. 
     
252.       printf("\n");
     
253. 
     
254.       {
     
255.         uint8_t  rdata[256] = {0};
     ( R! |, s8 @  I/ `4 M/ r
256.         uint16_t len        = RingBuffer_Out(fifo, rdata, sizeof(rdata));
       t2 }1 ]- b# |# S- g
257. 
     * c: L! W2 [6 w- T" A, {( ^* b
258.         if(len > 0)
     
259.         {
     
260.           printf("从FIFO中读出的数据，长度：%d\n", len);
     , D; e7 a" U( N9 K% e; a
261. 
     
262.           for(int i = 0; i < len; i++)
     
263.           {
     9 n' O1 l  i# X
264.             printf("%d ", rdata[i]);
     
265.           }
       S2 Q, F1 G& `! e+ ]  T
266. 
     " l- a! T9 U5 A* Z
267.           printf("\n");
     
268. 
     
269.           printf("FIFO读取成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
270.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
271.         }
     
272.         else
     3 e" A5 R& Q) \, i
273.         {
     : N" N1 A8 h8 d" B% h, `+ Q* {. c
274.           printf("FIFO读取失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
       s6 K# g0 g8 U* g: f
275.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
276.         }
     - ~5 p% z; }6 T6 E, S
277. 
     
278.         if(RingBuffer_IsFull(fifo) == true)
     
279.         {
     
280.           printf("FIFO满了！！！\n");
     
281.         }
     - }' C" N% {& M) j2 R9 F) T
282.         else
     ( U8 J! w( Q. ^5 {- \& Y# `: O
283.         {
     
284.           printf("FIFO没满！！！\n");
     
285.         }
     
286. 
     6 {" j% L- s% {6 g1 l& Q
287.         if(RingBuffer_IsEmpty(fifo) == true)
     " E1 {. k! y, b! p+ G  D
288.         {
     : K2 Y) C* p4 @0 ?& T- l
289.           printf("FIFO空了！！！\n");
     
290.         }
     4 I) N" _9 ]4 H6 H6 D
291.         else
     * q; P4 v9 s7 K* w
292.         {
     
293.           printf("FIFO没空！！！\n");
     
294.         }
     + s4 O5 d' t( Y! z% a  ?( B! o
295.       }
     % \# ^' p2 E& x& w0 R: {
296. 
     
297.       printf("\n");
     
298. 
     1 C6 C' r* p8 q9 a' {/ z
299.       {
     . i4 ^& B1 r, q/ H" O
300.         uint8_t  rdata[256] = {0};
     + _6 h1 U3 v( m! W: c' T6 P
301.         uint16_t len        = RingBuffer_Out(fifo, rdata, sizeof(rdata));
     
302. 
     3 J& H4 i8 H0 x9 ?4 N
303.         if(len > 0)
     - y+ ?; r; b# p9 X, p: r2 e; N# p- |" f
304.         {
     
305.           printf("从FIFO中读出的数据，长度：%d\n", len);
     ; T( r6 ?6 u0 p' J
306. 
     
307.           for(int i = 0; i < len; i++)
     
308.           {
     
309.             printf("%d ", rdata[i]);
     ' B( Q/ v# y8 a4 K" J
310.           }
     * G, Y4 v3 V" p( f5 p* y, P$ E: n' a! m
311. 
     
312.           printf("\n");
     5 `8 ~; z  V: p; E! C9 Y
313. 
     
314.           printf("FIFO读取成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
315.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     ' D- h7 U' `% W$ [
316.         }
     
317.         else
     
318.         {
     
319.           printf("FIFO读取失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     1 ~' E  ^$ j% K2 G* w
320.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
321.         }
     ! J8 v% Z! G" ~' S6 ~* }* D+ v
322. 
     
323.         if(RingBuffer_IsFull(fifo) == true)
     
324.         {
     
325.           printf("FIFO满了！！！\n");
     
326.         }
     0 ~* G( J3 w4 `9 D4 D3 Z' S' H
327.         else
     
328.         {
     " I& B$ U2 P5 C7 p: O$ |$ q
329.           printf("FIFO没满！！！\n");
     " s; \) `( |. d* G. X6 X+ j
330.         }
     / m% Y6 ^7 _; U" q
331. 
     
332.         if(RingBuffer_IsEmpty(fifo) == true)
     
333.         {
     
334.           printf("FIFO空了！！！\n");
     
335.         }
     
336.         else
     
337.         {
     
338.           printf("FIFO没空！！！\n");
     
339.         }
     $ w, U* |' }8 Y
340.       }
     
341. 
     1 j8 g5 w: l! _% I
342.       printf("\n\n\n");
     ' t1 `! j# T: ?; Q' u. R8 |
343.       Sleep(5000);
     , b, U- T0 H% T- u7 C
344.     }
     
345.   }
     $ W0 ?( z) F$ L- S: v' h5 z
346.   else
     
347.   {
     
348.     printf("FIFO创建失败\n");
     / p9 K) B. T" C8 H/ ]3 S9 Z
349.   }
     
350. 
       L, c* O& n) n
351.   for(;;)
     , {! X/ \1 b  D. z
352.   {
     5 w1 S; _! T4 c) J
353. 
     3 |4 O+ i2 B8 H( _
354.   }
     # ?  D' D) p" ^4 s4 M
355. }
     ' ]: Z: ~: y( {( w* @9 n& a9 U* `# J% l

复制代码

4 T$ v0 }0 o/ @# N5 E) G# X3，运行效果

谢谢分享

可以直接移植到嵌入式端，非常方便。