01、缓冲区
+ W+ J) x" ~- I7 p0 [: @& j, Z缓冲区看名字就知道，是缓冲数据用的。实现缓冲区最简单的办法时，定义多个数组，接收一包数据到数组A，就把接收数据的地址换成数组B，每个数据有个标记字节用于表示这个数组是否收到数据，收到数据是否处理完成。

& h5 K! }# p4 |; \0 ~
  `. b) Z/ `' W4 q  c, y上述方案是完全可行的，但有缺点：
$ `0 A' M, ^/ ~4 o  l) F

①缓冲数据组数一定，且有多变量，代码结构不太清晰。

- S' K  L5 _* f2 B2 g& `1 n9 J
$ s& f& o! f+ I2 _②接收数据长度可能大于数组大小，也可能小于数组大小。不灵活，需要接收数据很长时容易出错，且内存利用率低。
8 U6 n3 K5 [* w3 O7 T4 r. V$ F; e

6 j& W# ~% z0 H) A2 v. u& X解决这个问题的好办法是：环形缓冲区。
+ J( x* z! O% E4 T  P+ ]2 Q
3 |! H4 k' Z8 i: J4 M* x4 e
1 `6 O* t# Q& z6 O8 E- ~环形缓冲区就是一个带“头指针”和“尾指针”的数组。“头指针”指向环形缓冲区中可读的数据，“尾指针”指向环形缓冲区中可写的缓冲空间。通过移动“头指针”和“尾指针”就可以实现缓冲区的数据读取和写入。在通常情况下，应用程序读取环形缓冲区的数据仅仅会影响“头指针”，而串口接收数据仅仅会影响“尾指针”。当串口接收到新的数组，则将数组保存到环形缓冲区中，同时将“尾指针”加1，以保存下一个数据；应用程序在读取数据时，“头指针”加1，以读取下一个数据。当“尾指针”超过数组大小，则“尾指针”重新指向数组的首元素，从而形成“环形缓冲区”！，有效数据区域在“头指针”和“尾指针”之间。如下图

如上面说的，环形缓冲区其实就是一个数组，将其“剪开”，然后“拉直”后如下图
5 {0 u0 |! D. R  a: y7 d! e

5 S! D0 A. n  k0 r5 W

3 ]+ n2 l1 @3 Y4 d  e
& U; S  T! ?- Q+ ~环形缓冲区的特性
. @1 X- {7 u* d! @/ R. ^
& s* r8 b! k' m3 I% x& o$ ^+ v. L
1、先进新出。
. n8 D! F7 Q4 O% H
+ m3 a' l2 J6 n' r. Y, i
( b! ^7 w& h9 H! T" L3 F: t( j2、当缓冲区被使用完，且又有新的数据需要存储时，丢掉历史最久的数据，保存最新数据。
) J; p! ]/ c- |5 F% c' X

02、代码实现
: {, i  |# c9 Z# c  [环形缓冲区的实现很简单，只需要简单的几个接口即可。
2 {/ g2 s9 A( b1 w! x. n2 n4 W" ?

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

1. <font face="微软雅黑" size="3">#define  RINGBUFF_LEN          (500)     //定义最大接收字节数 500
   6 V) Y6 Y; T! s. b6 p' k' n* I
2. #define  RINGBUFF_OK           1     
   
3. #define  RINGBUFF_ERR          0   
     ~( J6 Q8 a: m1 x& ]
4. typedef struct
   
5. {
   
6.     uint16_t Head;           
   
7.     uint16_t Tail;
   
8.     uint16_t Lenght;
   ( n$ D. B* R" ]1 G- \+ u- c" ]$ j$ J1 H
9.     uint8_t  Ring_data[RINGBUFF_LEN];
   ! f5 i9 N& h; D. Q' E& l
10. }RingBuff_t;
    
11. RingBuff_t ringBuff;//创建一个ringBuff的缓冲区
    
12. </font>

复制代码

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

* i* ]$ ^, L! e, v: b
9 i! f* j$ y9 N环形缓冲区的初始化
6 l$ r" [% V$ {! v6 l- f, f' [

1. <font face="微软雅黑" size="3">/**
   
2. * @brief  RingBuff_Init
   
3. * @param  void
   
4. * @return void
   
5. * @note   初始化环形缓冲区
   
6. */
   
7. void RingBuff_Init(void)
   & \  W, a. r; {" _1 f
8. {
   # V' z  m( h4 }5 x' \
9.   //初始化相关信息
     q# D! e5 o8 K7 w1 Q, `0 |
10.   ringBuff.Head = 0;
    4 n3 B2 y, Y. ?5 s4 Y5 F; l
11.   ringBuff.Tail = 0;
    
12.   ringBuff.Lenght = 0;
    
13. }
    
14. </font>

复制代码

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


4 {  }8 E! N# c+ k  A& J: o# p环形缓冲区的写入
! J" \2 m9 X& P

1. <font face="微软雅黑" size="3">/**
   6 F1 I2 Z0 g+ F9 T4 i% H. o
2. * @brief  Write_RingBuff
   
3. * @param  uint8_t data
   * H  i- r% h8 |) A4 u( y* k' b
4. * @return FLASE:环形缓冲区已满，写入失败;TRUE:写入成功
   . y2 b9 ~: [1 T3 N& ~9 f, F" I- `
5. * @note   往环形缓冲区写入uint8_t类型的数据
   
6. */
   - f) x: H7 J1 _) K& K
7. uint8_t Write_RingBuff(uint8_t data)
   " i" D; A9 Y4 Y& ?- S4 l3 u2 p0 z
8. {
   
9.   if(ringBuff.Lenght >= RINGBUFF_LEN) //判断缓冲区是否已满
   
10.   {
    " R0 k8 J$ \4 h+ [$ h
11.     return RINGBUFF_ERR;
    1 C5 g+ K% A* ~$ p
12.   }
    
13.   ringBuff.Ring_data[ringBuff.Tail]=data;
    
14.   ringBuff.Tail = (ringBuff.Tail+1)%RINGBUFF_LEN;//防止越界非法访问
    , H2 `5 Q8 T) }& m/ [8 v4 I- c) A
15.   ringBuff.Lenght++;
    ' y  M8 l& h2 T7 O
16.   return RINGBUFF_OK;
    ! J% U3 ]) g' |3 z' W' C7 z1 r
17. }</font>

复制代码

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

& h9 r$ Y, z( }- @1 C
环形缓冲区的读取
7 b  c4 r. P7 ^. W
% I3 R9 Z% f1 ]( k& e

1. <font face="微软雅黑" size="3">
   
2. /**
   
3. * @brief  Read_RingBuff
   * o; W  I5 l- H  E& M9 v5 a/ v5 w/ X
4. * @param  uint8_t *rData，用于保存读取的数据
   0 c( j, A' Q% R  Q
5. * @return FLASE:环形缓冲区没有数据，读取失败;TRUE:读取成功
   
6. * @note   从环形缓冲区读取一个u8类型的数据
   
7. */
   
8. uint8_t Read_RingBuff(uint8_t *rData)
   
9. {
   
10.   if(ringBuff.Lenght == 0)//判断非空
    
11.   {
    
12.     return RINGBUFF_ERR;
    1 k+ F& f2 E1 p4 d2 k% U
13.   }
    
14.   *rData = ringBuff.Ring_data[ringBuff.Head];//先进先出FIFO，从缓冲区头出
    ; L& V0 D5 b2 ?3 a0 f  F
15.   ringBuff.Head = (ringBuff.Head+1)%RINGBUFF_LEN;//防止越界非法访问
    , o4 b" F# K, B! c
16.   ringBuff.Lenght--;
    1 I  X. X# x4 c
17.   return RINGBUFF_OK;
    
18. }
    
19. </font>

复制代码

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

$ a5 z6 B$ u. ^; N% r% C
: c2 |0 P' N+ n% M, u* t02、验证
光说不练假把式，下面我们就来验证上面的代码可行性。

: Y' `' w7 {5 L# B
串口中断函数中缓冲数据
! V5 s' k- b5 ~0 A$ [# p1 ?

1. <font face="微软雅黑" size="3">void USART1_IRQHandler(void)
     c. z6 C- m. c9 h: I$ ^
2. {
   . c6 H* m6 F. j) k, c% T
3.   if(USART_GetFlagStatus(USART1, USART_FLAG_RXNE))
   7 }8 l7 D' _% L$ \% y6 ~' i
4.   {
   % {+ S+ e$ n1 L$ j
5.     Write_RingBuff(USART_ReceiveData(USART1));
   4 z/ t* u9 z, W5 B7 Q  y' S
6.     USART_ClearFlag(USART1, USART_FLAG_RXNE);
   * Z6 k" X9 i1 \3 P5 q: y
7.   }
   ! D0 ]; ]& ^  w$ V2 n+ \8 E
8. }</font>

复制代码

在主循环中，读取缓冲区的数据，然后发送出去，因为是简单的demo，添加了延时模拟CPU处理其他任务。
7 X5 h: S- Z% v. S( U

1. <font face="微软雅黑" size="3">
   
2. while (1)
   
3.   {
   + f% ?7 s" u  K& {2 T
4.     if(Read_RingBuff(&data))            //从环形缓冲区中读取数据
   / {  s- t' E. w/ c- K( u7 Z
5.     {
   # z+ g/ Z! q( j7 O/ W+ p. b. z
6.       USART_SendData(USART1, data);
   / g  h( n: K& e( a+ u' d
7.     }
   $ C, w3 r7 ~% ?
8.     SysCtlDelay(1*(SystemCoreClock/3000));
   
9.   }
   
10. </font>

复制代码

验证，间隔100ms发送数据。
) A3 R( v- w, h- g* i  l
, r& K/ f4 q' m( B9 ^
; @3 h0 T5 y5 K1 }( X5 x! e
  H0 g  [, i' R/ D, @

% r+ h5 m+ [8 |  l结果显示没有出现丢包问题。如果你的应用场景串口通信速率快，数据量大或处理速度慢导致丢包，建议增大RINGBUFF_LEN的宏定义，增大缓冲区间即可。
6 F. A' A- ]9 k$ a/ n; J/ M, U) T. J( i
; w+ l8 L3 ]! V( n5 M# x& s
Keil和IAR的工程文件下载地址：
[url=https://github.com/strongercjd/STM32F207VCT6]https://github.com/strongercjd/STM32F207VCT6
[/url]
+ }; o" A$ v6 a" ?
, }) V3 N6 i) X" o$ h$ x& j1 p7 G
( k+ R- @. S3 c# E0 k8 S  X* M, c