51单片机

通用队列及其应用

2020-03-07 17:53发布

站内问答 / 51单片机
9308 11 11
本帖最后由 会笑的星星 于 2020-1-8 20:09 编辑

队列在我们编程的过程中经常会使用到，有时候一个项目中可能会使用多个不同的队列，为此我们可能需要编写多个针对不同队列的代码。虽然不同队列的数据内容、数据长度各不相同，但是出队与入队之类的操作却是一模一样的。因此，如果我们只是因为存储的内容或者长度不一样而编写多个不同的队列操作代码就会出现很多重复代码。为此，我设计了一个通用队列，仅使用一组接口就能操作多个不同的队列，而且具有比较好的适用性。
先上代码，再举几个例子。由于代码并不复杂，我只做了一些简单的注释，如果有不明白请提问。
  1. //app_queue.h

  3. #ifndef _APP_QUEUE_
  4. #define _APP_QUEUE_

  6. //#include "stdint.h"

  8. typedef unsigned char uint8_t;
  9. typedef unsigned int uint16_t;

  11. typedef enum
  12. {
  13.   Q_NONE,
  14.   Q_NON_NONE,
  15.   Q_S_NONE,
  16.   Q_S_OK,
  17. }Q_status_t;

  19. //如果你的队列很长，或者队列中每个元素占用的字节较多，最好把q_t的类型改为uint16_t.
  20. //原则上：当队列长度*队列中一个元素所占用的字节数量 小于 256时，q_t的类型使用uint8_t即可.
  21. //             当队列长度*队列中一个元素所占用的字节数量 大于 255时，q_t的类型必须使用uint16_t.
  22. typedef uint8_t q_t;
  23. typedef q_t *pq_t;

  25. typedef uint8_t *pq_data_t;

  27. typedef struct
  28. {
  29.   q_t head;
  30.   q_t end;
  31.   q_t q_len;
  32. }pos_t;

  34. //函数功能:初始化队列.
  35. //p_q      : 队列指针
  36. //q_max    : 队列元素个数
  37. //a_size   : 队列中一个元素的字节数量
  38. void app_queue_init(pq_t p_q, q_t q_max,uint8_t a_size);

  40. //函数功能:入队操作，将p_src指向的数据以及其后a_size个字节数据入队.
  41. void app_enqueue(pq_t p_q, pq_data_t p_src, uint8_t a_size);

  43. //函数功能:出队操作，从p_q指向的队列弹出一个元素，这个元素的首地址
  44. //         保存在p_des中，这个元素的字节数量为a_size.
  45. void app_dequeue(pq_t p_q, pq_data_t p_des, uint8_t a_size);

  47. //函数功能:判断队列是否为空.

  49. //函数返回: Q_NONE      --- 表示队列为空
  50. //          Q_NON_NONE  --- 表示队列非空
  51. uint8_t app_queue_none(pq_t p_q);

  53. //函数功能:判断p_q指向的队列中是否存在与目标元素相同的元素,如果有
  54. //         返回Q_S_OK,否则返回Q_S_NONE.
  55. //         所谓的目标元素,指的是p_src指向,大小为a_size的一个数据块

  57. //函数返回:Q_S_NONE --- 不相同
  58. //         Q_S_OK --- 相同
  59. uint8_t app_queue_search(pq_t p_q, pq_data_t p_src, uint8_t a_size);

  61. //函数功能:清空队列.
  62. void app_queue_clr(pq_t p_q);


  65. #endif
复制代码
  1. //app_queue.c

  3. #include "app_queue.h"
  4. #include "string.h"

  6. void app_queue_init(pq_t p_q, q_t q_max,uint8_t a_size)
  7. {
  8.   pos_t p;
  9.   uint8_t len;

  11.   len = sizeof(pos_t);
  12.   
  13.   memcpy(&p, p_q, len);
  14.   p.q_len = a_size * q_max;
  15.   memcpy(p_q, &p, len);
  16. }

  18. void app_queue_clr(pq_t p_q)
  19. {
  20.   pos_t p;
  21.   uint8_t len;

  23.   len = sizeof(pos_t);
  24.   
  25.   memcpy(&p, p_q, len);
  26.   p.end = 0;
  27.   p.head = 0;
  28.   memcpy(p_q, &p, len);
  29. }

  31. unsigned char app_queue_none(pq_t p_q)
  32. {
  33.   pos_t p;

  35.   memcpy(&p, p_q, sizeof(pos_t));

  37.   if(p.head == p.end)
  38.   {
  39.     return Q_NONE;
  40.   }
  41.   
  42.   return Q_NON_NONE;
  43. }

  45. void app_enqueue(pq_t p_q, pq_data_t p_src, uint8_t a_size)
  46. {
  47.   pos_t p;
  48.   uint8_t len;

  50.   len = sizeof(pos_t);

  52.   memcpy(&p, p_q, len);
  53.   
  54.   if(p.head == (p.end + a_size) % p.q_len)
  55.   {
  56.     return ;
  57.   }

  59.   memcpy((uint8_t *)(p_q+3)+p.end, p_src, a_size);
  60.   p.end = (p.end + a_size) % p.q_len;

  62.   memcpy(p_q, &p, len);
  63. }

  65. void app_dequeue(pq_t p_q, pq_data_t p_des, uint8_t a_size)
  66. {
  67.   pos_t p;
  68.   uint8_t len;

  70.   len = sizeof(pos_t);
  71.   memcpy(&p, p_q, len);
  72.    
  73.   if(p.head == p.end)
  74.   {
  75.     return ;
  76.   }

  78.   memcpy(p_des, (uint8_t *)(p_q+3)+p.head, a_size);
  79.   p.head = (p.head + a_size) % p.q_len;   
  80.   
  81.   memcpy(p_q, &p, len);
  82. }

  84. uint8_t app_queue_search(pq_t p_q, pq_data_t p_src, uint8_t a_size)
  85. {
  86.   pos_t p;
  87.   uint8_t *ps,*pt,*pm;
  88.   uint8_t i;

  90.   memcpy(&p, p_q, sizeof(pos_t));
  91.   
  92.   ps = (uint8_t *)(p_q+3);

  94.   while(p.head != p.end)
  95.   {
  96.     pt = ps + p.head;
  97.     pm = p_src;
  98.         
  99.     for(i = 0; i < a_size; i++)
  100.     {
  101.        if(*pt++ != *pm++) break;
  102.     }
  103.         
  104.     if(i == a_size)
  105.     {
  106.       return Q_S_OK;
  107.     }
  108.     else
  109.     {
  110.        p.head += a_size;
  111.        if(p.head >= p.q_len)
  112.        {
  113.          p.head = 0;               
  114.        }
  115.     }
  116.   }
  117.   
  118.   return Q_S_NONE;
  119. }
复制代码应用例子：
  1. #include "app_queue.h"

  3. #define D_Q_MAX 10
  4. #define R_Q_MAX 20

  6. typedef struct
  7. {
  8.    uint8_t mac[4];
  9.    uint8_t type;
  10.   uint8_t event;
  11.   uint8_t extend1;
  12. }dev_evt_t;

  14. typedef struct
  15. {
  16. //注意：在定义队列时，首先需要定义一个pos_t类型的变量，这个变量是一个占位变量，
  17. //应用者只需要定义它，不需要对它操作。pos_t定义好后，紧接着定义你的队列。
  18.   pos_t pos;
  19.   dev_evt_t d_q[D_Q_MAX];
  20. }dev_q_t;

  22. typedef struct
  23. {
  24.   pos_t pos;
  25.   uint16_t h_q[R_Q_MAX];
  26. }rx_q_t;

  28. dev_q_t dev_q;
  29. rx_q_t rx_q;

  31. main()
  32. {
  33.   //初始化队列dev_q
  34.   app_queue_init((pq_t)&dev_q, D_Q_MAX, sizeof(dev_evt_t));

  36.   //数据
  37.   dev_evt_t dev,dev_read;
  38.   dev.mac[0] = 0x01;
  39.   dev.mac[1] = 0x02;
  40.   dev.mac[2] = 0x03;
  41.   dev.mac[3] = 0x04;
  42.   dev.type = 0x06;
  43.   dev.event = 0x07;

  45.   //搜索队列中是否有重复数据，如果有，新的数据不会压入队列
  46.   if(app_queue_search((pq_t)&dev_q,(pq_data_t)&dev, sizeof(dev_evt_t)) == Q_S_NONE)
  47.   {
  48.     dev_evt_t dev;
  49.     dev.mac[0] = 0x01;
  50.     dev.mac[1] = 0x02;
  51.     dev.mac[2] = 0x03;
  52.     dev.mac[3] = 0x04;
  53.     dev.type = 0x06;
  54.     dev.event = 0x07;
  55.     //把数据压入队列。注意，不要忘记了地址符。
  56.     app_enqueue((pq_t)&dev_q, (pq_data_t)&dev, sizeof(dev_evt_t));
  57.   }
  58.   
  59.   //出队
  60.   app_dequeue((pq_t)&dev_q, (pq_data_t)&dev_read, sizeof(dev_evt_t));
  61.   if(dev_read.type == 0x06 && dev_read.event == 0x07)
  62.   {
  63.     //这样做没有任何意义，这里只做为例子展示
  64.   }
  65.   
  66.   //同理，针对队列rx_q的操作与上述类似
  67.   //初始化队列rx_q
  68.   app_queue_init((pq_t)&rx_q, R_Q_MAX, sizeof(uint16_t));  
  69.   
  70.   uint16_t rx_evt,evt_read;
  71.   rx_evt = 0xff01;
  72.   //入队
  73.   app_enqueue((pq_t)&rx_q, (pq_data_t)&rx_evt, sizeof(uint16_t));
  74.   //出队
  75.   app_dequeue((pq_t)&rx_q, (pq_data_t)&evt_read, sizeof(uint16_t));
  76.   
  77.   if(evt_read == 0xff01)
  78.   {
  79.      
  80.   }
  81. }
复制代码这个队列是经过实际检验的，所以如果你想用在自己的项目中，请放心使用，最后附上源码文件。
app_queue.zip (1.46 KB, 下载次数: 12) 2020-1-8 19:07 上传 点击文件名下载附件


友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
11条回答
会笑的星星
2020-03-08 15:51
本帖最后由 会笑的星星 于 2020-1-9 09:50 编辑
llllll008 发表于 2020-1-9 08:11
有什么项目，是会用到队列的，我几乎没有遇到过要用队列的项目

需要处理非常多的并行事件的项目基本都用得着。比如一个主控设备管理者几十个甚至上百个从设备的项目就需要。

一周热门 更多>