消息队列使用与C++使用

发布于 2021-09-30 13:34:56 浏览：1347 订阅该版

1. 使用C++的rtthread::Queue队列
```c++
#include <rtthread.h>
#include <Queue.h>
#include <vector>

rtthread::Queue<std::vector<uint8_t>, 100> testQueue;

void printVector(const std::vector<uint8_t> &vec)
{
    for(const auto &v:vec)
    {
        rt_kprintf("%02X ", v);
    }
    rt_kprintf("\r\n");
}

void TestCppQueue()
{
   std::vector<uint8_t> testVec(0);
   for(uint16_t i=0; i<10; i++)
       testVec.emplace_back(i);
   testQueue.put(testVec, 5);
   testVec.clear();
/*  增加出队前对进队后的数据进行修改*/
//   for(uint16_t i=0; i<10; i++)
//       testVec.emplace_back(9-i);
//   testVec.clear();
   testQueue.get(testVec);
   printVector(testVec);

}

/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(TestCppQueue, test cpp message );
```
此时输出：
![微信截图_20210930113608.png](https://oss-club.rt-thread.org/uploads/20210930/50385ffb98cbeb176c4ac1c4ef50c36b.png)

在数据进队后，出队前，对已经进队的数据进行修改：
```c++
void TestCppQueue()
{
   std::vector<uint8_t> testVec(0);
   for(uint16_t i=0; i<10; i++)
       testVec.emplace_back(i);
   testQueue.put(testVec, 5);
   testVec.clear();
/*  增加出队前对进队后的数据进行修改*/
   for(uint16_t i=0; i<10; i++)
       testVec.emplace_back(9-i);
   testVec.clear();
   testQueue.get(testVec);
   printVector(testVec);

}
```
则输出：
![微信截图_20210930113626.png](https://oss-club.rt-thread.org/uploads/20210930/03ffaecaaf620c0ed18ae87793483ba3.png)
这跟预期的结果不一样。

2. 用C进行测试：
```c
#include <rtthread.h>

#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>

struct msg
{
    rt_uint8_t *data_ptr;    /* 数据块首地址 */
    rt_uint32_t data_size;   /* 数据块大小   */
};

/* 消息队列控制块 */
static struct rt_messagequeue mq;
/* 消息队列中用到的放置消息的内存池 */
static rt_uint8_t msg_pool[2048];

/* 消息队列示例的初始化 */
int MsgMqInit(void)
{
    static rt_uint8_t isInit = 0;
    if(isInit ==1)
        return 0;
    isInit = 1;

rt_err_t result;
    /* 初始化消息队列 */
    result = rt_mq_init(&mq, "mqt",
                           &msg_pool[0], /* 内存池指向 msg_pool */
                           16, /* 每个消息的大小是 1 字节 */
                           sizeof(msg_pool), /* 内存池的大小是 msg_pool 的大小 */
                           RT_IPC_FLAG_FIFO); /* 如果有多个线程等待，优先级大小的方法分配消息 */

if (result == RT_EOK)
        return 0;
    LOG_E("init message queue failed.\n");
    return -1;
}

void printData( rt_uint8_t *dataBuf, rt_uint16_t dataLen)
{
    for(rt_uint16_t i=0; i<dataLen; i++)
    {
        rt_kprintf("%02X ", dataBuf[i]);
    }
    rt_kprintf("\r\n");
}

void send_op(void *data, rt_size_t length)
{
    struct msg msg_ptr;

msg_ptr.data_ptr = data;  /* 指向相应的数据块地址 */
    msg_ptr.data_size = length; /* 数据块的长度 */

/* 发送这个消息指针给 mq 消息队列 */
    LOG_D("Send data Addr[%08X] dataLen[%d]", msg_ptr.data_ptr, msg_ptr.data_size);
    int result = rt_mq_send(&mq, (void*)&msg_ptr, sizeof(struct msg));
    if (result != RT_EOK)
    {
        LOG_E("rt_mq_send ERR[%d]\n", result);
    }
}
void sendData(rt_uint8_t *data, rt_size_t length)
{

/* 发送这个消息指针给 mq 消息队列 */
    LOG_D("Send data Addr[%08X] dataLen[%d]", data, length);
    int result = rt_mq_send(&mq, (void*)data, length);
    if (result != RT_EOK)
    {
        LOG_E("rt_mq_send ERR[%d]\n", result);
    }
}

void message_recive()
{
    rt_uint8_t recData[100] = {0};
    struct msg msg_ptr; /* 用于放置消息的局部变量 */
    /* 从消息队列中接收消息到 msg_ptr 中 */
    LOG_D("Receive data to msg");
    if (rt_mq_recv(&mq, (void*)&msg_ptr, sizeof(struct msg), RT_WAITING_FOREVER) == RT_EOK)
    {
        /* 成功接收到消息，进行相应的数据处理 */
        LOG_D("RecData Addr[%08X] dataLen[%d]", msg_ptr.data_ptr, msg_ptr.data_size);
        rt_memcpy(recData, msg_ptr.data_ptr, msg_ptr.data_size);
        printData(msg_ptr.data_ptr, msg_ptr.data_size);
    }
}

void message_recive2()
{
    rt_uint8_t recData[100] = {0};
    /* 从消息队列中接收消息到 msg_ptr 中 */
    LOG_D("Receive data to msg");
    if (rt_mq_recv(&mq, (void*)recData,10, RT_WAITING_FOREVER) == RT_EOK)
    {
        /* 成功接收到消息，进行相应的数据处理 */
        LOG_D("RecData Addr[%08X] dataLen[%d]", recData, 10);
        printData(recData, 10);
    }
}

void TestMsgQueue1()
{

MsgMqInit();
    rt_uint8_t testData[10] = {0,1,2,3,4,5,6,7,8,9};
    send_op(testData, 10);
    for(rt_uint8_t i=0; i<10; i++)
    {
        testData[i] = 9-i;
    }
    send_op(testData, 10);
    rt_memset(testData, 0, 10);
    message_recive();

}
void TestMsgQueue2()
{

MsgMqInit();
    rt_uint8_t testData[10] = {0,1,2,3,4,5,6,7,8,9};
    sendData(testData, 10);
    for(rt_uint8_t i=0; i<10; i++)
    {
        testData[i] = 9-i;
    }
    sendData(testData, 10);
    rt_memset(testData, 0, 10);
    message_recive2();

}

/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(TestMsgQueue1, test message sample);
MSH_CMD_EXPORT(TestMsgQueue2, test message sample2);
```

(1). 运行TestMsgQueue1 这个是以官方文档只发送地址的方式(《消息队列使用场合》章节)
(2). 运行TestMsgQueue2，其实结果
![微信截图_20210930114948.png](https://oss-club.rt-thread.org/uploads/20210930/1f8d4cd020db063c1fdbfdd28c1fb5a6.png)

TestMsgQueue1是错误的，对于这个错误，官方文档这样说明：
![微信截图_20210930115740.png](https://oss-club.rt-thread.org/uploads/20210930/b69d916afaa3087d5d95dc86c0f48314.png.webp)
这个是否可以认为，不需要别外开辟一段内存？不新开辟的话，就会有出错的风险？

运行TestMsgQueue2的结果是正确的，跟1.的c++实现方式基本一致为什么1有出错？