. l: ^4 a. |1 b$ X9 N- i: l2 k. G3 Z

模仿kfifo实现的环形缓冲区

0 d) R7 P3 L' X. f% d' K
转载来源：模仿kfifo实现的环形缓冲区
5 ?! s. g' L+ ^$ ^
7 m( A% s& y, O2 U4 y
% F/ S+ E( r# X$ b: E; M. V' f: |7 ]GitHub仓库：http://github.com/XinLiGitHub/RingBuffer
8 e" O! N! w: EPS：博文不再更新，后续更新会在GitHub仓库进行。
: ]0 q0 |+ z: w  ~" f
4 G1 y" I5 u9 m5 J+ P    模仿kfifo实现的环形缓冲区。程序中涉及到环形缓冲区的概念，详细介绍见维基百科[Circular buffer](http://en.wikipedia.org/wiki/Circular_buffer)。

1，开发环境
      1，操作系统：Windows 10 专业版
) t' [7 \6 O" ~$ B3 h      2，IDE：Visual Studio 2015 专业版
$ b. f% c# }, d3 ?
2，程序源码
      RingBuffer.h文件

1. /**
   5 B. t$ d! K" u- J* {
2.   ******************************************************************************
   
3.   * @file    RingBuffer.h
   
4.   * @author  XinLi
   
5.   * @version v1.0
   : W# t8 {5 U! J! m3 p: w% ~5 r
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.   *
    $ E# @, t2 G  L# S1 Z. P
13.   * This program is free software: you can redistribute it and/or modify
    5 G, S: w( V* B! ?
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
    " N' [8 D1 l! U
16.   * (at your option) any later version.
    
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    , q, _1 i; h, w5 Z2 e
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    - q" k, e0 d$ q
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    9 K; U  g* T2 m3 V: P
21.   * GNU General Public License for more details.
    
22.   *
    # m3 O" N7 Z. X9 V9 l: x
23.   * You should have received a copy of the GNU General Public License
    " o3 }# z) f, A& Q) A
24.   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
25.   *
    
26.   ******************************************************************************
    * y( I$ |  f7 J, o. s
27.   */
    
28. 
    
29. #ifndef __RINGBUFFER_H
    
30. #define __RINGBUFFER_H
    
31. 
    $ X& v3 ]% u7 u5 P  \4 j8 Z0 w6 E5 p: Y% J
32. #ifdef __cplusplus
    , [& _2 y3 n! I5 N( n
33. extern "C" {
    & I" o1 N  [+ o- S! g
34. #endif
    8 I  C: U/ X; B" [8 a$ R% v. T* ?, ]" F
35. 
    ( `/ _% L7 |8 ]- l: I5 V9 ?
36. /* Header includes -----------------------------------------------------------*/
    
37. #include <stdint.h>
    
38. #include <stdbool.h>
    
39. 
    
40. /* Macro definitions ---------------------------------------------------------*/
    
41. #define RING_BUFFER_MALLOC(size)  malloc(size)
    " I/ J( z0 _* ^$ Z
42. #define RING_BUFFER_FREE(block)   free(block)
    " y4 A/ I) G7 T9 w# u) F
43. 
    
44. /* Type definitions ----------------------------------------------------------*/
    
45. typedef struct
    3 `7 @% s* a' N) D
46. {
    ) T& G% E3 N# W
47.   uint8_t *buffer;
    2 i4 A- O, t# ]. S& ~
48.   uint32_t size;
    
49.   uint32_t in;
    
50.   uint32_t out;
    , D1 t0 L! E. q
51. }RingBuffer;
    
52. 
    ; k! R( T/ h$ ?* _: G1 E. `
53. /* Variable declarations -----------------------------------------------------*/
    
54. /* Variable definitions ------------------------------------------------------*/
    - [7 w1 v7 [- n) C' p  t
55. /* Function declarations -----------------------------------------------------*/
    ! v1 u" O( |: Q: k( o& e
56. RingBuffer *RingBuffer_Malloc(uint32_t size);
    
57. void RingBuffer_Free(RingBuffer *fifo);
    + P9 ~' v  L' t1 H$ Q( f# y
58. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len);
    ; T: X( j# p" B# N" S+ [
59. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len);
      g& g' G: E) }, {8 z! M  M$ T( r
60. 
    # g3 u- c3 S2 V4 {. ?
61. /* Function definitions ------------------------------------------------------*/
    . i! X* {; K. @
62. 
    
63. /**
    
64.   * @brief  Removes the entire FIFO contents.
    
65.   * @param  [in] fifo: The fifo to be emptied.
    
66.   * @return None.
    
67.   */
    5 c# L6 ^. {- O! T
68. static inline void RingBuffer_Reset(RingBuffer *fifo)
    
69. {
    9 t) H* o  k3 c' r9 b$ U
70.   fifo->in = fifo->out = 0;
    + U3 R) g3 m& F
71. }
    1 t3 J1 k- X# d9 u% x, r+ T
72. 
    / G) q: _) ?) a4 D
73. /**
    
74.   * @brief  Returns the size of the FIFO in bytes.
    ; e8 p+ u0 U1 v1 Y
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)
    " Q! E% \2 q1 V
79. {
    & {8 N6 T* D$ ~! x& I
80.   return fifo->size;
    ; K% W  |5 G! w: n( A. H
81. }
    0 @8 y( ^; F% ]8 u& Y, y, E
82. 
    - Z+ t) z8 E# Z7 r5 B: z* a
83. /**
    
84.   * @brief  Returns the number of used bytes in the FIFO.
    
85.   * @param  [in] fifo: The fifo to be used.
    0 V0 U- R; P( i7 M1 r  b8 U/ A( y
86.   * @return The number of used bytes.
    ' L4 P, q6 M- W- s1 M
87.   */
    0 K' |3 }9 }5 f: `
88. static inline uint32_t RingBuffer_Len(RingBuffer *fifo)
    
89. {
    % [. Q) t+ Z3 {% s+ b
90.   return fifo->in - fifo->out;
    6 X* M) E5 o7 j9 j( z
91. }
    , p, y# L9 @( W2 Q6 z' F" l
92. 
    
93. /**
    1 X. ~3 T: ~7 i( T6 m; W0 {
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.
    " s. `$ g3 D* }! w) k
97.   */
    1 ?) q9 n, M% g( u% D$ `
98. static inline uint32_t RingBuffer_Avail(RingBuffer *fifo)
    
99. {
    
100.   return RingBuffer_Size(fifo) - RingBuffer_Len(fifo);
     2 x/ |8 Y- {7 h2 h8 A+ X3 q
101. }
     
102. 
     
103. /**
     - f# B+ _* r1 |) _
104.   * @brief  Is the FIFO empty?
     
105.   * @param  [in] fifo: The fifo to be used.
     + {) z8 A; i4 q) E' a+ O5 }# i
106.   * @retval true:      Yes.
     
107.   * @retval false:     No.
     
108.   */
     
109. static inline bool RingBuffer_IsEmpty(RingBuffer *fifo)
     # ?' p  F5 o. n
110. {
     - n! U9 P1 P/ _1 E, v
111.   return RingBuffer_Len(fifo) == 0;
     
112. }
     ( c: y7 }* G8 ~% N* q2 j
113. 
     * Q. C( x( m* U; x5 W
114. /**
     
115.   * @brief  Is the FIFO full?
     
116.   * @param  [in] fifo: The fifo to be used.
     6 `9 f, k- B# W( [2 J% V) `
117.   * @retval true:      Yes.
     2 r9 B9 r! I4 F. E- @
118.   * @retval false:     No.
     
119.   */
     ! v: \# u0 L; U8 w6 M* A
120. static inline bool RingBuffer_IsFull(RingBuffer *fifo)
     ) b% g0 ?! @+ h' r: W' \, D
121. {
     & P1 Z' G' _' e+ C
122.   return RingBuffer_Avail(fifo) == 0;
     * c7 s, `3 R! ^7 f1 T9 b
123. }
     
124. 
     . o: U' y# o" u
125. #ifdef __cplusplus
     0 z8 W3 k. V" V9 n5 S
126. }
     8 b9 S: U; w/ m
127. #endif
     & B; L0 K% x& O' n# F0 ]1 ]8 C, M
128. 
     ' u4 ^, J3 }3 ]# H) ^; p
129. #endif /* __RINGBUFFER_H */
     

复制代码

      RingBuffer.c文件
9 ?( o5 ]3 d& z* ]/ t* y

1. /**
   
2.   ******************************************************************************
   , a" e8 f1 W) d) B+ `  B+ Z/ p6 A
3.   * @file    RingBuffer.c
   
4.   * @author  XinLi
   ; H! H5 \0 y) h, g2 {/ K
5.   * @version v1.0
   
6.   * @date    15-January-2018
   
7.   * @brief   Ring buffer module source file.
   
8.   ******************************************************************************
   ' s& T' P/ l8 R5 i: t5 X# }; o
9.   * @attention
   0 s4 s* C5 `" N. |1 l" c
10.   *
    + _& h3 V) s8 q1 h6 a3 U2 B
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    # e. l$ E. P! N
12.   *
    
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
    
15.   * the Free Software Foundation, either version 3 of the License, or
    . x: X; |8 `" v
16.   * (at your option) any later version.
    0 @: X8 V, h+ L) l, p6 n
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    / l- U/ b; ?  ~
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    & [$ T6 u! i8 Q: L
21.   * GNU General Public License for more details.
    % h! `! P4 ^  f, J
22.   *
    
23.   * You should have received a copy of the GNU General Public License
    2 z# S% J( D" P9 Z9 S9 V6 g8 y
24.   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
    - a& H, t: F. `! a
25.   *
    
26.   ******************************************************************************
    
27.   */
    " |$ I0 V( o2 [) }4 Q/ {; y
28. 
    6 Y$ p6 Y6 c. y9 M( p/ K
29. /* Header includes -----------------------------------------------------------*/
    ; k# b& G5 O9 V( m4 S" L* P
30. #include "RingBuffer.h"
    
31. #include <stdlib.h>
    
32. #include <string.h>
    
33. 
    2 e0 d! {1 m9 p
34. /* Macro definitions ---------------------------------------------------------*/
    2 ]' r7 @# v5 f
35. /* Type definitions ----------------------------------------------------------*/
    
36. /* Variable declarations -----------------------------------------------------*/
    
37. /* Variable definitions ------------------------------------------------------*/
    7 o( b  a( N& t6 |+ y6 k+ Z. x
38. /* Function declarations -----------------------------------------------------*/
    9 w2 F4 R0 W4 C6 T& i
39. static bool is_power_of_2(uint32_t x);
    
40. static uint32_t roundup_pow_of_two(uint32_t x);
    9 h" Y7 P* s; k. Z: n5 h' ]
41. 
    $ q. Z- j# B6 }! f$ u
42. /* Function definitions ------------------------------------------------------*/
    
43. 
    8 c1 k) I3 L* ?( u7 C4 h6 |- A
44. /**
    
45.   * @brief  Allocates a new FIFO and its internal buffer.
    ; b2 M. R  E# G" ~! n1 ?& K* Y
46.   * @param  [in] size: The size of the internal buffer to be allocated.
    6 k3 D& i# A. c& Q  ]4 }
47.   * @note   The size will be rounded-up to a power of 2.
    
48.   * @return RingBuffer pointer.
    
49.   */
    8 f5 Q8 c8 c4 W) t+ U! d
50. RingBuffer *RingBuffer_Malloc(uint32_t size)
    
51. {
    ) t  \1 L, N' w8 L$ w1 Q
52.   RingBuffer *fifo = RING_BUFFER_MALLOC(sizeof(RingBuffer));
    ; x; W3 O# v" g) D" `1 Z- O$ p. K
53. 
    ( Z9 d1 m! r4 K4 A7 G2 ], |& p0 X
54.   if(fifo != NULL)
    
55.   {
    & m4 f* z5 q3 p3 x3 e0 s
56.     if(is_power_of_2(size) != true)
    - z1 z  b2 b7 M( `) @% H
57.     {
    
58.       if(size > 0x80000000UL)
    
59.       {
    % U; k4 Y7 Q+ S
60.         RING_BUFFER_FREE(fifo);
    ; m8 Q# L; T- q, J2 W
61.         fifo = NULL;
    ; m9 S, u/ e+ Y: o( p: t3 n6 H
62.         return fifo;
    
63.       }
    1 M+ v* x% S( v; k/ V- E: f/ h1 N
64. 
    
65.       size = roundup_pow_of_two(size);
    $ o& S% h& }0 h1 H/ K
66.     }
    / a& J8 t: @' C  i6 e2 Y
67. 
    
68.     fifo->size   = size;
    
69.     fifo->in     = 0;
    * z& ?3 {5 U8 ~" P
70.     fifo->out    = 0;
    
71.     fifo->buffer = RING_BUFFER_MALLOC(fifo->size);
    ' v, j0 W7 t. \5 `' Q
72. 
    $ A/ i% H5 k9 h+ V: R
73.     if(fifo->buffer == NULL)
    
74.     {
    3 M- q) \& w5 K' X! S' N
75.       RING_BUFFER_FREE(fifo);
    
76.       fifo = NULL;
    
77.       return fifo;
    + W( ]9 x# g5 l% l1 }& m
78.     }
    ' f4 Y* [. B- i8 \5 {- A. C4 E
79.   }
    + a# Q* ~. b. `0 Z
80. 
    % p% v; k5 b! I# s. s( {5 L
81.   return fifo;
    
82. }
    6 ?3 w2 `* ?8 o
83. 
    & O0 Z6 V! E, `7 X" A7 R/ U
84. /**
    
85.   * @brief  Frees the FIFO.
    & T1 _9 g  z$ H5 _
86.   * @param  [in] fifo: The fifo to be freed.
    
87.   * @return None.
    
88.   */
    
89. void RingBuffer_Free(RingBuffer *fifo)
    * D6 e( M( @( B' @: i  S7 y
90. {
      B9 t" a0 T; {
91.   RING_BUFFER_FREE(fifo->buffer);
    4 R4 [7 c& C; d6 ?4 G: w
92.   RING_BUFFER_FREE(fifo);
    
93.   fifo = NULL;
    " z5 |+ w9 i0 o0 ^. @! x2 z
94. }
    
95. 
    
96. /**
    
97.   * @brief  Puts some data into the FIFO.
    6 t( ^  h. z$ x
98.   * @param  [in] fifo: The fifo to be used.
    , g/ B& u/ H' R, V& e
99.   * @param  [in] in:   The data to be added.
    $ i9 y9 Z+ T' Z' F4 a9 R6 L1 q
100.   * @param  [in] len:  The length of the data to be added.
     
101.   * @return The number of bytes copied.
     
102.   * @note   This function copies at most @len bytes from the @in into
     
103.   *         the FIFO depending on the free space, and returns the number
     
104.   *         of bytes copied.
     7 n6 E2 _7 J3 R6 P! ?  w
105.   */
     
106. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len)
     4 p, I& v% J# A( {" C" x# Q
107. {
     8 X. v9 W: {0 J% T. {
108.   len = min(len, RingBuffer_Avail(fifo));
     
109. 
     : X. X: D+ ?$ L( t* P+ P* S$ Y
110.   /* First put the data starting from fifo->in to buffer end. */
     & H+ B  f, f- _; {7 |
111.   uint32_t l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));
     
112.   memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), in, l);
     4 z, W  R3 C$ P2 [3 k& h
113. 
     
114.   /* Then put the rest (if any) at the beginning of the buffer. */
     ; z8 v- N% z1 {. M
115.   memcpy(fifo->buffer, (uint8_t *)in + l, len - l);
     " T0 J' ~# v# F5 {3 }5 r; r3 Y3 r
116. 
     6 g  J& U5 M( w
117.   fifo->in += len;
     5 `7 r- z1 Y4 A2 N( [* b
118. 
     
119.   return len;
     - C0 s" }* b7 l# S7 m4 b
120. }
     $ c5 ^8 {0 o/ j  y) q: m# o
121. 
     $ w* Q* j: d1 {6 v* `5 h7 x( v$ v
122. /**
     
123.   * @brief  Gets some data from the FIFO.
     5 s2 {8 s. i5 U; h
124.   * @param  [in] fifo: The fifo to be used.
     7 k/ o- M8 d1 z0 ?; C0 ~3 H! |# @2 }- y
125.   * @param  [in] out:  Where the data must be copied.
     ! h( ]# a+ y9 N! [  ?3 d7 z1 m
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
     
129.   *         the @out and returns the number of copied bytes.
     $ F4 t. h: w# C$ o- V3 a2 M
130.   */
     
131. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len)
     
132. {
     
133.   len = min(len, RingBuffer_Len(fifo));
     0 |& u2 o2 {( h9 Q1 w* ]
134. 
     & N7 y0 j) Y1 c% T6 r" k
135.   /* First get the data from fifo->out until the end of the buffer. */
     " t* c; @4 k: G4 T2 ~) f
136.   uint32_t l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
     + e8 y. Z8 l0 F/ f: w
137.   memcpy(out, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
     
138. 
     . T/ }3 _& b: l& a  w5 w
139.   /* Then get the rest (if any) from the beginning of the buffer. */
     : u4 y3 m) ~5 I/ N6 m$ [
140.   memcpy((uint8_t *)out + l, fifo->buffer, len - l);
     
141. 
     * W# F) ~# q: ^# V; ^5 V
142.   fifo->out += len;
     
143. 
     
144.   return len;
     
145. }
     
146. 
     
147. /**
     
148.   * @brief  Determine whether some value is a power of two.
     ) _4 E  Y% D# x4 J
149.   * @param  [in] x: The number to be confirmed.
     9 C( z; o, n7 p5 L1 G: U
150.   * @retval true:   Yes.
     
151.   * @retval false:  No.
     8 x$ ^1 u& `& x
152.   * @note   Where zero is not considered a power of two.
     
153.   */
     * p0 @- \. i2 Q9 \5 ^
154. static bool is_power_of_2(uint32_t x)
     * D5 j; k3 ^! c. K# {: z
155. {
     5 A* R- q, P' u* h7 j% j5 J
156.   return (x != 0) && ((x & (x - 1)) == 0);
     & v1 h- E2 N7 H
157. }
     7 w& F' F2 }; ?1 ^9 _6 L" T
158. 
     
159. /**
     , F" g6 P- ?8 e( y
160.   * @brief  Round the given value up to nearest power of two.
     5 n6 \) H3 e/ @/ ]; M1 D
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)
     
165. {
     " w( V* U8 M7 I
166.   uint32_t b = 0;
     : K% q, D" |% _7 v% h. ]2 ^
167. 
     5 d, _7 w6 w9 j, |% M! K4 }) Y
168.   for(int i = 0; i < 32; i++)
     
169.   {
     
170.     b = 1UL << i;
     % F  E+ [/ c6 A% t6 Y. J
171. 
     1 ^$ S2 y/ {- s+ P7 q
172.     if(x <= b)
     ; {" |5 I+ P' W  l6 s& x7 F3 u+ s
173.     {
     7 U0 w& n2 N( X. c
174.       break;
     
175.     }
     5 D# a4 ?7 e! g& J/ Y
176.   }
     
177. 
     
178.   return b;
     * Z' g# e. v; f: A7 U
179. }
     1 S& K: _+ J4 O9 M

复制代码

/ r( ?2 t9 [7 L, i: k4 `% B: b      main.c文件
, q0 ~% W. Z% y

1. /**
   
2.   ******************************************************************************
   + |6 C# Z% n/ m! E
3.   * @file    main.c
   1 ?) N3 i" F/ Q0 _' _
4.   * @author  XinLi
   8 z/ Y7 m2 W; G, r/ H% |( D
5.   * @version v1.0
   " Z& O8 z% S- d+ q, m
6.   * @date    15-January-2018
   
7.   * @brief   Main program body.
   
8.   ******************************************************************************
   2 e, S- B7 i6 R( c0 C2 p' c
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
    2 C' c0 @) w/ x. ^7 ?
14.   * it under the terms of the GNU General Public License as published by
    4 M, t4 {) Z) J7 Q8 y' ~
15.   * the Free Software Foundation, either version 3 of the License, or
    & i' S' H" w+ q4 Z; ^
16.   * (at your option) any later version.
    5 ?9 P' Q  n2 x8 i2 o6 b
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    - T% {! z& N: t  h. {
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
      ?1 A4 v7 s: s
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    + R8 V. n& D9 F/ m. k# Q
22.   *
    ! H6 u3 Z6 i  g5 |
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.   *
    
26.   ******************************************************************************
    & u4 d8 Y  p. R
27.   */
    $ Q; M* a+ R0 {0 L3 D8 h$ V
28. 
    ) g0 r5 Y( h4 a' W- S
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "RingBuffer.h"
    
31. #include <stdio.h>
    1 i% |) G5 `- D  c. |' Q6 X
32. #include <windows.h>
    $ d- a! h  n( {. `5 d  j. k5 l! h
33. 
    
34. /* Macro definitions ---------------------------------------------------------*/
    7 @3 H2 _" J0 Z( ?
35. /* Type definitions ----------------------------------------------------------*/
    
36. /* Variable declarations -----------------------------------------------------*/
    # ~# S& A9 e! [: r0 Y& `& `6 _
37. /* Variable definitions ------------------------------------------------------*/
    & s7 c7 ]2 s# |! n8 R2 \2 b
38. /* Function declarations -----------------------------------------------------*/
    
39. /* Function definitions ------------------------------------------------------*/
      ~5 T0 g9 w' o  b+ G0 N
40. 
    . Y/ H1 @# B2 Q! `  J* ?+ ^
41. /**
    * W3 F1 e  N. K2 q- T
42.   * @brief  Main program.
    
43.   * @param  None.
    
44.   * @return None.
    
45.   */
    
46. int main(void)
    8 {6 W# w8 a+ E1 A( X  o; _1 D
47. {
    ) o( B- C7 j* u0 P6 ~
48.   uint8_t data[256] = {0};
    
49. 
    2 b: _+ S- |9 W: @
50.   for(int i = 0; i < sizeof(data); i++)
    0 _; c: x/ S0 m$ B6 T3 W1 w
51.   {
    
52.     data[i] = i;
    
53.   }
    " f! D6 d3 d$ z/ @' [, m: D5 e% q
54. 
    1 V0 ^0 a* M' Z+ P: C# Z3 p  i) y
55.   RingBuffer *fifo = RingBuffer_Malloc(sizeof(data));
    
56. 
    
57.   if(fifo != NULL)
    
58.   {
      |! A% J2 U0 }! K: c: {
59.     printf("FIFO创建成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
    
60.            RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
    
61. 
    
62.     if(RingBuffer_IsFull(fifo) == true)
    
63.     {
    ( Y: F8 E  M. B+ N
64.       printf("FIFO满了！！！\n");
    
65.     }
    " w/ ^) J' L) b+ Y8 l; W7 r* Q5 Z) ^
66.     else
    
67.     {
    . k- F$ A( ?  y' Z3 T: L+ U
68.       printf("FIFO没满！！！\n");
    4 [8 }" K3 w: f$ b0 o+ Z% x$ j
69.     }
    
70. 
    8 S6 E. L" {6 U1 C, a, D8 W) V
71.     if(RingBuffer_IsEmpty(fifo) == true)
    
72.     {
    
73.       printf("FIFO空了！！！\n");
    
74.     }
    
75.     else
    
76.     {
      Z/ y" F' B0 }( S
77.       printf("FIFO没空！！！\n");
    2 _( P: ], v; f9 F1 I* ^
78.     }
    
79. 
    , l  y! a: I' O9 M' ?# }: G1 C6 O; @
80.     printf("\n");
    
81. 
    
82.     for(;;)
    
83.     {
    
84.       {
    
85.         if(RingBuffer_In(fifo, data, sizeof(data) / 2) > 0)
    3 s+ }( Q, A8 ^& C# \* M  P
86.         {
    
87.           printf("FIFO写入成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
    
88.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
    8 d3 K, f# y2 E- j
89.         }
    + f. g, K; d  I* I; Y* X5 C
90.         else
    / e4 j9 t& G. K4 |
91.         {
    5 _, l* `1 v( m- d! [  e
92.           printf("FIFO写入失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
      p5 m0 h8 c/ L) f
93.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
    
94.         }
    0 H4 p$ k/ A# ?8 c! y
95. 
    * K2 n( m$ c( Y/ n  o! K/ b% w
96.         if(RingBuffer_IsFull(fifo) == true)
    ' @! x; k4 q) Y+ o7 c
97.         {
    4 z/ D- \; Q& P4 w3 L
98.           printf("FIFO满了！！！\n");
    
99.         }
    
100.         else
     
101.         {
     
102.           printf("FIFO没满！！！\n");
     
103.         }
     
104. 
     
105.         if(RingBuffer_IsEmpty(fifo) == true)
     % l4 e( i3 W. ~' i, q
106.         {
     
107.           printf("FIFO空了！！！\n");
     
108.         }
     
109.         else
     $ c2 M8 [& q; B9 h# N
110.         {
     $ u3 g, g2 d4 [/ P- P4 M
111.           printf("FIFO没空！！！\n");
     
112.         }
     7 v7 y) C: R0 E: I
113.       }
     
114. 
     
115.       printf("\n");
     
116. 
     
117.       {
     
118.         uint8_t rdata[64] = {0};
     
119.         uint8_t len       = RingBuffer_Out(fifo, rdata, sizeof(rdata));
     ) b. ]- ^5 }" s0 L, O! @
120. 
     " F, n6 S- ^) O5 S
121.         if(len > 0)
     
122.         {
     $ T& G' A% I4 S2 S% S7 m1 E% H: C
123.           printf("从FIFO中读出的数据，长度：%d\n", len);
     
124. 
     
125.           for(int i = 0; i < len; i++)
     
126.           {
     
127.             printf("%d ", rdata[i]);
     / O; w# {( g2 L# {
128.           }
     
129. 
     3 v/ ?/ {! n6 v2 {  ]
130.           printf("\n");
     
131. 
     ! @/ f$ d. {' ]$ F2 Y
132.           printf("FIFO读取成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     0 V# C9 |0 ]" _% k0 ^
133.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     . e6 I2 D) H& Q
134.         }
     1 n, D2 R2 O% h9 c' a) d7 c7 {
135.         else
     ; J. S8 a% G9 ^4 ~  r3 Q  J$ r
136.         {
     - Q, \5 k, S3 U. r$ d; b$ Q
137.           printf("FIFO读取失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
138.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     3 @9 v! V- ?  K, M$ N0 k9 |
139.         }
     
140. 
       L6 t/ @; B* B6 J
141.         if(RingBuffer_IsFull(fifo) == true)
     
142.         {
     
143.           printf("FIFO满了！！！\n");
     $ J5 J3 H0 [, w( k$ t& h3 ~' R
144.         }
     & @) |/ {+ ^7 J# z: _3 C+ c
145.         else
     
146.         {
     
147.           printf("FIFO没满！！！\n");
     1 S- \; T$ S7 h" A, U! P! g
148.         }
     7 {% k, e. ]( b3 ^; W+ I
149. 
     % V( \4 c- O8 \3 A9 D; V9 y
150.         if(RingBuffer_IsEmpty(fifo) == true)
     
151.         {
     * X# V- [8 L+ j- ~' A8 e+ h) t
152.           printf("FIFO空了！！！\n");
     ' S! ^9 i, R( M% H5 D5 D9 X1 C
153.         }
     
154.         else
     & h. Z% L6 \: ?- k+ C
155.         {
     & V) J" M; J2 b! S
156.           printf("FIFO没空！！！\n");
     - `9 U$ l+ }! g, [; p
157.         }
     
158.       }
     
159. 
     
160.       printf("\n");
     
161. 
     . H: S: u$ C6 Z( q( ?
162.       {
     
163.         RingBuffer_Reset(fifo);
     
164.         printf("FIFO清空成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
165.                RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     ) a! q0 ^4 X/ j" h; X
166. 
     0 i; @* ]# P% T1 b
167.         if(RingBuffer_IsFull(fifo) == true)
     
168.         {
     / @, f) X3 K: c, }+ y4 L) z
169.           printf("FIFO满了！！！\n");
     ' C+ c$ j& N. J2 O4 \
170.         }
     8 q4 `) v" l2 h4 x; v
171.         else
     
172.         {
     
173.           printf("FIFO没满！！！\n");
     
174.         }
     " M  X) x1 @1 l; Z0 n1 d
175. 
       _8 y: V* |6 K1 H8 i. `8 u
176.         if(RingBuffer_IsEmpty(fifo) == true)
     
177.         {
     5 J# A+ b! k0 J: e5 U
178.           printf("FIFO空了！！！\n");
     
179.         }
     6 c2 h* k' k; P5 |# N
180.         else
     
181.         {
     1 Q/ _: r( H3 U* H
182.           printf("FIFO没空！！！\n");
     8 `4 k8 E0 W4 j( l2 c1 A* M
183.         }
     . _% f% G  p- C8 x+ F% E2 ?
184.       }
     
185. 
     
186.       printf("\n");
     
187. 
     
188.       {
     9 c% Q, I1 U" j4 _+ a: ^
189.         if(RingBuffer_In(fifo, data, sizeof(data)) > 0)
       {7 n+ |/ s# @, ~
190.         {
     
191.           printf("FIFO写入成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
192.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
193.         }
     * }1 J# Z7 ?; }9 ?6 _
194.         else
     
195.         {
     
196.           printf("FIFO写入失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
197.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     3 m* p4 Y: Y: @6 ~' N
198.         }
     
199. 
     
200.         if(RingBuffer_IsFull(fifo) == true)
     
201.         {
     # b8 z# O" v6 B4 S7 x$ |+ h" Y( ]
202.           printf("FIFO满了！！！\n");
     
203.         }
     $ _1 M* c9 a: k$ Z. [' y. p
204.         else
     
205.         {
     
206.           printf("FIFO没满！！！\n");
     
207.         }
     ! O# b' L0 c0 O% c! K+ n
208. 
     
209.         if(RingBuffer_IsEmpty(fifo) == true)
     / A8 x  d; l1 _! i9 E
210.         {
     9 w- G+ _- }) y+ w- y: s
211.           printf("FIFO空了！！！\n");
     , l3 @2 q/ n4 X1 M( K- B! ?
212.         }
     
213.         else
     
214.         {
     ! `# ^1 H! m6 E
215.           printf("FIFO没空！！！\n");
     
216.         }
     & ^9 D3 @: w2 H. b
217.       }
     
218. 
     
219.       printf("\n");
     ( Z$ O- i# j; t/ ?+ W4 s3 X0 x
220. 
     / Y# i; c7 q7 ?0 J
221.       {
     
222.         if(RingBuffer_In(fifo, data, sizeof(data)) > 0)
     
223.         {
     
224.           printf("FIFO写入成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     2 A6 Q3 T6 A9 x& w3 \! a0 h% P3 T
225.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     - k5 M5 T' O2 B' @3 O# [( A
226.         }
     1 m9 B" m) l1 T9 a) C5 a
227.         else
     3 B! v5 S1 k% B3 q3 y9 [4 Z7 U
228.         {
     ' c8 o* e, l3 u* L) l
229.           printf("FIFO写入失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
230.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     , d8 q- a. m( B+ O3 J. _
231.         }
     & V' n5 b% t( K) M$ [
232. 
     
233.         if(RingBuffer_IsFull(fifo) == true)
     / u' r! a7 I3 H# n1 y
234.         {
     
235.           printf("FIFO满了！！！\n");
     # k! b: \0 O; U& A! g% Q
236.         }
     
237.         else
     
238.         {
     $ N  c) Y3 r# e6 G
239.           printf("FIFO没满！！！\n");
       J+ G* f3 o0 D
240.         }
     
241. 
     
242.         if(RingBuffer_IsEmpty(fifo) == true)
     ; k9 ?7 n7 b8 W% ?
243.         {
     
244.           printf("FIFO空了！！！\n");
     
245.         }
     
246.         else
     
247.         {
     
248.           printf("FIFO没空！！！\n");
     & i' ]; w4 B7 F  l
249.         }
     
250.       }
     , F5 x  u/ c  b  R: U4 }" n
251. 
     : k: h4 {9 w( y- O( |
252.       printf("\n");
     
253. 
     
254.       {
     
255.         uint8_t  rdata[256] = {0};
     
256.         uint16_t len        = RingBuffer_Out(fifo, rdata, sizeof(rdata));
       i0 U/ [5 b6 p$ {
257. 
     
258.         if(len > 0)
     9 {( ?  u9 B2 w/ h( |
259.         {
     
260.           printf("从FIFO中读出的数据，长度：%d\n", len);
     
261. 
     - a: q5 `. y& [
262.           for(int i = 0; i < len; i++)
     
263.           {
     ( o/ ]. o; t/ ^& O! V7 U$ ~8 H$ k* N% g
264.             printf("%d ", rdata[i]);
     
265.           }
     
266. 
     
267.           printf("\n");
     $ B& _: b: y+ r+ g
268. 
     
269.           printf("FIFO读取成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
270.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     9 s# I; [6 ]2 p
271.         }
     0 G8 L2 ?" w* t
272.         else
     
273.         {
     
274.           printf("FIFO读取失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     3 W+ m4 ~0 ?( L- ^& |* v: D
275.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     3 l& x! d  j- g& N6 q: Z! a2 v' \
276.         }
     + u* u9 s0 D# E" y5 d
277. 
     + B7 B8 V" N% U3 \1 {
278.         if(RingBuffer_IsFull(fifo) == true)
     
279.         {
     # E3 V4 s: t* e
280.           printf("FIFO满了！！！\n");
     5 N$ B( `0 J+ s  s3 U- D
281.         }
     5 |0 q) v' k7 O, e8 Y
282.         else
     
283.         {
     
284.           printf("FIFO没满！！！\n");
     
285.         }
     # M  b( D: m) w! m
286. 
     % o0 a! J% V7 ]1 Z- I5 ^, s: P
287.         if(RingBuffer_IsEmpty(fifo) == true)
     
288.         {
     9 [" E( |. g# P  b
289.           printf("FIFO空了！！！\n");
     
290.         }
     9 ]6 j1 x3 a5 K3 v' o
291.         else
     
292.         {
     * U* D: U. l2 I5 Z& ?3 K8 z- o
293.           printf("FIFO没空！！！\n");
     
294.         }
     
295.       }
     
296. 
     6 X$ c. N2 @/ d5 {& V5 Q& S1 y, q! V
297.       printf("\n");
     % ]. J9 T2 H- U' g
298. 
     
299.       {
     $ z4 U/ f8 k' H' Z
300.         uint8_t  rdata[256] = {0};
     % N& X$ ?$ Q% E: N* v% C, Q
301.         uint16_t len        = RingBuffer_Out(fifo, rdata, sizeof(rdata));
     
302. 
     8 C7 C, {2 r9 g5 s8 `
303.         if(len > 0)
     & G9 O% G/ d! S+ F; h& @6 e2 V
304.         {
     
305.           printf("从FIFO中读出的数据，长度：%d\n", len);
     8 w# h# F8 ~$ z1 l* {8 `
306. 
     
307.           for(int i = 0; i < len; i++)
     
308.           {
     
309.             printf("%d ", rdata[i]);
     - Q5 J" R! c3 u3 w
310.           }
     
311. 
     
312.           printf("\n");
     
313. 
     & \& e3 i" f; {+ ~3 z/ n: n
314.           printf("FIFO读取成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
315.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     * q* o$ L: q$ d8 _7 P
316.         }
     9 B) n. x  u# c, K& v) M
317.         else
     
318.         {
     
319.           printf("FIFO读取失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     ' Q; L: [6 p* @- y  z# H
320.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     - L1 O) G& z* L' `8 i- d
321.         }
     
322. 
     . V; Y6 U6 B4 j& X; z" p2 ~
323.         if(RingBuffer_IsFull(fifo) == true)
     
324.         {
     
325.           printf("FIFO满了！！！\n");
     
326.         }
     
327.         else
     0 Q% S3 P! l" q
328.         {
     # @3 t  ]$ ^/ C
329.           printf("FIFO没满！！！\n");
     
330.         }
     , X! z8 l% K' L/ ]
331. 
     & Y5 b5 ^; S- u3 u" o
332.         if(RingBuffer_IsEmpty(fifo) == true)
     
333.         {
     
334.           printf("FIFO空了！！！\n");
     / h8 T) i1 c/ p; J& F. y8 q
335.         }
     
336.         else
     
337.         {
     + p& h5 D# S& S7 [& N. v5 E0 \$ |
338.           printf("FIFO没空！！！\n");
     
339.         }
     
340.       }
     
341. 
     * n  \* C+ C6 R4 X: Q0 G/ ]" k
342.       printf("\n\n\n");
     
343.       Sleep(5000);
     
344.     }
     
345.   }
     
346.   else
     
347.   {
     
348.     printf("FIFO创建失败\n");
     6 m2 l; w  R5 z
349.   }
     1 }! k6 R& w- X- E. `% Z0 e9 x  m
350. 
     
351.   for(;;)
     / ^/ a6 L' n) k. F- V2 `) h& \
352.   {
     
353. 
     ) H" V9 ^8 X: D( L  J
354.   }
     9 z$ O8 \( U0 i7 e* R" q
355. }
     

复制代码

, P; O1 ?0 O& E7 i5 N3，运行效果

谢谢分享

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