uCOS-II消息队列深度解析：让STM32F103在KEIL5环境下舞动任务通信的华尔兹-优快云博客

本文链接：https://blog.youkuaiyun.com/SlientICE/article/details/149278898

文章概述（帮你们节约时间）

掌握uCOS-II消息队列的核心原理，理解其在实时系统中的数据传输机制
深入了解消息队列的数据存储结构和多任务访问策略
学会消息队列的阻塞机制处理，包括出队和入队的各种情况
熟练掌握消息队列的常用API函数及其参数配置
通过实际案例掌握消息队列在STM32F103项目中的应用技巧

初探消息队列的神秘面纱

还记得小时候玩过的传话游戏吗？一个人在队首说悄悄话，一个个传下去，最后一个人说出来。uCOS-II的消息队列就像是这个游戏的高级版本，只不过参与者变成了各种任务，而且还有了严格的纪律！

想象一下，如果你是一个餐厅老板，厨师们（生产者任务）做好菜品后需要通知服务员（消费者任务）上菜。但问题来了：厨师做菜的速度不一样，服务员上菜的速度也不一样，怎么保证菜品不会搞混，不会丢失，还能按顺序处理？这就是消息队列要解决的问题！

uCOS-II消息队列作为一种进程间通信（IPC）机制，为任务之间的数据传输提供了一种既安全又高效的解决方案。它不仅仅是一个简单的数据容器，更是一个智能的任务协调器，能够处理复杂的同步问题。

消息队列的数据存储架构

队列的内部结构剖析

消息队列的数据存储可以说是一门艺术！它采用了经典的FIFO（First In First Out）结构，就像银行排队一样，先来的先服务。但是，这个"银行"可不简单，它有着精巧的内部设计。

在uCOS-II中，消息队列的核心数据结构是OS_Q，这个结构体包含了队列运行所需的全部信息：

typedef struct os_q {
    struct os_q    *OSQPtr;           // 指向下一个队列控制块的指针
    void          **OSQStart;         // 指向消息队列存储区开始位置的指针
    void          **OSQEnd;           // 指向消息队列存储区结束位置的指针
    void          **OSQIn;            // 指向消息队列中下一个插入消息的位置
    void          **OSQOut;           // 指向消息队列中下一个取出消息的位置
    INT16U         OSQSize;           // 队列的大小（能存储的消息数量）
    INT16U         OSQEntries;        // 当前队列中的消息数量
} OS_Q;

这个结构体就像是一个智能的仓库管理系统。OSQStart和OSQEnd定义了仓库的边界，OSQIn指向下一个货物应该放置的位置，OSQOut指向下一个应该取出货物的位置。而OSQSize告诉我们这个仓库总共能存多少货物，OSQEntries则实时统计着当前有多少货物在库。

环形缓冲区的奇妙世界

消息队列的存储区域实际上是一个环形缓冲区，这个设计简直是天才之作！为什么说它是环形的？想象一下一个圆形的跑道，运动员们一圈一圈地跑。当OSQIn指针走到队列末尾时，它会自动回到队列的开始位置，形成一个闭环。

这种设计的好处是什么？内存利用率最大化！传统的线性队列在使用过程中会产生内存碎片，而环形队列则完美解决了这个问题。当队列满了之后，如果有消息被取走，立即就有新的空间可以使用。

让我们看看这个环形缓冲区是如何工作的：

$下一个位置={当前位置+1如果当前位置<队列末尾队列开始位置如果当前位置=队列末尾\text{下一个位置} = \begin{cases} \text{当前位置} + 1 & \text{如果当前位置} < \text{队列末尾} \\ \text{队列开始位置} & \text{如果当前位置} = \text{队列末尾} \end{cases}$

这个公式描述了指针在环形缓冲区中的移动规律。每当我们需要移动指针时，都会检查是否到达了缓冲区的末尾，如果是，则将指针重置到开始位置。

消息存储的粒度控制

在uCOS-II中，消息队列存储的并不是消息本身，而是消息的指针！这是一个非常巧妙的设计。为什么不直接存储消息内容呢？

首先，存储指针可以节省大量的内存空间。试想一下，如果每次都要复制整个消息内容到队列中，那么对于大型数据结构来说，内存开销将是巨大的。而存储指针只需要4个字节（在32位系统中）或8个字节（在64位系统中）。

其次，存储指针可以避免不必要的内存拷贝操作。数据拷贝不仅消耗CPU时间，还可能导致缓存失效，影响系统性能。通过传递指针，我们实现了零拷贝的数据传输。

但是，这种设计也带来了一个重要的责任：消息的生命周期管理。发送消息的任务必须确保消息内容在接收任务处理完毕之前不会被销毁或修改。这就像是你借给朋友一本书，在他还没看完之前，你不能把书收回来或者涂改书的内容。

多任务访问的协调艺术

临界区保护机制

多任务访问消息队列就像是多个人同时使用一个公共资源，如果没有合适的协调机制，就会出现混乱。想象一下，如果两个任务同时尝试向队列中添加消息，或者一个任务正在添加消息的同时另一个任务正在移除消息，会发生什么？数据结构可能会被破坏，系统可能会崩溃！

uCOS-II使用了一种简单而有效的方法来解决这个问题：关中断。当一个任务需要访问消息队列时，它会暂时关闭中断，确保在操作期间不会被其他任务打断。这就像是在公共厕所里锁门一样，确保一次只有一个人可以使用。

OS_CPU_SR  cpu_sr;

OS_ENTER_CRITICAL();              // 关中断
// 对消息队列的操作
OS_EXIT_CRITICAL();               // 开中断

这种机制的优点是简单可靠，缺点是在关中断期间，系统无法响应其他中断请求。因此，uCOS-II的设计者们非常谨慎地控制了临界区的大小，确保关中断的时间尽可能短。

等待列表的管理策略

当多个任务同时等待同一个消息队列时，uCOS-II需要一种机制来管理这些等待的任务。这就是等待列表（Wait List）的作用。

等待列表就像是医院的挂号排队系统。当一个任务需要从空队列中获取消息时，它会被挂起并加入到等待列表中。当有新消息到达时，系统会按照一定的策略选择一个等待的任务来处理这个消息。

uCOS-II支持两种等待策略：

FIFO策略：按照任务等待的先后顺序来分配消息，就像银行排队一样
优先级策略：按照任务的优先级来分配消息，高优先级的任务优先获得消息

这种设计的巧妙之处在于它的灵活性。不同的应用场景可以选择不同的策略。对于公平性要求高的应用，可以选择FIFO策略；对于实时性要求高的应用，可以选择优先级策略。

出队阻塞的处理机制

阻塞的产生原因

出队阻塞是消息队列使用中最常见的情况之一。当一个任务尝试从空队列中获取消息时，它面临两个选择：立即返回错误，或者等待直到有消息可用。

这就像是你去餐厅吃饭，发现今天的招牌菜卖完了。你可以选择换一个菜（立即返回错误），或者等待厨师做好新的招牌菜（阻塞等待）。在实时系统中，这种选择往往取决于具体的应用需求。

阻塞等待的实现细节

当任务选择阻塞等待时，uCOS-II会执行以下步骤：

任务状态转换：将当前任务从就绪状态转换为等待状态
加入等待列表：将任务加入到消息队列的等待列表中
触发调度：调用调度器选择其他就绪任务运行
等待唤醒：当有消息可用时，任务会被唤醒并重新进入就绪状态

这个过程就像是一个精心编排的舞蹈。每个任务都知道自己的角色，知道什么时候该退场，什么时候该上场。

超时机制的智能设计

为了防止任务无限期地等待，uCOS-II提供了超时机制。任务可以指定一个最大等待时间，如果在这个时间内没有收到消息，任务会被自动唤醒并返回超时错误。

这个机制的数学模型可以表示为：

$T唤醒=min⁡(T消息到达,T当前+T超时)T_{\text{唤醒}} = \min(T_{\text{消息到达}}, T_{\text{当前}} + T_{\text{超时}})$

其中：

$T唤醒T_{\text{唤醒}}$ ：任务被唤醒的时间
$T消息到达T_{\text{消息到达}}$ ：消息到达的时间
$T当前T_{\text{当前}}$ ：当前时间
$T超时T_{\text{超时}}$ ：设定的超时时间

这个公式告诉我们，任务会在消息到达或超时发生（两者中较早的那个）时被唤醒。

入队阻塞的精妙处理

队列满时的策略选择

入队阻塞发生在队列已满而任务仍然尝试发送消息的情况下。这种情况在实际应用中也很常见，特别是在生产者速度快于消费者速度的场景中。

面对满队列，任务同样有两种选择：

立即失败：直接返回错误，告诉调用者队列已满
阻塞等待：等待队列有空间后再发送消息

这种设计给了开发者很大的灵活性。对于不能丢失数据的应用，可以选择阻塞等待；对于可以丢失部分数据但要求快速响应的应用，可以选择立即失败。

背压（Backpressure）机制

入队阻塞实际上实现了一种自然的背压机制。当消费者处理速度跟不上生产者的产生速度时，队列会逐渐填满。一旦队列满了，生产者就会被阻塞，这样就自动调节了生产和消费的速度平衡。

这种机制就像是水管中的水流。当下游的流量小于上游的流量时，水管中的水压会逐渐增大，最终限制上游的流量。这是一个自平衡的系统！

死锁预防策略

在设计入队阻塞机制时，必须考虑死锁的可能性。如果任务A等待向队列1发送消息，而任务B等待向队列2发送消息，同时任务A需要从队列2接收消息，任务B需要从队列1接收消息，就可能发生死锁。

uCOS-II通过以下策略来预防死锁：

超时机制：为所有阻塞操作设置超时时间
避免嵌套等待：尽量避免在持有资源的情况下等待其他资源
资源排序：为所有资源定义一个全局顺序，按顺序申请资源

队列操作的可视化解析

空队列状态的特征

让我们从最简单的情况开始：空队列。此时队列中没有任何消息，各个指针的位置关系如下：

OSQIn == OSQOut
OSQEntries == 0

这种状态下，入队指针和出队指针指向同一个位置。这就像是一个空的圆形停车场，进入指示牌和离开指示牌指向同一个位置。

单消息入队过程

当第一个消息进入队列时，发生了什么？

将消息指针存储到OSQIn指向的位置
将OSQIn指针向前移动一位
增加OSQEntries计数

此时队列状态变为：

OSQIn == OSQOut + 1
OSQEntries == 1

这个过程就像是在空停车场停入第一辆车。停车指示牌向前移动了一位，而取车指示牌仍然指向原来的位置。

多消息的复杂舞蹈

随着更多消息的加入，队列开始展现出它的动态美。每次入队操作都会让OSQIn指针向前移动，每次出队操作都会让OSQOut指针向前移动。

当队列中有多个消息时，我们可以通过以下公式计算队列中的消息数量：

$OSQIn<OSQOut\text{消息数量} = \begin{cases} \text{OSQIn} - \text{OSQOut} & \text{如果 OSQIn} \geq \text{OSQOut} \\ \text{OSQSize} - (\text{OSQOut} - \text{OSQIn}) & \text{如果 OSQIn} < \text{OSQOut} \end{cases}$

这个公式考虑了环形缓冲区的特殊情况，即入队指针可能"绕一圈"回到出队指针之前。

队列满状态的判断

队列满的判断是一个微妙的问题。在环形缓冲区中，如果简单地使用OSQIn == OSQOut来判断队列满，就会与空队列的判断条件冲突。

uCOS-II采用了一种巧妙的解决方案：使用消息计数器OSQEntries。当OSQEntries == OSQSize时，队列就满了。这种方法避免了歧义，提供了清晰的状态判断。

消息队列常用函数深度剖析

OSQCreate - 队列创建函数

OSQCreate函数是消息队列的创建者，它负责初始化一个新的消息队列。这个函数的重要性就像是盖房子时打地基一样，地基不牢，地动山摇！

参数名	类型	意义
start	void **	指向消息队列存储区开始位置的指针
size	INT16U	队列的最大容量（消息数量）

函数返回值是一个指向事件控制块的指针，如果创建失败则返回NULL。

使用示例：

OS_EVENT *msg_queue;
void *msg_queue_storage[10];  // 能存储10个消息指针

msg_queue = OSQCreate(&msg_queue_storage[0], 10);
if (msg_queue == (OS_EVENT *)0) {
    // 队列创建失败
}

这个函数的内部实现非常精妙。它首先会检查系统资源是否足够，然后初始化队列控制块，最后将队列与事件控制块关联起来。整个过程就像是一个精密的工厂流水线，每个步骤都不可或缺。

OSQPost - 消息发送函数

OSQPost函数是消息的投递员，它负责将消息送达到队列中。这个函数有两个版本：普通版本和前端版本。

参数名	类型	意义
pevent	OS_EVENT *	指向消息队列事件控制块的指针
msg	void *	要发送的消息指针

普通版本OSQPost将消息添加到队列尾部，而前端版本OSQPostFront将消息添加到队列头部。这就像是普通邮件和加急邮件的区别。

INT8U err;
void *my_message = "Hello World";

err = OSQPost(msg_queue, my_message);
if (err != OS_NO_ERR) {
    // 发送失败
}

这个函数的执行过程包括：

检查队列是否已满
如果有任务等待消息，直接将消息传递给等待任务
如果没有等待任务，将消息添加到队列中
更新队列状态信息

OSQPend - 消息接收函数

OSQPend函数是消息的接收者，它负责从队列中取出消息。这个函数的行为会根据队列的状态和参数的设置而有所不同。

参数名	类型	意义
pevent	OS_EVENT *	指向消息队列事件控制块的指针
timeout	INT16U	等待超时时间（OS_TICKS_PER_SEC的倍数）
err	INT8U *	错误代码返回指针

函数返回值是接收到的消息指针。

INT8U err;
void *received_msg;

received_msg = OSQPend(msg_queue, 100, &err);  // 等待100个时钟节拍
if (err == OS_NO_ERR) {
    // 成功接收到消息
    printf("Received: %s\n", (char *)received_msg);
}

这个函数的智能之处在于它的多种行为模式：

如果队列中有消息，立即返回消息
如果队列为空且超时时间为0，立即返回错误
如果队列为空且超时时间不为0，任务被挂起等待

OSQFlush - 队列清空函数

OSQFlush函数是队列的清洁工，它负责清空队列中的所有消息。这个函数在某些特殊情况下非常有用，比如系统重置或错误恢复。

参数名	类型	意义
pevent	OS_EVENT *	指向消息队列事件控制块的指针

INT8U err;

err = OSQFlush(msg_queue);
if (err == OS_NO_ERR) {
    // 队列已清空
}

这个函数的执行过程非常简单但很重要：

进入临界区
重置入队和出队指针
清零消息计数器
退出临界区

OSQQuery - 队列状态查询函数

OSQQuery函数是队列的监控器，它提供了队列当前状态的详细信息。这个函数对于调试和监控非常有用。

参数名	类型	意义
pevent	OS_EVENT *	指向消息队列事件控制块的指针
pdata	OS_Q_DATA *	指向存储查询结果的结构体指针

OS_Q_DATA结构体包含了队列的详细信息：

typedef struct {
    void          *OSMsg;           // 指向下一个要被接收的消息
    INT16U         OSNMsgs;         // 队列中当前的消息数量
    INT16U         OSQSize;         // 队列的最大容量
    INT8U          OSEventTbl[OS_EVENT_TBL_SIZE];  // 等待任务列表
    INT8U          OSEventGrp;      // 等待任务组
} OS_Q_DATA;

消息队列使用的实践智慧

内存管理的艺术

使用消息队列时，内存管理是一个需要特别关注的问题。由于队列存储的是消息指针而不是消息本身，开发者需要负责消息的内存管理。

最常见的错误是发送局部变量的地址。当函数返回时，局部变量被销毁，但队列中仍然保存着指向这个已销毁变量的指针。这就像是给别人一个错误的地址，当他们去找的时候，那里已经空无一物！

正确的做法是使用动态内存分配或静态内存池：

// 错误的做法
void bad_function(void) {
    int local_data = 42;
    OSQPost(msg_queue, &local_data);  // 危险！
}

// 正确的做法
void good_function(void) {
    int *data = malloc(sizeof(int));
    *data = 42;
    OSQPost(msg_queue, data);
}

消息大小的优化策略

虽然消息队列存储的是指针，但消息本身的大小仍然会影响系统性能。大消息需要更多的内存拷贝时间，也会增加缓存失效的可能性。

一个好的策略是限制消息的大小，或者使用分层的消息结构。对于大数据，可以先发送一个包含数据位置信息的小消息，接收方再根据这个信息去获取实际数据。

优先级反转的预防

在使用消息队列时，可能会遇到优先级反转的问题。这种情况发生在高优先级任务等待低优先级任务发送的消息时。

解决这个问题的方法包括：

使用优先级继承机制
合理设计任务优先级
避免长时间占用CPU的任务

错误处理的最佳实践

每个消息队列操作都可能失败，良好的错误处理是系统稳定性的保证。不要忽略函数的返回值，要为每种可能的错误情况制定相应的处理策略。

INT8U err;
void *msg;

msg = OSQPend(msg_queue, 1000, &err);
switch (err) {
    case OS_NO_ERR:
        // 处理消息
        break;
    case OS_TIMEOUT:
        // 处理超时
        break;
    case OS_ERR_EVENT_TYPE:
        // 处理事件类型错误
        break;
    default:
        // 处理其他错误
        break;
}

实际应用案例：智能温度监控系统

让我们通过一个完整的实际案例来展示消息队列在STM32F103项目中的应用。这个案例是一个智能温度监控系统，包含温度采集、数据处理、显示和报警等功能。

系统架构设计

这个系统包含以下几个任务：

温度采集任务：定期读取传感器数据
数据处理任务：对采集到的数据进行滤波和分析
显示任务：更新LCD显示
报警任务：处理温度异常情况
通信任务：与上位机通信

这些任务之间通过消息队列进行通信：

// 定义消息结构
typedef struct {
    INT8U   msg_type;      // 消息类型
    INT16U  temperature;   // 温度值
    INT32U  timestamp;     // 时间戳
} TEMP_MSG;

// 创建消息队列
OS_EVENT *temp_msg_queue;
void *temp_msg_storage[20];

// 消息池
TEMP_MSG temp_msg_pool[20];
INT8U temp_msg_index = 0;

温度采集任务的实现

温度采集任务负责定期读取传感器数据，并将数据通过消息队列发送给数据处理任务：

void TempSensorTask(void *pdata) {
    INT8U err;
    TEMP_MSG *msg;
    INT16U temp_raw;
    
    pdata = pdata;  // 避免编译器警告
    
    while (1) {
        // 读取温度传感器
        temp_raw = ReadTemperatureSensor();
        
        // 获取消息缓冲区
        msg = GetTempMsgBuffer();
        if (msg != NULL) {
            // 填充消息内容
            msg->msg_type = MSG_TYPE_TEMP_DATA;
            msg->temperature = temp_raw;
            msg->timestamp = OSTimeGet();
            
            // 发送消息
            err = OSQPost(temp_msg_queue, msg);
            if (err != OS_NO_ERR) {
                // 处理发送失败
                ReleaseTempMsgBuffer(msg);
            }
        }
        
        // 等待100ms后再次采集
        OSTimeDly(OS_TICKS_PER_SEC / 10);
    }
}

数据处理任务的实现

数据处理任务接收温度数据，进行滤波处理，并根据处理结果发送相应的消息：

void DataProcessTask(void *pdata) {
    INT8U err;
    TEMP_MSG *msg;
    INT16U filtered_temp;
    static INT16U temp_history[5] = {0};
    static INT8U history_index = 0;
    
    pdata = pdata;
    
    while (1) {
        // 等待温度数据
        msg = (TEMP_MSG *)OSQPend(temp_msg_queue, 0, &err);
        if (err == OS_NO_ERR) {
            if (msg->msg_type == MSG_TYPE_TEMP_DATA) {
                // 更新历史数据
                temp_history[history_index] = msg->temperature;
                history_index = (history_index + 1) % 5;
                
                // 计算滤波后的温度
                filtered_temp = CalculateAverage(temp_history, 5);
                
                // 发送显示消息
                SendDisplayMessage(filtered_temp);
                
                // 检查是否需要报警
                if (filtered_temp > TEMP_ALARM_THRESHOLD) {
                    SendAlarmMessage(filtered_temp);
                }
            }
            
            // 释放消息缓冲区
            ReleaseTempMsgBuffer(msg);
        }
    }
}

显示任务的实现

显示任务负责更新LCD显示，显示当前温度值和系统状态：

void DisplayTask(void *pdata) {
    INT8U err;
    DISPLAY_MSG *msg;
    char temp_str[20];
    
    pdata = pdata;
    
    while (1) {
        // 等待显示消息
        msg = (DISPLAY_MSG *)OSQPend(display_msg_queue, 1000, &err);
        if (err == OS_NO_ERR) {
            switch (msg->msg_type) {
                case MSG_TYPE_TEMP_DISPLAY:
                    // 更新温度显示
                    sprintf(temp_str, "Temp: %d.%d°C", 
                            msg->temperature / 10, msg->temperature % 10);
                    LCD_DisplayString(0, 0, temp_str);
                    break;
                    
                case MSG_TYPE_ALARM_DISPLAY:
                    // 显示报警信息
                    LCD_DisplayString(0, 1, "ALARM: HIGH TEMP");
                    break;
                    
                default:
                    break;
            }
            
            // 释放消息缓冲区
            ReleaseDisplayMsgBuffer(msg);
        } else if (err == OS_TIMEOUT) {
            // 超时处理，可能显示系统状态
            LCD_DisplayString(0, 1, "System Running");
        }
    }
}

报警任务的实现

报警任务处理温度异常情况，可能包括蜂鸣器报警、LED指示等：

void AlarmTask(void *pdata) {
    INT8U err;
    ALARM_MSG *msg;
    
    pdata = pdata;
    
    while (1) {
        // 等待报警消息
        msg = (ALARM_MSG *)OSQPend(alarm_msg_queue, 0, &err);
        if (err == OS_NO_ERR) {
            switch (msg->msg_type) {
                case MSG_TYPE_HIGH_TEMP_ALARM:
                    // 启动蜂鸣器
                    BuzzerOn();
                    OSTimeDly(OS_TICKS_PER_SEC);  // 响1秒
                    BuzzerOff();
                    
                    // 点亮报警LED
                    AlarmLedOn();
                    break;
                    
                case MSG_TYPE_ALARM_CLEAR:
                    // 关闭报警LED
                    AlarmLedOff();
                    break;
                    
                default:
                    break;
            }
            
            // 释放消息缓冲区
            ReleaseAlarmMsgBuffer(msg);
        }
    }
}

系统初始化

在系统初始化阶段，需要创建所有的消息队列和任务：

void SystemInit(void) {
    // 创建消息队列
    temp_msg_queue = OSQCreate(&temp_msg_storage[0], 20);
    display_msg_queue = OSQCreate(&display_msg_storage[0], 10);
    alarm_msg_queue = OSQCreate(&alarm_msg_storage[0], 5);
    
    // 检查队列创建是否成功
    if (temp_msg_queue == NULL || display_msg_queue == NULL || alarm_msg_queue == NULL) {
        // 系统初始化失败
        while (1);
    }
    
    // 创建任务
    OSTaskCreate(TempSensorTask, (void *)0, &TempSensorTaskStk[TASK_STK_SIZE-1], TEMP_SENSOR_TASK_PRIO);
    OSTaskCreate(DataProcessTask, (void *)0, &DataProcessTaskStk[TASK_STK_SIZE-1], DATA_PROCESS_TASK_PRIO);
    OSTaskCreate(DisplayTask, (void *)0, &DisplayTaskStk[TASK_STK_SIZE-1], DISPLAY_TASK_PRIO);
    OSTaskCreate(AlarmTask, (void *)0, &AlarmTaskStk[TASK_STK_SIZE-1], ALARM_TASK_PRIO);
}

性能优化技巧

在实际应用中，还可以采用以下技巧来优化系统性能：

消息池管理：使用预分配的消息池避免频繁的内存分配和释放
批量处理：在数据处理任务中批量处理多个消息
优先级设置：合理设置各任务的优先级，确保关键任务能够及时响应
队列大小调优：根据实际情况调整队列大小，平衡内存使用和性能

性能调优的深层思考

消息队列长度的数学建模

确定合适的消息队列长度是一个复杂的优化问题。队列太短可能导致消息丢失，队列太长则浪费内存。我们可以使用排队论来建模这个问题。

假设消息到达率为 $λ\lambda$ ，消息处理率为 $μ\mu$ ，那么队列中的平均消息数量为：

$\frac{\rho}{1-\rho}$

其中 $ρ=λμ\rho = \frac{\lambda}{\mu}$ 是系统的利用率。

当 $ρ<1\rho < 1$ 时，系统是稳定的；当 $ρ≥1\rho \geq 1$ 时，队列会无限增长。

实时性分析

对于实时系统，我们更关心的是消息的最大延迟时间。在最坏情况下，一个消息可能需要等待队列中所有其他消息都被处理完毕。

如果队列长度为 $N$ ，消息处理时间为 $T$ ，那么最大延迟时间为：

$Dmax⁡=N×TD_{\max} = N \times T$

这个公式提醒我们，减少队列长度或提高处理速度都可以降低系统延迟。

内存使用优化

消息队列的内存使用可以通过以下公式计算：

$\times S_{\text{指针}} + N_{\text{消息}} \times S_{\text{消息}}$

其中：

$N$ 是队列长度
$S指针S_{\text{指针}}$ 是指针的大小（通常为4字节）
$N消息N_{\text{消息}}$ 是并发消息的数量
$S消息S_{\text{消息}}$ 是单个消息的大小

优化策略包括：

使用消息池减少内存碎片
压缩消息内容
使用引用计数共享大消息

故障诊断与调试技巧

常见问题的诊断

消息丢失
消息丢失通常由以下原因引起：

队列满时使用非阻塞发送
消息指针指向已释放的内存
多任务并发访问导致的竞态条件

诊断方法：

检查队列使用情况
验证消息生命周期
分析任务间的同步关系

性能问题
性能问题可能表现为：

消息处理延迟过大
系统响应时间不稳定
CPU使用率过高

诊断方法：

测量消息处理时间
分析任务调度情况
检查中断频率

调试工具的使用

队列状态监控

void PrintQueueStatus(OS_EVENT *pevent) {
    OS_Q_DATA qdata;
    INT8U err;
    
    err = OSQQuery(pevent, &qdata);
    if (err == OS_NO_ERR) {
        printf("队列状态:\n");
        printf("  当前消息数: %d\n", qdata.OSNMsgs);
        printf("  队列容量: %d\n", qdata.OSQSize);
        printf("  下一条消息: %p\n", qdata.OSMsg);
    }
}

消息跟踪

#define MSG_TRACE_ENABLE 1

#if MSG_TRACE_ENABLE
void LogMessage(const char *operation, void *msg) {
    printf("[%d] %s: %p\n", OSTimeGet(), operation, msg);
}
#else
#define LogMessage(op, msg) do {} while(0)
#endif

高级应用模式

消息路由模式

在复杂系统中，可以实现消息路由功能，根据消息内容将消息发送到不同的处理队列：

void MessageRouter(void *pdata) {
    GENERIC_MSG *msg;
    INT8U err;
    
    while (1) {
        msg = (GENERIC_MSG *)OSQPend(input_queue, 0, &err);
        if (err == OS_NO_ERR) {
            switch (msg->msg_type) {
                case MSG_TYPE_SENSOR_DATA:
                    OSQPost(sensor_queue, msg);
                    break;
                case MSG_TYPE_USER_INPUT:
                    OSQPost(ui_queue, msg);
                    break;
                case MSG_TYPE_NETWORK_DATA:
                    OSQPost(network_queue, msg);
                    break;
                default:
                    OSQPost(error_queue, msg);
                    break;
            }
        }
    }
}

消息聚合模式

对于需要批量处理的场景，可以实现消息聚合功能：

#define BATCH_SIZE 10

void MessageAggregator(void *pdata) {
    SENSOR_MSG *msgs[BATCH_SIZE];
    INT8U count = 0;
    INT8U err;
    
    while (1) {
        msgs[count] = (SENSOR_MSG *)OSQPend(sensor_queue, 100, &err);
        if (err == OS_NO_ERR) {
            count++;
            if (count >= BATCH_SIZE) {
                ProcessBatch(msgs, count);
                count = 0;
            }
        } else if (err == OS_TIMEOUT && count > 0) {
            // 超时处理已收集的消息
            ProcessBatch(msgs, count);
            count = 0;
        }
    }
}

消息过滤模式

在某些应用中，需要对消息进行过滤，只处理符合条件的消息：

BOOL MessageFilter(GENERIC_MSG *msg) {
    switch (msg->msg_type) {
        case MSG_TYPE_CRITICAL:
            return TRUE;  // 关键消息总是处理
        case MSG_TYPE_NORMAL:
            return (msg->priority >= current_priority_threshold);
        case MSG_TYPE_DEBUG:
            return debug_mode_enabled;
        default:
            return FALSE;
    }
}

void FilteredMessageHandler(void *pdata) {
    GENERIC_MSG *msg;
    INT8U err;
    
    while (1) {
        msg = (GENERIC_MSG *)OSQPend(input_queue, 0, &err);
        if (err == OS_NO_ERR) {
            if (MessageFilter(msg)) {
                ProcessMessage(msg);
            }
            ReleaseMessage(msg);
        }
    }
}

与其他IPC机制的比较

消息队列 vs 信号量

消息队列和信号量是两种不同的IPC机制，各有优势：

消息队列的优势：

可以传递数据，不仅仅是信号
支持多对多通信
提供缓冲机制，平衡生产者和消费者速度

信号量的优势：

开销更小，速度更快
更适合简单的同步场景
支持计数语义

选择建议：

需要传递数据时选择消息队列
只需要同步信号时选择信号量
对性能要求极高时选择信号量

消息队列 vs 邮箱

uCOS-II还提供了邮箱（Mailbox）机制，它们之间有什么区别呢？

消息队列的优势：

可以存储多个消息，提供缓冲能力
支持FIFO或优先级排序
更适合高频率的消息传递

邮箱的优势：

结构更简单，开销更小
适合一对一的简单通信
消息传递更直接

想象一下，邮箱就像是你家门口的信箱，一次只能放一封信；而消息队列就像是邮局的分拣系统，可以同时处理很多封信，还能按照不同的规则进行排序。

消息队列 vs 管道

在一些高级操作系统中，管道也是常用的IPC机制：

消息队列的优势：

消息边界清晰，不会出现半包问题
支持消息优先级
更适合结构化数据传输

管道的优势：

支持流式数据传输
适合大量连续数据
实现相对简单

错误处理的完整策略

错误分类与处理

在使用消息队列时，可能遇到的错误可以分为以下几类：

系统资源错误

OS_ERR_PEND_ISR：在中断服务程序中调用阻塞函数
OS_ERR_PEVENT_NULL：事件指针为空
OS_ERR_EVENT_TYPE：事件类型不匹配

超时错误

OS_TIMEOUT：等待超时
OS_ERR_TIMEOUT：超时参数错误

队列状态错误

OS_Q_FULL：队列已满
OS_Q_EMPTY：队列为空

参数错误

OS_ERR_PDATA_NULL：数据指针为空
OS_ERR_PEND_LOCKED：调度器被锁定时尝试阻塞

错误恢复机制

一个健壮的系统应该具备完善的错误恢复机制：

INT8U SendMessageWithRetry(OS_EVENT *pevent, void *msg, INT8U max_retries) {
    INT8U err;
    INT8U retry_count = 0;
    
    do {
        err = OSQPost(pevent, msg);
        if (err == OS_NO_ERR) {
            return OS_NO_ERR;  // 成功发送
        }
        
        // 根据错误类型决定是否重试
        if (err == OS_Q_FULL) {
            // 队列满，稍后重试
            OSTimeDly(10);  // 等待10个时钟节拍
            retry_count++;
        } else {
            // 其他错误，无法通过重试解决
            return err;
        }
    } while (retry_count < max_retries);
    
    return OS_ERR_TIMEOUT;  // 重试次数耗尽
}

系统监控与诊断

为了及时发现和解决问题，可以实现系统监控功能：

typedef struct {
    INT32U  total_messages;     // 总消息数
    INT32U  lost_messages;      // 丢失消息数
    INT32U  timeout_count;      // 超时次数
    INT32U  max_queue_usage;    // 最大队列使用量
    INT32U  avg_response_time;  // 平均响应时间
} QUEUE_STATISTICS;

QUEUE_STATISTICS queue_stats = {0};

void UpdateQueueStatistics(OS_EVENT *pevent, INT8U operation, INT8U result) {
    OS_Q_DATA qdata;
    
    switch (operation) {
        case QUEUE_OP_SEND:
            queue_stats.total_messages++;
            if (result != OS_NO_ERR) {
                queue_stats.lost_messages++;
            }
            break;
            
        case QUEUE_OP_RECEIVE:
            if (result == OS_TIMEOUT) {
                queue_stats.timeout_count++;
            }
            break;
    }
    
    // 更新最大队列使用量
    if (OSQQuery(pevent, &qdata) == OS_NO_ERR) {
        if (qdata.OSNMsgs > queue_stats.max_queue_usage) {
            queue_stats.max_queue_usage = qdata.OSNMsgs;
        }
    }
}

移植与兼容性考虑

不同平台的适配

虽然uCOS-II具有良好的可移植性，但在不同平台上使用时仍需注意一些差异：

STM32F103平台特点：

ARM Cortex-M3内核，32位系统
支持硬件中断优先级
内存对齐要求（4字节对齐）
缓存一致性问题较少

移植注意事项：

// 确保消息指针的对齐
#define MSG_ALIGN_SIZE    4
#define MSG_ALIGN_MASK    (MSG_ALIGN_SIZE - 1)

void* AlignedMalloc(INT32U size) {
    void *ptr;
    INT32U aligned_size = (size + MSG_ALIGN_MASK) & ~MSG_ALIGN_MASK;
    ptr = malloc(aligned_size);
    return ptr;
}

版本兼容性

不同版本的uCOS-II在消息队列实现上可能存在差异：

uCOS-II v2.86及以后版本：

增加了消息队列前端发送功能
改进了错误处理机制
优化了内存使用

向后兼容性处理：

#if OS_VERSION < 286
// 为旧版本提供兼容性函数
INT8U OSQPostFront(OS_EVENT *pevent, void *msg) {
    // 在旧版本中，可能需要自己实现这个功能
    return OS_ERR_NOT_SUPPORTED;
}
#endif

性能基准测试

基准测试方法

为了验证消息队列的性能，可以设计以下基准测试：

#define TEST_MSG_COUNT  1000
#define TEST_ITERATIONS 100

void BenchmarkMessageQueue(void) {
    OS_EVENT *test_queue;
    void *test_storage[50];
    INT32U start_time, end_time;
    INT32U total_time = 0;
    INT16U i, j;
    
    // 创建测试队列
    test_queue = OSQCreate(&test_storage[0], 50);
    
    for (i = 0; i < TEST_ITERATIONS; i++) {
        start_time = OSTimeGet();
        
        // 发送消息
        for (j = 0; j < TEST_MSG_COUNT; j++) {
            OSQPost(test_queue, (void *)j);
        }
        
        // 接收消息
        for (j = 0; j < TEST_MSG_COUNT; j++) {
            INT8U err;
            OSQPend(test_queue, 0, &err);
        }
        
        end_time = OSTimeGet();
        total_time += (end_time - start_time);
    }
    
    printf("平均处理时间: %d us/message\n", 
           (total_time * 1000) / (TEST_ITERATIONS * TEST_MSG_COUNT));
}

性能优化建议

基于基准测试结果，可以采用以下优化策略：

减少临界区时间：将复杂的操作移到临界区外
优化内存访问模式：确保数据结构对齐
使用合适的队列大小：避免频繁的阻塞和唤醒
批量处理：一次处理多个消息以分摊开销

安全性考虑

内存安全

消息队列的使用涉及指针操作，需要特别注意内存安全：

// 安全的消息发送函数
INT8U SafeSendMessage(OS_EVENT *pevent, void *msg) {
    // 检查参数有效性
    if (pevent == NULL || msg == NULL) {
        return OS_ERR_PDATA_NULL;
    }
    
    // 检查事件类型
    if (pevent->OSEventType != OS_EVENT_TYPE_Q) {
        return OS_ERR_EVENT_TYPE;
    }
    
    // 检查消息指针的有效性
    if (!IsValidMemoryAddress(msg)) {
        return OS_ERR_PDATA_NULL;
    }
    
    return OSQPost(pevent, msg);
}

资源泄漏防护

防止资源泄漏的关键是确保每个分配的资源都能被正确释放：

// 带超时的消息处理
void ProcessMessageWithTimeout(OS_EVENT *pevent, INT16U timeout) {
    INT8U err;
    void *msg;
    
    msg = OSQPend(pevent, timeout, &err);
    if (err == OS_NO_ERR) {
        // 使用异常处理确保资源释放
        __try {
            ProcessMessage(msg);
        } __finally {
            ReleaseMessage(msg);
        }
    }
}

实际项目中的设计模式

生产者-消费者模式

这是消息队列最经典的应用模式：

// 生产者任务
void ProducerTask(void *pdata) {
    PRODUCT_MSG *product;
    INT8U err;
    
    while (1) {
        // 生产产品
        product = ProduceProduct();
        if (product != NULL) {
            // 发送到队列
            err = OSQPost(product_queue, product);
            if (err != OS_NO_ERR) {
                // 处理发送失败
                HandleProductionError(product);
            }
        }
        
        // 控制生产速度
        OSTimeDly(PRODUCTION_INTERVAL);
    }
}

// 消费者任务
void ConsumerTask(void *pdata) {
    PRODUCT_MSG *product;
    INT8U err;
    
    while (1) {
        // 从队列获取产品
        product = (PRODUCT_MSG *)OSQPend(product_queue, 0, &err);
        if (err == OS_NO_ERR) {
            // 消费产品
            ConsumeProduct(product);
            
            // 释放资源
            ReleaseProduct(product);
        }
    }
}

工作队列模式

工作队列模式适用于需要多个工作线程处理任务的场景：

#define WORKER_COUNT 3

// 工作任务结构
typedef struct {
    void (*work_func)(void *);  // 工作函数
    void *work_data;            // 工作数据
    INT8U priority;             // 任务优先级
} WORK_ITEM;

// 工作者任务
void WorkerTask(void *pdata) {
    WORK_ITEM *work;
    INT8U err;
    INT8U worker_id = (INT8U)pdata;
    
    while (1) {
        // 获取工作项
        work = (WORK_ITEM *)OSQPend(work_queue, 0, &err);
        if (err == OS_NO_ERR) {
            // 执行工作
            work->work_func(work->work_data);
            
            // 释放工作项
            ReleaseWorkItem(work);
        }
    }
}

// 提交工作函数
INT8U SubmitWork(void (*func)(void *), void *data, INT8U priority) {
    WORK_ITEM *work = AllocateWorkItem();
    if (work == NULL) {
        return OS_ERR_MEM_FULL;
    }
    
    work->work_func = func;
    work->work_data = data;
    work->priority = priority;
    
    return OSQPost(work_queue, work);
}

事件驱动模式

事件驱动模式将系统设计为对各种事件的响应：

// 事件类型定义
typedef enum {
    EVENT_BUTTON_PRESS,
    EVENT_SENSOR_READING,
    EVENT_TIMER_EXPIRE,
    EVENT_NETWORK_DATA,
    EVENT_SYSTEM_ERROR
} EVENT_TYPE;

// 事件结构
typedef struct {
    EVENT_TYPE type;
    INT32U timestamp;
    void *data;
} SYSTEM_EVENT;

// 事件处理器
void EventHandler(void *pdata) {
    SYSTEM_EVENT *event;
    INT8U err;
    
    while (1) {
        event = (SYSTEM_EVENT *)OSQPend(event_queue, 0, &err);
        if (err == OS_NO_ERR) {
            switch (event->type) {
                case EVENT_BUTTON_PRESS:
                    HandleButtonPress(event->data);
                    break;
                case EVENT_SENSOR_READING:
                    HandleSensorReading(event->data);
                    break;
                case EVENT_TIMER_EXPIRE:
                    HandleTimerExpire(event->data);
                    break;
                case EVENT_NETWORK_DATA:
                    HandleNetworkData(event->data);
                    break;
                case EVENT_SYSTEM_ERROR:
                    HandleSystemError(event->data);
                    break;
            }
            
            ReleaseEvent(event);
        }
    }
}

调试技巧与工具

消息追踪系统

在开发过程中，追踪消息的流向对于调试非常重要：

#ifdef DEBUG_MESSAGE_TRACE
#define MAX_TRACE_ENTRIES 100

typedef struct {
    INT32U timestamp;
    void *queue;
    void *message;
    INT8U operation;  // 0=send, 1=receive
    INT8U task_id;
} MSG_TRACE_ENTRY;

MSG_TRACE_ENTRY msg_trace[MAX_TRACE_ENTRIES];
INT16U trace_index = 0;

void TraceMessage(void *queue, void *message, INT8U operation) {
    MSG_TRACE_ENTRY *entry = &msg_trace[trace_index];
    
    entry->timestamp = OSTimeGet();
    entry->queue = queue;
    entry->message = message;
    entry->operation = operation;
    entry->task_id = OSTaskQuery(OS_PRIO_SELF, &task_data);
    
    trace_index = (trace_index + 1) % MAX_TRACE_ENTRIES;
}

void PrintMessageTrace(void) {
    INT16U i;
    printf("Message Trace:\n");
    for (i = 0; i < MAX_TRACE_ENTRIES; i++) {
        MSG_TRACE_ENTRY *entry = &msg_trace[i];
        if (entry->timestamp > 0) {
            printf("[%d] Task %d %s message %p to/from queue %p\n",
                   entry->timestamp, entry->task_id,
                   entry->operation ? "received" : "sent",
                   entry->message, entry->queue);
        }
    }
}
#else
#define TraceMessage(q, m, o) do {} while(0)
#define PrintMessageTrace() do {} while(0)
#endif

死锁检测

死锁是多任务系统中的常见问题，可以通过以下方法检测：

#define MAX_TASKS 10
#define MAX_QUEUES 5

typedef struct {
    INT8U task_id;
    void *waiting_queue;
    INT32U wait_start_time;
} TASK_WAIT_INFO;

TASK_WAIT_INFO task_waits[MAX_TASKS];

void RecordTaskWait(INT8U task_id, void *queue) {
    TASK_WAIT_INFO *info = &task_waits[task_id];
    info->task_id = task_id;
    info->waiting_queue = queue;
    info->wait_start_time = OSTimeGet();
}

void CheckForDeadlock(void) {
    INT8U i, j;
    INT32U current_time = OSTimeGet();
    
    for (i = 0; i < MAX_TASKS; i++) {
        TASK_WAIT_INFO *info = &task_waits[i];
        if (info->waiting_queue != NULL) {
            // 检查是否等待时间过长
            if (current_time - info->wait_start_time > DEADLOCK_TIMEOUT) {
                printf("Potential deadlock detected: Task %d waiting for queue %p\n",
                       info->task_id, info->waiting_queue);
            }
        }
    }
}

高级特性实现

消息优先级队列

虽然标准的uCOS-II消息队列不支持优先级，但可以通过以下方式实现：

typedef struct {
    void *message;
    INT8U priority;
} PRIORITY_MSG;

// 优先级队列插入函数
INT8U PriorityQueueInsert(OS_EVENT *pevent, void *msg, INT8U priority) {
    PRIORITY_MSG *pmsg = AllocatePriorityMsg();
    if (pmsg == NULL) {
        return OS_ERR_MEM_FULL;
    }
    
    pmsg->message = msg;
    pmsg->priority = priority;
    
    // 根据优先级插入到合适位置
    return InsertByPriority(pevent, pmsg);
}

// 按优先级插入的实现
INT8U InsertByPriority(OS_EVENT *pevent, PRIORITY_MSG *pmsg) {
    OS_Q *pq;
    void **pstart, **pend, **pin;
    
    pq = (OS_Q *)pevent->OSEventPtr;
    pstart = pq->OSQStart;
    pend = pq->OSQEnd;
    pin = pq->OSQOut;
    
    // 找到合适的插入位置
    while (pin != pq->OSQIn) {
        PRIORITY_MSG *existing = (PRIORITY_MSG *)*pin;
        if (pmsg->priority > existing->priority) {
            break;
        }
        pin++;
        if (pin == pend) {
            pin = pstart;
        }
    }
    
    // 插入消息（需要移动现有消息）
    // 这里需要实现消息移动逻辑
    
    return OS_NO_ERR;
}

消息广播机制

实现一对多的消息广播：

#define MAX_SUBSCRIBERS 10

typedef struct {
    OS_EVENT *queues[MAX_SUBSCRIBERS];
    INT8U count;
} BROADCAST_GROUP;

// 订阅广播
INT8U SubscribeBroadcast(BROADCAST_GROUP *group, OS_EVENT *queue) {
    if (group->count >= MAX_SUBSCRIBERS) {
        return OS_ERR_PDATA_NULL;
    }
    
    group->queues[group->count++] = queue;
    return OS_NO_ERR;
}

// 广播消息
INT8U BroadcastMessage(BROADCAST_GROUP *group, void *msg) {
    INT8U i;
    INT8U err;
    INT8U success_count = 0;
    
    for (i = 0; i < group->count; i++) {
        err = OSQPost(group->queues[i], msg);
        if (err == OS_NO_ERR) {
            success_count++;
        }
    }
    
    return (success_count == group->count) ? OS_NO_ERR : OS_ERR_PEND_LOCKED;
}

实际案例：工业控制系统

让我们看一个更复杂的实际案例：工业控制系统中的数据采集与处理。

系统架构

这个系统包含：

多个传感器数据采集任务
数据预处理任务
控制算法计算任务
执行器控制任务
人机界面任务
数据记录任务

// 传感器数据结构
typedef struct {
    INT8U sensor_id;
    INT16U raw_value;
    INT32U timestamp;
    INT8U quality;  // 数据质量标志
} SENSOR_DATA;

// 控制命令结构
typedef struct {
    INT8U actuator_id;
    INT16U command_value;
    INT8U urgent;  // 紧急标志
} CONTROL_CMD;

// 系统状态结构
typedef struct {
    INT16U sensor_values[16];
    INT16U control_outputs[8];
    INT8U system_status;
    INT32U cycle_count;
} SYSTEM_STATUS;

数据采集任务

void SensorTask(void *pdata) {
    INT8U sensor_id = (INT8U)pdata;
    SENSOR_DATA *data;
    INT8U err;
    INT16U raw_value;
    
    while (1) {
        // 读取传感器数据
        raw_value = ReadSensor(sensor_id);
        
        // 分配消息缓冲区
        data = AllocateSensorData();
        if (data != NULL) {
            data->sensor_id = sensor_id;
            data->raw_value = raw_value;
            data->timestamp = OSTimeGet();
            data->quality = ValidateReading(raw_value);
            
            // 发送到数据处理队列
            err = OSQPost(sensor_data_queue, data);
            if (err != OS_NO_ERR) {
                // 处理发送失败
                ReleaseSensorData(data);
                LogError("Sensor data send failed", sensor_id);
            }
        }
        
        // 控制采集频率
        OSTimeDly(OS_TICKS_PER_SEC / 100);  // 100Hz采集
    }
}

数据预处理任务

void DataPreprocessTask(void *pdata) {
    SENSOR_DATA *sensor_data;
    PROCESSED_DATA *processed_data;
    INT8U err;
    
    while (1) {
        // 接收原始传感器数据
        sensor_data = (SENSOR_DATA *)OSQPend(sensor_data_queue, 0, &err);
        if (err == OS_NO_ERR) {
            // 数据预处理
            if (sensor_data->quality > MIN_QUALITY_THRESHOLD) {
                processed_data = AllocateProcessedData();
                if (processed_data != NULL) {
                    // 滤波处理
                    processed_data->filtered_value = ApplyFilter(sensor_data);
                    
                    // 单位转换
                    processed_data->engineering_value = ConvertToEngineering(
                        processed_data->filtered_value, sensor_data->sensor_id);
                    
                    // 发送到控制任务
                    err = OSQPost(control_data_queue, processed_data);
                    if (err != OS_NO_ERR) {
                        ReleaseProcessedData(processed_data);
                    }
                }
            }
            
            // 释放原始数据
            ReleaseSensorData(sensor_data);
        }
    }
}

控制算法任务

void ControlAlgorithmTask(void *pdata) {
    PROCESSED_DATA *input_data;
    CONTROL_CMD *control_cmd;
    INT8U err;
    static CONTROLLER_STATE controller_state = {0};
    
    while (1) {
        // 接收处理后的数据
        input_data = (PROCESSED_DATA *)OSQPend(control_data_queue, 0, &err);
        if (err == OS_NO_ERR) {
            // 执行控制算法
            INT16U control_output = PIDController(
                input_data->engineering_value, 
                GetSetpoint(input_data->sensor_id),
                &controller_state);
            
            // 生成控制命令
            control_cmd = AllocateControlCmd();
            if (control_cmd != NULL) {
                control_cmd->actuator_id = GetActuatorId(input_data->sensor_id);
                control_cmd->command_value = control_output;
                control_cmd->urgent = CheckUrgency(input_data->engineering_value);
                
                // 发送控制命令
                if (control_cmd->urgent) {
                    err = OSQPostFront(actuator_cmd_queue, control_cmd);
                } else {
                    err = OSQPost(actuator_cmd_queue, control_cmd);
                }
                
                if (err != OS_NO_ERR) {
                    ReleaseControlCmd(control_cmd);
                }
            }
            
            ReleaseProcessedData(input_data);
        }
    }
}

系统监控与故障处理

void SystemMonitorTask(void *pdata) {
    SYSTEM_STATUS *status;
    INT8U err;
    INT32U last_heartbeat[MAX_TASKS] = {0};
    
    while (1) {
        // 检查各任务的心跳
        CheckTaskHeartbeats(last_heartbeat);
        
        // 检查队列使用情况
        CheckQueueUsage();
        
        // 检查系统资源
        CheckSystemResources();
        
        // 生成系统状态报告
        status = GenerateSystemStatus();
        if (status != NULL) {
            // 发送到HMI任务
            err = OSQPost(hmi_queue, status);
            if (err != OS_NO_ERR) {
                ReleaseSystemStatus(status);
            }
            
            // 发送到数据记录任务
            err = OSQPost(datalog_queue, status);
            if (err != OS_NO_ERR) {
                // 数据记录失败不影响系统运行
            }
        }
        
        // 监控周期
        OSTimeDly(OS_TICKS_PER_SEC);  // 1秒监控一次
    }
}