OS_FLAG.C（3）

上篇我们介绍了创建和删除事件标志组函数，后来在接着看源代码的时候，发现倒着来更有助于理解。所以后面几篇我会选择较为合适的方式来不定期更博，方便大家理解。

1.介绍删除节点函数OS_FlagUnlink (OS_FLAG_NODE *pnode)：

/*$PAGE*/
/*2018/2/13
*********************************************************************************************************
*                                  UNLINK EVENT FLAG NODE FROM WAITING LIST
*                                   从等待列表中将事件标志节点取消关联（删除节点）
* Description: This function is internal to uC/OS-II and is used to unlink an event flag node from a
*              list of tasks waiting for the event flag.
*描述：该功能为内部函数，用来从等待事件标志任务列表中解除事件标志节点
* Arguments  : pnode         is a pointer to a structure which contains data about the task waiting for
*                            event flag bit(s) to be set.
*参数：                     --pnode：指向结构体的指针。该结构体中包含等待事件标志位的任务的数据。
* Returns    : none
*返回值：无
* Called by  : OS_FlagTaskRdy() OS_FLAG.C
*              OSFlagPend()     OS_FLAG.C
*              OSTaskDel()      OS_TASK.C
*可以被：OS_FLAG.C文件中的OS_FlagTaskRdy()和OSFlagPend()函数还有OS_TASK.C文件中的OSTaskDel()函数调用。
* Note(s)    : 1) This function assumes that interrupts are disabled.
*              2) This function is INTERNAL to uC/OS-II and your application should not call it.注释:1）该功能不可以被中断。为原子函数2）该功能为内部函数，你的应用程序不能调用。
*********************************************************************************************************
*/void  OS_FlagUnlink (OS_FLAG_NODE *pnode)/*pnode为要进行移除的节点*/
{#if OS_TASK_DEL_EN > 0uOS_TCB       *ptcb;#endifOS_FLAG_GRP  *pgrp;             /*pgrp指向事件标志组*/OS_FLAG_NODE *pnode_prev;        /*pnode_prev指向前一个节点*/OS_FLAG_NODE *pnode_next;      /*pnode_next指向后一个节点*/pnode_prev = (OS_FLAG_NODE *)pnode->OSFlagNodePrev;pnode_next = (OS_FLAG_NODE *)pnode->OSFlagNodeNext;if (pnode_prev == (OS_FLAG_NODE *)0) /*如果前一个节点为空。那么pnode指向的是等待列表的首节点（相当于删除首节点）*/{                      pgrp= (OS_FLAG_GRP *)pnode->OSFlagNodeFlagGrp;    /*pgrp指向要移除节点所在的组*/pgrp->OSFlagWaitList = (void *)pnode_next;       /*将该节点的下一个作为pgrp指向等待列表的指针*/if (pnode_next != (OS_FLAG_NODE *)0)            /*如果下一个节点不是空*/{pnode_next->OSFlagNodePrev = (OS_FLAG_NODE *)0;     /* 将下一个节点指向前一个节点的指针设置为空*/}} else/*如果前一个节点不为空，不是首节点（相当于从中间删除）*/{                                             pnode_prev->OSFlagNodeNext = pnode_next;               if (pnode_next != (OS_FLAG_NODE *)0) {                  pnode_next->OSFlagNodePrev = pnode_prev;            }}#if OS_TASK_DEL_EN > 0u        /*如果允许删除任务*/ptcb = (OS_TCB *)pnode->OSFlagNodeTCB;  /*将该节点指向的TCB节点赋给ptcb指针*/ptcb->OSTCBFlagNode = (OS_FLAG_NODE *)0;/*将该指针下的TCB标志节点设为空，表示删除*/#endif
}
#endif

从这个函数中不难看出，如果要删除节点，首先要看删除的是首节点还是中间结点或者尾节点，然后进行删除。

删除的方式这里也不需要赘述了，比较简单。可以参考上一篇。

2.介绍是否可以使任务变为就绪态（是否可以被调度）BOOLEAN OS_FlagTaskRdy (OS_FLAG_NODE *pnode,OS_FLAGS flags_rdy)函数：

/*$PAGE*/
/*2018/2/13
*********************************************************************************************************
*                              MAKE TASK READY-TO-RUN, EVENT(s) OCCURRED
*               是否可以使任务变为就绪态
* Description: This function is internal to uC/OS-II and is used to make a task ready-to-run because the
*              desired event flag bits have been set.
*描述：该功能函数是内部函数。作用为当事件标志位被设置后使任务变为就绪态。
* Arguments  : pnode         is a pointer to a structure which contains data about the task waiting for
*                            event flag bit(s) to be set.
*参数：         --pnode：指向结构体的指针。该结构体包括了等待事件标志位被设置的任务数据。
*              flags_rdy     contains the bit pattern of the event flags that cause the task to become
*                            ready-to-run.
*           --flags_rdy：事件标志组的位模式
* Returns    : OS_TRUE       If the task has been placed in the ready list and thus needs scheduling
*              OS_FALSE      The task is still not ready to run and thus scheduling is not necessary
*返回值:   OS_TRUE：返回真，说明任务已经被放在了就绪列表中，需要调度；OS_FALSE：返回假，说明该任务仍处于等待状态，不需要进行调度。
* Called by  : OSFlagsPost() OS_FLAG.C
*被OS_FLAG.C文件中的OSFlagsPost（）函数调用。
* Note(s)    : 1) This function assumes that interrupts are disabled.
*              2) This function is INTERNAL to uC/OS-II and your application should not call it.注释：1）该功能不可以被中断‘2）该功能为内部函数，你的应用程序不能调用。
*********************************************************************************************************
*/static  BOOLEAN  OS_FlagTaskRdy (OS_FLAG_NODE *pnode,OS_FLAGS      flags_rdy)
{OS_TCB   *ptcb;            /*指向TCB的指针*/BOOLEAN   sched;        /*是否调度的标志*/ptcb = (OS_TCB *)pnode->OSFlagNodeTCB; /*指向正在等待的任务的TCB*/ptcb->OSTCBDly       = 0u;               /*将TCB的延迟时间设置为0*/ptcb->OSTCBFlagsRdy  = flags_rdy;      ptcb->OSTCBStat     &= (INT8U)~(INT8U)OS_STAT_FLAG;ptcb->OSTCBStatPend  = OS_STAT_PEND_OK;if (ptcb->OSTCBStat == OS_STAT_RDY)      /*如果此时TCB状态为就绪态*/{                OSRdyGrp |= ptcb->OSTCBBitY;         /*将任务放在就绪队列中*/OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;  /*得到位掩码*/sched = OS_TRUE;          /*将调度标志设置为真*/} else{sched = OS_FALSE;          /*将调度标志设置为假*/}OS_FlagUnlink(pnode);         /*调用删除节点函数，将已放在就绪列表中的该节点从等待列表中删除*/return (sched);                    /*返回是否调度的真假值*/
}

该函数的作用很清楚：判断任务是否可以转化为就绪态。如果可以转化，就将标志设置为真，不可以，就设置为假，然后返回。

但是这里面有一个问题，我有点疑惑：

   OS_FlagUnlink(pnode);         /*调用删除节点函数，将已放在就绪列表中的该节点从等待列表中删除*/

该行语句不在if~else语句中，说明不论是否任务已经准备好从等待态转化为就绪态，都从等待列表中删除。这样对吗？或者是我哪里理解错误？请高手指点一二。

3.介绍初始化事件标志函数 OS_FlagInit (void)：

/*$PAGE*/
/*2018/2/13
*********************************************************************************************************
*                                    INITIALIZE THE EVENT FLAG MODULE
*                                       初始化事件标志
* Description: This function is called by uC/OS-II to initialize the event flag module.  Your application
*              MUST NOT call this function.  In other words, this function is internal to uC/OS-II.
*描述：该功能用来初始化事件标志模块。你的应用程序不能调用该功能。
* Arguments  : none
*参数：无
* Returns    : none
*返回值：无
* WARNING    : You MUST NOT call this function from your code.  This is an INTERNAL function to uC/OS-II.
警告：在你的代码中不能调用该功能，这是uc/os的内部函数。
*********************************************************************************************************
*/
void  OS_FlagInit (void)
{#if OS_MAX_FLAGS == 1u       /*如果只有一个标志*/OSFlagFreeList = (OS_FLAG_GRP *)&OSFlagTbl[0];  /*只有一个事件标志组，空闲列表指针指向标志表中第0号内容*/OSFlagFreeList->OSFlagType     = OS_EVENT_TYPE_UNUSED;/*将标志类型设置为未使用类型*/OSFlagFreeList->OSFlagWaitList = (void *)0;       /*将等待列表指针置为空*/OSFlagFreeList->OSFlagFlags    = (OS_FLAGS)0; /*将标志设为0*/#if OS_FLAG_NAME_EN > 0uOSFlagFreeList->OSFlagName     = (INT8U *)"?";   /*将名字设置为未命名*/#endif#endif#if OS_MAX_FLAGS >= 2u /*如果不止一个标志*/INT16U        ix;INT16U        ix_next; OS_FLAG_GRP  *pgrp1;    /*第一个指向事件标志组的指针*/OS_FLAG_GRP  *pgrp2;   /*第一个指向事件标志组的指针*/OS_MemClr((INT8U *)&OSFlagTbl[0], sizeof(OSFlagTbl));  /* 从内存中清除事件标志组表*/for (ix = 0u; ix < (OS_MAX_FLAGS - 1u); ix++)            /*遍历该表，初始化所有的事件标志*/{            ix_next = ix + 1u;pgrp1 = &OSFlagTbl[ix];pgrp2 = &OSFlagTbl[ix_next];pgrp1->OSFlagType = OS_EVENT_TYPE_UNUSED;       /*将标志类型设置为未使用类型*/pgrp1->OSFlagWaitList = (void *)pgrp2;         /*将指向下一个标志的指针赋给OSFlagWaitList*/#if OS_FLAG_NAME_EN > 0upgrp1->OSFlagName     = (INT8U *)(void *)"?"; /*将名称初始化为未命名*/#endif}pgrp1 = &OSFlagTbl[ix];         /*处理该表的最后一个*/pgrp1->OSFlagType     = OS_EVENT_TYPE_UNUSED;pgrp1->OSFlagWaitList = (void *)0;
#if OS_FLAG_NAME_EN > 0upgrp1->OSFlagName     = (INT8U *)(void *)"?";
#endifOSFlagFreeList        = &OSFlagTbl[0];
#endif
}

初始化函数我们之前在OS_CORE.C文件中也有过介绍。这个函数与那些初始化函数大同小异。此处不赘述。

4.介绍阻塞任务函数 void OS_FlagBlock (OS_FLAG_GRP *pgrp,OS_FLAG_NODE *pnode,OS_FLAGS flags,INT8U wait_type, INT32U timeout)

/*$PAGE*/
/*2018/2/13
*********************************************************************************************************
*                         SUSPEND TASK UNTIL EVENT FLAG(s) RECEIVED OR TIMEOUT OCCURS
*                           将任务挂起，直到标志被接收或者超时
* Description: This function is internal to uC/OS-II and is used to put a task to sleep until the desired
*              event flag bit(s) are set.
*描述：该功能为内部函数，用来将任务处于睡眠状态，知道事件标志位被设置
* Arguments  : pgrp          is a pointer to the desired event flag group.
*参数：                     -pgrp：指向事件标志组的指针
*              pnode         is a pointer to a structure which contains data about the task waiting for
*                            event flag bit(s) to be set.
*                           --pnode：指向结构体的指针。
*              flags         Is a bit pattern indicating which bit(s) (i.e. flags) you wish to check.
*                            The bits you want are specified by setting the corresponding bits in
*                            'flags'.  e.g. if your application wants to wait for bits 0 and 1 then
*                            'flags' would contain 0x03.
*                           --flags：存放你想检测的位。
*              wait_type     specifies whether you want ALL bits to be set/cleared or ANY of the bits
*                            to be set/cleared.
*                            You can specify the following argument:
*                            OS_FLAG_WAIT_CLR_ALL   You will check ALL bits in 'mask' to be clear (0)
*                            OS_FLAG_WAIT_CLR_ANY   You will check ANY bit  in 'mask' to be clear (0)
*                            OS_FLAG_WAIT_SET_ALL   You will check ALL bits in 'mask' to be set   (1)
*                            OS_FLAG_WAIT_SET_ANY   You will check ANY bit  in 'mask' to be set   (1)
*                           --timeout：设置等待类型：OS_FLAG_WAIT_CLR_ALLOS_FLAG_WAIT_CLR_ANYOS_FLAG_WAIT_SET_ALLOS_FLAG_WAIT_SET_ANY
*              timeout       is the desired amount of time that the task will wait for the event flag
*                            bit(s) to be set.
* Returns    : none
*返回值：无
* Called by  : OSFlagPend()  OS_FLAG.C
*被OS_FLAG.C文件中的OSFlagPend（）调用。
* Note(s)    : This function is INTERNAL to uC/OS-II and your application should not call it.注释：该功能为内部函数，你的应用程序不能调用。
*********************************************************************************************************
*/
static  void  OS_FlagBlock (OS_FLAG_GRP  *pgrp,OS_FLAG_NODE *pnode,OS_FLAGS      flags,INT8U         wait_type,INT32U        timeout)
{OS_FLAG_NODE  *pnode_next;     /*指向下一个节点的指针*/INT8U          y;/*设置当前TCB的参数*/OSTCBCur->OSTCBStat      |= OS_STAT_FLAG;  OSTCBCur->OSTCBStatPend   = OS_STAT_PEND_OK;OSTCBCur->OSTCBDly        = timeout;             /*TCB延时设置为timeout*//*以下几行代码都是将pnode设置为链表的新的头节点*/#if OS_TASK_DEL_EN > 0uOSTCBCur->OSTCBFlagNode   = pnode;            /* 将TCB与node联系起来 */#endifpnode->OSFlagNodeFlags    = flags;                /* 保存我们需要等待的标志*/pnode->OSFlagNodeWaitType = wait_type;            /*保存等待类型 */pnode->OSFlagNodeTCB      = (void *)OSTCBCur;     /*标志指向的TCB为当前的TCB*/pnode->OSFlagNodeNext     = pgrp->OSFlagWaitList; /*将节点的指针指向节点链表的头部*/pnode->OSFlagNodePrev     = (void *)0;pnode->OSFlagNodeFlagGrp  = (void *)pgrp;         /*连接事件标志组 */pnode_next                = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;/*下一个节点*/if (pnode_next != (void *)0)   /*如果为空地址，只有一个节点（就是本节点），如果非空，那么将该链表的头节点改为现在这个节点*/{                 pnode_next->OSFlagNodePrev = pnode;         }pgrp->OSFlagWaitList = (void *)pnode;y =  OSTCBCur->OSTCBY;                 /* 将当前的任务挂起（取消该任务的就绪态）更改就绪表和就绪组的相关值*/OSRdyTbl[y] &= (OS_PRIO)~OSTCBCur->OSTCBBitX;if (OSRdyTbl[y] == 0x00u) {OSRdyGrp &= (OS_PRIO)~OSTCBCur->OSTCBBitY;}
}

这个函数里提示一点：

 /*以下几行代码都是将pnode设置为链表的新的头节点*/#if OS_TASK_DEL_EN > 0uOSTCBCur->OSTCBFlagNode   = pnode;            /* 将TCB与node联系起来 */#endifpnode->OSFlagNodeFlags    = flags;                /* 保存我们需要等待的标志*/pnode->OSFlagNodeWaitType = wait_type;            /*保存等待类型 */pnode->OSFlagNodeTCB      = (void *)OSTCBCur;     /*标志指向的TCB为当前的TCB*/pnode->OSFlagNodeNext     = pgrp->OSFlagWaitList; /*将节点的指针指向节点链表的头部*/pnode->OSFlagNodePrev     = (void *)0;pnode->OSFlagNodeFlagGrp  = (void *)pgrp;         /*连接事件标志组 */pnode_next                = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;/*下一个节点*/

注释里提到了：这几行就是将当前的节点pnode设置为等待列表的新的头节点，取消其就绪状态，设置为挂起状态。

在这个的基础上理解上面几行语句就很简单了。

5.OSFlagQuery (OS_FLAG_GRP *pgrp,INT8U *perr)查询事件标志函数：

/*$PAGE*/
/*2018/2/13
*********************************************************************************************************
*                                           QUERY EVENT FLAG
*                                           查询事件标志
* Description: This function is used to check the value of the event flag group.
*描述：该功能用来检测事件标志组的值
* Arguments  : pgrp         is a pointer to the desired event flag group.
*参数：                     --pgrp：指向事件标志组的指针
*              perr          is a pointer to an error code returned to the called:
*                            OS_ERR_NONE                The call was successfull
*                            OS_ERR_FLAG_INVALID_PGRP   You passed a NULL pointer
*                            OS_ERR_EVENT_TYPE          You are not pointing to an event flag group
*                           --perr错误码指针：OS_ERR_NONE：无错误；OS_ERR_FLAG_INVALID_PGRP：pgrp为空指针；OS_ERR_EVENT_TYPE：没有指向事件标志组的指针。
* Returns    : The current value of the event flag group.
*返回值：事件标志组的当前值
* Called From: Task or ISR
任务或者中断调用。
*********************************************************************************************************
*/#if OS_FLAG_QUERY_EN > 0u
OS_FLAGS  OSFlagQuery (OS_FLAG_GRP  *pgrp,INT8U        *perr)
{OS_FLAGS   flags;              /*定义一个“当前位”状态*/#if OS_CRITICAL_METHOD == 3u                     OS_CPU_SR  cpu_sr = 0u;#endif#ifdef OS_SAFETY_CRITICAL           /*安全中断*/if (perr == (INT8U *)0) {OS_SAFETY_CRITICAL_EXCEPTION();}#endif#if OS_ARG_CHK_EN > 0u              /*检查参数*/if (pgrp == (OS_FLAG_GRP *)0) {             *perr = OS_ERR_FLAG_INVALID_PGRP;return ((OS_FLAGS)0);}#endifif (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) /*有效化事件标志块类型*/{ *perr = OS_ERR_EVENT_TYPE;return ((OS_FLAGS)0);}OS_ENTER_CRITICAL();       /*进入中断*/ flags = pgrp->OSFlagFlags; /*获取事件标志组的当前的事件标志位值*/OS_EXIT_CRITICAL();            /*关闭中断*/*perr = OS_ERR_NONE;       /*将错误码指针设置为成功调用*/return (flags);             /*返回当前事件标志状态*/
}
#endif

该函数关键语句就是上面标红的那一行。

6.设置或清除事件标志组OSFlagPost (OS_FLAG_GRP *pgrp,OS_FLAGS flags,INT8U opt，INT8U *perr)函数：

/*$PAGE*/
/*2018/2/13
*********************************************************************************************************
*                                         POST EVENT FLAG BIT(S)
*                                           设置或清除事件标志组
* Description: This function is called to set or clear some bits in an event flag group.  The bits to
*              set or clear are specified by a 'bit mask'.
*描述：该功能用来设置或者清除事件标志组中的一些位。这些位由位掩码来指定。
* Arguments  : pgrp          is a pointer to the desired event flag group.
*参数：                     --pgrp：指向事件标志组的指针
*              flags         If 'opt' (see below) is OS_FLAG_SET, each bit that is set in 'flags' will
*                            set the corresponding bit in the event flag group.  e.g. to set bits 0, 4
*                            and 5 you would set 'flags' to:
*                                0x31     (note, bit 0 is least significant bit)
*                           --flags：如果opt是OS_FLAG_SET，那么在flags中的每一位将在事件标志组中的相应位上也进行设置。例如：如果要将事件标志组中的位设置为0，4，5位为1，那么你就得将flags设置为00110001。（注释：0位是最低有效位）
*                            If 'opt' (see below) is OS_FLAG_CLR, each bit that is set in 'flags' will
*                            CLEAR the corresponding bit in the event flag group.  e.g. to clear bits 0,
*                            4 and 5 you would specify 'flags' as:0x31     (note, bit 0 is least significant bit)
*                           --如果opt为OS_FLAG_CLR，那么在flags中设置的每一位对应在事件标志组中的对应位将被清除掉。例如：如果要清除掉事件标志组中的第0，4，5位，你的flags就应该被指定为00110001（注释：0是最低有效位）
*
*              opt           indicates whether the flags will be:
*                                set     (OS_FLAG_SET) or
*                                cleared (OS_FLAG_CLR)
*                           --opt：有以下两种选择：set(OS_FLAG_SET)设置或者 cleared (OS_FLAG_CLR)清除。这两个不同的选择对flags有影响。
*              perr          is a pointer to an error code and can be:
*                            OS_ERR_NONE                The call was successfull
*                            OS_ERR_FLAG_INVALID_PGRP   You passed a NULL pointer
*                            OS_ERR_EVENT_TYPE          You are not pointing to an event flag group
*                            OS_ERR_FLAG_INVALID_OPT    You specified an invalid option
*                           --perr：指向错误码的指针，可以为以下值：OS_ERR_NONE：无错误；OS_ERR_FLAG_INVALID_PGRP：pgrp为空指针；OS_ERR_EVENT_TYPE：没有指向事件标志组的指针；OS_ERR_FLAG_INVALID_OPT：opt参数选择错误。
* Returns    : the new value of the event flags bits that are still set.
*返回值：flags被修改后的值
* Called From: Task or ISR
*由任务或者中断调用。
* WARNING(s) : 1) The execution time of this function depends on the number of tasks waiting on the event
*                 flag group.
*              2) The amount of time interrupts are DISABLED depends on the number of tasks waiting on
*                 the event flag group.警告：1）该功能的执行时间取决于事件标志组中的等待任务数量；2）时间中断无效的数目取决于事件标志组中的等待任务数。
*********************************************************************************************************
*///置位或清0事件标志组中的标志位(指针、标志位、条件值、错误码)
OS_FLAGS  OSFlagPost (OS_FLAG_GRP  *pgrp,OS_FLAGS      flags,INT8U         opt,INT8U        *perr)
{OS_FLAG_NODE *pnode;               /*指向标志节点的指针*/BOOLEAN       sched;               /*是否被调度变量*/OS_FLAGS      flags_cur;         /*当前的标志值（flags）*/OS_FLAGS      flags_rdy;         /*就绪的标志值（flags）*/BOOLEAN       rdy;                   /*是否就绪变量*/#if OS_CRITICAL_METHOD == 3u       /*中断被设置为类型3*/OS_CPU_SR     cpu_sr = 0u;#endif#ifdef OS_SAFETY_CRITICAL          /*定义安全中断*/if (perr == (INT8U *)0) {OS_SAFETY_CRITICAL_EXCEPTION();}#endif#if OS_ARG_CHK_EN > 0u                /*检查参数*/if (pgrp == (OS_FLAG_GRP *)0) /*有效化pgrp*/{               *perr = OS_ERR_FLAG_INVALID_PGRP;return ((OS_FLAGS)0);}#endifif (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) /*确定我们指向的是事件标志组*/{   *perr = OS_ERR_EVENT_TYPE;return ((OS_FLAGS)0);}
/*$PAGE*/OS_ENTER_CRITICAL();   /*进入中断*/switch (opt) {case OS_FLAG_CLR: /*opt为OS_FLAG_CLR*/pgrp->OSFlagFlags &= (OS_FLAGS)~flags;  /*清除在事件标志组中设置的位*/break;case OS_FLAG_SET: /*opt为OS_FLAG_SET*/pgrp->OSFlagFlags |=  flags;            /* 设置在事件标志组中设置的位*/break;default:                                 /*无效的选择*/OS_EXIT_CRITICAL();                     /*关中断*/*perr = OS_ERR_FLAG_INVALID_OPT;       /*将中断码设置为OS_ERR_FLAG_INVALID_OPT*/return ((OS_FLAGS)0);                 /*返回值为0*/}sched = OS_FALSE;                             /*将调度标志设置为false，表示不需要调度*/pnode = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;while (pnode != (OS_FLAG_NODE *)0)            /*浏览等待事件标志的所有任务*/{            switch (pnode->OSFlagNodeWaitType)        /*根据等待类型不同执行不同的代码*/{case OS_FLAG_WAIT_SET_ALL:          /*要求所有的位都被设置*/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;              /*可以进行调度*/}}break;case OS_FLAG_WAIT_SET_ANY:               /*任意一位被设置*/flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & pnode->OSFlagNodeFlags);if (flags_rdy != (OS_FLAGS)0)  /*有任何一个标志位被设置*/{rdy = OS_FlagTaskRdy(pnode, flags_rdy);   /*得到该节点对应的任务是否就绪标志*/if (rdy == OS_TRUE)                     /*该节点对应的任务已经就绪*/{sched = OS_TRUE;                  /*可以进行调度*/  }}break;/*下面两个case参考上文即可*/#if OS_FLAG_WAIT_CLR_EN > 0ucase OS_FLAG_WAIT_CLR_ALL:            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;                    }}break;case OS_FLAG_WAIT_CLR_ANY:          flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & pnode->OSFlagNodeFlags;if (flags_rdy != (OS_FLAGS)0) {rdy = OS_FlagTaskRdy(pnode, flags_rdy); if (rdy == OS_TRUE) {sched = OS_TRUE;                 }}break;#endifdefault:                        /*这四种情况都不是*/OS_EXIT_CRITICAL();         /*退出中断*/*perr = OS_ERR_FLAG_WAIT_TYPE;/*设置错误码为OS_ERR_FLAG_WAIT_TYPE*/return ((OS_FLAGS)0);         /*返回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);         /*返回当前的标志值*/
}

流程图为：

7. OSFlagPend (OS_FLAG_GRP *pgrp,OS_FLAGS flags, INT8U wait_type,INT32U timeout,INT8U *perr)等待事件标志组中的事件标志函数：

/*$PAGE*/
/*2018/2/12
*********************************************************************************************************
*                                        WAIT ON AN EVENT FLAG GROUP
*                                         等待事件标志组中的事件标志
* Description: This function is called to wait for a combination of bits to be set in an event flag
*              group.  Your application can wait for ANY bit to be set or ALL bits to be set.
*描述：任务等待事件标志组中的事件标志，可以是多个事件标志的不同组合方式。可以等待任意指定事件标志位置位或清0，也可以是全部指定事件标志位置位或清0。如果任务等待的事件标志位条件尚不满足，则任务会被挂起，直到指定的事件标志组合发生或指定的等待时间超时。
* Arguments  : pgrp          is a pointer to the desired event flag group.
*参数：                     --pgrp:指向事件标志组的指针
*              flags         Is a bit pattern indicating which bit(s) (i.e. flags) you wish to wait for.
*                            The bits you want are specified by setting the corresponding bits in
*                            'flags'.  e.g. if your application wants to wait for bits 0 and 1 then
*                            'flags' would contain 0x03.
*                           --flags：指定需要检查的事件标志位。置为1，则检查对应位；置为0，则忽略对应位。
*              wait_type     specifies whether you want ALL bits to be set or ANY of the bits to be set.
*                            You can specify the following argument:
*                           --wait_type：定义等待事件标志位的方式。可以定为以下几种
*                            OS_FLAG_WAIT_CLR_ALL   You will wait for ALL bits in 'mask' to be clear (0)
*                            OS_FLAG_WAIT_SET_ALL   You will wait for ALL bits in 'mask' to be set   (1)
*                            OS_FLAG_WAIT_CLR_ANY   You will wait for ANY bit  in 'mask' to be clear (0)
*                            OS_FLAG_WAIT_SET_ANY   You will wait for ANY bit  in 'mask' to be set   (1)
*                           --OS_FLAG_WAIT_CLR_ALL：所有指定事件标志位清0 ；OS_FLAG_WAIT_SET_ALL：任意指定事件标志位置1 ；OS_FLAG_WAIT_CLR_ANY：所有指定事件标志位清0 ；OS_FLAG_WAIT_SET_ANY：任意指定事件标志位置1 ；
*                            NOTE: Add OS_FLAG_CONSUME if you want the event flag to be 'consumed' by
*                                  the call.  Example, to wait for any flag in a group AND then clear
*                                  the flags that are present, set 'wait_type' to:
*                                  OS_FLAG_WAIT_SET_ANY + OS_FLAG_CONSUME
*                           --注释：如果你想在调用之后将事件标志组消耗掉，在等待类型后面加一个OS_FLAG_CONSUME。
*              timeout       is an optional timeout (in clock ticks) that your task will wait for the
*                            desired bit combination.  If you specify 0, however, your task will wait
*                            forever at the specified event flag group or, until a message arrives.
*                           --timeout：以时钟节拍数目的等待超时时限。如果在这一时限得不到事件，任务将恢复执行。timeout的值为0，表示将无限期地等待事件。timeout的最大值是65535个时钟节拍。timeout的值并不与时钟节拍同步，timeout计数器在下一个时钟节拍到来时开始递减。在这里，所谓下一个时钟节拍，也就是立刻就到来了。
*              perr          is a pointer to an error code and can be:
*                            OS_ERR_NONE               The desired bits have been set within the specified
*                                                      'timeout'.
*                            OS_ERR_PEND_ISR           If you tried to PEND from an ISR
*                            OS_ERR_FLAG_INVALID_PGRP  If 'pgrp' is a NULL pointer.
*                            OS_ERR_EVENT_TYPE         You are not pointing to an event flag group
*                            OS_ERR_TIMEOUT            The bit(s) have not been set in the specified
*                                                      'timeout'.
*                            OS_ERR_PEND_ABORT         The wait on the flag was aborted.
*                            OS_ERR_FLAG_WAIT_TYPE     You didn't specify a proper 'wait_type' argument.
*                           --perr：指向错误码的指针。可以为以下几种值：OS_ERR_NONE：无错误类型OS_ERR_PEND_ISR：从中断中调入该程序OS_ERR_FLAG_INVALID_PGRP：pgrp为空指针OS_ERR_EVENT_TYPE：没有指向事件标志组的指针OS_ERR_TIMEOUT：等待事件标志组的事件标志超时；OS_ERR_PEND_ABORT：等待标志被取消OS_ERR_FLAG_WAIT_TYPE：'wait_type'不是指定的参数之一。
* Returns    : The flags in the event flag group that made the task ready or, 0 if a timeout or an error
*              occurred.
*返回值：    如果任务就绪，返回事件标志组的标志。如果发生了超时或者其他错误,则返回0。
* Called from: Task ONLY
*只能由任务调用
* Note(s)    : 1) IMPORTANT, the behavior of this function has changed from PREVIOUS versions.  The
*                 function NOW returns the flags that were ready INSTEAD of the current state of the
*                 event flags.注释：1）该功能与以前版本的功能有些许差别。该版本下这个函数的返回值是是否等待就绪的标志而不是当前事件标志的状态。
*********************************************************************************************************
*///等待事件标志组的事件标志位(事件组指针、需要检查的标志位、等待事件标志位的方式、允许等待的时钟节拍、出错代码的时钟节拍)
OS_FLAGS  OSFlagPend (OS_FLAG_GRP  *pgrp,OS_FLAGS      flags,INT8U         wait_type,INT32U        timeout,INT8U        *perr)
{OS_FLAG_NODE  node;OS_FLAGS      flags_rdy;INT8U         result;INT8U         pend_stat;             /*挂起状态*/BOOLEAN       consume;                  /*是否为消耗类型标志*/
#if OS_CRITICAL_METHOD == 3u              /*中断类型被设定为3*/OS_CPU_SR     cpu_sr = 0u;
#endif#ifdef OS_SAFETY_CRITICAL             /*定义安全中断*/if (perr == (INT8U *)0) {OS_SAFETY_CRITICAL_EXCEPTION();}
#endif#if OS_ARG_CHK_EN > 0u                 /*检查参数*/if (pgrp == (OS_FLAG_GRP *)0)     {                      *perr = OS_ERR_FLAG_INVALID_PGRP;return ((OS_FLAGS)0);}
#endifif (OSIntNesting > 0u)             /*如果从中断中调用该函数*/{                               *perr = OS_ERR_PEND_ISR;        /*将错误码设置为OS_ERR_PEND_ISR*/                return ((OS_FLAGS)0);         /*返回值为0*/}if (OSLockNesting > 0u)                /*如果调度器被上锁了*/{                              *perr = OS_ERR_PEND_LOCKED;     /*无法调用该函数，将错误码设置为OS_ERR_PEND_LOCKED*/return ((OS_FLAGS)0);          /*返回值为0*/}if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) /*有效化事件标志类型*/{        *perr = OS_ERR_EVENT_TYPE;return ((OS_FLAGS)0);}result = (INT8U)(wait_type & OS_FLAG_CONSUME);    /*将等待类型和OS_FLAG_CONSUME做逻辑与运算，结果存到result中。*/if (result != (INT8U)0) {                       /* 如果不是0，说明是消耗类型 */wait_type &= (INT8U)~(INT8U)OS_FLAG_CONSUME;consume    = OS_TRUE;} else                 /*如果result是0，说明不是消耗类型*/{consume    = OS_FALSE;}
/*$PAGE*/OS_ENTER_CRITICAL();       /*进入中断*/switch (wait_type)          /*根据wait_type的状态执行不同的程序*/{case OS_FLAG_WAIT_SET_ALL:     /*如果是OS_FLAG_WAIT_SET_ALL类型*/flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & flags);   /*提取出我们需要的位 */if (flags_rdy == flags)  /*必须匹配到我们需要的所有的位*/{                    if (consume == OS_TRUE)  /*如果是消耗类型*/{                pgrp->OSFlagFlags &= (OS_FLAGS)~flags_rdy;   /*只清理掉我们需要的位 */}OSTCBCur->OSTCBFlagsRdy = flags_rdy;      /*将就绪标志保存到OSTCBFlagsRdy中*/OS_EXIT_CRITICAL();                       /* 退出中断*/*perr                   = OS_ERR_NONE;      /*将错误码设置为无错误类型*/return (flags_rdy);                     /*返回flags_rdy*/} else /*阻塞任务知道有事件发生或者超时 */{                                     OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);OS_EXIT_CRITICAL();}break;case OS_FLAG_WAIT_SET_ANY:flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & flags);  if (flags_rdy != (OS_FLAGS)0) {           if (consume == OS_TRUE) {              pgrp->OSFlagFlags &= (OS_FLAGS)~flags_rdy;   }OSTCBCur->OSTCBFlagsRdy = flags_rdy;  OS_EXIT_CRITICAL();                      *perr                   = OS_ERR_NONE;return (flags_rdy);} else{                                    OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);OS_EXIT_CRITICAL();}break;#if OS_FLAG_WAIT_CLR_EN > 0ucase OS_FLAG_WAIT_CLR_ALL:                         /* See if all required flags are cleared    */flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & flags;    /* Extract only the bits we want     */if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */if (consume == OS_TRUE) {                 /* See if we need to consume the flags      */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:flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & flags;   /* Extract only the bits we want      */if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag cleared                  */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;
#endifdefault:OS_EXIT_CRITICAL();flags_rdy = (OS_FLAGS)0;*perr      = OS_ERR_FLAG_WAIT_TYPE;return (flags_rdy);}
/*$PAGE*/OS_Sched();        /*进行调度。找需要运行的最高优先级任务*/ OS_ENTER_CRITICAL();/*进入中断*/if (OSTCBCur->OSTCBStatPend != OS_STAT_PEND_OK)  /*当前TCB挂起状态为取消或者超时状态*/{     pend_stat                = OSTCBCur->OSTCBStatPend;OSTCBCur->OSTCBStatPend  = OS_STAT_PEND_OK;OS_FlagUnlink(&node);OSTCBCur->OSTCBStat      = OS_STAT_RDY;            /* Yes, make task ready-to-run              */OS_EXIT_CRITICAL();flags_rdy                = (OS_FLAGS)0;switch (pend_stat) {case OS_STAT_PEND_ABORT:*perr = OS_ERR_PEND_ABORT;                /* Indicate that we aborted   waiting       */break;case OS_STAT_PEND_TO:default:*perr = OS_ERR_TIMEOUT;                   /* Indicate that we timed-out waiting       */break;}return (flags_rdy);}flags_rdy = OSTCBCur->OSTCBFlagsRdy;if (consume == OS_TRUE) {                              /* See if we need to consume the flags      */switch (wait_type) {case OS_FLAG_WAIT_SET_ALL:case OS_FLAG_WAIT_SET_ANY:                     /* Clear ONLY the flags we got              */pgrp->OSFlagFlags &= (OS_FLAGS)~flags_rdy;break;#if OS_FLAG_WAIT_CLR_EN > 0ucase OS_FLAG_WAIT_CLR_ALL:case OS_FLAG_WAIT_CLR_ANY:                     /* Set   ONLY the flags we got              */pgrp->OSFlagFlags |=  flags_rdy;break;
#endifdefault: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);
}

流程图如下：

到这里，OS_FLAG.C文件就介绍完了。中间有几个函数没有介绍，设置名称、获得名称函数。大家自行看源码，很简单。

下篇将会带着大家理一下整体的思路。

OS_FLAG.C（3）相关推荐

OS_FLAG.C（2）
本篇介绍OS_FLAG.C文件中的创建事件标志组函数*OSFlagCreate (OS_FLAGS flags,INT8U *perr)和删除事件标志组函数 *OSFlagDel (OS_FLAG_ ...
OS_FLAG.C（1）
本篇介绍OS_FLAG.C中的检测事件标志组的标志状态函数 OS_FLAGS OSFlagAccept (OS_FLAG_GRP *pgrp,OS_FLAGS flags,INT8U wait_t ...
OpenAPI使用（swagger3），Kotlin使用swagger3，Java使用swagger3，gradle、Maven使用swagger3
OpenAPI使用(swagger3) demo见Gitte 一.背景及名词解释 OpenAPI是规范的正式名称.规范的开发工作于2015年启动,当时SmartBear(负责Swagger工具开发的公 ...
2022-2028年中国第五代移动通信技术（5G）市场研究及前瞻分析报告
[报告类型]产业研究 [报告价格]4500起 [出版时间]即时更新(交付时间约3个工作日) [发布机构]智研瞻产业研究院 [报告格式]PDF版本报告介绍了中国第五代移动通信技术(5G)行业市场行业相 ...
2021-2027全球与中国经颅磁刺激仪（TMS）市场现状及未来发展趋势
[报告类型]产业研究 [报告价格]¥4500起 [出版时间]即时更新(交付时间约3个工作日) [发布机构]智研瞻产业研究院 [报告格式]PDF版本报告介绍了全球与中国经颅磁刺激仪(TMS)行业市场行 ...
Go 学习笔记（84）— Go 项目目录结构
1. 目录规范一个好的目录结构至少要满足以下几个要求. 命名清晰:目录命名要清晰.简洁,不要太长,也不要太短,目录名要能清晰地表达出该目录实现的功能,并且目录名最好用单数.一方面是因为单数足以说明这 ...
Redis 笔记（16）— info 指令和命令行工具（查看内存、状态、客户端连接数、监控服务器、扫描大key、采样服务器、执行批量命令等）
Info 命令返回关于 Redis 服务器的各种信息和统计数值.通过给定可选的参数 section ,可以让命令只返回某一部分的信息. 1. 显示模块 server : 一般 Redis 服务器信息, ...
Redis 笔记（12）— 单线程架构（非阻塞 IO、多路复用）和多个异步线程
Redis 使用了单线程架构.非阻塞 I/O .多路复用模型来实现高性能的内存数据库服务.Redis 是单线程的.那么为什么说是单线程呢? Redis 在 Reactor 模型内开发了事件处理器,这个 ...
Redis 笔记（10）— 发布订阅模式（发布订阅单个信道、订阅信道后的返回值分类、发布订阅多个信道）
1. 发布-订阅概念发布-订阅模式包含两种角色,分别为发布者和订阅者. 订阅者可以订阅一个或者若干个频道(channel): 而发布者可以向指定的频道发送消息,所有订阅此频道的订阅者都可以收到此消 ...

OS_FLAG.C（3）

OS_FLAG.C（3）相关推荐

最新文章

热门文章