模仿kfifo实现的环形缓冲区
* L; a. h$ `; }1 g4 m3 |5 a% q' A

9 M: ~$ Q8 t) m" ~转载来源：模仿kfifo实现的环形缓冲区


& K7 T! Z- P; R& _: H) JGitHub仓库：http://github.com/XinLiGitHub/RingBuffer
PS：博文不再更新，后续更新会在GitHub仓库进行。
. L( K+ |; E4 }
    模仿kfifo实现的环形缓冲区。程序中涉及到环形缓冲区的概念，详细介绍见维基百科[Circular buffer](http://en.wikipedia.org/wiki/Circular_buffer)。

$ w  l: l- }: u8 N/ C1，开发环境
) p: c, {3 `" I- Q6 e  n      1，操作系统：Windows 10 专业版
4 E( T6 L3 ]1 G' e      2，IDE：Visual Studio 2015 专业版
. D8 m  S0 V; T0 `& ~9 I) d4 }% B
% H2 w* K" H) A2，程序源码
1 G) ?6 u7 C9 Z3 Q$ o+ c( v- z% ]      RingBuffer.h文件

1. /**
   ! Y2 H3 B* \) M, J
2.   ******************************************************************************
   
3.   * @file    RingBuffer.h
   
4.   * @author  XinLi
   
5.   * @version v1.0
   % @* S! |' w0 Y) j! P8 T
6.   * @date    15-January-2018
     h" K% u1 L9 W- b& U
7.   * @brief   Header file for RingBuffer.c module.
   
8.   ******************************************************************************
   ) l) R* n5 r) F  T! J3 V
9.   * @attention
   
10.   *
    6 J, N. F  S* K7 N2 n) t" P
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    ( C& u( I: j+ i
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
    , @8 s5 t8 }' S; W
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
    
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    
22.   *
    & S+ n2 u7 S. _0 B- B
23.   * You should have received a copy of the GNU General Public License
    ( N- L* c$ b7 E/ G
24.   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
25.   *
    $ r. m; ~& Q, n% ^
26.   ******************************************************************************
    3 D3 G' b7 s/ f  [
27.   */
    # }  n" y8 O3 T/ V8 e! C* b
28. 
    # R6 i/ u. o. v9 G
29. #ifndef __RINGBUFFER_H
    
30. #define __RINGBUFFER_H
    
31. 
    9 Q7 J& K+ B" g8 ?4 X3 y5 x# W8 i8 p
32. #ifdef __cplusplus
    " N: i. ^+ A  M; K
33. extern "C" {
    
34. #endif
    + r0 ^6 _; E" W6 Z( q7 i% w' u
35. 
    
36. /* Header includes -----------------------------------------------------------*/
    $ p$ K: L! }1 z, p2 C) x2 L
37. #include <stdint.h>
    
38. #include <stdbool.h>
    
39. 
    
40. /* Macro definitions ---------------------------------------------------------*/
    
41. #define RING_BUFFER_MALLOC(size)  malloc(size)
    " `. ]; B, O+ Y% ?0 C- P2 F% l2 _
42. #define RING_BUFFER_FREE(block)   free(block)
    
43. 
    $ U) [1 [" x, N( y5 @% x
44. /* Type definitions ----------------------------------------------------------*/
    1 O+ m4 H- p( k; P
45. typedef struct
    
46. {
    
47.   uint8_t *buffer;
    ; o8 \( O" j) J- L/ x7 I
48.   uint32_t size;
    ; s; R- ?/ p2 y$ N3 p6 j8 N+ o
49.   uint32_t in;
    4 r  t$ s) y/ j1 u* F2 U% o4 v* a  k
50.   uint32_t out;
    
51. }RingBuffer;
    
52. 
    4 I1 @  P0 d" `4 ]
53. /* Variable declarations -----------------------------------------------------*/
    6 V" u9 m: M0 X/ U! C% c
54. /* Variable definitions ------------------------------------------------------*/
    : x2 a$ \# ^2 b! w2 z9 \; F: N# F0 m
55. /* Function declarations -----------------------------------------------------*/
    * x% p- V; j0 R! C4 ]
56. RingBuffer *RingBuffer_Malloc(uint32_t size);
      [6 `8 {7 c# f
57. void RingBuffer_Free(RingBuffer *fifo);
    
58. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len);
    
59. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len);
    , h0 E3 Z' _6 n; n! X! u/ J
60. 
    & q- W7 I- k2 x8 h6 W+ b# u
61. /* Function definitions ------------------------------------------------------*/
    
62. 
    
63. /**
    
64.   * @brief  Removes the entire FIFO contents.
    
65.   * @param  [in] fifo: The fifo to be emptied.
    
66.   * @return None.
    
67.   */
    0 B& Z6 K8 O% g+ d
68. static inline void RingBuffer_Reset(RingBuffer *fifo)
    
69. {
    
70.   fifo->in = fifo->out = 0;
    
71. }
    
72. 
    
73. /**
    4 b2 v2 Y9 x& E) ~
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)
    $ ?, w, o/ }! E' e4 \* a/ [# I
79. {
    0 p! a1 Q! C* e4 Z- Y$ i0 Q
80.   return fifo->size;
    % ^! t, ~7 M) {$ ~" a( @  X4 _
81. }
    3 G" i2 w. `5 W7 d+ B0 I
82. 
    7 W) s8 K) r4 s- ]$ s8 u  ~
83. /**
    
84.   * @brief  Returns the number of used bytes in the FIFO.
    ; `/ f! \. _6 T) f9 L
85.   * @param  [in] fifo: The fifo to be used.
    
86.   * @return The number of used bytes.
    / u3 z% [1 {& n' I2 w+ K. N
87.   */
    
88. static inline uint32_t RingBuffer_Len(RingBuffer *fifo)
    
89. {
    : n) \. ~% S( t- n% F; H0 u' [) R
90.   return fifo->in - fifo->out;
    ! V: r: s# p( Y) t& F
91. }
    ( }* T% Y4 ~% G  V
92. 
    1 s5 K5 m5 m, \% G/ A# m0 a
93. /**
    + G2 ?2 D, t- X3 K
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.
    $ }6 R1 ], {6 e. O: v* \
97.   */
    6 y/ }" Z; Y' o; z' z8 X; m7 P# T& }
98. static inline uint32_t RingBuffer_Avail(RingBuffer *fifo)
      F6 G9 i. E7 I( X: w% L5 G0 V1 V
99. {
    ' D$ |. V$ t# j  `
100.   return RingBuffer_Size(fifo) - RingBuffer_Len(fifo);
     + m8 z; f8 R: ^2 i/ i5 f
101. }
     - _* K* R4 I3 I3 t: ?" f
102. 
     , Q3 S9 ^  D( j# j4 o' B
103. /**
     5 [$ D( L' y3 d+ y- o3 v
104.   * @brief  Is the FIFO empty?
     " U3 I7 D* [0 K% F2 f
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)
     
110. {
     
111.   return RingBuffer_Len(fifo) == 0;
     
112. }
     ' n% b' L4 e+ q  I5 o
113. 
     
114. /**
     
115.   * @brief  Is the FIFO full?
     ' N8 _, k8 ]; G! z
116.   * @param  [in] fifo: The fifo to be used.
     ' b5 `7 ?4 V6 q
117.   * @retval true:      Yes.
     
118.   * @retval false:     No.
     6 D% e& C7 J" s
119.   */
     
120. static inline bool RingBuffer_IsFull(RingBuffer *fifo)
     
121. {
     
122.   return RingBuffer_Avail(fifo) == 0;
     
123. }
     
124. 
     4 M3 x8 H" s, \  Y
125. #ifdef __cplusplus
     9 \- |& F7 h9 t8 n
126. }
     
127. #endif
     5 |4 X3 O; {0 b  R1 o
128. 
     * _& S6 W, q: J9 v7 b3 b
129. #endif /* __RINGBUFFER_H */
     

复制代码

      RingBuffer.c文件

1. /**
   
2.   ******************************************************************************
   
3.   * @file    RingBuffer.c
   
4.   * @author  XinLi
   
5.   * @version v1.0
   & ^+ z7 j6 v. ?5 [* x
6.   * @date    15-January-2018
   ) t" W' b7 p/ h" A& M6 Y! M8 b
7.   * @brief   Ring buffer module source file.
   
8.   ******************************************************************************
   
9.   * @attention
   5 n9 U6 q3 a, ^/ }
10.   *
    . R3 R4 y7 x1 e' I; b4 U/ H" s! d& e
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    9 @9 Z+ k4 o3 Q2 N
12.   *
      l9 Q" i, ^3 d. k) [
13.   * This program is free software: you can redistribute it and/or modify
      X# W& S$ u, q6 d* a! Y
14.   * it under the terms of the GNU General Public License as published by
    2 z; F% ]/ ^$ U' h0 m% I8 a
15.   * the Free Software Foundation, either version 3 of the License, or
    9 N/ i- m8 H; `" T
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
    6 X& l2 l: _' ]9 t2 U3 F* K
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
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/>.
    * U8 i( o6 H: h1 j9 U, N5 M
25.   *
    : i- Z; B0 t1 g  H
26.   ******************************************************************************
    
27.   */
    
28. 
    7 a( V# B% B. Y" X$ y+ \5 q
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "RingBuffer.h"
    ( o) Q  W1 _; m
31. #include <stdlib.h>
    & P4 M/ A( g" T( b' W1 b3 N% ]6 R
32. #include <string.h>
    
33. 
    5 x) k$ J+ x, `% w: Z" _
34. /* Macro definitions ---------------------------------------------------------*/
    , H: o1 j7 K9 }3 N
35. /* Type definitions ----------------------------------------------------------*/
    , L$ w: g# Q0 o2 I
36. /* Variable declarations -----------------------------------------------------*/
    ( D5 p& K2 k  q4 m: r
37. /* Variable definitions ------------------------------------------------------*/
    
38. /* Function declarations -----------------------------------------------------*/
    
39. static bool is_power_of_2(uint32_t x);
    * L0 Z5 P" k( ~
40. static uint32_t roundup_pow_of_two(uint32_t x);
    6 y$ e( r$ Y+ r( t  B7 W: q8 u
41. 
    8 V  i% U, F5 ]+ e
42. /* Function definitions ------------------------------------------------------*/
    
43. 
    & R! T4 S/ j  y* p8 a  W
44. /**
    
45.   * @brief  Allocates a new FIFO and its internal buffer.
    
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.
    
48.   * @return RingBuffer pointer.
    ) d& z: ~2 B( c. g. M' I
49.   */
    2 O, Y* q' Z3 b0 T) G) U
50. RingBuffer *RingBuffer_Malloc(uint32_t size)
    * V7 }  `, g/ ~+ ]8 J
51. {
    
52.   RingBuffer *fifo = RING_BUFFER_MALLOC(sizeof(RingBuffer));
    
53. 
    
54.   if(fifo != NULL)
    
55.   {
    
56.     if(is_power_of_2(size) != true)
    
57.     {
    
58.       if(size > 0x80000000UL)
    8 u/ W' n% U2 }( e3 H7 m5 I! v' q
59.       {
    
60.         RING_BUFFER_FREE(fifo);
    " J( U5 ?: W) B& {' {
61.         fifo = NULL;
    $ [- {+ b1 `9 Y7 ^  y* ]+ g
62.         return fifo;
    
63.       }
    
64. 
    
65.       size = roundup_pow_of_two(size);
    + e& Z  c" M0 U" Y% _( _
66.     }
    % b4 h2 P- Z0 Q; t3 g
67. 
    6 O8 _9 h5 q+ X* G# T  V
68.     fifo->size   = size;
    2 M8 a# Y5 o8 b( ?# d5 r
69.     fifo->in     = 0;
    
70.     fifo->out    = 0;
    
71.     fifo->buffer = RING_BUFFER_MALLOC(fifo->size);
    
72. 
    
73.     if(fifo->buffer == NULL)
    ' B2 A( w! M. l# s  U' d
74.     {
    
75.       RING_BUFFER_FREE(fifo);
    ( Z9 B* T9 m+ F0 l; Y' ?
76.       fifo = NULL;
    
77.       return fifo;
    ' S7 D. g8 u* S/ r/ F6 ^; ^  L, ?
78.     }
    
79.   }
    
80. 
    . k2 e) r* S" d/ W
81.   return fifo;
    
82. }
    5 O; k5 P" ?: k! D" P& y  J+ v* T
83. 
    
84. /**
    
85.   * @brief  Frees the FIFO.
    2 f. M) e, q* w2 E8 c  W7 m
86.   * @param  [in] fifo: The fifo to be freed.
    
87.   * @return None.
    
88.   */
    ( W& M* F' [. H9 p) Z
89. void RingBuffer_Free(RingBuffer *fifo)
    / Q4 O. j/ r" F3 F  q9 |; k6 O3 Q
90. {
    4 B6 H6 e: q% C% M. \
91.   RING_BUFFER_FREE(fifo->buffer);
    
92.   RING_BUFFER_FREE(fifo);
    & j+ T; _4 m" A' p. b) B
93.   fifo = NULL;
    , w8 v8 |# P, R/ K- G( O6 X
94. }
    5 i+ ?, x$ u' L" b5 M1 j
95. 
    6 o( C. l; v$ N- |+ d* D
96. /**
    " X/ E5 f8 ~# q, ?0 y4 J
97.   * @brief  Puts some data into the FIFO.
    , H  `7 H. x3 V6 H( P4 i
98.   * @param  [in] fifo: The fifo to be used.
    9 K- _* t* P- e/ f
99.   * @param  [in] in:   The data to be added.
    
100.   * @param  [in] len:  The length of the data to be added.
     3 E! U/ A( j# a0 E; i
101.   * @return The number of bytes copied.
     5 b' ?" W( j3 B, l4 V; G/ d& W
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
     ' }, K9 F/ a+ o& M' c) R4 m
104.   *         of bytes copied.
     4 m7 @5 v/ k7 C& {# \) e2 X; E/ \4 H
105.   */
     
106. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len)
     
107. {
     
108.   len = min(len, RingBuffer_Avail(fifo));
     
109. 
     , D9 D6 t7 O$ N5 A; F( A
110.   /* First put the data starting from fifo->in to buffer end. */
     * s3 b8 l- |( T0 P- I
111.   uint32_t l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));
     0 s/ y1 N/ T  }- {" O8 h3 T( @( I
112.   memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), in, l);
     * L, u3 K' R  b0 W
113. 
     
114.   /* Then put the rest (if any) at the beginning of the buffer. */
     
115.   memcpy(fifo->buffer, (uint8_t *)in + l, len - l);
     
116. 
     ) i6 F6 Z- n' y, V7 W
117.   fifo->in += len;
     ) n) n( l" {, R. ^  v& E0 b
118. 
     
119.   return len;
     . h& u' ^4 R, n
120. }
     
121. 
     3 r6 L/ O. q0 l; z
122. /**
     
123.   * @brief  Gets some data from the FIFO.
     
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
     
129.   *         the @out and returns the number of copied bytes.
     
130.   */
     & [" W) }4 a( h
131. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len)
     
132. {
     
133.   len = min(len, RingBuffer_Len(fifo));
     
134. 
     
135.   /* First get the data from fifo->out until the end of the buffer. */
     1 @9 D' f& q! n/ h* f$ o
136.   uint32_t l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
     
137.   memcpy(out, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
     
138. 
     
139.   /* Then get the rest (if any) from the beginning of the buffer. */
     0 |& ~! h9 c- V- ^' e
140.   memcpy((uint8_t *)out + l, fifo->buffer, len - l);
     ; O3 f- m) j4 d6 l
141. 
     $ ~+ J' _1 G" P5 E6 ~6 o
142.   fifo->out += len;
     
143. 
     - R3 T- e+ K; F( n' x$ _2 q0 ~5 b& N
144.   return len;
     $ G2 u- i/ w# I5 s  t
145. }
     
146. 
     
147. /**
     1 y+ R9 n4 }* O+ r+ t9 K; v( s
148.   * @brief  Determine whether some value is a power of two.
     ( x9 [' ]7 ]1 R6 n) a
149.   * @param  [in] x: The number to be confirmed.
     2 [7 Y9 Z  E2 W5 A* p
150.   * @retval true:   Yes.
     
151.   * @retval false:  No.
     * @6 w( |+ C* W( A) F3 b1 v
152.   * @note   Where zero is not considered a power of two.
     
153.   */
     
154. static bool is_power_of_2(uint32_t x)
     
155. {
     
156.   return (x != 0) && ((x & (x - 1)) == 0);
     
157. }
     
158. 
     
159. /**
     8 L9 ?# K6 X! ]  Y
160.   * @brief  Round the given value up to nearest power of two.
     5 g5 i3 v1 c" l4 i  i! [" i  P" r
161.   * @param  [in] x: The number to be converted.
     
162.   * @return The power of two.
     , N: A& N; d2 A+ f
163.   */
       G5 E8 f7 c: ]* f- ^  U
164. static uint32_t roundup_pow_of_two(uint32_t x)
     
165. {
     1 ?$ q+ k0 Q7 D; F1 c6 \
166.   uint32_t b = 0;
     9 s. t8 J' _7 c0 I/ l! ^
167. 
     
168.   for(int i = 0; i < 32; i++)
     0 P- V+ E% m. e0 V" A
169.   {
     1 ^0 q1 {8 p* w
170.     b = 1UL << i;
     
171. 
     % s; T: s3 u9 {& c. [" f
172.     if(x <= b)
     + i+ v2 Q- s+ H# Y, Q: N
173.     {
     
174.       break;
     
175.     }
     
176.   }
     
177. 
     
178.   return b;
     * ?: O/ X- P  m8 u
179. }
     + j- b9 N) V4 k

复制代码

' B: ?4 D6 A0 H0 P) g      main.c文件
% z; y1 g- F9 |# ~4 N

1. /**
   & v  @( j1 L/ x  e- j7 g
2.   ******************************************************************************
   - B2 I$ G+ m) j8 W7 Z+ h
3.   * @file    main.c
   
4.   * @author  XinLi
   1 L! r& ?+ A. Q5 r/ U, u  Z: u
5.   * @version v1.0
   
6.   * @date    15-January-2018
   ' a. _$ }0 U0 s6 O! ~& A) F+ C
7.   * @brief   Main program body.
   
8.   ******************************************************************************
   ' b% S4 H+ h! U& B, t
9.   * @attention
   7 s+ _; C2 c( U" j2 u
10.   *
    ! p6 g# e, W4 R" `; L4 k( H
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    8 J3 w5 |% N- p, y5 l$ L, x/ \
13.   * This program is free software: you can redistribute it and/or modify
    + P4 h% w% K4 t% M* D% o
14.   * it under the terms of the GNU General Public License as published by
    + T9 [. p, G/ q5 Z: U! x
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    / C0 C! {- @7 @# T
17.   *
    + m/ v5 S, T6 r
18.   * This program is distributed in the hope that it will be useful,
    ( ?5 Y7 ^3 }3 |
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    / f- q% k- y5 l, K
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    - r0 w) W" @, Z& x9 y$ |/ O8 j5 K
21.   * GNU General Public License for more details.
    ( e) g( _1 r0 M* a7 b
22.   *
    
23.   * You should have received a copy of the GNU General Public License
    , B5 B3 l! q8 I
24.   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
25.   *
    
26.   ******************************************************************************
    : x0 ]7 f* Y: n
27.   */
    
28. 
    + e* R3 A' l3 `1 w( {
29. /* Header includes -----------------------------------------------------------*/
    ) K! R  A+ N: ?8 ^
30. #include "RingBuffer.h"
    
31. #include <stdio.h>
    
32. #include <windows.h>
    ( d5 K: |8 ?. p  R2 x
33. 
    & o" k7 }- b: F- v# p; Q
34. /* Macro definitions ---------------------------------------------------------*/
    $ _" a' l( i3 p9 Y) f! z% x
35. /* Type definitions ----------------------------------------------------------*/
    
36. /* Variable declarations -----------------------------------------------------*/
    0 `4 w$ z( n8 T  ^" p( F
37. /* Variable definitions ------------------------------------------------------*/
      h: K; u3 O; X6 x
38. /* Function declarations -----------------------------------------------------*/
    
39. /* Function definitions ------------------------------------------------------*/
      d, t1 \1 z8 H# T0 k6 u) ]
40. 
    " \$ n* z: T. |7 g" b5 `+ I
41. /**
    
42.   * @brief  Main program.
    
43.   * @param  None.
    
44.   * @return None.
    & ]& e% C( z" z# t
45.   */
    % |5 m7 t1 @. g4 E  b
46. int main(void)
    
47. {
    7 c, W& {5 R# L% o
48.   uint8_t data[256] = {0};
    0 m' S$ m: p- G: B0 o; D
49. 
    6 I, E$ Z- g9 X8 X7 Y& i$ N0 @4 K
50.   for(int i = 0; i < sizeof(data); i++)
    ; A; v7 I0 s" a. D2 V  E1 @
51.   {
    
52.     data[i] = i;
    
53.   }
    
54. 
    / g# A. _0 t: s5 ^! D2 c* T9 G' y" g
55.   RingBuffer *fifo = RingBuffer_Malloc(sizeof(data));
    2 e5 [( A/ e  F2 y  T. X0 O
56. 
    & h3 Y9 ]/ B: G' ~
57.   if(fifo != NULL)
    / [+ P- s4 E  B
58.   {
    
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)
    5 {4 z4 X$ B, L5 k- S
63.     {
    
64.       printf("FIFO满了！！！\n");
    
65.     }
    
66.     else
    4 o9 @* C/ F' c$ F
67.     {
    # L, s  Q/ }* ^( e* X
68.       printf("FIFO没满！！！\n");
    8 o' g7 `" w/ V! X2 z
69.     }
    : l" `4 T" Q7 \
70. 
    9 D# W# Q' Y. y3 [
71.     if(RingBuffer_IsEmpty(fifo) == true)
    
72.     {
    7 g9 n6 q9 F0 B; O8 p. j, a
73.       printf("FIFO空了！！！\n");
    9 |" E  D. f  L; b+ V: b
74.     }
    $ q7 c! }$ m7 c6 J, M' e/ c
75.     else
    " s4 @* e7 J# g/ g. E
76.     {
    - w# a  w8 U: {( j9 U
77.       printf("FIFO没空！！！\n");
    
78.     }
    1 r2 @# x" E& |) ?0 B% f
79. 
    
80.     printf("\n");
    . q  k! O( P) p; _
81. 
    5 F* A; M# ~7 o7 r# a
82.     for(;;)
      F# ^. l% M9 V6 E1 N
83.     {
    
84.       {
    / |) [  i5 @1 i
85.         if(RingBuffer_In(fifo, data, sizeof(data) / 2) > 0)
    
86.         {
    
87.           printf("FIFO写入成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
    $ j. {6 W$ i/ |
88.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
    3 {7 l3 p3 f, m9 M+ N* l& o. \
89.         }
      o5 D  N( Y7 q! d. f/ u) T
90.         else
    
91.         {
    5 Q; x+ X" y& _! k' E) e
92.           printf("FIFO写入失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
    ( N4 a- l1 c5 |/ k/ @
93.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
    
94.         }
    
95. 
    
96.         if(RingBuffer_IsFull(fifo) == true)
    8 Q; T( I8 f' u; @
97.         {
    ' z" A; }. ?; p9 l/ [) c
98.           printf("FIFO满了！！！\n");
    , Z1 `7 T+ f- \, C1 `
99.         }
    
100.         else
     
101.         {
     
102.           printf("FIFO没满！！！\n");
     
103.         }
     
104. 
     1 y3 @0 ?6 b3 |/ u3 s5 U
105.         if(RingBuffer_IsEmpty(fifo) == true)
     
106.         {
     
107.           printf("FIFO空了！！！\n");
     
108.         }
     / E* v# Y7 k; r- X+ a, y& P
109.         else
     ( f' {, o  F9 x; B
110.         {
     / l( G! \7 q* {) u, n
111.           printf("FIFO没空！！！\n");
     
112.         }
     % G6 d: ~6 @* K$ d
113.       }
     * z+ e3 h8 s# K* U" t
114. 
     
115.       printf("\n");
     
116. 
     , O  y5 i4 N, P& x$ T
117.       {
     ) [1 I0 E; |: `* u; Z; b
118.         uint8_t rdata[64] = {0};
     7 v2 ]/ s9 @6 o3 W* W
119.         uint8_t len       = RingBuffer_Out(fifo, rdata, sizeof(rdata));
     
120. 
     
121.         if(len > 0)
     
122.         {
     7 g- [7 y+ m: S, ~7 e; ~' l, D
123.           printf("从FIFO中读出的数据，长度：%d\n", len);
     2 {" a: S& r- p" h. ]  f0 ^% Z! ]0 x
124. 
     
125.           for(int i = 0; i < len; i++)
     
126.           {
     
127.             printf("%d ", rdata[i]);
     
128.           }
     
129. 
     . b/ }) \4 _7 Y, V2 ]
130.           printf("\n");
     
131. 
     
132.           printf("FIFO读取成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     ; `! d- w9 _5 g! F2 X: M
133.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
134.         }
     . K+ r: V, [2 I; B
135.         else
     7 `5 H( [! T3 g3 {  l/ u$ w( ]# x) t
136.         {
     6 D: w; F# f5 u* d+ V) v4 e$ h
137.           printf("FIFO读取失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     2 O! F% _- i( L0 ?" o5 X
138.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     0 I- r* T/ e( O; u
139.         }
     
140. 
     
141.         if(RingBuffer_IsFull(fifo) == true)
     / \% ~. x7 @  s* L* g5 D- k  v
142.         {
     ; K! ^2 H5 [( e
143.           printf("FIFO满了！！！\n");
     
144.         }
     
145.         else
     
146.         {
     
147.           printf("FIFO没满！！！\n");
     : ?- y" p, N' v4 e* }
148.         }
     
149. 
     
150.         if(RingBuffer_IsEmpty(fifo) == true)
     
151.         {
     
152.           printf("FIFO空了！！！\n");
     9 I9 j1 J$ L# d2 M0 h9 `7 L
153.         }
     
154.         else
     
155.         {
     
156.           printf("FIFO没空！！！\n");
     
157.         }
     % T) p) N  B, r8 Z& f
158.       }
     5 d8 V  W* r5 v
159. 
       D* M6 X* H( u& Y
160.       printf("\n");
     
161. 
     ; A  n) s5 q8 \% }
162.       {
     ' m# c; @% f- M
163.         RingBuffer_Reset(fifo);
     9 d! T, b2 n2 Q7 n0 u
164.         printf("FIFO清空成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
165.                RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     - Q% r! C& h& F* [4 H& ~1 E
166. 
     
167.         if(RingBuffer_IsFull(fifo) == true)
     
168.         {
     
169.           printf("FIFO满了！！！\n");
     
170.         }
     
171.         else
     3 i; b& O- @  R/ U: E5 o" p
172.         {
     * ]1 R7 z9 V4 T0 |$ N/ ^4 ?' k' V
173.           printf("FIFO没满！！！\n");
     4 y* e/ a2 w: V* [! a# a0 O" O
174.         }
     
175. 
     
176.         if(RingBuffer_IsEmpty(fifo) == true)
     2 [$ q! t9 d6 Y1 n
177.         {
     - g" q& A0 B- K* D0 L
178.           printf("FIFO空了！！！\n");
     
179.         }
     
180.         else
     
181.         {
     - l/ v1 ?2 S) Z$ h
182.           printf("FIFO没空！！！\n");
     . u4 x, ~1 U% p( k% H/ W- u) o8 @* ?- r: X
183.         }
     3 \1 I1 _' C0 ^7 q* d1 g5 {) S
184.       }
     * `5 l) _! c3 D* L- w) H/ K
185. 
     
186.       printf("\n");
     
187. 
     
188.       {
     * p. q, V+ F4 |( y' ]8 ~0 M! ?
189.         if(RingBuffer_In(fifo, data, sizeof(data)) > 0)
     
190.         {
     % Q+ H* n6 \0 ~4 s" `- b
191.           printf("FIFO写入成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
192.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     " [7 e7 u1 w0 X% L  G
193.         }
     
194.         else
     ( A5 c9 D9 u6 ?5 c) ]
195.         {
     ( J$ b# D! J1 u* t2 V, l$ F
196.           printf("FIFO写入失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
197.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     * K& ?; G* ?* A+ F, ^
198.         }
     
199. 
     8 n" f( {* V1 v5 L. p" z
200.         if(RingBuffer_IsFull(fifo) == true)
     1 B. P$ D8 i  U
201.         {
     
202.           printf("FIFO满了！！！\n");
     
203.         }
     # i, d* @# C- f& g- r8 r4 _
204.         else
     ! a# k. L1 R. X( ?: X+ e0 E" N
205.         {
     3 r9 H9 n, b+ W
206.           printf("FIFO没满！！！\n");
     
207.         }
     % S* o. b. ~5 p8 ^, `
208. 
     . \9 O* ?) u4 L6 E! M+ n! x
209.         if(RingBuffer_IsEmpty(fifo) == true)
     # Y" ]) w+ _0 p3 l: ~! L1 ]+ T
210.         {
     
211.           printf("FIFO空了！！！\n");
     
212.         }
     
213.         else
     
214.         {
     ' ?2 E" K% S, h' ]) Q
215.           printf("FIFO没空！！！\n");
     ! B1 ~6 p  t( K0 U; j! g8 w
216.         }
     , w- p" b! D" C+ Y8 \% V
217.       }
     
218. 
     
219.       printf("\n");
     2 o; \/ X. Z. g6 _( d- ], h
220. 
     $ s# f& b+ ~  e* J  s- d
221.       {
     " L4 ?* W2 H. [. D0 k0 `
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));
     $ j& m9 A, g2 u1 @: C7 Q
226.         }
     + \8 e9 M) J  d9 z1 C+ {  T) j
227.         else
     
228.         {
     & ]- U+ d# \" S- B  Q0 c
229.           printf("FIFO写入失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     
230.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
231.         }
     
232. 
     
233.         if(RingBuffer_IsFull(fifo) == true)
     " k# ~) S; p1 w, M. S0 o5 v! `
234.         {
     # h) i, P2 S) {" P5 l2 M7 D: `
235.           printf("FIFO满了！！！\n");
     5 k% X# Q. J$ I* _% o* c! o9 D
236.         }
     2 a* G9 z0 Q& q: W; v
237.         else
     
238.         {
     
239.           printf("FIFO没满！！！\n");
     
240.         }
     * b+ ]) r: s7 w+ o7 p
241. 
     
242.         if(RingBuffer_IsEmpty(fifo) == true)
     
243.         {
     
244.           printf("FIFO空了！！！\n");
     7 H0 [4 j1 b* m( h. s, @
245.         }
     ( a# b, K! K8 g5 _9 a6 U
246.         else
     
247.         {
     ' \% l: U& ^/ F& S! T8 b
248.           printf("FIFO没空！！！\n");
     
249.         }
     ' i! |/ M& E) Q0 \6 A+ d
250.       }
     & E2 v  b9 O) Q8 [! e: S! ]
251. 
     3 f/ x& {9 ~0 _: h3 |
252.       printf("\n");
     ' q. D2 S! ~' \1 `. f" A
253. 
     0 S7 e2 K  N9 E# V6 t0 j
254.       {
     
255.         uint8_t  rdata[256] = {0};
     6 c0 J. x# D0 R" Q3 A: t+ m1 O
256.         uint16_t len        = RingBuffer_Out(fifo, rdata, sizeof(rdata));
     ; [9 J5 C" E# d. N
257. 
     
258.         if(len > 0)
     / D4 h' W( F7 o0 b
259.         {
     1 D; w) v- F' b. @
260.           printf("从FIFO中读出的数据，长度：%d\n", len);
     
261. 
     
262.           for(int i = 0; i < len; i++)
     
263.           {
     9 {! q9 p2 v0 K4 l0 J
264.             printf("%d ", rdata[i]);
     
265.           }
     9 ~1 B( |) f8 g
266. 
     
267.           printf("\n");
     
268. 
     , z& |. K/ W) U" c$ T, {
269.           printf("FIFO读取成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     0 \+ u& K1 T: _$ N9 J7 g; }0 W
270.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
271.         }
     
272.         else
     
273.         {
     
274.           printf("FIFO读取失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     8 T1 R: S. d( L( S9 x) u/ s( p
275.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     , y% Z7 U0 v0 ?
276.         }
     * B! {" i1 Q- i! A2 n1 j% Z$ t
277. 
     
278.         if(RingBuffer_IsFull(fifo) == true)
     & r; j* q$ q, K9 e% e
279.         {
     8 Z- O2 d* k4 L( j9 s* N5 L% D; h
280.           printf("FIFO满了！！！\n");
     
281.         }
     ( P! G( r* P" i
282.         else
     
283.         {
     
284.           printf("FIFO没满！！！\n");
     
285.         }
     ' e) m' X' p! P5 D4 f; M
286. 
     
287.         if(RingBuffer_IsEmpty(fifo) == true)
     . ?* E2 G3 V' Y3 D+ W& `9 s& J3 H
288.         {
     2 r( h" @# _6 i; d* d
289.           printf("FIFO空了！！！\n");
     + b0 @2 j# ~/ j. X
290.         }
     , h" E& [9 }* _9 _
291.         else
     : n. P& H  r3 f
292.         {
     4 |4 D3 o+ C7 X5 T
293.           printf("FIFO没空！！！\n");
     # E9 H7 a6 F0 i# t( X8 B
294.         }
     
295.       }
     ' N" A0 |5 L1 y% ^) ~9 R( A
296. 
     , }# c6 b: B! u$ B
297.       printf("\n");
     0 l# `8 b5 g" B/ a$ |' G( W
298. 
     0 ?  M4 ]) f% }
299.       {
     
300.         uint8_t  rdata[256] = {0};
     
301.         uint16_t len        = RingBuffer_Out(fifo, rdata, sizeof(rdata));
     
302. 
     8 u& w3 F- ?& A. E, q& N
303.         if(len > 0)
     ' J. y7 ?6 S& L) f+ t) L
304.         {
     ; U5 T/ v, t* E0 G5 z: Q/ b
305.           printf("从FIFO中读出的数据，长度：%d\n", len);
     ! h. O  h. F, [6 |3 E
306. 
     
307.           for(int i = 0; i < len; i++)
     5 L# U4 ?% |6 G/ {1 i# [+ v
308.           {
     
309.             printf("%d ", rdata[i]);
     ! t: N5 j2 y% [  g- b
310.           }
     7 I' h$ W; J4 g* q* @2 Q% ^6 h
311. 
     
312.           printf("\n");
     ) {' q" Y# |2 F8 g" k9 d1 Z5 v
313. 
     
314.           printf("FIFO读取成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     5 _+ m& k; p& B5 t  n
315.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     
316.         }
     
317.         else
     
318.         {
     9 h$ _1 Z, T1 s/ e, ^: {
319.           printf("FIFO读取失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
     3 f1 z+ a: E7 i
320.                  RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
     1 i; }; L/ V) q, R, m! c
321.         }
     
322. 
     
323.         if(RingBuffer_IsFull(fifo) == true)
     : t$ x$ }6 \7 A  M* K- b; h% E* A/ d
324.         {
     $ B3 J0 C/ k1 F4 K
325.           printf("FIFO满了！！！\n");
     
326.         }
     : e' w- E5 |/ @& X
327.         else
     - N# F; c6 ^3 G9 \" ?& ?. g( N& y
328.         {
     
329.           printf("FIFO没满！！！\n");
     
330.         }
     % V! F3 o1 S& S/ e" q& Z
331. 
     
332.         if(RingBuffer_IsEmpty(fifo) == true)
     1 e: N' E3 F! u; G# g
333.         {
     
334.           printf("FIFO空了！！！\n");
     - v& C6 U2 Y1 h4 b& M8 X
335.         }
     
336.         else
     1 a. s) b5 W5 P
337.         {
     ) A' C# t2 \8 ^- I; X9 X' X5 W: s
338.           printf("FIFO没空！！！\n");
     
339.         }
     ; }: ?; T6 x* Y6 C- J; E6 T
340.       }
       X2 D" _1 H/ \/ Z( n' x
341. 
     
342.       printf("\n\n\n");
     . y5 C/ x( j0 {$ P  @3 x; O
343.       Sleep(5000);
     
344.     }
     
345.   }
     * C9 m' z- i* A
346.   else
     
347.   {
     
348.     printf("FIFO创建失败\n");
     
349.   }
     
350. 
     
351.   for(;;)
     - t6 t: T& d8 ~
352.   {
     
353. 
     
354.   }
     0 L0 u3 I3 p1 p4 I+ N& h
355. }
     

复制代码

3，运行效果
" Q% T. B" m; l3 N& m$ O% i' V2 L! b

5 C) j( Q; l. t+ F9 X; k2 R

bargagebaobei 发表于 2018-3-7 16:38
+ d6 C$ T1 X) q4 i. P亲 可以给个链接吗

7 G6 `! q: U, e* e# OGitHub仓库：http://github.com/XinLiGitHub/RingBuffer

MrJiu 发表于 2018-3-7 13:39
C语言数据结构里面有，很快就可以实现！！！

kfifo 可以实现，一个线程写，一个线程读，不需要任何的保护。无锁编程才是他的精髓。

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

谢谢分享，学习了

谢谢分享
以前搞过ram模拟fifo，还没用过环形fifo，学习学习。
  u& h8 o3 z9 ^: m3 r

感谢楼主分享

这个程序例程很受用，也谢谢楼主的分享了。

& j, [9 I  N! w+ M( x4 d7 z6 s* [谢谢分享，学习了

这是从Linux内核里面弄出来的。

C语言数据结构里面有，很快就可以实现！！！

MrJiu 发表于 2018-3-7 13:39
C语言数据结构里面有，很快就可以实现！！！

巧夺天工的kfifo(修订版)

十分感谢楼主的分享啊 省的我自己费脑筋啊

怎么才能收藏帖子呢

bargagebaobei 发表于 2018-3-7 15:21
怎么才能收藏帖子呢

可以去GitHub，有完整的工程。

XinLiYF 发表于 2018-3-7 16:13
可以去GitHub，有完整的工程。

4 U1 R; F2 M+ r3 \, [亲 可以给个链接吗