一步一步教你使用uCOS-II

uC/OS-II要求用户在定时中断的服务程序中，调用系统提供的与时钟节拍相关的系统函数，例如中断级的任务切换函数，系统时间函数。

uCOS时间管理的相关函数

1：任务延迟函数OSTimeDly()

Ucos提供一个可以被任务调用而将任务延时一段特定时间的功能函数，即OSTimeDly().任务调用OSTimeDly()后，一旦规定的时间期满或者有其他的任务通过调用OSTimeDlyResume()取消了延时，他就会进入就绪状态。只有当该任务在所有就绪态任务中具有最高的优先级，它才会立即运行。

2：按时，分，秒延时函数OSRimeDLyHMSM()

与OSTimeDly()一样，调用OSRimeDlyHMSM()函数也会是UCOS进行一次任务调度，并且执行下一个优先级最高的就绪任务。当OSTimeDlyHMSM()后，一旦规定的时间期满，或者有OSTimeDlyResume()，它就会马上处于就绪态。同样，只有当该任务在所有就绪态任务中具有最高的优先级，他才开始运行。

3：恢复延时的任务OSTimeDlyResume()

延时的任务可以不等待延时的期满，而是通过其他任务取消延时而使自己处于就绪态，可以通过该函数来实现，实际上，OSTimeDlyResume()也可以唤醒正在等待的事件。

4：系统时间OSTimeGet()和OSTimeSet()

在ANSI C中是使用malloc和free两个函数来动态分配和释放内存。例如在Linux系统中就是这样。但在嵌入式实时系统中，多次这样的操作会导致内存碎片，因为嵌入式系统尤其是uCOS是实地址模式，这种模式在分配任务堆栈时需要整块连续的空间，否则任务无法正确运行。且由于内存管理算法的原因，malloc和free的执行时间也是不确定。这点是实时内核最大的矛盾。

基于以上的原因uC/OS-II中把连续的大块内存按分区管理。每个分区中包含整数个大小相同的内存块，但不同分区之间的内存快大小可以不同。用户需要动态分配内存时，系统选择一个适当的分区，按块来分配内存。释放内存时将该块放回它以前所属的分区，这样能有效解决碎片问题，同时执行时间也是固定的。

同时uCOS-II根据以上的处理封装了适合于自己的动态内存分配函数OSMemGet（）和OSMemPut（），但是使用这两个函数动态分配内存前需要先创建内存空间，也就是第二段咱们介绍的内存分块。呵呵，不罗嗦了，具体的关于内存管理的函数如下：

内存控制块的数据结构

Typedef

struct

{void   *osmemaddr    ;指向内存分区起始地址的指针。

Void   *osmemfreelist  ;指向下一个空余内存控制块或者下一个空余内存块的指针，

Int32u  osmemblksize  ;内存分区中内存块的大小，是建立内存分区时定义的。

Int32u osmemnblks     ;内存分区中总的内存块数量，也是建立该内存分区时定义的。

Int32u  osmemnfree    ;内存分区块中当前获得的空余块数量。

}os_mem;

1；建立一个内存分区，OSMemCreate()

2：分配一个内存块，OSMemGet()

应用程序通过调用该函数，从已经建立的内存分区中申请一个内存块。该函数唯一的参数是指向特定内存分区的指针。

3：释放一个内存块，OSMemPut()

当应用程序不再使用一个内存块时，必须及时的把它释放，并放回到相应的内存分区中，这个操作就是通过调用该函数实现的。

4：查询一个内存分区的状态，OSQMemQuery()。

前面已经给大家介绍了如何在PC机上调试UCOS，方法和需要的软件都介绍给大家了，相信有兴趣的朋友已经安装调试了，下面咱们就让自己的第一个任务在PC上Run起来。

OK，下面我就分步介绍建立自己的第一个任务

第一步：CopyC:\SOFTWARE\uCOS-II目录下的EX1_x86L文件夹。作为我们的工程模板

第二步：修改工程模板的名字为：HelloEEWorld

第三部：按照咱们前面的《使用 BC31 工具编译 UCOS‐II 的源码过程 》修改配置文件；

第四步：修改Test.c文件，建立自己的第一个任务

具体的内容我就不再帖子上写了。大家可以参考附件HelloEEWorld.rar里面的Test.c文件。然后编译

不可剥夺型内核

不可剥夺型内核要求每个任务自我放弃CPU 的所有权。 不可剥夺型调度法也称作合作型多任务，各个任务彼此合作共享一个 CPU。异步事件还是由中断服务来处理。中断服务可以使一个高优先级的任务由挂起状态变为就绪状态。 但中断服务以后控制权还是回到原来被中断了的那个任务，直到该任务主动放弃 CPU 的使用权时，那个高优先级的任务才能获得 CPU的使用权。

不可剥夺型内核允许每个任务运行，直到该任务自愿放弃 CPU的控制权。中断可以打入运行着的任务。 中断服务完成以后将 CPU 控制权还给被中断了的任务。任务级响应时间要大大好于前后系统，但仍是不可知的，商业软件几乎没有不可剥夺型内核。

不可剥夺型内核的工作过程见下图：

可剥夺型内核

当系统响应时间很重要时，要使用可剥夺型内核。因此，μC/OS-Ⅱ以及绝大多数商业上销售的实时内核都是可剥夺型内核。 最高优先级的任务一旦就绪， 总能得到CPU 的控制权。当一个运行着的任务使一个比它优先级高的任务进入了就绪态， 当前任务的CPU使用权就被剥夺了，或者说被挂起了，那个高优先级的任务立刻得到了 CPU的控制权。如果是中断服务子程序使一个高优先级的任务进入就绪态，中断完成时，中断了的任务被挂起，优先级高的那个任务开始运行。使用可剥夺型内核，最高优先级的任务什么时候可以执行，可以得到 CPU的控制权是可知的。使用可剥夺型内核使得任务级响应时间得以最优化。

可剥夺型内核的工作过程是这样的：

UCOS-II 任务调度

UCOS-II的文件结构

任务的资源主要包括以下几部分，ECB控制块、任务堆栈、任务代码及与CPU共用的寄存器和CPU的使用权

 （1）信号量可以分为两种：一种是二值信号量（0和1），一种是N值信号量（计数式信号量）。

二值信号量的意思是可以有多少任务同时享用这个信号量。比如二值信号，就是只有1个任务可以使用。当有一个任务使用该信号量的时候，那么其他需要使用该信号量的任务就必须等待，直到该任务释放该信号量。这种信号量可以看作一把钥匙。

对于N值信号量（计数式信号量），就是说可以同时有N-1个任务同时使用该信号量。对于二值信号量，N=1。

 （2）建立信号量的工作必须在任务级代码中或者多任务启动之前完成。

二：任务如何得到信号量的问题：

 想得到信号量的任务，必须执行等待操作（pend）。在信号量的建立的时候，我们首先确定了该信号量可以被共享的资源数（N），并将其赋值给pevent->OSEventCnt。如果信号量有效(非0)，即pevent->OSEventCnt>0，则信号量减1，任务得以继续运行。如果信号量无效，即pevent->OSEventCnt==0，则等待信号量的任务就被列入等待信号量的任务表中。许多内核允许定义等待超时，当等待时间超过了设定值，该信号量还是无效，则等待该信号量的任务进入就绪态，准备运行，并返回出错代码(等待超时错误)。

三：任务对信号量的释放问题：

任务执行发信号（post）操作来释放信号量。如果没有任务等待信号量，那么信号量的值仅是简单的加1（则信号量大于0，有效）；如果有任务等待该信号量，那么就会有另一个任务进入就绪态，信号量的值就不加1。

之后，这个释放的信号量给那个等待中的任务，要看内核如何调度的。收到信号量的任务可能是如下两者之一：

◆等待任务中，优先级最高的；（uc/os-ii仅支持这种方式）。

◆最早开始等待信号量的任务（如果是按先进先出FIFO原则）。

四：信号量的有效与无效的问题：

信号量有效：信号量的计算器非0（.OSEventCnt！=0）。信号量有效表示任务对资源可用。

信号量无效：信号量的计算器为0。信号量无效表示任务对目前资源不可用，需要等待其他另一个任务（或者中断服务子程序）发出该信号量（OSSemPost）。

五：关于信号量的三个重要函数：

◆OSSemCreate() 创建一个信号量  （注：由任务或启动代码操作）

创建工作必须在任务级代码中或者多任务启动之前完成。功能只要是先获取一个事件控制块ECB，写入一些参数。其中调用了OS_EeventWaitListInt()函数，对事件控制块的等待任务列表进行初始化。完成初始化工作后，返回一个该信号量的句柄(Handle)。

◆OSSemPend() 等待一个信号量                  （注：只能由任务操作）

 本函数应用于任务试图获得共享资源的使用权、任务需要与其他任务或中断同步及任务需要等待特定事件发生的场合。

 如果任务Task_A调用OSSemPend()，且信号量的值有效(非0)，那么OSSemPend()递减信号量计数器（.OSEventCnt），并返回该值。换句话说，Task_A获取到共享资源的使用权了，之后就执行该资源。

 如果如果任务Task_A调用OSSemPend()，信号量无效(为0)，那么OSSemPend()调用OS_EventTaskWait()函数，把Task_A放入等待列表中。（等待到什么时候呢？要看OSSemPost()(或者等待超时情况)，由它释放信号量并检查任务执行权，见下资料）

◆OSSemPost() 发出（释放）一个信号量          （注：由任务或中断操作）

本函数其中调用OS_EventTaskRdy()函数，把优先级最高的任务Task_A（在这假如是Task_A，另外假设当前调用OSSemPost()的任务是Task_B）从等待任务列表中去除，并使它进入就绪态。然后调用OSSched()进行任务调度。如果Task_A是当前就绪态中优先级最高的任务，则内核执行Task_A；否则，OSSched()直接返回，Task_B继续执行。

关键代码剖析：

void  OSMutexPend (OS_EVENT *pevent, INT16U timeout, INT8U *err)

{

 //不得在中断中调用该函数

if (OSIntNesting > 0) {                                

      *err = OS_ERR_PEND_ISR;                            

      return;

}

OS_ENTER_CRITICAL();    

//信号量可用                                              

if ((INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8) 

                             == OS_MUTEX_AVAILABLE) {

      pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8;      

      //将计数器低8为置成占用该mutex的任务（当前任务）的优先级。

      pevent->OSEventCnt |= OSTCBCur->OSTCBPrio;

      //在mutex中保存占用信号量的任务：修改该mutex的OSEventPtr ，使其指向当前任务

      pevent->OSEventPtr  = (void *)OSTCBCur;            

      OS_EXIT_CRITICAL();

      //信号量可用，正常返回。

      *err  = OS_NO_ERR;

      return;

}

//信号量不可用：即已被占用

//从该信号量中获得PIP

pip   = (INT8U)(pevent->OSEventCnt >> 8); 

//从该信号量中获得占用该信号量的任务的优先级。                    

mprio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8);  

//从信号量中获得占用该信号量的任务

ptcb  = (OS_TCB *)(pevent->OSEventPtr);  

/*

   如果原先占用该mutex的优先级比提出申请该mutex的任务的优先级低

（mprio > OSTCBCur->OSTCBPrio），则提升原任务的优先级至PIP

*/

if (ptcb->OSTCBPrio != pip && mprio > OSTCBCur->OSTCBPrio) {  

      if ((OSRdyTbl[ptcb->OSTCBY] & ptcb->OSTCBBitX) != 0x00) {     

          if ((OSRdyTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0x00) {

              OSRdyGrp &= ~ptcb->OSTCBBitY;

          }

          //若原任务已就绪，则将其从就绪表中删除，并置就绪标志rdy

          rdy = TRUE;

      } else {

          rdy = FALSE;                                          

      }

      //修改优先级，及相关参数

      ptcb->OSTCBPrio  = pip;                     

      ptcb->OSTCBY    = ptcb->OSTCBPrio >> 3;

      ptcb->OSTCBBitY  = OSMapTbl[ptcb->OSTCBY];

      ptcb->OSTCBX     = ptcb->OSTCBPrio & 0x07;

      ptcb->OSTCBBitX   = OSMapTbl[ptcb->OSTCBX];

      //如果原任务是就绪的，则继续让新的优先级就绪

      if (rdy == TRUE) {                                

          OSRdyGrp               |= ptcb->OSTCBBitY;    

          OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;

      }

      OSTCBPrioTbl[pip]   = (OS_TCB *)ptcb;

}

//让提出申请的任务先等待（从就绪表中删除，如mutex的等待队列）………

OSTCBCur->OSTCBStat |= OS_STAT_MUTEX;            

OSTCBCur->OSTCBDly   = timeout;                   

OS_EventTaskWait(pevent);  

OS_EXIT_CRITICAL();

//执行任务切换（如果原来低优先级的任务优先级被抬高了，则该任务将被执行）

OS_Sched();                                        

OS_ENTER_CRITICAL();

//提出申请的任务被唤醒继续执行

if (OSTCBCur->OSTCBStat & OS_STAT_MUTEX) {

//1）由于等待超时被定时器唤醒        

      OS_EventTO(pevent);

      OS_EXIT_CRITICAL();

      *err = OS_TIMEOUT;                            

      return;

}

/*

    2）原先占用mutex的任务执行完成释放了mutex

       并唤醒了等待该mutex的最高优先级的任务

*/

OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0;

OS_EXIT_CRITICAL();

*err = OS_NO_ERR;

}

关键代码剖析：

INT8U  OSMutexPost (OS_EVENT *pevent)

{

 //不得在中断中调用该函数

if (OSIntNesting > 0) {                           

      return (OS_ERR_POST_ISR);                    

}

OS_ENTER_CRITICAL();

//从该信号量中获得PIP

pip  = (INT8U)(pevent->OSEventCnt >> 8);          

/*

从该信号量中获得占用该信号量的任务的优先级。

在OSEventCnt中的低8位保存占用mutex的任务的原始优先级，

不随优先级的提高而改变。

*/

prio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8);  

/*

确认释放mutex的任务确实是占用mutex的任务自身。

占用/申请mutex的任务的优先级可能是pip(被提高)，也可能是原先任务的优先级。

*/

if (OSTCBCur->OSTCBPrio != pip && 

      OSTCBCur->OSTCBPrio != prio) {               

      OS_EXIT_CRITICAL();

      //若释放mutex的任务非占用/申请的任务，则返回错误信息。

      return (OS_ERR_NOT_MUTEX_OWNER);

}

 //若当前释放mutex的任务的优先级为pip，则需将该任务的优先级降到原来水平

if (OSTCBCur->OSTCBPrio == pip) {

 //首先将pip从就绪表删除

      if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) {

          OSRdyGrp &= ~OSTCBCur->OSTCBBitY;

      }

      //将任务优先级修改为原始优先级，并修改相关参数

      OSTCBCur->OSTCBPrio   = prio;

      OSTCBCur->OSTCBY     = prio >> 3;

      OSTCBCur->OSTCBBitY   = OSMapTbl[OSTCBCur->OSTCBY];

      OSTCBCur->OSTCBX      = prio & 0x07;

      OSTCBCur->OSTCBBitX    = OSMapTbl[OSTCBCur->OSTCBX];

      //将修改优先级后的任务重新如就绪表

      OSRdyGrp           |= OSTCBCur->OSTCBBitY;

      OSRdyTbl[OSTCBCur->OSTCBY] |= OSTCBCur->OSTCBBitX;

      OSTCBPrioTbl[prio]    = (OS_TCB *)OSTCBCur;

}

OSTCBPrioTbl[pip] = (OS_TCB *)1;                  

//若mutex的等待列表不空，唤醒等待列表中最高优先级的任务，并将mutex分配给它

if (pevent->OSEventGrp != 0x00) {           

/*

      唤醒等待列表中最高优先级的任务（从mutex等待列表中删除，使其入就绪表），

      清除等待任务的OS_STAT_MUTEX标志，并返回其优先级prio

*/

      prio  = OS_EventTaskRdy(pevent, (void *)0, OS_STAT_MUTEX);

      pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8;  

      //将mutex分配给新任务：置OSEventCnt为prio

      pevent->OSEventCnt |= prio;

      //在mutex中保存占用信号量的任务

      pevent->OSEventPtr  = OSTCBPrioTbl[prio];     

      OS_EXIT_CRITICAL();

      //任务切换（如果唤醒的任务优先级比当前任务高，则使唤醒的任务得到运行）

      OS_Sched();                                   

      return (OS_NO_ERR);

}

//mutex的等待列表为空，即该mutex可用：置mutex可用标志及占用任务指针。

pevent->OSEventCnt |= OS_MUTEX_AVAILABLE;        

pevent->OSEventPtr  = (void *)0;

OS_EXIT_CRITICAL();

return (OS_NO_ERR);

}

今天我们就看看事件标志组的使用和管理吧

事件标志组（event flag）包含两部分：

typedef struct

{

INT8U OSFlagType;

void *OSFlagWaitList;

OS_FLAGS OSFlagFlags;

}OS_FLAG_GRP;

1 组中各事件状态的标志位

2 等待这些标志位或清除的任务列表 （这里是双向链表） 用于删除标志时检查是否有等待该

标志的任务链表包含3个数据结构： OS_FLAG_GRP, OS_TCB,OS_FLAG-NODE 用来记录任务在等待哪些标志位及等待方式（与/或），当一个任务开始等待某些标志位时建立一个OS_FLAG-NODE，当这些等待的事件标志位发生后，删除数据结构。

当某个任务需要与多个任务同步时，须要使用事件标志组。

⒈弄清楚OS_FLAG_GRP、OS_FLAG_NODE和OS_TCB之间的关系。

当一个任务开始等待某些事件标志位时，就回建立一个事件标志节点OS_FLAG_NODE数据结构，并且将任务所要等待的事件标志位写入OS_FLAG_NODE的分量.OSFlagNodeFlags。然后将该数据结构分量.OSFlagNodeFLagGrp指向事件标志组OS_FLAG_GRP，将.OSFlagNodeTCB指向该任务的控制块OS_TCB，建立起任务与事件标志组之间的联系，说明该任务是等待该事件标志组中某些事件标志位的任务。当有多个任务都需要等待某个事件标志组中某些事件标志位时，这些任务分别建立自己的事件标志节点。并且将这些事件标志节点通过分量.OSFlagNodeNext和.OSFlagNodePrev连接成链。

⒉任务可以等待事件标志组中某些位置位1，也可以等待事件标志组中某些位清0，而置1（或清0）又可以分为所有事件都发生的“与”型和任何一个事件发生的“或”型。这样便有了4种不同的类型存放在.OSFlagNodeWaitType（OS_FLAG_NODE）中。

⒊事件标志组和信号量我觉得是有不同的。

信号量建立以后，假设初始值为N，前N个任务调用OSSemPend（）函数都会得到信号量。之后如果第Ｎ＋１个任务调用OSSemPend（）函数申请信号量，该任务将会被置为等待事件发生的状态（睡眠态）。只到前N个任务中有任务运行完了所要运行的程序，调用OSSenmPost（）函数，释放了所占用了信号量，第N+1个任务。（这里假设该任务是所有等待信号量任务中优先级最高的任务）才会获得信号量，被从睡眠态转入就绪态。

而事件标志组是事件标志组建立之后，某个任务需要事件标志组中某些事件标志位（置位或者清0）才能继续运行，于是任务调用OSFlagPend（）函数，而此时若这些标志位满足要求，任务返回，继续执行。否则，任务将被挂起。而当有另外一个任务调用OSFlagPost（）函数将前一个任务所需要的标志位（置位或清0）使之满足要求，前一个被挂起的任务将被置为就绪态。因此几个任务可以同时得到所需要的事件标志进入就绪态。注意：只要任务所需要的标志位满足要求，任务便进入就绪态。与信号量不同，信号量中的任务需要是在等待该信号量中优先级最高的任务才能得到信号量进入就绪态。事件标志组可以一个任务与多个任务同步，而信号量只能是一个任务与另一个任务同步。

各个任务之间把自己的数据封装完毕后可以以邮箱的形式发送给其它的任务使用，从而达到任务间通信的目的。

应用程序可以使用多少个邮箱，其最大数目是由OS_CFG.H文件中的配置常数OS_MAX_EVENTS设定。

下面以一个实例来向大家讲解一下邮箱的使用过程。

具体的邮箱使用过程如下：

第一步：在程序开始先定义一个邮箱，是指针形式的。定义函数如下：

OS_EVENT *MsgBox;

第二步：在主程序中建立邮箱：

MsgBox = OSMboxCreate((void *)0); // 创建邮箱并初始化为空 

第三步：在接受函数中定义接受时需用到的两个变量，一个为指针形式

INT8U   err;

INT32U *msg;

在其循环函数中接受邮箱信息：

msg = OSMboxPend(MsgBox, 0, &err); // 接收Task1发来的消息

Messgae = msg[0]; // 接收消息到指定的变量

第四步：在发送函数中也需要先定义两个变量

INT8U err;

volatile  INT32U MsgData = 1000;

也是在其循环函数中发送邮箱信息：

err = OSMboxPost(MsgBox, (void*)&MsgData); // 向TaskPWM发送消息

注意：在使用时一定要注意数据类型的定义，一定要统一起来。

下面分别对油箱相关的函数做一个简要的描述。

任务或者中断服务子程序都可以调用函数OSMboxPost()，OSMboxPostOpt() ，而只有任务可以调用OSMboxDel() OSMboxPend()， OSMboxQuery()。

void *OSMboxAccept (OS_EVENT *pevent)  无等待的从邮箱中得到一则消息。

OS_EVENT *OSMboxCreate (void *msg)  建立一个邮箱。

msg:用来初始化建立的消息邮箱，如果该指针不为空，则建立的消息邮箱将含有消息。

返回值：指向分配给所建立的消息邮箱的事件控制块的指针。如果没有可用的事件控制块，则返回空指针。

OS_EVENT *OSMboxDel (OS_EVENT *pevent, INT8U opt, INT8U *err)

删除一个邮箱。当将OS_CFG.H文件中的OS_MBOX_DEL_EN设为1时，该函数才会被编译。使用该函数时要注意，多个任务可能试图操作已经删除的邮箱。在删除邮箱之前，必须首先删除可能操作该邮箱的所有任务。

pevent:指向邮箱的指针。该指针是在邮箱建立时返回给用户应用程序的指针。

opt:该先项定义邮箱的删除条件，可以选择只能在已经没有任何在等待该邮箱的消息时，才能删除邮箱(OS_DEL_NO_PEND)；或者不管有没有任务在等待邮箱的消息，立即删除邮箱（OS_DEL_ALWAYS)，在这种情况 下，所有等待邮箱消息的任务都会立即进入就绪态。

err:指向出错代码的指针。返回的出错代码可以是以下几种情况之一。

OS_NO_ERR 调用成功，邮箱已经被删除。

OS_ERR_DEL_ISR 试图在中断服务子程序中删除邮箱。

OS_ERR_INVALID_OPT 无效的opt参数，用户没有将opt定义为上述两种情况之一。

OS_ERR_EVENT_TYPE pevent不是指向邮箱的指针。

OS_ERR_PEVENT_NULL 已经没有OS_EVENT数据结构可以使用。

返回值：返回NULL表示邮箱已被删除；返回pevent表示邮箱没有删作。

void *OSMboxPend (OS_EVENT *pevent, INT16U timeout, INT8U *err)  等待邮箱中的消息。

pevent:指向即将接收消息的消息邮箱的指针。

timeout:允许一个任务在经过了指定数目的时钟节拍后还没有得到需要的消息时恢复运行。如果该值为0表示任务将持续等待消息。

err:指向包含错误码的变量的指针。该函数返回的错误码可能为下述几种情况

OS_NO_ERR 消息被正确地接收。

OS_TIMEOUT 消息没有在指定的等待时间内送到。

OS_ERR_EVENT_TYPE pevent不是指向消息邮箱的指针。

OS_ERR_PEND_ISR 从中断调用该函数。

OS_ERR_PEVENT_NULL　pevent是空指针。

返回值：该函数返回接收的消息并将*err置为OS_NO_ERR.

INT8U OSMboxPost (OS_EVENT *pevent, void *msg)  向邮箱发送一则消息。

pevent:指向即将接收消息的消息邮箱的指针。

msg:即将实际发送给任务的的消息。消息是一个以指针表示的苛种数据类型的变量，在不同的程序中消息的使用也可能不同。不允许传递一个空指针，国灰这意味着消息邮箱为空。

返回值：该函数的返回值为下述之一：

OS_NO_ERR 消息成功地放到消息邮箱中。

OS_MBOX_FULL 消息邮箱已经包含了其他消息，已满。

OS_ERR_EVENT_TYPE pevent不是指向消息邮箱的指针。

OS_ERR_PEVENT_NULL pevent是空指针。

OS_ERR_POST_NULL_PTR 用户试图发出空指针。根据规则，在这里不支持空指针。

INT8U OSMboxPostOpt (OS_EVENT *pevent, void *msg, INT8U opt)  向邮箱发送一则消息。该函数可以向等待邮箱的所有任务发送消息（广播）。

pevent:指向即将接收消息的消息邮箱的指针。

msg:即将实际发送给任务的消息。消息是一个以指针表示的某种数据类型的变量，在不同的程序中消息的使用也可能不同。不允许传递一个空指针，因为这意味着消息邮箱为空。

opt:定义消息只发给等待邮箱消息的任务中优先级最高的任务（将opt置为OS_POST_OPT_NONE)，或者让所有等待 邮箱消息的任务都得到消息（将opt置为OS_POST_OPT_BROADCAST)。

返回值：

err 指向包含错误码的变量指针，返回的错误码可能为下述几种之一：

OS_NO_ERR 消息成功地放到消息邮箱中。

OS_MBOX_FULL 消息邮箱已经包含了其他消息，已满。

OS_ERR_EVENT_TYPE pevent不是指向消息邮箱的指针。

OS_ERR_PEVENT_NULL pevent是空指针。

OS_ERR_POST_NULL_PTR 用户试图发出空指针。根据规则，在这里不支持空指针。 

INT8U OSMboxQuery (OS_EVENT *pevent, OS_MBOX_DATA *p_mbox_data)  查询一个邮箱的状态。

pevent:指向即将接收消息的消息邮箱的指针。

pdata:指向OS_MBOX_DATA数据结构的指针，该数据结构包含下述成员。

void *OSMsg； /*消息邮箱中消息的复制*/

INT8U OSEventTbl[OS_EVENT_TBL_SIZE]; /*消息邮箱等待队列的复制*/

INT8U OSEventGrp

返回值：该函数返回值为下述之一：

OS_NO_ERR 调用成功

OS_ERR_EVENT_NULL pevent是空指针

OS_ERR_EVENT_TYPE pevent不是指向消息邮箱的指针

一是传递指向一个数组的指针。发端采用如下方式：

OSMboxPost(ComSendMbox, (void *)ComBufRec);         

其中的ComBufRec就是数组名，也表示指向该数组的指针，将原来的字符型数组名（或指针）变成(void *)类型，而接收端，利用

send_ptr = (uint8 *)OSMboxPend(ComSendMbox, 0, &err);      

将(void *)类型还原为指针。

二是传递一个字符型变量。发端采用如下方式：

OSMboxPost(KeyMbox, (void *)key_value);             

其中的key_value就是字符型变量，将原来的字符型变量变成(void *)类型，而接收端，利用

key = (INT8U)OSMboxPend(KeyMbox, 0, &err);    

将(void *)类型还原为字符型变量。

这种情况下最好时避免0值的使用，如果非使用不可。建议在0值前加一个辅助变量。这样可以避免邮箱接收数据后认为是空的情况的发生