关于RT-thread 消息队列的一些疑问

发布于 2024-08-16 14:32:05 浏览：281 订阅该版

#1消息队列初始化时的msg_size参数含义

```c
rt_err_t rt_mq_init(rt_mq_t mq, const char* name,
                        void *msgpool, rt_size_t msg_size,
                        rt_size_t pool_size, rt_uint8_t flag);
```

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20240816/7e30de73d9848b24e6ad3ce1a0118e39.png.webp)

我的的消息结构体是这样的，每次传递一个消息send_data[]大于2个字节，为什么消息还能发送并接收成功？

```c
typedef struct {
    ID_t eDataID;
    rt_uint32_t lDataValue;
}Data_t;
/*  定义 2 个结构体 */
static const Data_t send_data[2] =
{
        {eMotorSpeed, 10}, // CAN 线程发送的数据
        {eSpeedSetPoint, 500} // HMI 线程
};
```

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20240816/a00a9cdf75a288b37ab94cdf2660db14.png.webp)

#2关于线程接收问题

源码见最后。接收线程是一个没有问题，若两个线程分别接收CAN数据和HMI数据，假如CAN接收数据线程的优先级高于HMI线程的话，那么CAN线程会有限读取消息队列中的数据，若读到的HMI的数据，那么这一个HMI的数据是不是就被丢掉了，因为读取消息队列中的数据时，它的head指针会变化。

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20240816/029fb63a178ef2cd13769561557442cf.png.webp)

#源码

```c
/*
 * Copyright (c) 2006-2024, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2024-08-15     RT-Thread    first version
 */

#include <rtthread.h>

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

#define THREAD_PRIORITY         25
#define THREAD_STACK_SIZE       512
#define THREAD_TIMESLICE        5

static rt_thread_t thread1;
static rt_thread_t thread2;
static rt_thread_t thread3;
//static rt_thread_t thread4;

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

/*  定义 2 种数据来源 (ID) */
typedef enum
{
    eMotorSpeed,
    eSpeedSetPoint
} ID_t;
/*  定义在消息队列中传输的数据的格式 */
typedef struct {
    ID_t eDataID;
    rt_uint32_t lDataValue;
}Data_t;
/*  定义 2 个结构体 */
static const Data_t send_data[2] =
{
        {eMotorSpeed, 10}, // CAN 线程发送的数据
        {eSpeedSetPoint, 500} // HMI 线程
};

/*  线程 1 的入口函数 */
static void thread1_entry(void *parameter)
{
    int result;
    Data_t *buf = parameter;
    while(1)
    {
        /*  发送消息 */
        result = rt_mq_send(&mq, buf, sizeof(buf));
        if (result == RT_EFULL)
        {
            rt_kprintf("rt_mq_send FULL\n");
        }
        else if(result ==RT_ERROR)
        {

rt_kprintf("rt_mq_send ERR\n");
        }
        rt_thread_mdelay(20);
    }
}

/*  线程 3 的入口函数 */
static void thread3_entry(void *parameter)
{
    Data_t buf;
        while(1)
        {
            /*  接收消息 */
            if (rt_mq_recv(&mq, &buf, sizeof(buf), RT_WAITING_FOREVER) == RT_EOK)
            {
               if(buf.eDataID == eSpeedSetPoint)
                {
                    rt_kprintf("From HMI = %d\r\n", buf.lDataValue);
                }
               ////若只用一个接收线程这里打开，若开启thread4,这里屏蔽
               else if(buf.eDataID == eMotorSpeed)
               {
                   rt_kprintf("From CAN =%d\r\n", buf.lDataValue);
               }
            }
            rt_thread_mdelay(10);
        }
}

///*  线程 4 的入口函数 */
//static void thread4_entry(void *parameter)
//{
//    Data_t buf;
//
//        while(1)
//        {
//            /*  接收消息 */
//            if (rt_mq_recv(&mq, &buf, sizeof(buf), RT_WAITING_FOREVER) == RT_EOK)
//            {
//                if(buf.eDataID == eMotorSpeed)
//                {
//                    rt_kprintf("From CAN =%d\r\n", buf.lDataValue);
//                }
//
//            }
//            rt_thread_mdelay(10);
//        }
//}
int main(void)
{
    rt_err_t result;
    /*  初始化消息队列 */
    result = rt_mq_init(&mq, // 消息队列对象的句柄
                        "mqt", // 消息队列的名字
                         &msg_pool[0], // 内存池指向 msg_pool
                         2, // 每个消息的大小是 1 字节
                         sizeof(msg_pool), // 内存池的大小是 msg_pool 的大小
                         RT_IPC_FLAG_FIFO); // 如果有多个线程等待，按照先来先得到的方法分配消息
    if (result != RT_EOK)
    {
        rt_kprintf("rt_mq_init ERR\n");
        return -1;
    }
    /*  创建动态线程 thread1 ，优先级为 THREAD_PRIORIT = 15 */
    thread1 = rt_thread_create("thread1", // 线程名字
                                thread1_entry, // 入口函数
                                (void *)&send_data[0], // 入口 函数参数
                                THREAD_STACK_SIZE, // 栈大小
                                THREAD_PRIORITY, // 线程优先级
                                THREAD_TIMESLICE); // 线程时间片大小
    /*  判断创建结果 , 再启动线程 1 */
    if (thread1 != RT_NULL)
        rt_thread_startup(thread1);
    /*  创建动态线程 thread2 ，优先级为 THREAD_PRIORIT = 15 */
    thread2 = rt_thread_create("thread2", // 线程名字
                                thread1_entry, // 入口函数
                                (void *)&send_data[1], // 入口函数参数
                                THREAD_STACK_SIZE, // 栈大小
                                THREAD_PRIORITY, // 线程优先级
                                THREAD_TIMESLICE); // 线程时间片大小
    /*  判断创建结果 , 再启动线程 2 */
    if (thread2 != RT_NULL)
        rt_thread_startup(thread2);
    /*  创建动态线程 thread3 ，优先级为 THREAD_PRIORIT+1 = 16 */
    thread3 = rt_thread_create("thread3", // 线程名字
                                thread3_entry, // 入口函数
                                RT_NULL, // 入口函数参数
                                THREAD_STACK_SIZE, // 栈大小
                                THREAD_PRIORITY + 1, // 线程优先级
                                THREAD_TIMESLICE); // 线程时间片大小
    /*  判断创建结果 , 再启动线程 3 */
    if (thread3 != RT_NULL)
        rt_thread_startup(thread3);

//    /*  创建动态线程 thread3 ，优先级为 THREAD_PRIORIT+1 = 16 */
//       thread4 = rt_thread_create("thread4", // 线程名字
//                                   thread4_entry, // 入口函数
//                                   RT_NULL, // 入口函数参数
//                                   THREAD_STACK_SIZE, // 栈大小
//                                   THREAD_PRIORITY - 2, // 线程优先级
//                                   THREAD_TIMESLICE); // 线程时间片大小
//       /*  判断创建结果 , 再启动线程 4 */
//       if (thread4 != RT_NULL)
//           rt_thread_startup(thread4);

return 0;
}
```