21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › STM32 C语言编写环形存储区
返回列表 发新帖我要提问

[其他ST产品] STM32 C语言编写环形存储区

[复制链接]
1071|17
 楼主| 梵蒂冈是神uy 发表于 2022-11-30 15:43 | 显示全部楼层 |阅读模式
C语言, ST, STM, STM32, 存储区
前言
在产品开发中经常碰到帧数据丢失或接收过来非整帧的情况，为增加代码的可靠性，采用环形存储区的方式将数据先行缓存，然后进行帧判断、解析、执行。

一、环形存储区简介
简言之，环形存储区就是我们定义或者动态分配的一段连续的数据存储区域。其工作过程是通过头和尾两个索引在这段连续的存储区域进行数据的读出和写入，就好像将这一块儿连续的数据存储区行程了一个闭环，这就是环形的含义。
当数据写入时尾索引增加，当数据读取时头索引增加。具有FIFO的特性。
由以上可知，要将一个连续存储区域作为环形存储区需要四个元素：连续存储区域首地址、连续存储区域大小、头索引及尾索引。

回复

收藏 举报

相关帖子
 楼主| 梵蒂冈是神uy 发表于 2022-11-30 15:44 | 显示全部楼层
环形存储区C语言代码实现
废话不多说，直接贴出代码。本代码亲测通过，希望能够帮助有需要的同学。如果正式你需要的或者能够帮助你希望点个赞呦。
回复

收藏 举报

 楼主| 梵蒂冈是神uy 发表于 2022-11-30 15:45 | 显示全部楼层
RingBuff.c文件实现
复制
  1. #include "RingBuff.h"
    


  2. 

  3. /**
    

  4.  * [url=home.php?mod=space&uid=247401]@brief[/url] 环形缓冲区初始化
    

  5.  * @param[in] pRingBuff 环形缓冲区结构体地址
    

  6.  * @param[in] buf_size  环形缓存区大小（字节数）
    

  7.  * @return[out]  
    

  8.  */
    

  9. void RingBuff_Init(RingBuff_t *pRingBuff, unsigned int buf_size)
    

  10. {
    

  11.         RingBuff_t                 *ringbuff         = NULL;
    

  12.         unsigned int         size                 = 0;
    


  13. 

  14.         ringbuff = pRingBuff;
    

  15.         size         = buf_size;
    

  16.         
    

  17.         ringbuff->buffer = (uint8_t*)calloc(size, sizeof(uint8_t));
    

  18.         ringbuff->size = size;
    

  19.         ringbuff->head = 0;
    

  20.         ringbuff->tail = 0;        
    

  21. }
    


  22. 


  23. 

  24. /**
    

  25.  * @brief 判断环形缓冲区是否为空
    

  26.  * @param[in] pRingBuff 环形缓冲区结构体地址
    

  27.  * @return[out]          RING_TRUE                空
    

  28.  *                                         RING_FALSE                非空
    

  29.  */
    

  30. static unsigned char RingBuff_isEmpty(RingBuff_t *pRingBuff) 
    

  31. {
    

  32.         RingBuff_t *ringbuff = NULL;
    


  33. 

  34.         ringbuff = pRingBuff;
    


  35. 

  36.         if(ringbuff->head == ringbuff->tail)
    

  37.         {
    

  38.                 return RING_TRUE;
    

  39.         }
    

  40.         return RING_FALSE;
    

  41. }
    


  42. 


  43. 

  44. /**
    

  45.  * @brief 判断环形缓冲区是否为满
    

  46.  * @param[in] pRingBuff 环形缓冲区结构体地址
    

  47.  * @return[out]          RING_TRUE                满
    

  48.  *                                         RING_FALSE                非满
    

  49.  */
    

  50. static unsigned char RingBuff_isFull(RingBuff_t *pRingBuff)
    

  51. {
    

  52.         RingBuff_t *ringbuff = NULL;
    


  53. 

  54.         ringbuff = pRingBuff;
    


  55. 

  56.         if((ringbuff->tail + 1) % ringbuff->size == ringbuff->head)
    

  57.         {
    

  58.                 return RING_TRUE;
    

  59.         }
    

  60.         return RING_FALSE;
    

  61. }
    


  62. 


  63. 

  64. /**
    

  65.  * @brief 从环形缓冲区头部读出一个字节
    

  66.  * @param[in] pRingBuff 环形缓冲区结构体地址
    

  67.  * @param[in] pData         读出缓冲区字节所将要存储的地址
    

  68.  * @return[out]  RING_OK        读出成功，
    

  69.  *                                  RING_ERR        读出失败
    

  70.  */
    

  71. static unsigned char RingBuff_ReadOneByte(RingBuff_t *pRingBuff, unsigned char *pData)
    

  72. {
    

  73.         RingBuff_t                 *ringbuff = NULL;
    

  74.         unsigned char         *temp = NULL;
    


  75. 

  76.         ringbuff = pRingBuff;
    

  77.         temp         = pData;
    


  78. 

  79.         //判空
    

  80.         if(RING_TRUE == RingBuff_isEmpty(ringbuff))
    

  81.         {
    

  82.                 SYSlog("ring buffer is empty!\r\n");
    

  83.                 return RING_ERR;
    

  84.         }
    


  85. 

  86.         *temp = ringbuff->buffer[ringbuff->head];
    

  87.         ringbuff->head = (ringbuff->head + 1) % ringbuff->size;
    

  88.         return RING_OK;
    

  89. }
    


  90. 


  91. 

  92. /**
    

  93.  * @brief 向环形缓冲区的尾部写入一个字节
    

  94.  * @param[in] pRingBuff 环形缓冲区结构体地址
    

  95.  * @param[in] pData         将要写入缓冲区的字节的地址
    

  96.  * @return[out]  RING_OK        写入成功，
    

  97.  *                                  RING_ERR        写入失败
    

  98.  */
    

  99. static unsigned char RingBuff_WriteOneByte(RingBuff_t *pRingBuff, unsigned char *pData)
    

  100. {
    

  101.         RingBuff_t                 *ringbuff = NULL;
    

  102.         unsigned char         *temp = NULL;
    


  103. 

  104.         ringbuff = pRingBuff;
    

  105.         temp         = pData;
    


  106. 

  107.         //判满
    

  108.         if(RING_TRUE == RingBuff_isFull(ringbuff))
    

  109.         {
    

  110.                 SYSlog("ring buffer is full!\r\n");
    

  111.                 return RING_ERR;
    

  112.         }
    


  113. 

  114.         ringbuff->buffer[ringbuff->tail] = *temp;
    

  115.         ringbuff->tail = (ringbuff->tail + 1) % ringbuff->size;
    

  116.         return RING_OK;
    

  117. }
    


  118. 


  119. 

  120. /**
    

  121.  * @brief 从环形缓冲区读出多个字节
    

  122.  * @param[in] pRingBuff 环形缓冲区结构体地址
    

  123.  * @param[in] pData         读出缓冲区多字节将要存储的首地址
    

  124.  * @param[in] Size                读出环形缓冲区的字节数
    

  125.  * @return[out]  RING_OK        读出成功，
    

  126.  *                                  RING_ERR        读出失败
    

  127.  */
    

  128. unsigned char RingBuff_ReadNByte(RingBuff_t *pRingBuff, unsigned char *pData, int Size)
    

  129. {
    

  130.         RingBuff_t                 *ringbuff = NULL;
    

  131.         unsigned char         *temp = NULL;
    

  132.         int                                size = 0;
    


  133. 

  134.         ringbuff = pRingBuff;
    

  135.         temp         = pData;
    

  136.         size         = Size;
    


  137. 

  138.         for(int i = 0; i < size; i++)
    

  139.         {
    

  140.                 if(RingBuff_ReadOneByte(ringbuff, temp + i) == RING_ERR)
    

  141.                 {
    

  142.                         return RING_ERR;
    

  143.                 }
    

  144.         }
    

  145.         return RING_OK;
    

  146. }
    


  147. 

  148. //
    

  149. /**
    

  150.  * @brief 向环形缓冲区写入多个字节
    

  151.  * @param[in] pRingBuff 环形缓冲区结构体地址
    

  152.  * @param[in] pData         将要写入缓冲区多字节的首地址
    

  153.  * @param[in] Size                写入环形缓冲区的字节数
    

  154.  * @return[out]  RING_OK        写入成功，
    

  155.  *                                  RING_ERR        写入失败
    

  156.  */
    

  157. unsigned char RingBuff_WriteNByte(RingBuff_t *pRingBuff, unsigned char *pData, int Size)
    

  158. {
    

  159.         RingBuff_t                 *ringbuff = NULL;
    

  160.         unsigned char         *temp = NULL;
    

  161.         int                                size = 0;
    


  162. 

  163.         ringbuff = pRingBuff;
    

  164.         temp         = pData;
    

  165.         size         = Size;
    


  166. 

  167.         for(int i = 0; i < size; i++)
    

  168.         {
    

  169.                 if(RingBuff_WriteOneByte(ringbuff, temp + i) == RING_ERR)
    

  170.                 {
    

  171.                         return RING_ERR;
    

  172.                 }
    

  173.         }
    

  174.         return RING_OK;
    

  175. }
    


  176. 


  177. 

  178. /**
    

  179.  * @brief 获取当前环形缓冲区中有效数据的长度
    

  180.  * @param[in] pRingBuff 环形缓冲区结构体地址
    

  181.  * @return[out]          有效数据长度
    

  182.  */
    

  183. int RingBuff_GetValidLen(RingBuff_t *pRingBuff)
    

  184. {
    

  185.         RingBuff_t         *ringbuff         = NULL;
    

  186.         int                 temp                 = 0;
    

  187.         ringbuff = pRingBuff;
    


  188. 

  189.         if(ringbuff->tail >= ringbuff->head)
    

  190.         {
    

  191.                 temp = ringbuff->tail - ringbuff->head;
    

  192.         }
    

  193.         else
    

  194.         {
    

  195.                 temp =  ringbuff->tail + ringbuff->size - ringbuff->head;
    

  196.         }
    


  197. 

  198.         return temp;
    

  199. }
    


  200. 


  201. 

  202. /**
    

  203.  * @brief 获取当前环形缓冲区中空闲数据的长度
    

  204.  * @param[in] pRingBuff 环形缓冲区结构体地址
    

  205.  * @return[out]          空闲数据长度
    

  206.  */
    

  207. int RingBuff_GetIdleLen(RingBuff_t *pRingBuff)
    

  208. {
    

  209.         RingBuff_t         *ringbuff         = NULL;
    

  210.     int                 temp                 = 0;
    

  211.         ringbuff = pRingBuff;
    


  212. 

  213.         if(ringbuff->tail >= ringbuff->head)
    

  214.         {
    

  215.                 temp = ringbuff->size - ringbuff->tail + ringbuff->head;
    

  216.         }
    

  217.         else
    

  218.         {
    

  219.                 temp = ringbuff->head - ringbuff->tail;
    

  220.         }
    

  221.         
    

  222.         return temp;
    

  223. }
    


  224. 


  225. 

  226. /**
    

  227.  * @brief 获取当前头部数据
    

  228.  * @param[in] pRingBuff 环形缓冲区结构体地址
    

  229.  * @return[out]          当前头部数据
    

  230.  */
    

  231. unsigned char RingBuff_GetHeadItem(RingBuff_t *pRingBuff)
    

  232. {
    

  233.         unsigned char temp = 0;
    

  234.         RingBuff_t         *ringbuff = NULL;
    


  235. 

  236.         ringbuff = pRingBuff;
    

  237.         
    

  238.         temp = ringbuff->buffer[ringbuff->head];
    


  239. 

  240.         return temp;
    

  241. }
    


  242. 


  243. 

  244. /**
    

  245.  * @brief 获取指定下标数据
    

  246.  * @param[in] pRingBuff 环形缓冲区结构体地址
    

  247.  * @param[in] index     环形缓冲区下标（环形缓冲区首地址的偏移量）
    

  248.  * @return[out]          环形缓冲区下标指定的数据
    

  249.  */
    

  250. unsigned char RingBuff_GetIndexItem(RingBuff_t *pRingBuff, int index)
    

  251. {
    

  252.         unsigned char res = 0;
    

  253.         RingBuff_t         *ringbuff = NULL;
    

  254.         int                 temp          = 0;
    


  255. 

  256.         ringbuff = pRingBuff;
    

  257.         temp         = index;
    


  258. 

  259.         res = ringbuff->buffer[temp % ringbuff->size];
    


  260. 

  261.         return res;
    

  262. }
    


  263. 


  264. 

  265. /**
    

  266.  * @brief 释放环形缓冲区
    

  267.  * @param[in] pRingBuff 环形缓冲区结构体地址
    

  268.  * @return[out]          
    

  269.  */
    

  270. void RingBuff_Release(RingBuff_t *pRingBuff)
    

  271. {
    

  272.         RingBuff_t         *ringbuff = NULL;
    


  273. 

  274.         ringbuff = pRingBuff;
    


  275. 

  276.         free(ringbuff->buffer);
    

  277.         ringbuff->size = 0;
    

  278.         ringbuff->head = 0;
    

  279.         ringbuff->tail = 0;
    

  280. }
回复

收藏 举报

 楼主| 梵蒂冈是神uy 发表于 2022-11-30 15:45 | 显示全部楼层
RingBuff.h文件实现
复制
  1. #ifndef __RingBuff_H_
    

  2. #define __RingBuff_H_
    


  3. 

  4. #include    <stdlib.h>
    

  5. #include    <string.h>
    

  6. #include    "main.h"
    

  7. #include    "usart.h"
    


  8. 


  9. 

  10. enum
    

  11. {
    

  12.         RING_FALSE,
    

  13.         RING_TRUE,
    

  14. };
    


  15. 

  16. enum
    

  17. {
    

  18.         RING_ERR,
    

  19.         RING_OK,
    

  20. };
    


  21. 

  22. typedef struct ringBuff{
    

  23.     unsigned char *buffer; //数据缓冲区指针
    

  24.     unsigned int size;     //队列的大小 
    

  25.     unsigned int head;     //队列的头部，读取之后偏移            
    

  26.     unsigned int tail;     //队列的尾部，写入之后偏移    
    

  27. }RingBuff_t;
    


  28. 

  29. void RingBuff_Init(RingBuff_t *pRingBuff, unsigned int buf_size);
    

  30. unsigned char RingBuff_ReadNByte(RingBuff_t *pRingBuff, unsigned char *pData, int Size);
    

  31. unsigned char RingBuff_WriteNByte(RingBuff_t *pRingBuff, unsigned char *pData, int Size);
    

  32. int RingBuff_GetValidLen(RingBuff_t *pRingBuff);
    

  33. int RingBuff_GetIdleLen(RingBuff_t *pRingBuff);
    

  34. unsigned char RingBuff_GetHeadItem(RingBuff_t *pRingBuff);
    

  35. unsigned char RingBuff_GetIndexItem(RingBuff_t *pRingBuff, int index);
    

  36. void RingBuff_Release(RingBuff_t *pRingBuff);
    

  37. #endif /* __RingBuff_H_ */
回复

收藏 举报

 楼主| 梵蒂冈是神uy 发表于 2022-11-30 15:46 | 显示全部楼层
总结
以上就是想要分享的内容，感谢大家阅读交流，不对支持敬请指正。
回复

收藏 举报

51xlf 发表于 2022-11-30 23:40 | 显示全部楼层
有完整的工程文件吗？
回复

收藏 举报

zerorobert 发表于 2022-12-14 10:03 | 显示全部楼层
如何创建环形缓存               
回复

收藏 举报

pl202 发表于 2022-12-14 10:58 | 显示全部楼层
这个数据会出现覆盖的吗？              
回复

收藏 举报

mikewalpole 发表于 2022-12-17 14:26 | 显示全部楼层
缓冲区其实就是一个存储区域,它是由专门的硬件寄存器所组成的。  
回复

收藏 举报

Undshing 发表于 2022-12-17 16:23 | 显示全部楼层
可以分享一下工程文件吗？
回复

收藏 举报

iyoum 发表于 2022-12-17 21:40 | 显示全部楼层
环形存储区就是我们定义或者动态分配的一段连续的数据存储区域。
回复

收藏 举报

mollylawrence 发表于 2022-12-18 11:23 | 显示全部楼层
调用同一接口如串口时,会出现干涉情况。  
回复

收藏 举报

51xlf 发表于 2022-12-18 12:06 | 显示全部楼层
这个可以应用其他的单片机上的吗？
回复

收藏 举报

mikewalpole 发表于 2022-12-18 17:03 | 显示全部楼层
环形缓冲区算法在哪里呢              
回复

收藏 举报

lihuami 发表于 2022-12-18 17:43 | 显示全部楼层
怎样用c语言实现一个环形缓存区!  
回复

收藏 举报

everyrobin 发表于 2022-12-18 19:50 | 显示全部楼层
STM32串口开发之环形缓冲区  
回复

收藏 举报

pixhw 发表于 2023-1-14 17:27 | 显示全部楼层
FIFO机制在嵌入式开发中串口数据收发处理相当方便
回复

收藏 举报

51xlf 发表于 2023-1-19 13:33 | 显示全部楼层
这个可以shixainFIFO环形存储器吗？
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

梵蒂冈是神uy

53

主题

735

帖子

1

粉丝
快速回复 在线客服 返回列表 返回顶部