嵌入式通信艺术：RT-Thread消息队列设计与实现详解

文章总结（帮你们节约时间）

• RT-Thread消息队列提供了线程间异步通信机制，通过复制而非引用传递数据，确保了数据独立性和安全性。
• 消息队列API包括创建/删除、初始化/脱离、发送/接收等功能，支持普通消息、紧急消息和等待发送，适应不同应用场景。
• 在STM32F103平台上，消息队列可用于构建模块化、松耦合的系统架构，实现输入处理、命令控制和数据传输等功能。
• 优化消息队列性能需考虑消息大小、队列长度、内存管理和实时性需求，针对资源受限的嵌入式系统提供高效通信解决方案。

在嵌入式实时操作系统开发中，线程间通信是一个至关重要的概念，而消息队列则是实现这种通信最强大且灵活的方式之一。想象一下，如果线程是工厂中的工人，那消息队列就像是一条传送带，源源不断地将数据从一个工位传递到另一个工位，实现高效协同工作。今天，我们将深入探讨RT-Thread中消息队列的工作原理、实现方式和应用场景，让你彻底掌握这一重要的通信机制。

消息队列概述

消息队列是RT-Thread提供的一种异步通信机制，允许线程、中断服务例程之间传递可变长度的消息。如果把操作系统比作一个城市，那消息队列就像是城市中的物流系统，将各种"包裹"(消息)精确地从发送者送达到接收者手中。

为什么我们需要消息队列呢？想象一下这样的场景：一个线程负责采集传感器数据，另一个线程负责处理这些数据。如果没有消息队列，这两个线程之间的数据传递将变得非常复杂，可能需要使用全局变量或其他方式，这不仅增加了耦合度，还可能引入竞态条件。而消息队列提供了一种优雅的解决方案，使数据传递变得简单、可靠且线程安全。

消息队列工作机制

RT-Thread中的消息队列实现了一种先进先出(FIFO)的数据结构，类似于我们日常生活中排队的概念 —— 先来的人先被服务。当发送线程将消息放入队列时，消息被复制到队列的存储区；当接收线程从队列中获取消息时，消息被从队列复制到接收线程的缓冲区。

消息队列的这种"复制而非引用"的传递方式确保了数据的安全性和独立性。就像你把一份文件复印给同事，而不是把原件给他，这样你们两个人就可以各自独立地处理各自的副本，不会相互干扰。

消息队列还提供了阻塞机制：当队列为空时，接收线程可以选择等待；当队列已满时，发送线程也可以选择等待。这种机制使得消息队列成为线程同步的有效工具。

消息队列控制块

在RT-Thread中，消息队列由struct rt_messagequeue结构体表示：

struct rt_messagequeue
{
   
   
    struct rt_ipc_object parent;       /* 继承自IPC对象 */
    void                *msg_pool;     /* 消息队列的消息缓冲区 */
    rt_uint16_t          msg_size;     /* 每个消息的大小 */
    rt_uint16_t          max_msgs;     /* 消息队列能容纳的最大消息数 */
    rt_uint16_t          entry;        /* 当前消息队列中的消息数 */
    void                *msg_queue_head; /* 消息链表头 */
    void                *msg_queue_tail; /* 消息链表尾 */
    void                *msg_queue_free; /* 空闲消息链表 */
};

这个结构体包含了消息队列的所有重要信息，如消息池指针、消息大小、最大消息数等。理解这个结构体对于深入理解消息队列的工作原理至关重要。

消息队列管理函数

RT-Thread提供了一系列API用于创建、发送、接收和删除消息队列。让我们详细了解这些函数的用法和实现原理。

创建和删除消息队列

要使用消息队列，首先需要创建一个。RT-Thread提供了以下函数用于创建消息队列：

rt_mq_t rt_mq_create(const char* name, rt_size_t msg_size, rt_size_t max_msgs, rt_uint8_t flag);

这个函数的参数包括：

参数名	类型	描述
name	const char*	消息队列的名称
msg_size	rt_size_t	每条消息的大小(字节)
max_msgs	rt_size_t	消息队列中最大消息数量
flag	rt_uint8_t	队列标志，RT_IPC_FLAG_FIFO表示FIFO方式或RT_IPC_FLAG_PRIO表示按优先级方式唤醒线程

当不再需要消息队列时，可以使用以下函数将其删除：

rt_err_t rt_mq_delete(rt_mq_t mq);

这个函数会释放所有与消息队列关联的资源，包括消息队列控制块和消息缓冲区。如果有线程阻塞在这个消息队列上，它们会被唤醒并收到RT_ERROR错误码。

初始化和脱离消息队列

除了动态创建，RT-Thread还支持静态消息队列初始化：

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);

这个函数适用于那些需要在编译时确定消息队列内存分配的场景。与动态创建不同，静态初始化不会从堆中分配内存，而是使用用户提供的内存块。

当静态初始化的消息队列不再需要时，可以使用以下函数将其脱离：

rt_err_t rt_mq_detach(rt_mq_t mq);

这个函数不会释放消息队列的内存(因为它是静态分配的)，但会将消息队列从内核对象管理器中移除。

发送消息

RT-Thread提供了多种方式发送消息到消息队列：

rt_err_t rt_mq_send(rt_mq_t mq, void* buffer, rt_size_t size);

这个函数用于向消息队列发送普通消息。如果队列已满，函数会立即返回RT_EFULL错误码。

rt_err_t rt_mq_send_wait(rt_mq_t mq, void* buffer, rt_size_t size, rt_int32_t timeout);

与上一个函数不同，这个函数在队列满时会等待指定的超时时间，直到有空间可用或超时发生。

rt_err_t rt_mq_urgent(rt_mq_t mq, void* buffer, rt_size_t size);

紧急消息会被放在队列的前端，而不是尾端，这样可以优先处理重要的消息。这就像有人插队一样，但这种"插队"是合法且必要的！

接收消息

接收消息是通过以下函数完成的：

rt_err_t rt_mq_recv(rt_mq_t mq, void* buffer, rt_size_t size, rt_int32_t timeout);

这个函数从消息队列中接收一条消息。如果队列为空，函数可以选择阻塞等待指定的超时时间。

消息队列内部实现

现在，让我们深入了解消息队列的内部实现。消息队列的核心是一个环形缓冲区，类似于一个固定大小的"圆桌"，消息被依次放在这个"圆桌"上。当表满时，新的消息必须等待，直到有旧消息被消费掉。

消息存储结构

在RT-Thread中，消息队列使用一个链表结构来管理消息。每个消息包含两部分：消息头和消息体。消息头用于链表连接，而消息体则包含实际的数据。

当创建消息队列时，系统会分配一块连续的内存作为消息池，并将其划分为多个消息块。这些消息块一开始都在空闲链表上，当消息被发送时，一个空闲块会被移到消息队列的尾部。当消息被接收时，队列头部的消息会被移回空闲链表。

这种设计使得消息队列的操作非常高效，只需要简单的指针操作即可完成消息的添加和删除。

线程同步机制

消息队列不仅仅是一个数据结构，它还包含了线程同步机制。当线程试图从空队列接收消息时，它会被阻塞并放入等待链表；当有新消息到达时，等待链表上的线程会被唤醒。

同样，当线程试图向满队列发送消息时，它也可能被阻塞，直到有空间可用。这种机制确保了数据传输的可靠性和效率。

消息队列应用示例

让我们通过一个具体示例来看看如何使用消息队列进行线程间通信。以下是一个简单的生产者-消费者模型：

#include <rtthread.h>

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

ALIGN(RT_ALIGN_SIZE)
static char producer_stack[1024];
static struct rt_thread producer_thread;

/* 生产者线程入口 */
static void producer_thread_entry(void *parameter)
{
   
   
    int i = 0;
    char msg_str[20];

    while (1)
    {
   
   
        /* 构建消息 */
        rt_snprintf(msg_str, sizeof(msg_str), "message %d", i++);
        
        /* 发送消息到消息队列 */
        if (rt_mq_send(&mq, msg_str, sizeof(msg_str)) != RT_EOK)
        {
   
   
            rt_kprintf("消息队列已满，发送失败！\n");
        }
        else
        {
   
   
            rt_kprintf("生产者：发送 %s\n", msg_str);
        }
        
        /* 延时1秒 */
        rt_thread_mdelay(1000);
    }
}

ALIGN(RT_ALIGN_SIZE)
static char consumer_stack[1024];
static struct rt_thread consumer_thread;

/* 消费者线程入口 */
static void consumer_thread_entry(void *parameter)
{
   
   
    char msg_str[20];

    while (1)
    {
   
   
        /* 从消息队列中接收消息 */
        if (rt_mq_recv(&mq, msg_str, sizeof(msg_str), RT_WAITING_FOREVER) == RT_EOK)
        {
   
   
            rt_kprintf("消费者：接收 %s\n", msg_str);
        }
        
        /* 延时2秒，模拟处理消息的时间 */
        rt_thread_mdelay(2000);
    }
}

/* 消息队列示例初始化 */
int messagequeue_sample(void)
{
   
   
    rt_err_t result;

    /* 初始化消息队列 */
    result = rt_mq_init(&mq,
                        "mqt",
                        &msg_pool[0],          /* 内存池指向msg_pool */
                        20,                    /* 每条消息的大小为20字节 */
                        sizeof(msg_pool),      /* 内存池的大小是msg_pool的大小 */
                        RT_IPC_FLAG_FIFO);     /* 如果有多个线程等待，按FIFO方式分配消息 */

    if (result != RT_EOK)
    {
   
   
        rt_kprintf("初始化消息队列失败。\n");
        return -1;
    }

    /* 初始化生产者线程 */
    rt_thread_init(&producer_thread,
                   "producer",
                   producer_thread_entry,
                   RT_NULL,
                   &producer_stack[0],
                   sizeof(producer_stack),
                   10, 5);
    rt_thread_startup(&producer_thread);

    /* 初始化消费者线程 */
    rt_thread_init(&consumer_thread,
                   "consumer",
                   consumer_thread_entry,
                   RT_NULL,
                   &consumer_stack[0],
                   sizeof(consumer_stack),
                   10, 5);
    rt_thread_startup(&consumer_thread);

    return 0;
}

/* 导出到msh命令列表 */
MSH_CMD_EXPORT(messagequeue_sample, message queue sample)