21ic电子技术开发论坛 › 个人版区 › 贝贝的实验室 › 一个循环队列的实现(升级版本)
返回列表 发新帖我要提问

一个循环队列的实现(升级版本)

[复制链接]
1664|1
 楼主| keer_zu 发表于 2022-1-19 14:08 | 显示全部楼层 |阅读模式
Queue, define, se, unsigned, TE, round


头文件
复制
  1. #ifndef __ROUND_ROBIN__
    

  2. #define __ROUND_ROBIN__
    


  3. 

  4. #define QUE_OK 0
    

  5. #define QUE_ERR -1
    


  6. 

  7. #define QUE_TURN 1
    

  8. #define QUE_FALSE 0
    

  9.         
    


  10. 

  11. #ifndef NULL
    

  12. #define NULL ((void *)0)
    

  13. #endif
    


  14. 

  15. typedef struct{
    

  16.         char *buf;
    

  17.         unsigned int buf_size;
    

  18.         int front;
    

  19.         int rear;
    

  20. }robin_queue_t;
    


  21. 


  22. 

  23. void queue_init(robin_queue_t *q);
    

  24. int queue_length(robin_queue_t *q);
    

  25. int queue_is_full(robin_queue_t *q);
    

  26. int queue_insert(robin_queue_t *q,char item);
    

  27. int queue_insert_frame(robin_queue_t *q,char *buff,unsigned int len);
    

  28. int queue_is_empty(robin_queue_t *q);
    

  29. char *queue_get_item(robin_queue_t *q);
    

  30. int queue_del_item(robin_queue_t *q);
    

  31. int queue_add_index(robin_queue_t *q,unsigned len);
    

  32. int queue_get_frame(robin_queue_t *q,char *buff);
    


  33. 


  34. 


  35. 

  36. #endif
    

  37.   


回复

收藏 举报

相关帖子
 楼主| keer_zu 发表于 2022-1-19 14:09 | 显示全部楼层
实现

复制
  1. /******************************************************************************
    

  2.                                                                             
    

  3.  File Name:      round_robin_queue.c                                                
    

  4.  Copyright:                                                                              
    

  5.  Version:                                                                
    

  6.  Description:    
    


  7. 

  8.  Author:                                EMAIL: 
    

  9.  Kevin.Zu                          zukeqiang@gmail.com
    

  10.                                                            
    

  11. *******************************************************************************
    

  12.  Revision History
    

  13.  ------------------------------------------------------------------------- 
    

  14.  DATE           NAME                   DESCRIPTION                               
    

  15.  20130515                Kevin.Zu                Create 
    

  16.  20131205                Kevin.Zu                Ported to linux
    

  17.  20211213                zukeqiang                ported to tbox
    


  18. 

  19. *******************************************************************************/
    

  20. #include <string.h>
    

  21. #include <stdio.h>
    

  22. #include "round_robin_queue.h"
    

  23. #include "os_depend.h"
    


  24. 


  25. 

  26. #define EC20_RECV_BUF_SIZE 1024
    


  27. 

  28. char ec20_recv_buf[EC20_RECV_BUF_SIZE];
    


  29. 

  30. robin_queue_t  ec20_recv_queue = {
    

  31.         .buf = ec20_recv_buf,
    

  32.         .buf_size = EC20_RECV_BUF_SIZE
    

  33. };
    


  34. 

  35. #define RS485_RECV_BUF_SIZE 1024
    


  36. 

  37. char rs485_recv_buf[RS485_RECV_BUF_SIZE];
    


  38. 

  39. robin_queue_t  rs485_recv_queue = {
    

  40.         .buf = rs485_recv_buf,
    

  41.         .buf_size = RS485_RECV_BUF_SIZE
    

  42. };
    


  43. 


  44. 


  45. 

  46. /********************** frame buffer queue ******************************/
    

  47. void queue_init(robin_queue_t *q)
    

  48. {
    

  49.         q->front = 0;
    

  50.         q->rear = 0;
    

  51.         
    

  52.         memset(q->buf,0,q->buf_size);
    

  53. }
    


  54. 

  55. int queue_length(robin_queue_t *q)
    

  56. {
    

  57.         if(q == NULL)
    

  58.                 return QUE_ERR;
    

  59.         
    

  60.         if(q->rear >= q->front) {
    

  61.                 return q->rear - q->front;
    

  62.         } else {
    

  63.                 return q->rear + q->buf_size - q->front;
    

  64.         }
    

  65. }
    


  66. 


  67. 


  68. 

  69. int queue_is_full(robin_queue_t *q)
    

  70. {
    

  71.         if(q == NULL)
    

  72.                 return QUE_ERR;
    

  73.         
    

  74.         if(q->front == (q->rear + 1) % q->buf_size) //
    

  75.                 return QUE_TURN;  
    

  76.         else  
    

  77.                 return QUE_FALSE;  
    

  78. }
    


  79. 


  80. 

  81. int queue_insert(robin_queue_t *q,char item)
    

  82. {
    

  83.         if(q == NULL)
    

  84.                 return QUE_ERR;  
    

  85.         
    

  86.         if(queue_is_full(q))
    

  87.                 return QUE_ERR;  
    


  88. 

  89.         
    

  90.         ENTER_CRITICAL();
    

  91.         q->buf[q->rear] = item;
    

  92.         q->rear = (q->rear + 1) % q->buf_size; //
    

  93.         EXIT_CRITICAL();
    


  94. 

  95.         
    

  96.         return QUE_OK;  
    


  97. 

  98. }
    


  99. 

  100. int queue_insert_frame(robin_queue_t *q,char *buff,unsigned int len)
    

  101. {
    

  102.         int i;
    

  103.         
    

  104.         if(q == NULL) {
    

  105.                 return QUE_ERR;  
    

  106.         }
    


  107. 

  108.         if(len > q->buf_size - queue_length(q) -1 ) {
    

  109.                 printf("The data length exceeds the buffer margin!\n");
    

  110.                 return QUE_ERR;
    

  111.         }
    


  112. 

  113.         for(i = 0;i < len;i ++) {
    

  114.                 q->buf[q->rear] = buff[i];
    

  115.                 ENTER_CRITICAL();
    

  116.                 q->rear = (q->rear + 1) % q->buf_size; 
    

  117.                 EXIT_CRITICAL();
    

  118.         }
    


  119. 

  120.         
    

  121.         return QUE_OK;  
    


  122. 

  123. }
    


  124. 


  125. 

  126. int queue_is_empty(robin_queue_t *q)
    

  127. {
    

  128.         if(q == NULL)
    

  129.                 return QUE_ERR;
    

  130.         
    

  131.         if(q->front == q->rear) {
    

  132.                 return QUE_TURN;  
    

  133.         } else  {
    

  134.                 return QUE_FALSE;  
    

  135.         }
    

  136. }
    


  137. 

  138. inline char *queue_get_item(robin_queue_t *q)
    

  139. {
    

  140.         char *item;
    

  141.         
    

  142.         if(!queue_is_empty(q)) {
    

  143.                 item = q->buf + q->front;
    

  144.                 
    

  145.                 ENTER_CRITICAL();
    

  146.                 q->front = (q->front + 1) % q->buf_size;
    

  147.                 EXIT_CRITICAL();
    

  148.                 
    

  149.                 return item;
    

  150.         } else {
    

  151.                 return NULL;
    

  152.         }
    

  153. }
    


  154. 

  155. int queue_del_item(robin_queue_t *q)
    

  156. {  
    

  157.         if(q == NULL)
    

  158.                 return QUE_ERR;
    

  159.         
    

  160.         if(queue_is_empty(q))
    

  161.                 return QUE_ERR;
    


  162. 

  163.          ENTER_CRITICAL();
    

  164.         q->front  = (q->front  + 1) % q->buf_size;  
    

  165.         EXIT_CRITICAL();
    


  166. 

  167.         return QUE_OK;        
    

  168. }
    


  169. 

  170. int queue_add_index(robin_queue_t *q,unsigned len)
    

  171. {
    

  172.         if(q == NULL)
    

  173.                 return QUE_ERR;
    


  174. 

  175.         ENTER_CRITICAL();
    

  176.         q->rear = (q->rear + len) % q->buf_size; //
    

  177.         EXIT_CRITICAL();
    


  178. 

  179.         return QUE_OK;
    

  180. }
    


  181. 

  182. int queue_get_frame(robin_queue_t *q,char *buff)
    

  183. {
    

  184.         int i = 0;
    

  185.         if(buff == NULL) {
    

  186.                 return QUE_ERR;
    

  187.         }
    

  188.         
    

  189.         while(!queue_is_empty(q)){
    

  190.                 buff[i] = *(q->buf + q->front);
    

  191.                 
    

  192.                 ENTER_CRITICAL();
    

  193.                 q->front = (q->front + 1) % q->buf_size;
    

  194.                 EXIT_CRITICAL();
    

  195.                 i ++;
    

  196.         }
    


  197. 

  198.         return i;
    

  199. }
    


  200. 


  201. 

  202. ///////////////////////////////////////////// test ////////////////////////////////////
    


  203. 

  204. #define TEST_BUF_SIZE 1000
    

  205. char test_buf[TEST_BUF_SIZE];
    


  206. 

  207. robin_queue_t  test_queue = {
    

  208.         .buf = test_buf,
    

  209.         .buf_size = TEST_BUF_SIZE
    

  210. };
    


  211. 


  212. 

  213. void _test_queue(void)
    

  214. {
    

  215.         int i;
    

  216.         char *item = NULL;
    


  217. 

  218.         char tbuf[200];
    

  219.         for(i = 0;i < 200;i ++) {
    

  220.                 tbuf[i] = 100 + i;
    

  221.         }
    

  222.         
    

  223.         queue_init(&test_queue);
    


  224. 

  225.         for(i = 1;i < test_queue.buf_size/2;i ++) {
    

  226.                 queue_insert(&test_queue,(char)i);
    

  227.         }
    


  228. 

  229.         printf("====len:%d\n",queue_length(&test_queue));
    


  230. 

  231.         while(!queue_is_empty(&test_queue)) {
    

  232.                 item = queue_get_item(&test_queue);
    

  233.                 if(item != NULL) {
    

  234.                         printf("item:%d  ",*item);
    

  235.                 }
    

  236.         }
    


  237. 

  238.         printf("\n\n");
    


  239. 

  240.         int it = test_queue.buf_size/2;
    


  241. 

  242.         while(!queue_is_full(&test_queue)) {
    

  243.                 printf("insert:%d  ",it);
    

  244.                 queue_insert(&test_queue,(char)it);
    

  245.                 it ++;
    

  246.         }
    


  247. 

  248.         printf("\n\n");
    


  249. 

  250.         printf("====len:%d\n",queue_length(&test_queue));
    


  251. 

  252.         queue_insert_frame(&test_queue,tbuf,200);
    

  253.         
    

  254.         printf("==++++==len:%d\n",queue_length(&test_queue));
    


  255. 

  256.         while(!queue_is_empty(&test_queue)) {
    

  257.                 item = queue_get_item(&test_queue);
    

  258.                 if(item != NULL) {
    

  259.                         printf("item:%d  ",*item);
    

  260.                 }
    

  261.         }
    


  262. 

  263.         printf("==----==len:%d\n",queue_length(&test_queue));
    

  264.         
    

  265. }
    


  266. 


  267. 


  268. 


  269.


回复

收藏 举报

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

本版积分规则

keer_zu
个人签名：qq群：49734243 Email:zukeqiang@gmail.com

1488

主题

12949

帖子

55

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