01、缓冲区
缓冲区看名字就知道，是缓冲数据用的。实现缓冲区最简单的办法时，定义多个数组，接收一包数据到数组A，就把接收数据的地址换成数组B，每个数据有个标记字节用于表示这个数组是否收到数据，收到数据是否处理完成。
' J' s8 p. ?* W0 d

上述方案是完全可行的，但有缺点：
) r2 V% x+ a. g6 v$ i, O

, u' a+ x2 d  }' x6 D①缓冲数据组数一定，且有多变量，代码结构不太清晰。
% m# a" d) `, w& P3 Q+ k! a

, c! _( [: z. q% Y- S②接收数据长度可能大于数组大小，也可能小于数组大小。不灵活，需要接收数据很长时容易出错，且内存利用率低。

/ R& {# K3 E' ?% D
  M# A5 J: Z( O) ~, c+ C5 R解决这个问题的好办法是：环形缓冲区。
) i1 q# M# @4 S- }3 f6 m- ]
. U" i- H  [5 x" ]- Z7 A. J6 k/ D% I4 n
7 k( [4 G* K3 X( ^# }8 E1 [( O9 o7 G环形缓冲区就是一个带“头指针”和“尾指针”的数组。“头指针”指向环形缓冲区中可读的数据，“尾指针”指向环形缓冲区中可写的缓冲空间。通过移动“头指针”和“尾指针”就可以实现缓冲区的数据读取和写入。在通常情况下，应用程序读取环形缓冲区的数据仅仅会影响“头指针”，而串口接收数据仅仅会影响“尾指针”。当串口接收到新的数组，则将数组保存到环形缓冲区中，同时将“尾指针”加1，以保存下一个数据；应用程序在读取数据时，“头指针”加1，以读取下一个数据。当“尾指针”超过数组大小，则“尾指针”重新指向数组的首元素，从而形成“环形缓冲区”！，有效数据区域在“头指针”和“尾指针”之间。如下图

如上面说的，环形缓冲区其实就是一个数组，将其“剪开”，然后“拉直”后如下图
+ `4 Q! c# @! |

+ C5 E; y' ]: V3 d7 L/ j

; f2 s. z6 r! k
) y# r. M0 T  d& O2 h' b; E$ p环形缓冲区的特性
/ v& n& [( j4 G& m  P) G
* }" V; ]9 ^! I+ u  ?2 g" W  y1 ]; W
+ }: n$ e, q( K) b% J1、先进新出。

2 S% B, |  @/ l$ V5 r& ^! c9 H
2、当缓冲区被使用完，且又有新的数据需要存储时，丢掉历史最久的数据，保存最新数据。
( ^+ E( a! Q) {" G, Y

6 m) m' w6 h: |02、代码实现
( l) o6 @' o3 M9 J% G% Q8 o环形缓冲区的实现很简单，只需要简单的几个接口即可。
: a7 g& L3 l+ h4 g9 D& H

首先需要创建一个环形缓冲区

1. <font face="微软雅黑" size="3">#define  RINGBUFF_LEN          (500)     //定义最大接收字节数 500
   
2. #define  RINGBUFF_OK           1     
   
3. #define  RINGBUFF_ERR          0   
   ( Y; T: h$ U# s- I. d. F8 e
4. typedef struct
   
5. {
   8 b& l. T' a/ y! \+ l' k
6.     uint16_t Head;           
   
7.     uint16_t Tail;
   
8.     uint16_t Lenght;
   
9.     uint8_t  Ring_data[RINGBUFF_LEN];
   
10. }RingBuff_t;
    
11. RingBuff_t ringBuff;//创建一个ringBuff的缓冲区
    
12. </font>

复制代码

当我们发现环形缓冲区被“冲爆”时，也就是缓冲区满了，但是还有待缓冲的数据时，只需要修改RINGBUFF_LEN的宏定义，增大缓冲区间即可。

8 ~4 M, m" H' Q2 r" N' \
环形缓冲区的初始化
% q! D; a' R5 {

1. <font face="微软雅黑" size="3">/**
   6 a$ |; F9 w* @4 R' K0 O& |
2. * @brief  RingBuff_Init
   2 F2 n  K$ C) D" s6 L
3. * @param  void
   " b' G9 v6 x& G+ O* C- G
4. * @return void
   ; {8 U1 t' r2 W8 a& j# e* @7 t
5. * @note   初始化环形缓冲区
   6 J9 p& F) I, f" _0 w+ o
6. */
   
7. void RingBuff_Init(void)
   
8. {
   # o8 N- E1 l3 n9 x& Z3 K
9.   //初始化相关信息
   
10.   ringBuff.Head = 0;
    
11.   ringBuff.Tail = 0;
    . z& b/ v% z( z/ I$ n
12.   ringBuff.Lenght = 0;
    8 j+ y# Z+ n$ Y, l' [1 r
13. }
    : L- P- C6 Y5 H; C) d
14. </font>

复制代码

主要是将环形缓冲区的头，尾和长度清零，表示没有任何数据存入。
) H# x" ~( J5 f- E

$ O, R  C3 ]6 S, Z8 l! s环形缓冲区的写入
3 S7 {: z) ~* V2 L+ q, z$ S8 _

1. <font face="微软雅黑" size="3">/**
   ; O+ q% s- p  L1 P* {  e' t
2. * @brief  Write_RingBuff
   # }/ u1 I  m" }
3. * @param  uint8_t data
   ( f. S  l  ^" J/ O( N) @4 a  F
4. * @return FLASE:环形缓冲区已满，写入失败;TRUE:写入成功
   
5. * @note   往环形缓冲区写入uint8_t类型的数据
   
6. */
   
7. uint8_t Write_RingBuff(uint8_t data)
     C: ]3 r) _/ y! ]! E
8. {
   * V' h' x* ?2 s& v' S
9.   if(ringBuff.Lenght >= RINGBUFF_LEN) //判断缓冲区是否已满
   1 u+ u/ r# Q( e! J! _
10.   {
    7 u9 c% X5 K3 h. c
11.     return RINGBUFF_ERR;
    
12.   }
    
13.   ringBuff.Ring_data[ringBuff.Tail]=data;
    9 O% I; A- v4 G) g% W5 k
14.   ringBuff.Tail = (ringBuff.Tail+1)%RINGBUFF_LEN;//防止越界非法访问
    
15.   ringBuff.Lenght++;
    ) {5 `% B( b3 k# F" T& D
16.   return RINGBUFF_OK;
    0 \' M; u$ I$ S. c
17. }</font>

复制代码

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

环形缓冲区的读取

% k4 i9 u5 o' e0 X# s: `) B

1. <font face="微软雅黑" size="3">
   
2. /**
   3 h% R1 B$ o/ t2 @/ u2 I
3. * @brief  Read_RingBuff
   / B  M- o  Q( q$ `/ H8 h2 w  Y
4. * @param  uint8_t *rData，用于保存读取的数据
     A4 T2 \0 M% d" F, [
5. * @return FLASE:环形缓冲区没有数据，读取失败;TRUE:读取成功
   ( E5 z" r# i6 d9 }$ u
6. * @note   从环形缓冲区读取一个u8类型的数据
   
7. */
   
8. uint8_t Read_RingBuff(uint8_t *rData)
   ) }1 b( Z4 Y1 ~) k& K
9. {
   : s, Q! O3 y' R- K' n
10.   if(ringBuff.Lenght == 0)//判断非空
    / V2 a: L6 a2 u+ c# j9 j
11.   {
    
12.     return RINGBUFF_ERR;
    
13.   }
    / S# o# e2 R; _9 I) h! S, v% D. f
14.   *rData = ringBuff.Ring_data[ringBuff.Head];//先进先出FIFO，从缓冲区头出
    
15.   ringBuff.Head = (ringBuff.Head+1)%RINGBUFF_LEN;//防止越界非法访问
    , K# t, |+ r- C
16.   ringBuff.Lenght--;
    
17.   return RINGBUFF_OK;
    
18. }
    - c0 q! P+ }, S( d' G
19. </font>

复制代码

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

  x; ?" d: b6 {! Z6 v8 Y% Z
  V* }  g- a# H6 T02、验证
' m/ m0 m0 |( W% N3 P- j光说不练假把式，下面我们就来验证上面的代码可行性。

2 V+ Y% f% h$ a# Z
. C  Q6 e+ J$ h& y6 X" |1 s) W串口中断函数中缓冲数据
6 j5 X3 g2 Y7 u5 J  x

1. <font face="微软雅黑" size="3">void USART1_IRQHandler(void)
   
2. {
   0 N* b: U, j4 `- D/ C" h
3.   if(USART_GetFlagStatus(USART1, USART_FLAG_RXNE))
   
4.   {
   4 R7 [$ Z$ u" ?. p7 @" n" ^2 Z/ _
5.     Write_RingBuff(USART_ReceiveData(USART1));
   $ p9 X: ^+ E6 N& i- F1 \- p
6.     USART_ClearFlag(USART1, USART_FLAG_RXNE);
   7 Q, t0 a/ `8 @6 B/ F- B) c3 [
7.   }
   / X0 X( A, b( n& I6 U% M; }4 b' j
8. }</font>

复制代码

在主循环中，读取缓冲区的数据，然后发送出去，因为是简单的demo，添加了延时模拟CPU处理其他任务。
. I1 j/ B0 ?( Y' U  S* S- {

1. <font face="微软雅黑" size="3">
   
2. while (1)
   
3.   {
   ! V: p6 B: b4 s/ W
4.     if(Read_RingBuff(&data))            //从环形缓冲区中读取数据
   
5.     {
   
6.       USART_SendData(USART1, data);
   
7.     }
   
8.     SysCtlDelay(1*(SystemCoreClock/3000));
   $ m( k  P" G5 |0 y4 @1 y( J. a
9.   }
   * _* j3 i. Y) B8 I! ]
10. </font>

复制代码

验证，间隔100ms发送数据。



2 s& A9 W, L: ]. t" I( i

结果显示没有出现丢包问题。如果你的应用场景串口通信速率快，数据量大或处理速度慢导致丢包，建议增大RINGBUFF_LEN的宏定义，增大缓冲区间即可。
' W7 x, P* q2 k7 I$ S
6 ]" Q) b; g/ f( J& m
Keil和IAR的工程文件下载地址：
; e9 o$ G' M: ], H, O[url=https://github.com/strongercjd/STM32F207VCT6]https://github.com/strongercjd/STM32F207VCT6
0 @- ?- O. G$ a% r3 M: A2 E[/url]