01、缓冲区
缓冲区看名字就知道，是缓冲数据用的。实现缓冲区最简单的办法时，定义多个数组，接收一包数据到数组A，就把接收数据的地址换成数组B，每个数据有个标记字节用于表示这个数组是否收到数据，收到数据是否处理完成。
0 m) V$ X1 {) |3 S: p$ h' }) L; E) y
$ b9 X/ n) d' V- [' c' Y% c
上述方案是完全可行的，但有缺点：

* I" p  o6 b1 `9 u. W! f
①缓冲数据组数一定，且有多变量，代码结构不太清晰。
( M3 i/ Y: f- f! g% T8 T

②接收数据长度可能大于数组大小，也可能小于数组大小。不灵活，需要接收数据很长时容易出错，且内存利用率低。
" C0 `/ b* z7 z  b5 V- p
9 F6 p; T. @  V5 o) i2 X, N: |
解决这个问题的好办法是：环形缓冲区。


4 d6 |1 l' a: z+ [4 a' {: y8 n环形缓冲区就是一个带“头指针”和“尾指针”的数组。“头指针”指向环形缓冲区中可读的数据，“尾指针”指向环形缓冲区中可写的缓冲空间。通过移动“头指针”和“尾指针”就可以实现缓冲区的数据读取和写入。在通常情况下，应用程序读取环形缓冲区的数据仅仅会影响“头指针”，而串口接收数据仅仅会影响“尾指针”。当串口接收到新的数组，则将数组保存到环形缓冲区中，同时将“尾指针”加1，以保存下一个数据；应用程序在读取数据时，“头指针”加1，以读取下一个数据。当“尾指针”超过数组大小，则“尾指针”重新指向数组的首元素，从而形成“环形缓冲区”！，有效数据区域在“头指针”和“尾指针”之间。如下图
0 j  n7 S4 u2 l% _5 d. Z+ c2 K6 D
如上面说的，环形缓冲区其实就是一个数组，将其“剪开”，然后“拉直”后如下图


0 O& P  ?8 S$ \! y# ^
3 G4 }- c% @" k* Y1 t
% M5 f0 ?9 K; ^7 m$ U' M6 h1 ~; O7 T
5 o$ N/ y7 y  r1 a8 O环形缓冲区的特性


1、先进新出。
# p4 s2 G- q* r
- r6 d2 e1 G; w7 }# `7 M
' X, L" w0 I% k- d' i  j* n( x2、当缓冲区被使用完，且又有新的数据需要存储时，丢掉历史最久的数据，保存最新数据。
5 O  W# k$ {% L4 W# z3 P

% N! u6 o2 T8 l# [8 W! X* Z/ k  _' s02、代码实现
环形缓冲区的实现很简单，只需要简单的几个接口即可。

( ^$ H+ ~& L! Y' |! t3 h& x% ]
* o0 ], c+ c# n( R" v7 ~% K首先需要创建一个环形缓冲区

1. <font face="微软雅黑" size="3">#define  RINGBUFF_LEN          (500)     //定义最大接收字节数 500
   6 l" M1 Q7 _$ }! g
2. #define  RINGBUFF_OK           1     
   5 l3 w3 N- Q' |. n8 f( E
3. #define  RINGBUFF_ERR          0   
   ! k6 O2 e  S' q0 \
4. typedef struct
   7 y8 ]. x! J7 m3 z( P
5. {
   ( {9 d# Y$ W1 x. ^7 b
6.     uint16_t Head;           
   
7.     uint16_t Tail;
   , F" y. h, j5 J
8.     uint16_t Lenght;
   
9.     uint8_t  Ring_data[RINGBUFF_LEN];
   
10. }RingBuff_t;
    . J$ N4 A  k* e2 ~$ F3 R
11. RingBuff_t ringBuff;//创建一个ringBuff的缓冲区
    0 F. h9 F* J1 b/ d& z, T3 B
12. </font>

复制代码

当我们发现环形缓冲区被“冲爆”时，也就是缓冲区满了，但是还有待缓冲的数据时，只需要修改RINGBUFF_LEN的宏定义，增大缓冲区间即可。
2 \5 d; a+ R( |5 d( D" P# f$ j% o
: x; O/ _1 H! D' O
环形缓冲区的初始化
" L+ g" {) ]4 ~

1. <font face="微软雅黑" size="3">/**
   
2. * @brief  RingBuff_Init
   5 e8 i/ n( t. h
3. * @param  void
   % u+ ?% \3 P/ E' \* ~9 W2 Y
4. * @return void
   
5. * @note   初始化环形缓冲区
   + k+ ^% I; @/ ^5 L) x2 `* \* L+ M! X
6. */
   
7. void RingBuff_Init(void)
   $ L$ k+ [2 C' \) j2 j  q
8. {
     X4 \) a% O: c# ^, C
9.   //初始化相关信息
   % g3 T% ~+ t, g2 u# Y" e  D$ m/ \
10.   ringBuff.Head = 0;
    
11.   ringBuff.Tail = 0;
    / U0 v% Q( q0 `8 @
12.   ringBuff.Lenght = 0;
    
13. }
    
14. </font>

复制代码

主要是将环形缓冲区的头，尾和长度清零，表示没有任何数据存入。

9 V, L: H8 F2 {2 `9 U5 y
$ J4 J& a, J6 D: n: C1 k: ~0 m环形缓冲区的写入
8 G# r7 c; ^+ m  o: D1 D# o* y2 a
4 s  \" C5 |( K: ~

1. <font face="微软雅黑" size="3">/**
   
2. * @brief  Write_RingBuff
   7 E! U9 i% a1 e1 ]* g% W# I
3. * @param  uint8_t data
   & A: ?3 u) t* P4 f. `
4. * @return FLASE:环形缓冲区已满，写入失败;TRUE:写入成功
   
5. * @note   往环形缓冲区写入uint8_t类型的数据
   ! z6 z% T0 Z6 r) \! i- o
6. */
   
7. uint8_t Write_RingBuff(uint8_t data)
   6 \# ?$ C  U7 D8 c0 j# N
8. {
   ( M$ Q1 w* M) @* v$ a$ v1 ]- l
9.   if(ringBuff.Lenght >= RINGBUFF_LEN) //判断缓冲区是否已满
   
10.   {
    
11.     return RINGBUFF_ERR;
    1 T5 B+ n. J- L' `! F
12.   }
    $ |# L' m; [- f
13.   ringBuff.Ring_data[ringBuff.Tail]=data;
    
14.   ringBuff.Tail = (ringBuff.Tail+1)%RINGBUFF_LEN;//防止越界非法访问
    2 o5 E' m3 q; W7 u# o6 F6 p
15.   ringBuff.Lenght++;
    ! C. f+ q0 s4 I; U
16.   return RINGBUFF_OK;
    
17. }</font>

复制代码

这个接口是写入一个字节到环形缓冲区。这里注意：大家可以根据自己的实际应用修改为一次缓冲多个字节。并且这个做了缓冲区满时报错且防止非法越界的处理，大家可以自行修改为缓冲区满时覆盖最早的数据。


环形缓冲区的读取

1 `0 P1 H/ v6 p: }, F' I9 y

1. <font face="微软雅黑" size="3">
   0 p6 D9 E( q! t$ a3 y
2. /**
   8 C4 x: @+ M+ A  Y
3. * @brief  Read_RingBuff
   
4. * @param  uint8_t *rData，用于保存读取的数据
   ; `$ r7 d2 A$ Q/ l: k
5. * @return FLASE:环形缓冲区没有数据，读取失败;TRUE:读取成功
   7 I6 O) K2 p! c
6. * @note   从环形缓冲区读取一个u8类型的数据
   ) W. n0 e+ N* ^8 {
7. */
   * s- l8 b5 b+ ^- g5 f0 \
8. uint8_t Read_RingBuff(uint8_t *rData)
   
9. {
   . C1 T* ~7 G9 J1 y
10.   if(ringBuff.Lenght == 0)//判断非空
    
11.   {
    8 {: a! ?9 e6 [/ t  h
12.     return RINGBUFF_ERR;
    
13.   }
    
14.   *rData = ringBuff.Ring_data[ringBuff.Head];//先进先出FIFO，从缓冲区头出
    
15.   ringBuff.Head = (ringBuff.Head+1)%RINGBUFF_LEN;//防止越界非法访问
    
16.   ringBuff.Lenght--;
    * X8 H) k, Y' a
17.   return RINGBUFF_OK;
    6 d! B$ M- {' m8 L. T
18. }
    / F( j8 u6 {- C; R# x% J
19. </font>

复制代码

读取的话也很简单，同样是读取一个字节，大家可以自行修改为读取多个字节。

1 z; `, _/ E' V1 }: C6 ~
, |# [) m; Y- a6 j02、验证
' k, _" ]& H: L光说不练假把式，下面我们就来验证上面的代码可行性。
0 p9 M' X  h, C
! ?* \; t; x3 W, ]7 ]' q
! D# h- N( A) s串口中断函数中缓冲数据
# s& U* H4 j3 p, X% Q
) P# Q0 Y" i- h; ?

1. <font face="微软雅黑" size="3">void USART1_IRQHandler(void)
   
2. {
   % C! ^5 u+ w: ^7 `" r( O
3.   if(USART_GetFlagStatus(USART1, USART_FLAG_RXNE))
   2 `( \% q7 C% @7 x
4.   {
   $ R8 v6 @6 u% @! _0 S  A/ h* N
5.     Write_RingBuff(USART_ReceiveData(USART1));
   # ]$ ], F! n6 C+ {! R! z: x
6.     USART_ClearFlag(USART1, USART_FLAG_RXNE);
   ( t2 E! u) d- H; ]0 i
7.   }
   4 z+ ?4 F; a9 H& n
8. }</font>

复制代码

在主循环中，读取缓冲区的数据，然后发送出去，因为是简单的demo，添加了延时模拟CPU处理其他任务。

1. <font face="微软雅黑" size="3">
   
2. while (1)
     D5 ?( d8 ~+ x5 S' C, M. P
3.   {
   5 S" R. M& M9 X$ M/ ^" G
4.     if(Read_RingBuff(&data))            //从环形缓冲区中读取数据
   
5.     {
   3 G( t5 P6 J0 q- H, E% _& g
6.       USART_SendData(USART1, data);
   ; n' z* m: I+ J8 O* w
7.     }
     z4 C: W1 Q0 B( m- T3 [! S1 R
8.     SysCtlDelay(1*(SystemCoreClock/3000));
   1 U9 w$ a& K! a# w& o! a
9.   }
   ; z- S& @% |* F  {
10. </font>

复制代码

验证，间隔100ms发送数据。
$ U5 |5 ^( t$ p
1 a. \: _, Y, T) @) n
$ B/ U( \; Z( T7 v) n" I8 ?

; \! u. _1 S! T; r& m7 C+ {9 K
' Z2 ^, S) H: d) O4 ~) w结果显示没有出现丢包问题。如果你的应用场景串口通信速率快，数据量大或处理速度慢导致丢包，建议增大RINGBUFF_LEN的宏定义，增大缓冲区间即可。

- F& X0 V- l! \: J
Keil和IAR的工程文件下载地址：
% Y4 |" G+ B2 Q0 d$ I[url=https://github.com/strongercjd/STM32F207VCT6]https://github.com/strongercjd/STM32F207VCT6
. W. O1 {9 E# w5 D* Y9 o( Y2 K[/url]


3 t0 O7 u- c% g+ [' N