UC/OS II 事件标志组管理（二）

事件标志组管理由9个函数实现，下面的8函数加上之前的初始化函数，其代码定义在os_flag.c中。

1：创建事件标志组OSFlagCreate

创建事件标志组函数OSFlagCreate主要功能为从空闲链表中去一块时间标志组控制块，进行一些属性的设置。

其函数原型为：OS_FLAG_GRP  *OSFlagCreate (OS_FLAGS  flags,INT8U    *perr)  其中flags是事件组合的标志,是位掩码，表示事件要等待哪些位。如果应用程序等待任务组中事件标志中的0到2，则为0x05

除了参数检查之外，主要的功能的代码如下：

pgrp = OSFlagFreeList;                          

    if (pgrp != (OS_FLAG_GRP *)0) {                 /* See if we have event flag groups available      */

                                                    //从空闲链表表头取事件标志组控制块

        OSFlagFreeList       = (OS_FLAG_GRP *)OSFlagFreeList->OSFlagWaitList;

        pgrp->OSFlagType     = OS_EVENT_TYPE_FLAG;  //设置为标志组事件

        pgrp->OSFlagFlags    = flags;               //将形参的事件标志flag赋值给OSFlagFlags成员

        pgrp->OSFlagWaitList = (void *)0;           //首个事件标志节点指针设置为空

2：事件标志组阻塞函数OS_FlagBlock

事件标志组阻塞函数是将等待事件标志组的任务阻塞，知道请求的事件标志被设置

其函数原型如下：static  void  OS_FlagBlock (OS_FLAG_GRP  *pgrp, OS_FLAG_NODE  *pnode,OS_FLAGS  flags,INT8U  wait_type, INT32U  timeout)

wait_type：等待类型，说明是所有等待所有位都被置位还是只要任务位被置位。

函数功能实现代码如下：

 //更改当前任务的任务控制块控制信息

  OSTCBCur->OSTCBStat      |= OS_STAT_FLAG;

    OSTCBCur->OSTCBStatPend   = OS_STAT_PEND_OK;

    OSTCBCur->OSTCBDly        = timeout;              

#if OS_TASK_DEL_EN > 0u

    OSTCBCur->OSTCBFlagNode   = pnode;                //将任务控制块的事件标志节点指针指向该节点

#endif

//设置标志组节点

    pnode->OSFlagNodeFlags    = flags;                /* Save the flags that we need to wait for       */
    pnode->OSFlagNodeWaitType = wait_type;            /* Save the type of wait we are doing            */

    pnode->OSFlagNodeTCB      = (void *)OSTCBCur;     /* Link to task's TCB                            */

    pnode->OSFlagNodeNext     = pgrp->OSFlagWaitList; //将节点的指针指向节点链表的头部

    pnode->OSFlagNodePrev     = (void *)0;

    pnode->OSFlagNodeFlagGrp  = (void *)pgrp;      /* Link to Event Flag Group                      */

    pnode_next                = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;

    if (pnode_next != (void *)0) {                    /*如果为空地址，只有一个节点（就是本节点），如果不为空地址，那么将该链表的头节点改为现在这个节点 */

        pnode_next->OSFlagNodePrev = pnode;           /将之前头节点指向现在这个节点/

    }

    pgrp->OSFlagWaitList = (void *)pnode; //将事件标志组指向该节点

//上面的的功能就是将pnode设置为链表的新的头节点

    y            =  OSTCBCur->OSTCBY;                 //取消该任务的就绪状态

    OSRdyTbl[y] &= (OS_PRIO)~OSTCBCur->OSTCBBitX;
    if (OSRdyTbl[y] == 0x00u) {

        OSRdyGrp &= (OS_PRIO)~OSTCBCur->OSTCBBitY;

3：请求事件标志OSFlagPend

该函数的主要功能是用于等待事件标志组中的组合条件。

函数的主要源码如下：

wait_type等待类型可以是下面说的四种情况之一加上或者不加OS_FLAG_CONSUME 。

#define  OS_FLAG_WAIT_CLR_ALL           0u  

#define  OS_FLAG_WAIT_CLR_ANY           1u 

#define  OS_FLAG_WAIT_SET_ALL           2u  

#define  OS_FLAG_WAIT_SET_ANY           3u  

#define  OS_FLAG_CONSUME             0x80u  

例如wait_type可以为OS_FLAG_WAIT_CLR_ALL，即0x01或者OS_FLAG_WAIT_CLR_ALL + OS_FLAG_CONSUME  即0x81。两个的区别在于是否是消耗类型的。

所谓的消耗与否，就是事件组满足条件后，获得事件标志组后。事件标志组控制块的对应事件标志清除，即消耗掉。

flags是事件组合的标志,是位掩码，表示事件要等待哪些位。如果应用程序等待任务组中事件标志中的0到2，即掩码为0x05。

result = (INT8U)(wait_type & OS_FLAG_CONSUME);  //将wiat_type与OS_FLAG_COUNSUME进行与，结果存放在result中。若是rusult为0，则说明wait_type是没有加上OS_FLAG_CONSUME的，也就是非消耗类型的，否则就是消耗类型的

    if (result != (INT8U)0) {                              /* See if we need to consume the flags      */

        wait_type &= (INT8U)~(INT8U)OS_FLAG_CONSUME; //消耗类型的，就将wait_type的高四位清零，保留低四位

        consume    = OS_TRUE;  //消耗类型的，conusme 设为ture

    } else {
        consume    = OS_FALSE; //非消耗类型，consume设为false

    }

下面就是根据不同的wait_type等待类型就是执行不同的代码

case OS_FLAG_WAIT_SET_ALL:                         //等待选择的所有位都置1

             flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & flags);   //事件标志组中与掩码进行and运算，提取出事件标志位的位中所满足条件的位。即掩码和标志位都为1的位，即为请求的标志位

             if (flags_rdy == flags) {                     //判断是否所有请求的标志都被置位。如果是

                 if (consume == OS_TRUE) {                 //看是否为消耗类型

                     pgrp->OSFlagFlags &= (OS_FLAGS)~flags_rdy;   //清零请求事件组中对应请求标志位的位，消耗了事件

                 }

                 OSTCBCur->OSTCBFlagsRdy = flags_rdy;      //将当前的请求的标志位存在当前任务控制块的OSTCBFlagsRdy中

                 OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
                 *perr                   = OS_ERR_NONE;

                 return (flags_rdy);

             } else {                                      //否则阻塞，等待事件标志组完成或者是超时

                 OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
                 OS_EXIT_CRITICAL();
             }

             break;

case OS_FLAG_WAIT_SET_ANY:               //等待选择的任何位置位1

             flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & flags);    /* Extract only the bits we want    */

             if (flags_rdy != (OS_FLAGS)0) {               //是否有任何为被置为1

                 if (consume == OS_TRUE) {                 //消耗类型

                     pgrp->OSFlagFlags &= (OS_FLAGS)~flags_rdy;    /* Clear ONLY the flags that we got */
                 }
                 OSTCBCur->OSTCBFlagsRdy = flags_rdy;      /* Save flags that were ready               */
                 OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
                 *perr                   = OS_ERR_NONE;

                 return (flags_rdy);

             } else {                                      //不满足条件，则阻塞

                 OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
                 OS_EXIT_CRITICAL();
             }

             break;

case OS_FLAG_WAIT_CLR_ALL:                         //等待选的所有位都为0

             flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & flags;    //这跟前面有所不同，在前面用了一个取反，因为这里等待是要求所有位（对应的位）为0

             if (flags_rdy == flags) {                     //设置的等待的所有位都为0

                 if (consume == OS_TRUE) {                 //

                     pgrp->OSFlagFlags |= flags_rdy;       /* Set ONLY the flags that we wanted        */
                 }
                 OSTCBCur->OSTCBFlagsRdy = flags_rdy;      /* Save flags that were ready               */
                 OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
                 *perr                   = OS_ERR_NONE;
                 return (flags_rdy);
             } else {                                      /* Block task until events occur or timeout */
                 OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
                 OS_EXIT_CRITICAL();
             }

             break;

case OS_FLAG_WAIT_CLR_ANY: //选择等待的位有任何一位为0

             flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & flags;   /* Extract only the bits we want      */

             if (flags_rdy != (OS_FLAGS)0) {               //设置的等待位中有一位被置0

                 if (consume == OS_TRUE) {                 /* See if we need to consume the flags      */
                     pgrp->OSFlagFlags |= flags_rdy;       /* Set ONLY the flags that we got           */
                 }
                 OSTCBCur->OSTCBFlagsRdy = flags_rdy;      /* Save flags that were ready               */
                 OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
                 *perr                   = OS_ERR_NONE;
                 return (flags_rdy);
             } else {                                      /* Block task until events occur or timeout */
                 OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
                 OS_EXIT_CRITICAL();
             }

             break;

OS_Sched();                                            //执行调度

当任务重新就绪（超时或者得到满足），任务从这里开始执行。

    OS_ENTER_CRITICAL();

    if (OSTCBCur->OSTCBStatPend != OS_STAT_PEND_OK) {      //回到任务就绪后的原因

        pend_stat                = OSTCBCur->OSTCBStatPend;
        OSTCBCur->OSTCBStatPend  = OS_STAT_PEND_OK;

        OS_FlagUnlink(&node);

        OSTCBCur->OSTCBStat      = OS_STAT_RDY;            //修改任务任务控制块的运行状态

        OS_EXIT_CRITICAL();
        flags_rdy                = (OS_FLAGS)0;
        switch (pend_stat) {

            case OS_STAT_PEND_ABORT:

                 *perr = OS_ERR_PEND_ABORT;                //异常

                 break;

            case OS_STAT_PEND_TO:
            default:

                 *perr = OS_ERR_TIMEOUT;                   //超时

                 break;

        }

        return (flags_rdy);//因为是超时或者异常而恢复到就绪状态，所以直接返回

    }

//下面是在时间内，条件得到满足，需要完成的

    flags_rdy = OSTCBCur->OSTCBFlagsRdy; //从任务控制块中取出等待事件组的标志

    if (consume == OS_TRUE) {                              //消耗类型，则需要根据不同的等待类型，对等待事件组进行清除。

        switch (wait_type) {

            case OS_FLAG_WAIT_SET_ALL:

            case OS_FLAG_WAIT_SET_ANY:                     

                 pgrp->OSFlagFlags &= (OS_FLAGS)~flags_rdy;
                 break;

#if OS_FLAG_WAIT_CLR_EN > 0u
            case OS_FLAG_WAIT_CLR_ALL:
            case OS_FLAG_WAIT_CLR_ANY:                     /* Set   ONLY the flags we got              */
                 pgrp->OSFlagFlags |=  flags_rdy;
                 break;
#endif
            default:
                 OS_EXIT_CRITICAL();
                 *perr = OS_ERR_FLAG_WAIT_TYPE;
                 return ((OS_FLAGS)0);
        }
    }

    OS_EXIT_CRITICAL();

    *perr = OS_ERR_NONE;                                   /* Event(s) must have occurred   */

    return (flags_rdy);

4：查询事件标志组组信息OSFlagQuery

函数原型为OS_FLAGS  OSFlagQuery (OS_FLAG_GRP  *pgrp, INT8U   *perr)

5：标志节点任务就绪OS_FlagTaskRdy

该函数的原型如下：BOOLEAN  OS_FlagTaskRdy (OS_FLAG_NODE *pnode,OS_FLAGS      flags_rdy)

其主要功能是将标志节点pnode指向的任务转为就绪态

代码如下：

OS_TCB   *ptcb;

    BOOLEAN   sched;

//获取任务控制块的地址，同时将任务控制块修改跟事件标志组相关的数据结构

    ptcb                 = (OS_TCB *)pnode->OSFlagNodeTCB; 

    ptcb->OSTCBDly       = 0u;
    ptcb->OSTCBFlagsRdy  = flags_rdy; 
    ptcb->OSTCBStat     &= (INT8U)~(INT8U)OS_STAT_FLAG;

    ptcb->OSTCBStatPend  = OS_STAT_PEND_OK;

    if (ptcb->OSTCBStat == OS_STAT_RDY) {                  //任务状态为就绪

        OSRdyGrp               |= ptcb->OSTCBBitY;         //更新就绪数组和就绪表

        OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
        sched                   = OS_TRUE;
    } else {
        sched                   = OS_FALSE;
    }
    OS_FlagUnlink(pnode);
    return (sched);

}

6：删除事件标志组OSFlagDel

该函数的原型如下：OS_FLAG_GRP  *OSFlagDel (OS_FLAG_GRP  *pgrp, INT8U  opt,INT8U *perr)

该函数的主要功能就是删除事件组，并且对相应的数据结构进行操作。

参数opt有两种情况，OS_DEL_NO_PEND和OS_DEL_ALWAYS。

OS_DEL_NO_PEND 在没有任务等待该事件组的的时候删除该事件标志组

OS_DEL_ALWAYS  不管什么情况，始终删除该标志组

其主要代码如下：

if (pgrp->OSFlagWaitList != (void *)0) {               //是否有事件标志节点，从而判断是否有任务等待该事件标志组

        tasks_waiting = OS_TRUE;                           /* Yes                                      */
    } else {
        tasks_waiting = OS_FALSE;                          /* No                                       */

    }

  switch (opt) {

case OS_DEL_NO_PEND:                               //在没有任务等待的情况下删除事件标志组

             if (tasks_waiting == OS_FALSE) { //判断是否有任务等待该事件标志组，如果是有就进行删除操作

                 pgrp->OSFlagName     = (INT8U *)(void *)"?";

                 pgrp->OSFlagType     = OS_EVENT_TYPE_UNUSED; //将事件标志组类型改为OS_EVENT_TYPE_UNUSED，即未被使用

                 pgrp->OSFlagWaitList = (void *)OSFlagFreeList; //将该事件标志组加入到事件标志组空闲链表中

                 pgrp->OSFlagFlags    = (OS_FLAGS)0;
                 OSFlagFreeList       = pgrp;   
                 OS_EXIT_CRITICAL();
                 *perr                = OS_ERR_NONE;

                 pgrp_return          = (OS_FLAG_GRP *)0;  /* Event Flag Group has been deleted        */

             } else { //有任务在等待该事件标志组，不执行删除操作，返回

                 OS_EXIT_CRITICAL();
                 *perr                = OS_ERR_TASK_WAITING;
                 pgrp_return          = pgrp;
             }
             break;

        case OS_DEL_ALWAYS:                                //当为始终删除该等待事件组的时候

             pnode = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;//指向等待事件组的节点链表

             while (pnode != (OS_FLAG_NODE *)0) {          //遍历该链表

                 (void)OS_FlagTaskRdy(pnode, (OS_FLAGS)0); //将该链表中的节点指向的任务转为就绪状态

                 pnode = (OS_FLAG_NODE *)pnode->OSFlagNodeNext;

             }

//下面就是该等待事件标志组控制块加入到空闲链表中

             pgrp->OSFlagName     = (INT8U *)(void *)"?"; 

#endif
             pgrp->OSFlagType     = OS_EVENT_TYPE_UNUSED;
             pgrp->OSFlagWaitList = (void *)OSFlagFreeList;/* Return group to free list                */
             pgrp->OSFlagFlags    = (OS_FLAGS)0;
             OSFlagFreeList       = pgrp;

             OS_EXIT_CRITICAL();

             if (tasks_waiting == OS_TRUE) {               //如果之前是有任务在等待事件标志组

                 OS_Sched();                               //执行调度

             }
             *perr = OS_ERR_NONE;
             pgrp_return          = (OS_FLAG_GRP *)0;      /* Event Flag Group has been deleted        */
             break;

        default:
             OS_EXIT_CRITICAL();
             *perr                = OS_ERR_INVALID_OPT;
             pgrp_return          = pgrp;
             break;

    }

7：提交事件标志组OSFlagPost

提交事件标志组函数将对事件标志组中的事件标志进行操作，并且根据事件等待的标志，恢复阻塞的任务就绪。

其函数原型如下：OS_FLAGS  OSFlagPost (OS_FLAG_GRP  *pgrp,OS_FLAGS      flags,INT8U         opt,  INT8U        *perr)

其参数中OPT 有两个选项OS_FLAG_SET和OS_FLAG_CLR，flags为掩码之前有解释很详细。

OS_FLAG_SET是将掩码对应的位置为1

OS_FLAG_CLR是将掩码对应的位置为0

其源码如下：

switch (opt) {

        case OS_FLAG_CLR: //掩码对应的位清零

             pgrp->OSFlagFlags &= (OS_FLAGS)~flags;  //掩码取反然后将，进行AND运算，就将掩码对应的位置清零

             break;

        case OS_FLAG_SET: //掩码对应的位置为1

             pgrp->OSFlagFlags |=  flags;            //直接进行OR运算，对应的位就为1

             break;

        default:
             OS_EXIT_CRITICAL();                     /* INVALID option                                 */
             *perr = OS_ERR_FLAG_INVALID_OPT;
             return ((OS_FLAGS)0);

    }

    sched = OS_FALSE;                                //sched取值表示该是否需要进行调度

    pnode = (OS_FLAG_NODE *)pgrp->OSFlagWaitList; //取得第一个事件标志节点的地址

    while (pnode != (OS_FLAG_NODE *)0) {             //若该地址不为空，则说说明标志节点链表不为空，同时说明有任务在等待该事件标志组，遍历该链表

        switch (pnode->OSFlagNodeWaitType) {  //事件标志节点的等待类型

            case OS_FLAG_WAIT_SET_ALL:               //所有等待事件对应的位设置为1

                 flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & pnode->OSFlagNodeFlags);

                 if (flags_rdy == pnode->OSFlagNodeFlags) { //判断事情是全部否发生

                     rdy = OS_FlagTaskRdy(pnode, flags_rdy);  //若是，则将对应任务运行状态由阻塞转为就绪

                     if (rdy == OS_TRUE) {

                         sched = OS_TRUE;                     //同时sched赋值，表示可以调度

                     }
                 }
                 break;

            case OS_FLAG_WAIT_SET_ANY:               //任一等待事件的位设置为1

                 flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & pnode->OSFlagNodeFlags);
                 if (flags_rdy != (OS_FLAGS)0) {

                     rdy = OS_FlagTaskRdy(pnode, flags_rdy);  /* Make task RTR, event(s) Rx'd*/

                     if (rdy == OS_TRUE) {
                         sched = OS_TRUE;                     /* When done we will reschedule          */
                     }
                 }
                 break;

#if OS_FLAG_WAIT_CLR_EN > 0u

            case OS_FLAG_WAIT_CLR_ALL:               //所有的等待事件的位都为0

                 flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & pnode->OSFlagNodeFlags;

                 if (flags_rdy == pnode->OSFlagNodeFlags) { 

                     rdy = OS_FlagTaskRdy(pnode, flags_rdy);  /* Make task RTR, event(s) Rx'd          */
                     if (rdy == OS_TRUE) {
                         sched = OS_TRUE;                     /* When done we will reschedule          */
                     }
                 }
                 break;

            case OS_FLAG_WAIT_CLR_ANY:               //若有等待事件对应的位的任意位为0

                 flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & pnode->OSFlagNodeFlags;
                 if (flags_rdy != (OS_FLAGS)0) {
                     rdy = OS_FlagTaskRdy(pnode, flags_rdy);  /* Make task RTR, event(s) Rx'd          */
                     if (rdy == OS_TRUE) {
                         sched = OS_TRUE;                     /* When done we will reschedule          */
                     }
                 }
                 break;
#endif
            default:
                 OS_EXIT_CRITICAL();
                 *perr = OS_ERR_FLAG_WAIT_TYPE;
                 return ((OS_FLAGS)0);
        }

        pnode = (OS_FLAG_NODE *)pnode->OSFlagNodeNext; /指向下一个节点/

    }
    OS_EXIT_CRITICAL();
    if (sched == OS_TRUE) { //调度
        OS_Sched();

    }

 

    OS_ENTER_CRITICAL();
    flags_cur = pgrp->OSFlagFlags; 
    OS_EXIT_CRITICAL();

    *perr     = OS_ERR_NONE;

    return (flags_cur);//返回事件标志组的事件标志

}

从这里可以看出，当有事件标志组提交的时候，事件标志组的管理以及获取不是根据优先级优先得到的，而是后申请（阻塞）的任务先得到，先申请（阻塞）任务后得到。

因为后面申请并阻塞的任务的时候，最近阻塞节点总是在链表的第一个节点，而唤醒等待任务的时候，是遍历的，第一个任务肯定是最早的。这是跟前面的信号量是有很大的不同

8：不等待请求事件标志组OSFlagAccept

该函数的主要功能就是请求事件标志组，若事件标志组的不可用，则不阻塞，转而执行其他。

其函数原型如下：OS_FLAGS  OSFlagAccept (OS_FLAG_GRP  *pgrp, OS_FLAGS      flags, INT8U         wait_type,NT8U        *perr)

该函数的实现跟请求事件标志组差不多。差别在于等待事件标志组不可用的时候。该函数的直接返回，并返回不可用状态。