01、缓冲区
缓冲区看名字就知道，是缓冲数据用的。实现缓冲区最简单的办法时，定义多个数组，接收一包数据到数组A，就把接收数据的地址换成数组B，每个数据有个标记字节用于表示这个数组是否收到数据，收到数据是否处理完成。
: G8 ]' r0 G7 K, d6 U, H. p

7 ?% ~; r. R8 E上述方案是完全可行的，但有缺点：
1 c$ I# m" F; T, j" P

0 P! [) l! b3 B9 t  w/ F/ I①缓冲数据组数一定，且有多变量，代码结构不太清晰。


0 ~% X6 y# o* @! K②接收数据长度可能大于数组大小，也可能小于数组大小。不灵活，需要接收数据很长时容易出错，且内存利用率低。


- W3 ~5 {+ i; M% K5 T' z' T$ _解决这个问题的好办法是：环形缓冲区。
* Q4 u4 D% N7 I) d2 V
! J( M" g3 j. K7 {
" }6 \( ~  ^* `& J1 w$ c环形缓冲区就是一个带“头指针”和“尾指针”的数组。“头指针”指向环形缓冲区中可读的数据，“尾指针”指向环形缓冲区中可写的缓冲空间。通过移动“头指针”和“尾指针”就可以实现缓冲区的数据读取和写入。在通常情况下，应用程序读取环形缓冲区的数据仅仅会影响“头指针”，而串口接收数据仅仅会影响“尾指针”。当串口接收到新的数组，则将数组保存到环形缓冲区中，同时将“尾指针”加1，以保存下一个数据；应用程序在读取数据时，“头指针”加1，以读取下一个数据。当“尾指针”超过数组大小，则“尾指针”重新指向数组的首元素，从而形成“环形缓冲区”！，有效数据区域在“头指针”和“尾指针”之间。如下图
$ I3 b8 _2 k) b/ z$ _, Y& O
: p. A5 F# K5 N如上面说的，环形缓冲区其实就是一个数组，将其“剪开”，然后“拉直”后如下图
0 Q( W4 Y: c0 m- ~
' _8 ^3 v$ W2 m0 }4 q5 y% f0 T; X
  t* r9 \. ?2 v# z( _, g


环形缓冲区的特性

- A* ^2 x$ J! r5 x: v
7 I; M6 X1 ~1 O% i$ o6 ?1、先进新出。
9 S0 h: W! m/ Q% r3 J
' n2 g, A& s' w; c1 n
2、当缓冲区被使用完，且又有新的数据需要存储时，丢掉历史最久的数据，保存最新数据。
! S5 T, F* L) q* e5 e9 N" l

1 e) f7 i+ Z0 v' i2 N* e$ Y02、代码实现
环形缓冲区的实现很简单，只需要简单的几个接口即可。
* g4 A, r) U- l) S
+ m3 [2 a. |0 \; @3 ~
首先需要创建一个环形缓冲区

1. <font face="微软雅黑" size="3">#define  RINGBUFF_LEN          (500)     //定义最大接收字节数 500
   % j5 o  c- O9 W$ T" p% @  w* S( I9 Y
2. #define  RINGBUFF_OK           1     
   * H5 [% F4 X0 q( [" ^+ Z& g
3. #define  RINGBUFF_ERR          0   
   
4. typedef struct
   
5. {
   
6.     uint16_t Head;           
   
7.     uint16_t Tail;
   
8.     uint16_t Lenght;
   0 y( J7 f$ Q( L" C. f& ~
9.     uint8_t  Ring_data[RINGBUFF_LEN];
   
10. }RingBuff_t;
    0 L  {  u( O  r
11. RingBuff_t ringBuff;//创建一个ringBuff的缓冲区
    
12. </font>

复制代码

当我们发现环形缓冲区被“冲爆”时，也就是缓冲区满了，但是还有待缓冲的数据时，只需要修改RINGBUFF_LEN的宏定义，增大缓冲区间即可。
. ^" _6 ^3 n- q: h2 B, ?

% i6 S' {* c& N$ a$ \环形缓冲区的初始化

1. <font face="微软雅黑" size="3">/**
   
2. * @brief  RingBuff_Init
   
3. * @param  void
   
4. * @return void
   & a# a- a" Q8 W# N& x, @
5. * @note   初始化环形缓冲区
   ' C0 F+ z8 q% d; V4 K
6. */
   2 e7 {# v) K3 y. ~. G
7. void RingBuff_Init(void)
   : V5 f" i" w+ Z/ t6 q7 u/ w
8. {
   
9.   //初始化相关信息
   
10.   ringBuff.Head = 0;
    
11.   ringBuff.Tail = 0;
    
12.   ringBuff.Lenght = 0;
    
13. }
    
14. </font>

复制代码

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


& A" }4 H% L+ {& N1 N3 I0 a( ~环形缓冲区的写入

& a  y6 l2 {0 z1 \' a

1. <font face="微软雅黑" size="3">/**
   4 R0 K6 A# u; s( t" U
2. * @brief  Write_RingBuff
   - N) ^* p' h, p1 Q2 |6 E0 [" q
3. * @param  uint8_t data
   * Z  s3 J% y! b; n
4. * @return FLASE:环形缓冲区已满，写入失败;TRUE:写入成功
   $ _$ Y% u% ^; Y* R" B
5. * @note   往环形缓冲区写入uint8_t类型的数据
   
6. */
   
7. uint8_t Write_RingBuff(uint8_t data)
   
8. {
   
9.   if(ringBuff.Lenght >= RINGBUFF_LEN) //判断缓冲区是否已满
   
10.   {
    
11.     return RINGBUFF_ERR;
    9 v9 ^; B( {! o4 w$ T3 h2 P/ ^
12.   }
    $ I' W& c# x8 x7 x; F3 V% s0 e
13.   ringBuff.Ring_data[ringBuff.Tail]=data;
    
14.   ringBuff.Tail = (ringBuff.Tail+1)%RINGBUFF_LEN;//防止越界非法访问
    4 b- g- n" I3 I& r
15.   ringBuff.Lenght++;
    ; t: w  B( K; ?/ c% x
16.   return RINGBUFF_OK;
    
17. }</font>

复制代码

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

2 f' b' ?* T2 m0 p+ l6 _
# w# s2 E2 E- f6 c; z  V环形缓冲区的读取
- o9 K6 M/ B/ z
- u2 v% c4 D" C4 c! @; o0 }0 m% s

1. <font face="微软雅黑" size="3">
   9 Z( {9 i! Q$ ?* [6 d) U
2. /**
   
3. * @brief  Read_RingBuff
   
4. * @param  uint8_t *rData，用于保存读取的数据
   
5. * @return FLASE:环形缓冲区没有数据，读取失败;TRUE:读取成功
   , e3 R9 [5 P2 l% m3 ^/ U" [
6. * @note   从环形缓冲区读取一个u8类型的数据
   
7. */
   # M; ]; H6 _6 A: G: a3 n
8. uint8_t Read_RingBuff(uint8_t *rData)
   : F# t* G# J( X/ E  w
9. {
   
10.   if(ringBuff.Lenght == 0)//判断非空
    
11.   {
    . H* d8 }3 \/ F$ c) L5 \; z+ Y
12.     return RINGBUFF_ERR;
    1 d  ~0 O" \! b& m
13.   }
    8 L4 z+ `9 q' v. b9 l
14.   *rData = ringBuff.Ring_data[ringBuff.Head];//先进先出FIFO，从缓冲区头出
    
15.   ringBuff.Head = (ringBuff.Head+1)%RINGBUFF_LEN;//防止越界非法访问
    + B/ T8 x' c( `+ N( ]
16.   ringBuff.Lenght--;
    
17.   return RINGBUFF_OK;
    
18. }
    
19. </font>

复制代码

读取的话也很简单，同样是读取一个字节，大家可以自行修改为读取多个字节。
8 Z! A8 p  x1 I7 k& H. f- o1 A
; }/ y- q9 y- J2 k
02、验证
光说不练假把式，下面我们就来验证上面的代码可行性。

" c9 W7 Y! V1 m; e! S. {
% N5 n$ C: ^& k/ j1 Y串口中断函数中缓冲数据

1. <font face="微软雅黑" size="3">void USART1_IRQHandler(void)
   
2. {
   . n% W7 d1 U. E: V" Q
3.   if(USART_GetFlagStatus(USART1, USART_FLAG_RXNE))
     R# u3 o9 n( r, R0 T3 Y& ]
4.   {
   : n" |, V9 I% ^  j/ j) d
5.     Write_RingBuff(USART_ReceiveData(USART1));
   " K# R+ T( i" ]" Q
6.     USART_ClearFlag(USART1, USART_FLAG_RXNE);
   8 H, w  \. z1 }* Q
7.   }
   & o$ W& r: a2 `# N+ a
8. }</font>

复制代码

在主循环中，读取缓冲区的数据，然后发送出去，因为是简单的demo，添加了延时模拟CPU处理其他任务。
2 Q1 P$ m, F* G1 W7 j4 Q" ?& ^- G

1. <font face="微软雅黑" size="3">
   - S6 c( n/ Z  F1 K1 o: _( }
2. while (1)
   
3.   {
   # u! O6 ]/ f" w- q2 z
4.     if(Read_RingBuff(&data))            //从环形缓冲区中读取数据
   
5.     {
   
6.       USART_SendData(USART1, data);
   
7.     }
   " \% v7 \0 M" v+ ]
8.     SysCtlDelay(1*(SystemCoreClock/3000));
   # h3 n6 X4 [) f/ T
9.   }
   & c! i" `( b( B' V/ I
10. </font>

复制代码

验证，间隔100ms发送数据。
* x: ?: K' ~5 d+ M0 G
+ ^- U) \  ~$ _6 ~* E8 B- H
, d# [$ ~! g, u, ?/ C) q9 l5 r, O
# g1 g& ]! u' c2 A' W
/ M4 j$ Y1 j) k
结果显示没有出现丢包问题。如果你的应用场景串口通信速率快，数据量大或处理速度慢导致丢包，建议增大RINGBUFF_LEN的宏定义，增大缓冲区间即可。

5 m# F3 ?* ~+ l# _+ x. f3 {
- y4 j# G1 [2 T- X* d6 |. j+ JKeil和IAR的工程文件下载地址：
[url=https://github.com/strongercjd/STM32F207VCT6]https://github.com/strongercjd/STM32F207VCT6
0 [9 x, z0 x* U! S! C+ W[/url]

  o& S) S- i& G7 R, J