rt_mq_消息队列_msg_queue

rt_msgqueue rt_mq_recv()接收卡死

发布于 2025-07-25 15:29:33 浏览：146 订阅该版

[tocm]

# 在使用消息队列rt_mq_recv时候卡死

```c
static struct rt_messagequeue TX_CanMsg_mq;

__attribute__((aligned (4))) __attribute__((section("EXRAM"))) rt_uint8_t RX_CanMsg_pool[sizeof(can_app_msg_t) * 50];
__attribute__((aligned (4))) __attribute__((section("EXRAM"))) rt_uint8_t TX_CanMsg_pool[sizeof(can_app_msg_t) * 50];

//initial code
int can_app_init()
{
    rt_err_t res;

res = rt_mq_init(&TX_CanMsg_mq,
                     "tx_can_mq",             
                     &TX_CanMsg_pool[0],              
                     sizeof(can_app_msg_t),       
                     sizeof(TX_CanMsg_pool),           */
                     RT_IPC_FLAG_FIFO);

return res;
}
//产生canframe 放入消息队列
static int can_tx_frame(uint32_t ID, uint8_t* data, uint8_t len)
{

can_app_msg_t canapp_msg;
    canapp_msg.canid = ID;
    rt_memcpy(canapp_msg.data, data, len);
    return rt_mq_send(&TX_CanMsg_mq, &canapp_msg, sizeof(can_app_msg_t));
    //return can_write(&canapp_msg);
}

//从消息队列取出数据并发送
static void can_tx_thread(void* parameter)
{
    int i;
    int ret = 0;
    can_app_msg_t can_app_msg;

while(1)
    {
        if(rt_mq_recv(&TX_CanMsg_mq, &can_app_msg, sizeof(can_app_msg_t), 0) > 0)//一旦can线中途断开，发送被阻塞，这里就卡死在这里整个线程阻塞
        {
            i = 0;
            do
            {
                ret = can_write(&can_app_msg);
                i++;
            }
            while(i < 10 && ret);
        }
        else
        {
			rt_thread_mdelay(100);
		}
    }
}

```
暂时没看出来为啥卡死，调试时候发现消息队列一旦满了，就会卡死

1 个回答

用户名由3_15位 2025-07-26

代码总在「分分钟搞定」的狂喜与「必有暗坑」的隐忧间往复

Spring_Wang 2025-07-26

这家伙很懒，什么也没写！

用户名由3_15位 2025-07-27

代码总在「分分钟搞定」的狂喜与「必有暗坑」的隐忧间往复

用户名由3_15位 2025-07-27

代码总在「分分钟搞定」的狂喜与「必有暗坑」的隐忧间往复

用户名由3_15位 2025-07-27

代码总在「分分钟搞定」的狂喜与「必有暗坑」的隐忧间往复

Spring_Wang 2025-07-27

这家伙很懒，什么也没写！

Spring_Wang 2025-07-27

这家伙很懒，什么也没写！

用户名由3_15位 2025-07-28

代码总在「分分钟搞定」的狂喜与「必有暗坑」的隐忧间往复

用户名由3_15位 2025-07-28

代码总在「分分钟搞定」的狂喜与「必有暗坑」的隐忧间往复

[@Spring_Wang](https://club.rt-thread.org/u/f02dee22600e692f)

```c
#include <rtthread.h>

#define THREAD_PRIORITY_RECV   10
#define THREAD_PRIORITY_SEND   9  // 发送线程优先级稍高
#define THREAD_STACK_SIZE      4096 // 保持较大的栈空间
#define THREAD_TIMESLICE       5

// 消息队列控制块
static rt_mq_t test_mq = RT_NULL;

// 线程控制块
static rt_thread_t recv_thread = RT_NULL;
static rt_thread_t send_thread = RT_NULL;

// 消息队列相关定义
#define MQ_NAME       "mq_drain_test" // 新名称，意为“排空测试”
#define MQ_MAX_MSGS   50
#define MQ_MSG_SIZE   sizeof(rt_uint32_t)

/* 接收线程入口 (已修改) */
static void recv_thread_entry(void *parameter)
{
    rt_uint32_t received_data;
    rt_ssize_t recv_size;
    rt_uint32_t received_count = 0; // 新增：用于计数的变量

rt_kprintf("Receiver thread started.\n");

// 1. 阻塞自己，让发送线程先运行并填满队列
    rt_kprintf("Receiver thread is now blocking for 500 ticks...\n");
    rt_thread_mdelay(500);
    rt_kprintf("Receiver thread woke up, starting to drain the queue.\n");

// 2. 关键修改：使用循环来接收所有消息
    while (1)
    {
        // 使用非阻塞方式接收，如果队列为空，它会立即返回
        recv_size = rt_mq_recv(test_mq, &received_data, MQ_MSG_SIZE, RT_WAITING_NO);

if (recv_size == MQ_MSG_SIZE)
        {
            // 成功接收到一条消息
            rt_kprintf("Receiver got message: %u (total received: %u)\n", received_data, ++received_count);
        }
        else if (recv_size == -RT_ETIMEOUT)
        {
            // 这是预期的结果：当所有消息都被接收后，队列变空，recv会返回超时
            rt_kprintf("Receiver: Queue is empty now, which is expected.\n");
            break; // 成功排空队列，退出循环
        }
        else
        {
            // 发生了意外的错误
            rt_kprintf("Receiver: Unexpected error, recv returned %d.\n", recv_size);
            break; // 退出循环
        }
        rt_thread_mdelay(10);
    }

// 3. 最终验证
    if (received_count == MQ_MAX_MSGS)
    {
        rt_kprintf("Receiver test PASSED: Successfully received all %d messages.\n", MQ_MAX_MSGS);
    }
    else
    {
        rt_kprintf("Receiver test FAILED: Expected %d messages, but got %u.\n", MQ_MAX_MSGS, received_count);
    }
    rt_kprintf("Receiver thread finished.\n");
}

/* 发送线程入口 (保持不变) */
static void send_thread_entry(void *parameter)
{
    rt_uint32_t i;
    rt_err_t result;

rt_kprintf("Sender thread started.\n");

rt_kprintf("Sender thread is filling the message queue (size = %d)...\n", MQ_MAX_MSGS);
    for (i = 0; i < MQ_MAX_MSGS + 10; i++)
    {
        result = rt_mq_send(test_mq, &i, MQ_MSG_SIZE);
        if (result != RT_EOK)
        {
            rt_kprintf("Sender failed to send message %u, error: %d\n", i, result);
            return;
        }
        rt_kprintf("Sender sent: %u\n", i);
    }
    rt_kprintf("Message queue is now FULL.\n");
    rt_kprintf("Sender thread finished its job of filling the queue.\n");
}

/* 测试初始化函数 */
int mq_drain_queue_test(void)
{
    // 创建一个消息队列
    test_mq = rt_mq_create(MQ_NAME, MQ_MSG_SIZE, MQ_MAX_MSGS, RT_IPC_FLAG_FIFO);
    if (test_mq == RT_NULL)
    {
        rt_kprintf("Failed to create message queue.\n");
        return -1;
    }
     rt_kprintf("Message queue for drain test created successfully.\n");

// 创建接收线程
    recv_thread = rt_thread_create("recv_t", recv_thread_entry, RT_NULL,
                                   THREAD_STACK_SIZE, THREAD_PRIORITY_RECV, THREAD_TIMESLICE);
    if (recv_thread != RT_NULL)
    {
        rt_thread_startup(recv_thread);
    }
    else {
        rt_kprintf("Failed to create receiver thread.\n");
        return -1;
    }

// 创建发送线程
    send_thread = rt_thread_create("send_t", send_thread_entry, RT_NULL,
                                   THREAD_STACK_SIZE, THREAD_PRIORITY_SEND, THREAD_TIMESLICE);
    if (send_thread != RT_NULL)
    {
        rt_thread_startup(send_thread);
    } else {
        rt_kprintf("Failed to create sender thread.\n");
        return -1;
    }

return 0;
}

/* 导出到 MSH 控制台 */
MSH_CMD_EXPORT(mq_drain_queue_test, Test draining all messages from a full mq);
```

```log
 \ | /
- RT -     Thread Operating System
 / | \     5.2.1 build Jul 21 2025 09:13:13
 2006 - 2024 Copyright by RT-Thread team
msh >mq
mq_drain_queue_test
msh >mq_drain_queue_test
Message queue for drain test created successfully.
Receiver thread started.
Receiver thread is now blocking for 500 ticks...
Sender thread started.
Sender thread is filling the message queue (size = 50)...
Sender sent: 0
Sender sent: 1
Sender sent: 2
Sender sent: 3
Sender sent: 4
Sender sent: 5
Sender sent: 6
Sender sent: 7
Sender sent: 8
Sender sent: 9
Sender sent: 10
Sender sent: 11
Sender sent: 12
Sender sent: 13
Sender sent: 14
Sender sent: 15
Sender sent: 16
Sender sent: 17
Sender sent: 18
Sender sent: 19
Sender sent: 20
Sender sent: 21
Sender sent: 22
Sender sent: 23
Sender sent: 24
Sender sent: 25
Sender sent: 26
Sender sent: 27
Sender sent: 28
Sender sent: 29
Sender sent: 30
Sender sent: 31
Sender sent: 32
Sender sent: 33
Sender sent: 34
Sender sent: 35
Sender sent: 36
Sender sent: 37
Sender sent: 38
Sender sent: 39
Sender sent: 40
Sender sent: 41
Sender sent: 42
Sender sent: 43
Sender sent: 44
Sender sent: 45
Sender sent: 46
Sender sent: 47
Sender sent: 48
Sender sent: 49
Sender failed to send message 50, error: -28
msh >Receiver thread woke up, starting to drain the queue.
Receiver got message: 0 (total received: 1)
Receiver got message: 1 (total received: 2)
Receiver got message: 2 (total received: 3)
Receiver got message: 3 (total received: 4)
Receiver got message: 4 (total received: 5)
Receiver got message: 5 (total received: 6)
Receiver got message: 6 (total received: 7)
Receiver got message: 7 (total received: 8)
Receiver got message: 8 (total received: 9)
Receiver got message: 9 (total received: 10)
Receiver got message: 10 (total received: 11)
Receiver got message: 11 (total received: 12)
Receiver got message: 12 (total received: 13)
Receiver got message: 13 (total received: 14)
Receiver got message: 14 (total received: 15)
Receiver got message: 15 (total received: 16)
Receiver got message: 16 (total received: 17)
Receiver got message: 17 (total received: 18)
Receiver got message: 18 (total received: 19)
Receiver got message: 19 (total received: 20)
Receiver got message: 20 (total received: 21)
Receiver got message: 21 (total received: 22)
Receiver got message: 22 (total received: 23)
Receiver got message: 23 (total received: 24)
Receiver got message: 24 (total received: 25)
Receiver got message: 25 (total received: 26)
Receiver got message: 26 (total received: 27)
Receiver got message: 27 (total received: 28)
Receiver got message: 28 (total received: 29)
Receiver got message: 29 (total received: 30)
Receiver got message: 30 (total received: 31)
Receiver got message: 31 (total received: 32)
Receiver got message: 32 (total received: 33)
Receiver got message: 33 (total received: 34)
Receiver got message: 34 (total received: 35)
Receiver got message: 35 (total received: 36)
Receiver got message: 36 (total received: 37)
Receiver got message: 37 (total received: 38)
Receiver got message: 38 (total received: 39)
Receiver got message: 39 (total received: 40)
Receiver got message: 40 (total received: 41)
Receiver got message: 41 (total received: 42)
Receiver got message: 42 (total received: 43)
Receiver got message: 43 (total received: 44)
Receiver got message: 44 (total received: 45)
Receiver got message: 45 (total received: 46)
Receiver got message: 46 (total received: 47)
Receiver got message: 47 (total received: 48)
Receiver got message: 48 (total received: 49)
Receiver got message: 49 (total received: 50)
Receiver: Queue is empty now, which is expected.
Receiver test PASSED: Successfully received all 50 messages.
Receiver thread finished.
```