01、缓冲区
1 M5 ^+ Z( }, B4 T2 E/ w缓冲区看名字就知道，是缓冲数据用的。实现缓冲区最简单的办法时，定义多个数组，接收一包数据到数组A，就把接收数据的地址换成数组B，每个数据有个标记字节用于表示这个数组是否收到数据，收到数据是否处理完成。

6 J4 e+ n; {" Q8 a4 B$ e0 g
% Q6 ]" M. L8 g, K3 P' r上述方案是完全可行的，但有缺点：

( R4 z1 \6 [& Q# J
2 j% V7 b! e* V1 K% e* w  w+ [' ~①缓冲数据组数一定，且有多变量，代码结构不太清晰。


②接收数据长度可能大于数组大小，也可能小于数组大小。不灵活，需要接收数据很长时容易出错，且内存利用率低。


解决这个问题的好办法是：环形缓冲区。
4 k$ x0 Z4 b" b5 n/ S

环形缓冲区就是一个带“头指针”和“尾指针”的数组。“头指针”指向环形缓冲区中可读的数据，“尾指针”指向环形缓冲区中可写的缓冲空间。通过移动“头指针”和“尾指针”就可以实现缓冲区的数据读取和写入。在通常情况下，应用程序读取环形缓冲区的数据仅仅会影响“头指针”，而串口接收数据仅仅会影响“尾指针”。当串口接收到新的数组，则将数组保存到环形缓冲区中，同时将“尾指针”加1，以保存下一个数据；应用程序在读取数据时，“头指针”加1，以读取下一个数据。当“尾指针”超过数组大小，则“尾指针”重新指向数组的首元素，从而形成“环形缓冲区”！，有效数据区域在“头指针”和“尾指针”之间。如下图
5 E0 p: u( a  }5 J  U' X4 j
如上面说的，环形缓冲区其实就是一个数组，将其“剪开”，然后“拉直”后如下图
$ D# g# @0 i* W. ?
7 Q% }* P9 C  }1 |7 C) n
1 ~7 C7 b  H/ b* E& Y5 s
5 ~  s4 G9 F0 F0 E5 u. i8 D, k

; I! N8 ~1 ~* w+ v5 e* g环形缓冲区的特性


1、先进新出。


2、当缓冲区被使用完，且又有新的数据需要存储时，丢掉历史最久的数据，保存最新数据。
$ X4 s3 \* s: v) u- N, D4 n5 [
) }. B; ~+ B% i# e" J" p
02、代码实现
环形缓冲区的实现很简单，只需要简单的几个接口即可。
3 `7 B5 r- e/ e; I

  y+ ~# O* C0 {- z: w0 A首先需要创建一个环形缓冲区

1. <font face="微软雅黑" size="3">#define  RINGBUFF_LEN          (500)     //定义最大接收字节数 500
   3 K6 w- Z( y7 l
2. #define  RINGBUFF_OK           1     
   
3. #define  RINGBUFF_ERR          0   
   
4. typedef struct
   
5. {
   
6.     uint16_t Head;           
   ; `: o0 D; |" @. `
7.     uint16_t Tail;
     M, r0 @. E: Q
8.     uint16_t Lenght;
   : K3 G2 X+ t- ?' p9 }9 a
9.     uint8_t  Ring_data[RINGBUFF_LEN];
   
10. }RingBuff_t;
    2 t2 v4 E7 ?8 C% @2 [( m* m
11. RingBuff_t ringBuff;//创建一个ringBuff的缓冲区
    
12. </font>

复制代码

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

, N6 Y; x; d( k! M/ ~
: r# z* m0 a) ]7 W# f$ n环形缓冲区的初始化

1. <font face="微软雅黑" size="3">/**
   
2. * @brief  RingBuff_Init
   
3. * @param  void
   ) G- S) U& |. S2 T$ v
4. * @return void
   * j- U# ~4 K7 _/ s" {
5. * @note   初始化环形缓冲区
   4 A  P1 a2 h& f  V6 W
6. */
   . I8 n3 v& a4 N) C6 K* X* d8 B
7. void RingBuff_Init(void)
   
8. {
   
9.   //初始化相关信息
   6 k8 P  C3 F7 A8 o: M
10.   ringBuff.Head = 0;
    / _' C& L/ Y& d" V( S3 N
11.   ringBuff.Tail = 0;
    , G. Y$ C# s* l  L; Q
12.   ringBuff.Lenght = 0;
    
13. }
    5 U! P3 l0 K% r5 L; D
14. </font>

复制代码

主要是将环形缓冲区的头，尾和长度清零，表示没有任何数据存入。
+ }4 N# y* X+ K2 k% [
0 ^0 ?) v8 ]. G* v: |; t+ u* m
/ ~" u4 f3 O- a4 g环形缓冲区的写入
, _+ C( `# ]+ R$ r6 I1 A

1. <font face="微软雅黑" size="3">/**
   
2. * @brief  Write_RingBuff
   : f5 e2 E8 A0 A! `7 w# c
3. * @param  uint8_t data
   ) ]9 ]0 k/ ^0 F6 [) t3 S  M
4. * @return FLASE:环形缓冲区已满，写入失败;TRUE:写入成功
   
5. * @note   往环形缓冲区写入uint8_t类型的数据
   
6. */
   ; R: x. s. }3 J% H
7. uint8_t Write_RingBuff(uint8_t data)
   
8. {
   
9.   if(ringBuff.Lenght >= RINGBUFF_LEN) //判断缓冲区是否已满
   ! w1 c$ X1 S4 ]
10.   {
    5 R! x! d. L  \. d5 \) @7 S7 _
11.     return RINGBUFF_ERR;
    9 |+ }1 T/ h5 W0 c* m' k
12.   }
    
13.   ringBuff.Ring_data[ringBuff.Tail]=data;
      `; q0 u; Q8 c. s2 h, [
14.   ringBuff.Tail = (ringBuff.Tail+1)%RINGBUFF_LEN;//防止越界非法访问
    & F4 Y- A3 c+ u
15.   ringBuff.Lenght++;
    7 Z/ B. Z6 a* m
16.   return RINGBUFF_OK;
    3 r" ?+ U9 N+ Y+ z$ \+ Q
17. }</font>

复制代码

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


: N4 w8 b3 v7 q  F! T环形缓冲区的读取

1. <font face="微软雅黑" size="3">
   + {: u; Q4 E/ `
2. /**
   2 b6 O8 j) K% A( n/ k7 z' p
3. * @brief  Read_RingBuff
   
4. * @param  uint8_t *rData，用于保存读取的数据
   # F" Q6 A+ x! g+ d8 {
5. * @return FLASE:环形缓冲区没有数据，读取失败;TRUE:读取成功
   % b+ F7 X& M/ K
6. * @note   从环形缓冲区读取一个u8类型的数据
   + \3 ?& c' }3 k+ ^; I8 {' Y
7. */
   ' y& a( Q$ R1 M" U5 D' g
8. uint8_t Read_RingBuff(uint8_t *rData)
   
9. {
   
10.   if(ringBuff.Lenght == 0)//判断非空
    
11.   {
    
12.     return RINGBUFF_ERR;
    
13.   }
    
14.   *rData = ringBuff.Ring_data[ringBuff.Head];//先进先出FIFO，从缓冲区头出
    ( l. O0 j: y6 U
15.   ringBuff.Head = (ringBuff.Head+1)%RINGBUFF_LEN;//防止越界非法访问
    % ?/ Z: M1 i% @/ S) Y+ S# c
16.   ringBuff.Lenght--;
    - i6 t% ^2 B# h0 m
17.   return RINGBUFF_OK;
    ) m" m" x* `0 x6 n- \2 [
18. }
    . g, L9 R3 t9 @/ `
19. </font>

复制代码

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

& k( I2 y+ a$ Y5 s) t) @1 b
5 b1 i) e4 k  j  h' z02、验证
光说不练假把式，下面我们就来验证上面的代码可行性。


串口中断函数中缓冲数据

/ d  [' s4 B. m  }

1. <font face="微软雅黑" size="3">void USART1_IRQHandler(void)
   - H' P. x# O$ X3 K
2. {
   
3.   if(USART_GetFlagStatus(USART1, USART_FLAG_RXNE))
   
4.   {
   
5.     Write_RingBuff(USART_ReceiveData(USART1));
   
6.     USART_ClearFlag(USART1, USART_FLAG_RXNE);
   
7.   }
   : m  d9 _$ m* |* R, h. f$ y" k" t% z' |
8. }</font>

复制代码

在主循环中，读取缓冲区的数据，然后发送出去，因为是简单的demo，添加了延时模拟CPU处理其他任务。
2 q! H- x2 P: o* W  {0 b% ]; G  U' u+ `

1. <font face="微软雅黑" size="3">
   
2. while (1)
   
3.   {
   ; v' C$ r+ K' |- a) m7 X
4.     if(Read_RingBuff(&data))            //从环形缓冲区中读取数据
   2 U( Y5 C  j2 I" @/ Z
5.     {
   
6.       USART_SendData(USART1, data);
   
7.     }
   
8.     SysCtlDelay(1*(SystemCoreClock/3000));
   $ A1 C' u7 M6 b# {6 Z- R
9.   }
   $ L1 R" R8 `7 E1 A$ D5 }
10. </font>

复制代码

验证，间隔100ms发送数据。
4 ^, X) K+ i& w$ }: n3 `

* L9 j( ^0 `4 y7 i! h4 J


结果显示没有出现丢包问题。如果你的应用场景串口通信速率快，数据量大或处理速度慢导致丢包，建议增大RINGBUFF_LEN的宏定义，增大缓冲区间即可。
2 `6 X' X* S/ p; [$ K' j1 R- n  B
8 S  ^( A4 |, U, l8 p
! ^; D  z$ i' T% c9 e5 I* P* zKeil和IAR的工程文件下载地址：
[url=https://github.com/strongercjd/STM32F207VCT6]https://github.com/strongercjd/STM32F207VCT6
) R5 c5 i6 m4 A' \4 R[/url]

9 e# R+ ^. E0 c! Q4 L( q8 h! Z