! W: X# D; Y+ _) M) E$ b
/ e8 F& l) w5 W* E

模仿kfifo实现的环形缓冲区

; F+ h# L5 ~! o+ K! c
转载来源：模仿kfifo实现的环形缓冲区


3 n. b& ^8 ?* s  B' XGitHub仓库：http://github.com/XinLiGitHub/RingBuffer
PS：博文不再更新，后续更新会在GitHub仓库进行。

& A) D3 N6 q) u; b    模仿kfifo实现的环形缓冲区。程序中涉及到环形缓冲区的概念，详细介绍见维基百科[Circular buffer](http://en.wikipedia.org/wiki/Circular_buffer)。
& c1 S5 N$ f6 l% R1 i7 G9 B+ O
/ m, D  A; V  S/ H  m- E1，开发环境
      1，操作系统：Windows 10 专业版
      2，IDE：Visual Studio 2015 专业版

0 V4 Y# z, ?1 G6 ?2，程序源码
      RingBuffer.h文件

1. /**
   
2.   ******************************************************************************
   * u# f- P( u* Q
3.   * @file    RingBuffer.h
   
4.   * @author  XinLi
   + r7 j+ ?$ b+ I& r
5.   * @version v1.0
   . h4 y- C% ?7 {0 a/ X6 q
6.   * @date    15-January-2018
   9 A3 U% ]! L% V! B
7.   * @brief   Header file for RingBuffer.c module.
   
8.   ******************************************************************************
   $ s' [! B! [* o1 G" |  y
9.   * @attention
   % ^" g' @1 h& M7 [7 t7 B- l! d
10.   *
    & d) t1 b0 w- Q6 |- G% I, G& O
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
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
    0 f6 z% L+ q8 r' E0 B/ H
15.   * the Free Software Foundation, either version 3 of the License, or
    
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
    ; M& Q+ }; {" _( X0 [
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    * x. |6 w: [# R  N
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/>.
    # a  E) Q9 ~' L8 I/ l
25.   *
    
26.   ******************************************************************************
    $ o: J0 f- D! X5 X; O- W7 G+ j
27.   */
    ; r- Z1 j; H, T, G$ j2 H
28. 
    
29. #ifndef __RINGBUFFER_H
    , N1 x$ K: a: x3 M( S
30. #define __RINGBUFFER_H
    2 w' n. }" z0 K, s" d' W+ }+ |1 T
31. 
    - L) j2 k6 W5 M' }' k
32. #ifdef __cplusplus
    ' ?# @) {- ?; {' X
33. extern "C" {
    # P+ }/ l7 u* Q1 p# e
34. #endif
    0 x/ T* l# W2 f; i& e# t
35. 
    4 a) j4 o0 a) y5 I/ N& \
36. /* Header includes -----------------------------------------------------------*/
    
37. #include <stdint.h>
    
38. #include <stdbool.h>
    7 g3 l7 o- X6 \" G
39. 
    % i& \$ p: h! R5 t% p
40. /* Macro definitions ---------------------------------------------------------*/
    
41. #define RING_BUFFER_MALLOC(size)  malloc(size)
    
42. #define RING_BUFFER_FREE(block)   free(block)
    
43. 
    
44. /* Type definitions ----------------------------------------------------------*/
    
45. typedef struct
    8 r6 v* U. I1 c. z* v, R! ~1 O& n/ U
46. {
    3 b9 B* |$ @- V  l0 ^" x( W
47.   uint8_t *buffer;
    0 l5 F8 C8 a! p
48.   uint32_t size;
    - h8 ~; m5 ^- E) ~7 T& O+ C
49.   uint32_t in;
    
50.   uint32_t out;
    
51. }RingBuffer;
    
52. 
    
53. /* Variable declarations -----------------------------------------------------*/
    " z- Q( v4 u8 o8 M
54. /* Variable definitions ------------------------------------------------------*/
    
55. /* Function declarations -----------------------------------------------------*/
    / ^/ g8 u8 F$ y, ^/ O& M0 }, w
56. RingBuffer *RingBuffer_Malloc(uint32_t size);
    7 s( v/ L+ R! ?  A3 Z7 B( v
57. void RingBuffer_Free(RingBuffer *fifo);
    + V3 E) y2 Y6 `0 W
58. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len);
    ) n, \3 h+ g4 l8 A
59. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len);
    ( `0 F  d' n/ p- ?
60. 
    6 i5 b5 u% \5 l3 n* y
61. /* Function definitions ------------------------------------------------------*/
    ' N! J6 x; {' Q# C* s
62. 
    
63. /**
    $ r" ~4 X2 X# ^' |) H& |
64.   * @brief  Removes the entire FIFO contents.
    ' ~: V- |  l# s! H/ v; L
65.   * @param  [in] fifo: The fifo to be emptied.
    $ T! u% Q& i/ l) `% V/ R! U* y% {
66.   * @return None.
    
67.   */
    
68. static inline void RingBuffer_Reset(RingBuffer *fifo)
    ) [4 f( z4 J/ L3 E* k" O
69. {
    ) Z( [5 P! k. @& y: r1 _  u
70.   fifo->in = fifo->out = 0;
    & w- ]2 }3 ]6 ?
71. }
    
72. 
    
73. /**
    , J) r; P: d! U2 W" H2 c/ Y
74.   * @brief  Returns the size of the FIFO in bytes.
    
75.   * @param  [in] fifo: The fifo to be used.
    ) w2 V. A# s! P* P" U8 `* r# [
76.   * @return The size of the FIFO.
    4 J5 T  k4 E1 q. t3 h2 w
77.   */
    
78. static inline uint32_t RingBuffer_Size(RingBuffer *fifo)
    7 E% G4 y% c9 W% W$ N* ]
79. {
    - @* m, L1 Y6 e; b' c. d$ @/ {. o
80.   return fifo->size;
    : {  d7 a% c0 A5 E$ `
81. }
    3 n9 D4 B, t+ _- F
82. 
    
83. /**
    * z3 z* M# m, z! C; |- ]/ S6 q
84.   * @brief  Returns the number of used bytes in the FIFO.
    ) X# I$ e3 ~3 N0 |4 ?
85.   * @param  [in] fifo: The fifo to be used.
    
86.   * @return The number of used bytes.
    % _4 s9 ?  _5 Y4 _' B# D
87.   */
    3 t% s3 \9 ?" j. h3 C* Q2 Z
88. static inline uint32_t RingBuffer_Len(RingBuffer *fifo)
    
89. {
    
90.   return fifo->in - fifo->out;
      N+ G: A9 R9 H' A
91. }
    ) z; w3 E0 V$ j/ G7 K8 |$ L
92. 
    
93. /**
    5 r) F8 O' @# s: g1 z8 a& n
94.   * @brief  Returns the number of bytes available in the FIFO.
    & ?% ~% l( b/ u9 p
95.   * @param  [in] fifo: The fifo to be used.
    
96.   * @return The number of bytes available.
    6 _/ I" U, l9 \3 A" y6 X
97.   */
    
98. static inline uint32_t RingBuffer_Avail(RingBuffer *fifo)
    
99. {
    , G5 l7 `% B' O. r& B; a; `
100.   return RingBuffer_Size(fifo) - RingBuffer_Len(fifo);
     8 @6 t8 ^; S/ j/ `
101. }
     # y7 ^: Y. U  S
102. 
     " Z' L  g% N3 c& h5 Q7 g% j1 q
103. /**
     9 G1 H/ p0 W  m# R: ~6 Q
104.   * @brief  Is the FIFO empty?
     ! n$ L5 F3 r0 f+ a, l% s* C
105.   * @param  [in] fifo: The fifo to be used.
     
106.   * @retval true:      Yes.
     
107.   * @retval false:     No.
     
108.   */
     
109. static inline bool RingBuffer_IsEmpty(RingBuffer *fifo)
     ; q2 A6 }* J* c, K+ f! l
110. {
     
111.   return RingBuffer_Len(fifo) == 0;
     
112. }
     & b0 w9 N% r% ~; _' ~& y9 s, _
113. 
     % t) ?6 N# L4 s2 N8 p# |
114. /**
     * Y8 G5 B. Q+ p& e5 g. y
115.   * @brief  Is the FIFO full?
     / x4 @, @  R$ ~3 S1 f
116.   * @param  [in] fifo: The fifo to be used.
     % Y0 Q5 U7 M3 L9 F. y$ u1 |4 C
117.   * @retval true:      Yes.
     
118.   * @retval false:     No.
     
119.   */
     + c% P5 p) n6 G! Z
120. static inline bool RingBuffer_IsFull(RingBuffer *fifo)
     
121. {
     5 B5 Y# [6 C4 q4 B  p5 p! A- {8 {
122.   return RingBuffer_Avail(fifo) == 0;
     
123. }
     
124. 
     1 H" [+ }$ j* i
125. #ifdef __cplusplus
     8 R4 x8 j) y: t; g( o5 N1 H. T
126. }
     
127. #endif
     
128. 
     
129. #endif /* __RINGBUFFER_H */
     - w& c' E8 m' E  s

复制代码

* f3 g$ s5 z9 J2 x6 T" R      RingBuffer.c文件

1. /**
   1 I% X% u0 K* ^' p
2.   ******************************************************************************
   
3.   * @file    RingBuffer.c
   % b! a, L( v5 ?, W) ]8 e7 W
4.   * @author  XinLi
   , x  O0 G+ }+ N: h' V9 G: p  X# k
5.   * @version v1.0
   
6.   * @date    15-January-2018
   
7.   * @brief   Ring buffer module source file.
   
8.   ******************************************************************************
   
9.   * @attention
   / V! ?6 Y( J; T
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    , _$ u% m2 A2 ~  h* Q
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 j% |8 V* H9 v( d: Y! {
16.   * (at your option) any later version.
    8 z2 _; I5 s3 y* n; f) a$ f
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
    9 O% E6 {: T8 _' d7 Y
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    0 _' T; j) g# I8 B2 b  ?
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/>.
    " @7 ^- }. V$ n& O8 q1 N/ I( B
25.   *
    4 x, }1 p5 G* p9 F. p5 h& p
26.   ******************************************************************************
    
27.   */
    
28. 
    
29. /* Header includes -----------------------------------------------------------*/
    # t7 a2 |  z% C7 E8 C9 p$ j
30. #include "RingBuffer.h"
    7 u- {" }6 r: L$ M- d* j5 N
31. #include <stdlib.h>
    ! y/ t7 B' u; M; O  ^; r& O1 B
32. #include <string.h>
    1 n, k( N7 ^* |
33. 
    ( }$ o8 D1 T# d/ D, ^; T
34. /* Macro definitions ---------------------------------------------------------*/
    
35. /* Type definitions ----------------------------------------------------------*/
    ; Y! b& w0 E7 Q# ?5 W
36. /* Variable declarations -----------------------------------------------------*/
    
37. /* Variable definitions ------------------------------------------------------*/
    
38. /* Function declarations -----------------------------------------------------*/
    
39. static bool is_power_of_2(uint32_t x);
    
40. static uint32_t roundup_pow_of_two(uint32_t x);
    - |. J, t# g# Q% R* P
41. 
    7 j7 ^. m2 t$ l2 B! ^& m
42. /* Function definitions ------------------------------------------------------*/
    
43. 
    " m  K, e1 J, J( n
44. /**
    4 I$ I3 D7 V8 ^3 M" t0 t
45.   * @brief  Allocates a new FIFO and its internal buffer.
    
46.   * @param  [in] size: The size of the internal buffer to be allocated.
    - ^  D9 ?# Q' h4 y6 P( t
47.   * @note   The size will be rounded-up to a power of 2.
    / U3 W; ?: e9 V) \. ~2 L+ q. M7 Q
48.   * @return RingBuffer pointer.
    
49.   */
    : \8 `4 X& T( Q3 c0 L4 p) ?
50. RingBuffer *RingBuffer_Malloc(uint32_t size)
      K1 t- a! t, d/ u
51. {
    
52.   RingBuffer *fifo = RING_BUFFER_MALLOC(sizeof(RingBuffer));
    
53. 
    6 ^1 t# F, Q$ v0 t
54.   if(fifo != NULL)
    4 t8 l/ h; w) n# E4 V
55.   {
    
56.     if(is_power_of_2(size) != true)
    
57.     {
    0 ?! ^; j, M. X6 m7 o2 @* h; D$ G
58.       if(size > 0x80000000UL)
    
59.       {
    5 F, L: R" b% g- C. ~
60.         RING_BUFFER_FREE(fifo);
    - s3 b1 X  e. \0 p! e  @
61.         fifo = NULL;
    
62.         return fifo;
    7 S/ u. |" w6 J; P. {3 P9 y
63.       }
    3 s$ J7 q8 y6 R* M
64. 
    
65.       size = roundup_pow_of_two(size);
    
66.     }
    
67. 
    
68.     fifo->size   = size;
    # x% G! c* s, S9 I1 ~' T2 O9 `
69.     fifo->in     = 0;
    
70.     fifo->out    = 0;
    
71.     fifo->buffer = RING_BUFFER_MALLOC(fifo->size);
    ( i1 L' d0 m' r& A& k
72. 
    
73.     if(fifo->buffer == NULL)
    # q# W' D" \0 L3 E9 L
74.     {
    
75.       RING_BUFFER_FREE(fifo);
    - P0 y: `8 q# n. |( n2 y& C
76.       fifo = NULL;
    
77.       return fifo;
    , T8 i2 x2 m1 ~
78.     }
    
79.   }
    
80. 
    
81.   return fifo;
    3 d' H/ C# r& P. @$ ?9 Y- l
82. }
    
83. 
    % c7 E$ v( n! z
84. /**
    9 D0 e2 j; m* o+ L
85.   * @brief  Frees the FIFO.
    
86.   * @param  [in] fifo: The fifo to be freed.
    2 W* O8 P6 k3 r7 Y# X4 _
87.   * @return None.
    
88.   */
    0 X% e. l% t5 z0 k3 y& k
89. void RingBuffer_Free(RingBuffer *fifo)
    9 [1 H) E0 C: B7 j- a0 P9 k
90. {
    : B' L7 Z) u4 }
91.   RING_BUFFER_FREE(fifo->buffer);
    # `7 w% N4 ?0 c5 {& U
92.   RING_BUFFER_FREE(fifo);
    4 j0 @5 L6 C: [8 ?4 i
93.   fifo = NULL;
    # v7 t8 J1 w! T8 U* L' Y, o# \( t
94. }
    # M- @- {; c; o/ w7 T' `9 I; s0 r
95. 
    % v$ @3 p8 K+ O( ~! g
96. /**
    : `# P/ R8 T* r& P
97.   * @brief  Puts some data into the FIFO.
    5 f$ r+ K) x! ^. L
98.   * @param  [in] fifo: The fifo to be used.
    & d  {! d' U0 l. `# D. C6 M
99.   * @param  [in] in:   The data to be added.
    4 l4 c0 j1 O1 h
100.   * @param  [in] len:  The length of the data to be added.
     3 C' D% ^' i& e0 {# F& K% P/ [
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
     3 ~  ]6 Z, O. u" B
104.   *         of bytes copied.
     
105.   */
     
106. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len)
     : K3 E5 R- R0 t6 |; v* b( z
107. {
     7 \8 }7 F# o2 _7 K. y
108.   len = min(len, RingBuffer_Avail(fifo));
     % S; t+ B- [6 f% t! a
109. 
     4 ~0 M2 P3 U( y
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)));
     
112.   memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), in, l);
     
113. 
     : b' N" ]  B. l
114.   /* Then put the rest (if any) at the beginning of the buffer. */
     
115.   memcpy(fifo->buffer, (uint8_t *)in + l, len - l);
     
116. 
     ( W' d/ A4 E5 Q- W6 ?! l
117.   fifo->in += len;
     ) v" C% T  |1 E# ]% z6 N- ~
118. 
     
119.   return len;
     & K/ E; t8 _+ ?% m8 H$ @
120. }
     5 n* N+ S2 B. \$ |7 V. i
121. 
     4 ]2 P+ i+ P3 ?/ V8 _; _
122. /**
     
123.   * @brief  Gets some data from the FIFO.
     & T! Z' g" Q9 V, P  }2 N* T
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.
     % x7 _; Z6 `: V3 M# u9 Q0 ?
127.   * @return The number of copied bytes.
     
128.   * @note   This function copies at most @len bytes from the FIFO into
     7 ]+ @$ }8 a- ], D% c5 P
129.   *         the @out and returns the number of copied bytes.
     3 u3 Y0 K8 H; d3 D( i/ j; F( a' g8 k
130.   */
     
131. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len)
     + t$ g: b- S2 r
132. {
     7 b9 ^! Q1 |' k5 H1 i
133.   len = min(len, RingBuffer_Len(fifo));
     
134. 
     ; K, u# b5 _! P
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)));
     ! U% D5 S0 O# Y8 E6 Y6 o
137.   memcpy(out, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
     / v( u- y0 h) B# i* p4 w( E& c
138. 
     
139.   /* Then get the rest (if any) from the beginning of the buffer. */
     & j+ X6 l) M, y' u4 O+ ]+ R+ Q
140.   memcpy((uint8_t *)out + l, fifo->buffer, len - l);
     
141. 
     
142.   fifo->out += len;
     
143. 
     
144.   return len;
     & c7 W: ?5 b1 _7 s% v- P# M& @
145. }
     , F3 O2 G6 n5 G+ j9 F1 n
146. 
     , @* _' P! q5 M* Q
147. /**
     
148.   * @brief  Determine whether some value is a power of two.
     
149.   * @param  [in] x: The number to be confirmed.
       e, A. G+ U3 }$ F4 h
150.   * @retval true:   Yes.
     ! f: s- t4 C2 f9 V2 L# Y2 E
151.   * @retval false:  No.
     4 v8 s7 Y# ^- a" x' Y+ n! V
152.   * @note   Where zero is not considered a power of two.
     
153.   */
     
154. static bool is_power_of_2(uint32_t x)
     
155. {
     ( _7 W* U# S' D5 G2 ^: S( e
156.   return (x != 0) && ((x & (x - 1)) == 0);
     
157. }
     0 K8 S" R8 A$ e
158. 
     ; K' x- t* D% ?4 x" C
159. /**
     
160.   * @brief  Round the given value up to nearest power of two.
     
161.   * @param  [in] x: The number to be converted.
     
162.   * @return The power of two.
     
163.   */
     ' X! h9 ^: R+ A5 f9 X' n
164. static uint32_t roundup_pow_of_two(uint32_t x)
     , _. N) P( b6 `7 S$ H3 B% u
165. {
     
166.   uint32_t b = 0;
     
167. 
     4 Y# q: y' O7 H( ]5 \. v
168.   for(int i = 0; i < 32; i++)
     
169.   {
     & I! r6 G1 M% D1 g0 b/ r, e  g
170.     b = 1UL << i;
     
171. 
     8 x# m' g- v+ O( R7 \9 |0 J2 I
172.     if(x <= b)
     2 V. C+ M' W1 V
173.     {
     
174.       break;
     
175.     }
     
176.   }
     , X) q5 c4 E: {
177. 
     + I2 `; l! X8 u4 B4 D, l
178.   return b;
     % o7 B- \( d: ~! G9 S
179. }
     ( N+ q+ k+ V# x; G3 ]; r& j/ X

复制代码

      main.c文件
- Y+ g! H% c# s# w2 }

1. /**
   
2.   ******************************************************************************
   ) p. ~* q6 g' B7 ^
3.   * @file    main.c
   . M5 k/ f1 D& i/ F
4.   * @author  XinLi
   
5.   * @version v1.0
   
6.   * @date    15-January-2018
   
7.   * @brief   Main program body.
   - J4 Y6 S0 A; Y3 ?1 v3 |
8.   ******************************************************************************
   
9.   * @attention
   4 p% B* i  h$ B5 Q4 @
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    ) x% A2 J7 L% z9 C
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
    $ \% }7 x! ~% t! D/ A. j& o
16.   * (at your option) any later version.
    5 `/ B% K# `2 G; W2 n
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
    + t  Q! J) Q0 d# l
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    ! R! G9 T8 [+ k$ X8 r8 V
21.   * GNU General Public License for more details.
    ) `6 `3 I  `2 R! w, Y
22.   *
    $ N7 i* T# D$ ^. D
23.   * You should have received a copy of the GNU General Public License
    7 \$ y: s% y% i. c3 T* C$ n* Y
24.   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
    , a- Q1 P9 n8 k% M( i
25.   *
    3 j0 M8 I& ]5 @! D  n
26.   ******************************************************************************
    - t7 g, m8 n5 ]  }+ Y6 G
27.   */
    1 `2 a; X1 j- @9 }0 m7 z  }" D7 @
28. 
    
29. /* Header includes -----------------------------------------------------------*/
    8 ~: L. }* j7 ^) N: ?
30. #include "RingBuffer.h"
    
31. #include <stdio.h>
    * R1 b: t) [# T! t' r6 y1 \
32. #include <windows.h>
    
33. 
    , ~9 h# D" p3 `0 l" r4 v' J
34. /* Macro definitions ---------------------------------------------------------*/
    0 W# X# F# u$ R$ E
35. /* Type definitions ----------------------------------------------------------*/
    
36. /* Variable declarations -----------------------------------------------------*/
    " Y: a4 h. y+ R* F
37. /* Variable definitions ------------------------------------------------------*/
    
38. /* Function declarations -----------------------------------------------------*/
    ! R, P1 j8 X% Z* X( P
39. /* Function definitions ------------------------------------------------------*/
    
40. 
    4 `( E3 B# h1 A" l0 a# V/ _
41. /**
    2 i, g8 A7 J" w; a& ~
42.   * @brief  Main program.
    , W' }7 ^) y/ B7 s
43.   * @param  None.
    
44.   * @return None.
    9 e. `5 i. n" f( Z3 r6 E) ]. x; ?
45.   */
    * l$ l) b! `! V# N" v! u& M* T1 E
46. int main(void)
    9 Y: ~: f! k' _
47. {
    
48.   uint8_t data[256] = {0};
    ) X  Z6 Q8 H8 k7 j* b3 y5 b
49. 
    
50.   for(int i = 0; i < sizeof(data); i++)
    " {4 }; C( Y& y3 }/ I0 W
51.   {
    - h; v1 }3 f0 Z* V/ O9 K7 v/ F' |3 t: q
52.     data[i] = i;
    0 r2 j! l# [/ h
53.   }
    
54. 
    
55.   RingBuffer *fifo = RingBuffer_Malloc(sizeof(data));
    4 r' P: R+ r/ N# W+ e- @6 k
56. 
      Y' M% }' j6 x' m! Q) Y5 Y! S
57.   if(fifo != NULL)
    ) T$ R  Z8 u5 u! F% e! S0 w
58.   {
    + V$ K* v  ?  M4 Q: x
59.     printf("FIFO创建成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
    3 _; i0 G) N6 ~. N
60.            RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
    
61. 
    
62.     if(RingBuffer_IsFull(fifo) == true)
    * R, G& z8 N" @
63.     {
    1 L2 [1 @4 e5 S" p& L4 p! M
64.       printf("FIFO满了！！！\n");
    
65.     }
    ' V2 n" |& T. t# U
66.     else
    ' ], ~1 E1 K1 W- j" e9 n$ E3 i% N
67.     {
    
68.       printf("FIFO没满！！！\n");
      V3 q% ^' R7 }: z$ j
69.     }
    : ?9 w  i& N, `$ M. K, ]1 j& z
70. 
    
71.     if(RingBuffer_IsEmpty(fifo) == true)
    
72.     {
    ' S: o2 l0 a" V" A
73.       printf("FIFO空了！！！\n");
    * r, Q# H8 r+ ]. ~$ x3 Z
74.     }
    
75.     else
    
76.     {
    0 Q9 e  l6 E9 R) U
77.       printf("FIFO没空！！！\n");
    # g, d4 Q0 ~1 s: c( }- b  y2 d; ]  e8 `
78.     }
    / b2 {" B7 F' M
79. 
    
80.     printf("\n");
    
81. 
    ; I# O( w8 W- Z* h
82.     for(;;)
    ' g2 L1 L" k" h* N" N  V0 d
83.     {
    5 _$ Q7 q& {) u- j. a0 Q' C" T
84.       {
    
85.         if(RingBuffer_In(fifo, data, sizeof(data) / 2) > 0)
    " P3 o5 S) j$ P: b
86.         {
    " Q5 o! S* ~, [" t# T
87.           printf("FIFO写入成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
    
88.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
      f0 @8 _# k: I- Y' j# Y2 ]9 |) a# S% p
89.         }
    5 E+ G: Z4 X/ l& D2 j' G6 Y
90.         else
    3 F5 V4 _- n, M( B; Z  b
91.         {
    
92.           printf("FIFO写入失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
    
93.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
    
94.         }
    
95. 
    
96.         if(RingBuffer_IsFull(fifo) == true)
    0 o2 n" l7 n& \( S
97.         {
      i4 y3 z6 C+ ~9 n' P
98.           printf("FIFO满了！！！\n");
    5 R" @" o; i5 {1 d( A! w& k
99.         }
    
100.         else
     9 ?4 x' y8 {! e, j: K
101.         {
     , B* b9 i5 }% I0 l$ l! q
102.           printf("FIFO没满！！！\n");
     2 J2 k! g. r$ Y5 y3 T( a
103.         }
     
104. 
       w7 r; `# A* `" `
105.         if(RingBuffer_IsEmpty(fifo) == true)
     % p, Y; k$ o9 v2 |# \
106.         {
     
107.           printf("FIFO空了！！！\n");
     
108.         }
     * O3 b# K8 |0 |$ {2 W3 Y
109.         else
     2 t% C! p' s9 Y5 N& y' @
110.         {
     
111.           printf("FIFO没空！！！\n");
     
112.         }
     # [  r6 D' F3 d$ J
113.       }
     3 r: P8 G3 T/ e. s
114. 
     
115.       printf("\n");
     
116. 
     5 ?8 Z  Y7 x& ~7 m6 b
117.       {
     ! G7 B! `! G. F; ]# X- }, L% k0 |
118.         uint8_t rdata[64] = {0};
     - h  n( E8 `( M: r" Z. J% n
119.         uint8_t len       = RingBuffer_Out(fifo, rdata, sizeof(rdata));
     # ^1 Z0 k! T! O
120. 
     : z! D2 B" G- ?6 i$ K
121.         if(len > 0)
     
122.         {
     7 C2 E' P; I. S" X  }$ ^; X! s. d
123.           printf("从FIFO中读出的数据，长度：%d\n", len);
     ' I( [  v" S9 d8 A% Y0 L7 n
124. 
     & m7 W5 y( B& [5 z! g' J- f: L
125.           for(int i = 0; i < len; i++)
     ( X3 M+ Q$ T: R
126.           {
     0 d% B5 a" U3 |$ E  a/ s
127.             printf("%d ", rdata[i]);
     : Z$ X8 F' D0 c$ I6 z
128.           }
     
129. 
     0 t7 V. ]* |1 p2 O: A# m$ x3 g3 H2 a
130.           printf("\n");
     
131. 
     6 i. p$ i) M" P6 T- W
132.           printf("FIFO读取成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     ; _+ E8 H. _4 x# F& u
133.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
134.         }
     - j( d, f$ \. ]9 V! _8 C, g6 e, K
135.         else
     - d- h/ W) T6 U, f' `* ]0 M% i/ [
136.         {
     
137.           printf("FIFO读取失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
138.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     + E5 j  H& V4 S5 o
139.         }
     ( `* o7 L0 Y* N, C/ b6 ?
140. 
     
141.         if(RingBuffer_IsFull(fifo) == true)
     3 G- e. s; L( D
142.         {
     
143.           printf("FIFO满了！！！\n");
     5 M: C# r8 H! v6 U- _
144.         }
     * }8 m# s7 ]0 J: u
145.         else
     
146.         {
     
147.           printf("FIFO没满！！！\n");
     
148.         }
     
149. 
     
150.         if(RingBuffer_IsEmpty(fifo) == true)
     - H. D7 |2 q% t, t6 s' z6 v* B' }
151.         {
     
152.           printf("FIFO空了！！！\n");
     
153.         }
     
154.         else
     * ^, T0 L! v* M; ]5 U! |0 g+ {
155.         {
     
156.           printf("FIFO没空！！！\n");
     * w# K5 |4 N+ O* J/ I
157.         }
     9 _, t5 N) t" z' L
158.       }
     
159. 
     ; c/ Z9 @* H$ M* B% g% L3 Z- u
160.       printf("\n");
     
161. 
     
162.       {
     0 @+ ?" C6 c# j  J+ t- |9 w- y4 S0 j" J/ O
163.         RingBuffer_Reset(fifo);
     % l3 b6 E% B& R& K- ~. Q5 q
164.         printf("FIFO清空成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     . R4 f& a  G7 u, S! _) n6 p: w
165.                RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
166. 
     
167.         if(RingBuffer_IsFull(fifo) == true)
     ; }- Z" ^7 J; f1 a- x/ Y
168.         {
     
169.           printf("FIFO满了！！！\n");
     / ~- s6 i  Q! S" x- F) k+ {
170.         }
     ; Y6 w, L( U# X4 G
171.         else
     
172.         {
     ; A. C  t& S" M
173.           printf("FIFO没满！！！\n");
     
174.         }
     4 e/ \( k6 {8 s
175. 
     
176.         if(RingBuffer_IsEmpty(fifo) == true)
     
177.         {
     ' F2 E* Y6 l$ g) _4 t$ v+ d" y$ T$ K# f
178.           printf("FIFO空了！！！\n");
     2 n+ N1 R6 d; A/ p( J6 _5 d2 j5 }
179.         }
     
180.         else
     
181.         {
     
182.           printf("FIFO没空！！！\n");
     + r  u" B8 X5 V( h
183.         }
     3 p2 u4 W* J6 v% R/ p) S5 B' I
184.       }
     
185. 
     
186.       printf("\n");
     ; W* V3 v6 S8 j8 w
187. 
     
188.       {
     
189.         if(RingBuffer_In(fifo, data, sizeof(data)) > 0)
     
190.         {
     
191.           printf("FIFO写入成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     5 l' D& D2 i4 _
192.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     / X' @- C& k* b' K# _
193.         }
     # T0 U6 B7 q6 {) A5 q5 w
194.         else
     
195.         {
     
196.           printf("FIFO写入失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     $ a+ [; |7 L+ o6 J% D
197.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
198.         }
     
199. 
     
200.         if(RingBuffer_IsFull(fifo) == true)
     $ N- V5 G* F* O% d% Y! j) Q5 ~
201.         {
     - V7 F9 k3 L) Z7 x9 M6 q6 q9 E
202.           printf("FIFO满了！！！\n");
     0 D7 K0 c* R% e- S
203.         }
     2 J( V: ~* C0 M& z7 t
204.         else
     2 r- W$ H8 @' i4 T5 }5 F! E
205.         {
     ! s+ |2 l2 Z( I: D" A" Q
206.           printf("FIFO没满！！！\n");
     
207.         }
     
208. 
     ( i0 e6 \' |6 l$ \: m5 a# j) |2 f
209.         if(RingBuffer_IsEmpty(fifo) == true)
     3 ~. ?4 u* n; C+ {/ b. Y% l
210.         {
     
211.           printf("FIFO空了！！！\n");
     3 E1 ]/ ~  ]# g: s% ^1 B, e% o
212.         }
     + s) u1 b  F2 h- l$ M: F
213.         else
     
214.         {
     4 S! {8 Y/ U* V( C3 O. {8 M
215.           printf("FIFO没空！！！\n");
     8 t/ o% q( n3 A' z
216.         }
     
217.       }
     . h4 K9 }& u" U  I) R% e
218. 
     
219.       printf("\n");
     1 n9 W* I: A) j  k. O4 j9 t
220. 
     6 O' k8 r  j, C
221.       {
     ' _' p2 U4 ^; `- v. I3 A# v
222.         if(RingBuffer_In(fifo, data, sizeof(data)) > 0)
     
223.         {
     
224.           printf("FIFO写入成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     " f- _  t! y; ?
225.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
226.         }
     $ H% S7 f, ^" q
227.         else
     . g& g, ]. P' T
228.         {
     # r9 v: o* H. D, [
229.           printf("FIFO写入失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     5 s0 m: e: {& s0 x3 \
230.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     , \* L' T( J" w0 H
231.         }
     
232. 
     
233.         if(RingBuffer_IsFull(fifo) == true)
     
234.         {
     ! s- C5 l5 ~5 Y- C# H9 P: j
235.           printf("FIFO满了！！！\n");
     ' M+ D5 [" Y* z9 e# |: n1 w
236.         }
     
237.         else
     
238.         {
     
239.           printf("FIFO没满！！！\n");
     
240.         }
     
241. 
     2 n+ ~/ f0 B; V9 h" O
242.         if(RingBuffer_IsEmpty(fifo) == true)
     
243.         {
     
244.           printf("FIFO空了！！！\n");
     ; R1 `- c, P+ N+ K- M# K: N- k
245.         }
     : W8 D8 S2 B1 H" g+ n
246.         else
     
247.         {
     
248.           printf("FIFO没空！！！\n");
     
249.         }
     : ?. s: z! ^. O( E7 n
250.       }
     % T5 |& K, F8 c$ C! S
251. 
     
252.       printf("\n");
     
253. 
     
254.       {
     - I% R; ^9 Z) u4 e
255.         uint8_t  rdata[256] = {0};
     
256.         uint16_t len        = RingBuffer_Out(fifo, rdata, sizeof(rdata));
     
257. 
     
258.         if(len > 0)
     1 I) _6 V6 g  r  @& d+ I
259.         {
     
260.           printf("从FIFO中读出的数据，长度：%d\n", len);
     " p7 g) }; q6 s7 C& |' ^! d  J' q
261. 
     
262.           for(int i = 0; i < len; i++)
     
263.           {
     
264.             printf("%d ", rdata[i]);
     $ k7 `3 P! l6 `' {/ ]8 q; {7 a
265.           }
     : ?& W1 L: ^7 b% D  {
266. 
     ) K9 q! E/ z$ Z5 j( J0 z7 ^1 y  l
267.           printf("\n");
     
268. 
     $ p5 ~, C+ B$ G
269.           printf("FIFO读取成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
270.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     # I- |: y. D# U0 @4 ~
271.         }
     
272.         else
     
273.         {
     7 u+ U5 a# Y& d8 p1 _
274.           printf("FIFO读取失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
275.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     , P# C% n$ K5 ~
276.         }
     
277. 
     
278.         if(RingBuffer_IsFull(fifo) == true)
     
279.         {
       s$ K( `$ B+ E  S4 D0 ~- _( }
280.           printf("FIFO满了！！！\n");
       F2 \' Z4 J" m3 T
281.         }
     5 }9 t* Y' b! P% l
282.         else
     ; n3 W( F; s/ E! F/ U' ^3 K
283.         {
     4 ]* Z4 v/ c. p8 k
284.           printf("FIFO没满！！！\n");
     
285.         }
     ; X/ }3 [& a" k; _0 @
286. 
     
287.         if(RingBuffer_IsEmpty(fifo) == true)
     0 w  I# _( L3 ?- c  C/ j# U
288.         {
     
289.           printf("FIFO空了！！！\n");
     4 _! K$ m" \& P  e' k% E. \4 t
290.         }
     
291.         else
     
292.         {
     
293.           printf("FIFO没空！！！\n");
     5 g6 @2 s, s* u0 G+ d8 c
294.         }
     
295.       }
     4 G( \" y! W* k" r% y
296. 
     
297.       printf("\n");
     4 I4 Y# ]: o2 o6 }) L$ a1 u
298. 
     + D  t6 O; ]& |0 ~7 C; G7 y/ s
299.       {
     
300.         uint8_t  rdata[256] = {0};
     + O6 E9 r1 k/ L1 Y( |' D
301.         uint16_t len        = RingBuffer_Out(fifo, rdata, sizeof(rdata));
     ' e* A- g. ^/ i- p% D4 [
302. 
     
303.         if(len > 0)
     + W8 ^9 M7 {: p( s. Z* ^7 P- \
304.         {
     + @! f) ^8 m1 `
305.           printf("从FIFO中读出的数据，长度：%d\n", len);
     
306. 
     ) Z' q6 J% u. H: ]- M& W
307.           for(int i = 0; i < len; i++)
     
308.           {
     
309.             printf("%d ", rdata[i]);
     2 @, m) {$ H! c3 c! i
310.           }
     
311. 
     + l- F# W7 ^5 f- L
312.           printf("\n");
     5 _+ v) C, Q; Z3 H3 i1 I
313. 
     $ [- }" x9 u8 P; J
314.           printf("FIFO读取成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     $ E1 V; l9 |2 z- t) Z5 `7 o8 v
315.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
316.         }
     
317.         else
     
318.         {
     
319.           printf("FIFO读取失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
320.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     / ~) X' C3 ]# a# S
321.         }
     
322. 
     
323.         if(RingBuffer_IsFull(fifo) == true)
     3 M  p' {: Z# Z6 @. @4 c
324.         {
     
325.           printf("FIFO满了！！！\n");
     ! r. y5 p! v  P) Z8 w4 r
326.         }
     - L* l( q2 Z1 A; _( L8 i
327.         else
     
328.         {
     
329.           printf("FIFO没满！！！\n");
     
330.         }
     
331. 
     0 m) A% V9 K9 O2 T) F" D4 p8 E
332.         if(RingBuffer_IsEmpty(fifo) == true)
     : S, G* H) l: J" s0 \. n
333.         {
     : P# w0 M+ {, e2 i* [
334.           printf("FIFO空了！！！\n");
     
335.         }
     1 x0 E4 x8 Q" X, [( w
336.         else
     - [+ @7 D; O- W& z7 J9 y1 A' t: P
337.         {
     
338.           printf("FIFO没空！！！\n");
     3 o0 b/ W8 c+ L* U
339.         }
     . _  B; R2 I$ \9 S
340.       }
     - ?# m8 a% f9 ~$ A) U, u
341. 
     
342.       printf("\n\n\n");
     8 @) h# V& Q! T
343.       Sleep(5000);
     
344.     }
     
345.   }
       [; l- C; l% ^6 s8 i0 b3 [8 D6 f; _
346.   else
     : E- u9 c# j% X( z9 r
347.   {
     
348.     printf("FIFO创建失败\n");
     ( H. a) K, H- `/ v8 w! `! o7 ]
349.   }
     - P' R8 l0 F4 @3 O
350. 
       _* |0 A7 N3 |0 J0 |8 x2 a& Q6 r
351.   for(;;)
     9 Y/ B, C4 T: W1 K) k
352.   {
     + D. A- T% C4 b
353. 
     
354.   }
     2 b" t% G6 b6 U1 f1 C7 _4 X
355. }
     

复制代码

3，运行效果
9 z. {  \- g2 V& x

4 H: p- ?% _3 N' ]3 D  O

谢谢分享

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