Ucos源码分析------事件标志组

一如既往_

已于 2023-11-25 21:19:29 修改

阅读量317

点赞数 6

分类专栏： RTOS 文章标签： mcu

于 2023-11-20 23:46:15 首次发布

本文链接：https://blog.csdn.net/qq_43306777/article/details/134506665

版权

RTOS 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

Ucos源码分析

1.Ucos源码分析------任务控制块与任务调度
 2.Ucos源码分析------事件控制块与事件控制
 3.Ucos源码分析------信号量
 4.Ucos源码分析------邮箱与队列
 5.Ucos源码分析------事件标志组
 6.Ucos源码分析------内存管理
 7.Ucos源码分析------临界区与中断管理
 8.Ucos源码分析------OS启动
 9.Ucos总结

事件标志组的等待任务表的实现与其它事件不同：
事件标志组的waitlist指针指向等待节点，代替了其它事件类型的任务等待表。
一个事件标志组的多个任务标志组节点，代表等待该事件标志组的的任务。

1.事件标志组

当某任务要与多个事件同步时，使用事件标志组。
同步方式有独立型同步和关联型同步。

独立型同步：等待多个事件时，任何一个事件发生，任务都被同步。
关联型同步：等待多个事件时，所有的事件都发生，任务才被同步。

任务标志组控制块的基本成员如下

控制块成员
OSFlagType	事件类型，默认为OS_EVENT_TYPE_FLAG
*OSFlagWaitList	等待事件标志组的任务节点指针
OSFlagFlags	指定位数的任务标志组

任务标志组控制节点，是等待列表的实现形式，是任务标志组事件与任务连接的媒介
任务标志组控制节点的基本成员如下

节点成员
OSFlagNodeNext	等待列表中下一个节点的指针
OSFlagNodePrev	等待列表中上一个节点的指针
OSFlagNodeTCB	该节点所指向的任务，即任务控制块
OSFlagNodeFlagGrp	该节点所指向的件标志组控制块
OSFlagNodeFlags	该节点所指向的任务标志组
OSFlagNodeWaitType	事件等待形式

2.任务的等待与就绪

因为事件标志组的等待任务列表与其他事件不一样，所以任务等待和就绪实现也不一样。

任务等待
事件标志组控制块的等待任务列表的指针（pgrp->OSFlagWaitList）指向第一个调用的任务

static  void  OS_FlagBlock (OS_FLAG_GRP *pgrp, OS_FLAG_NODE *pnode, OS_FLAGS flags, INT8U wait_type, INT16U timeout)
{
    //事件标志组节点
    OS_FLAG_NODE  *pnode_next;

    // 当前任务的 等待事件标志组 状态置位
    OSTCBCur->OSTCBStat      |= OS_STAT_FLAG;
    //  当前任务的等待延时
    OSTCBCur->OSTCBDly        = timeout;              /* Store timeout in task's TCB                   */
#if OS_TASK_DEL_EN > 0
    OSTCBCur->OSTCBFlagNode   = pnode;                /* TCB to link to node                           */
#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; /* Add node at beginning of event flag wait list */
    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) {                    /* Is this the first NODE to insert?             */
        //不是形成双向链表
        pnode_next->OSFlagNodePrev = pnode;           /* No, link in doubly linked list                */
    }
    //将节点加入到 事件标志组事件的 任务等待表
    pgrp->OSFlagWaitList = (void *)pnode;
                                                      /* Suspend current task until flag(s) received   */
    //当前任务移出就绪表                                                 
    if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) {
        OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
    }
}

任务就绪

static  BOOLEAN  OS_FlagTaskRdy (OS_FLAG_NODE *pnode, OS_FLAGS flags_rdy)
{
    OS_TCB   *ptcb;
    BOOLEAN   sched;

    //获取当前时间标志组节点的任务
    ptcb                = (OS_TCB *)pnode->OSFlagNodeTCB;  /* Point to TCB of waiting task             */
    //任务超时清除
    ptcb->OSTCBDly      = 0;
    //任务标志组 等待的事件标志置位
    ptcb->OSTCBFlagsRdy = flags_rdy;
    //任务等待事件标志组 状态清除
    ptcb->OSTCBStat    &= ~OS_STAT_FLAG;
    //判断任务是否是就绪态
    if (ptcb->OSTCBStat == OS_STAT_RDY) {                  /* Put task into ready list                 */
        //是就绪态 将任务移到任务就绪表
        OSRdyGrp               |= ptcb->OSTCBBitY;
        OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
        //任务是就绪态 移到任务就绪表 返回允许调度
        sched                   = TRUE;
    } else {
        //任务是就绪态 移到任务就绪表 返回允许调度
        sched                   = FALSE;
    }
    //将任务标志组节点 移除,将等待任务清除
    OS_FlagUnlink(pnode);
    return (sched);
}

事件标志组节点的删除

void  OS_FlagUnlink (OS_FLAG_NODE *pnode)
{
#if OS_TASK_DEL_EN > 0
    OS_TCB       *ptcb;
#endif
    OS_FLAG_GRP  *pgrp; 
    OS_FLAG_NODE *pnode_prev;
    OS_FLAG_NODE *pnode_next;

    //待删除节点的前一个节点
    pnode_prev = (OS_FLAG_NODE *)pnode->OSFlagNodePrev;
    //待删除节点的后一个节点
    pnode_next = (OS_FLAG_NODE *)pnode->OSFlagNodeNext;
    //如果待删除节点是等待表的第一个节点
    if (pnode_prev == (OS_FLAG_NODE *)0) {                      /* Is it first node in wait list?      */
        //获取该节点对应的事件标志组事件控制块
        pgrp                 = (OS_FLAG_GRP *)pnode->OSFlagNodeFlagGrp;
        //事件标志组事件控制块的 等待表指针指向待删除节点的下一个节点
        pgrp->OSFlagWaitList = (void *)pnode_next;              /*      Update list for new 1st node   */
        //如果后一个节点存在
        if (pnode_next != (OS_FLAG_NODE *)0) {
            //后一个节点 成为等待表的第一个节点
            pnode_next->OSFlagNodePrev = (OS_FLAG_NODE *)0;     /*      Link new 1st node PREV to NULL */
        }
    } else { 
        //节点删除                                                   /* No,  A node somewhere in the list   */
        pnode_prev->OSFlagNodeNext = pnode_next;                /*      Link around the node to unlink */
        //如果后一个节点存在
        if (pnode_next != (OS_FLAG_NODE *)0) {                  /*      Was this the LAST node?        */
            //形成双向链表
            pnode_next->OSFlagNodePrev = pnode_prev;            /*      No, Link around current node   */
        }
    }
#if OS_TASK_DEL_EN > 0
    ptcb                = (OS_TCB *)pnode->OSFlagNodeTCB;
    ptcb->OSTCBFlagNode = (OS_FLAG_NODE *)0;
#endif
}

3.任务标志组的获取

OS_FLAGS OSFlagPend (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT16U timeout, INT8U *err)
参数：
　　pgrp：事件标志组控制块
　　flags ：事件标志组
　　wait_type ：等待类型
　　　　OS_FLAG_WAIT_SET_ALL：所有位都置1
　　　　OS_FLAG_WAIT_SET_ANY：任一位置1
　　　　OS_FLAG_WAIT_SET_ALL：所有位都置0
　　　　 OS_FLAG_WAIT_SET_ANY：任一位置0
　　timeout ：超时
　　err：获取错误信息的指针
函数还要注意使用完事件标志位后，事件标志位是否清除

OS_FLAGS  OSFlagPend (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT16U timeout, INT8U *err)
{
#if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
    OS_CPU_SR     cpu_sr;
#endif
    OS_FLAG_NODE  node;
    OS_FLAGS      flags_cur;
    OS_FLAGS      flags_rdy;
    BOOLEAN       consume;

    //不能中断调用
    if (OSIntNesting > 0) {                                /* See if called from ISR ...               */
        *err = OS_ERR_PEND_ISR;                            /* ... can't PEND from an ISR               */
        return ((OS_FLAGS)0);
    }
#if OS_ARG_CHK_EN > 0
    if (pgrp == (OS_FLAG_GRP *)0) {                        /* Validate 'pgrp'                          */
        *err = OS_FLAG_INVALID_PGRP;
        return ((OS_FLAGS)0);
    }
    if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {          /* Validate event block type                */
        *err = OS_ERR_EVENT_TYPE;
        return ((OS_FLAGS)0);
    }
#endif
   //收到指定事件后,复位flag事件组,将相应的事件标志清0 
    if (wait_type & OS_FLAG_CONSUME) {                     /* See if we need to consume the flags      */
        wait_type &= ~OS_FLAG_CONSUME;
        consume    = TRUE;
    } else {
        consume    = FALSE;
    }
/*$PAGE*/
    OS_ENTER_CRITICAL();
    switch (wait_type) {
        //事件标志组 所有标志都置1
        case OS_FLAG_WAIT_SET_ALL:                         /* See if all required flags are set        */
            //事件标志组中已经发生的标志 与 任务所需标志“与”运算，取出任务 关心的任务标志组中的标志
             flags_rdy = pgrp->OSFlagFlags & flags;        /* Extract only the bits we want            */
            //事件标志组中的标志状态，满足任务标志需求
            //flags_rdy与任务请求的标志 要相等   
             if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */
                //判断使用到的标志是否需要清除
                 if (consume == TRUE) {                    /* See if we need to consume the flags      */
                    //清除使用到的标志位 置0
                     pgrp->OSFlagFlags &= ~flags_rdy;      /* Clear ONLY the flags that we wanted      */
                 }
                 //获取现在任务标志组中的标志
                 flags_cur = pgrp->OSFlagFlags;            /* Will return the state of the group       */
                 OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
                 *err      = OS_NO_ERR;
                 //返回
                 return (flags_cur);
             }
            //事件标志组中的标志状态，不满足任务需要的标志需求
              else {                                      /* Block task until events occur or timeout */
                //当前任务移出就绪表，当前任务借助事件标志组节点完成等待事件表
                 OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
                 OS_EXIT_CRITICAL();
             }
             break;
        //事件标志组 任一标志置1
        case OS_FLAG_WAIT_SET_ANY:
            //事件标志组中已经发生的标志 与 任务所需标志“与”运算，取出任务 关心的任务标志组中的标志
             flags_rdy = pgrp->OSFlagFlags & flags;        /* Extract only the bits we want            */
            //事件标志组中的标志状态，满足任务标志需求
            // 满足只发生一个  flags_rdy不为0就可
             if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag set                      */
                //判断使用到的标志是否需要清除
                 if (consume == TRUE) {                    /* See if we need to consume the flags      */
                    //清除使用到的标志位 置0
                     pgrp->OSFlagFlags &= ~flags_rdy;      /* Clear ONLY the flags that we got         */
                 }
                 //获取现在任务标志组中的标志
                 flags_cur = pgrp->OSFlagFlags;            /* Will return the state of the group       */
                 OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
                 *err      = OS_NO_ERR;
                 //返回
                 return (flags_cur);
             }
              //事件标志组中的标志状态，不满足任务需要的标志需求
              else {                                      /* Block task until events occur or timeout */
                //当前任务移出就绪表，当前任务借助事件标志组节点完成等待事件表
                 OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
                 OS_EXIT_CRITICAL();
             }
             break;

#if OS_FLAG_WAIT_CLR_EN > 0
        //事件标志组 所有标志都置0
        case OS_FLAG_WAIT_CLR_ALL:                         /* See if all required flags are cleared    */
            // flags_rdy = (~pgrp->OSFlagFlags) & flags; 
            //  取出关心的位，将0 翻转位1 进行判断
             flags_rdy = ~pgrp->OSFlagFlags & flags;       /* Extract only the bits we want            */
            //事件标志组中的标志状态，满足任务标志需求
            //flags_rdy与任务请求的标志 要相等   
             if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */
                //判断使用到的标志是否需要清除
                 if (consume == TRUE) {                    /* See if we need to consume the flags      */
                     //清除使用到的标志位 置1
                     pgrp->OSFlagFlags |= flags_rdy;       /* Set ONLY the flags that we wanted        */
                 }
                 //获取现在任务标志组中的标志                 
                 flags_cur = pgrp->OSFlagFlags;            /* Will return the state of the group       */
                 OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
                 *err      = OS_NO_ERR;
                 return (flags_cur);
             }
              //事件标志组中的标志状态，不满足任务需要的标志需求
              else {                                      /* Block task until events occur or timeout */
                //当前任务移出就绪表，当前任务借助事件标志组节点完成等待事件表
                 OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
                 OS_EXIT_CRITICAL();
             }
             break;
        //事件标志组 任一标志置0
        case OS_FLAG_WAIT_CLR_ANY:
            //  取出关心的位，将0 翻转位1 进行判断
             flags_rdy = ~pgrp->OSFlagFlags & flags;       /* Extract only the bits we want            */
            //事件标志组中的标志状态，满足任务标志需求
            //flags_rdy不为0   
             if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag cleared                  */
                //判断使用到的标志是否需要清除
                 if (consume == TRUE) {                    /* See if we need to consume the flags      */
                     //清除使用到的标志位 置1
                     pgrp->OSFlagFlags |= flags_rdy;       /* Set ONLY the flags that we got           */
                 }
                 //获取现在任务标志组中的标志                 
                 flags_cur = pgrp->OSFlagFlags;            /* Will return the state of the group       */
                 OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
                 *err      = OS_NO_ERR;
                 return (flags_cur);
             } 
            //事件标志组中的标志状态，不满足任务需要的标志需求
             else {                                      /* Block task until events occur or timeout */
                 //当前任务移出就绪表，当前任务借助事件标志组节点完成等待事件表
                 OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
                 OS_EXIT_CRITICAL();
             }
             break;
#endif

        default:
             OS_EXIT_CRITICAL();
             flags_cur = (OS_FLAGS)0;
             *err      = OS_FLAG_ERR_WAIT_TYPE;
             return (flags_cur);
    }
    //任务调度
    OS_Sched();                                            /* Find next HPT ready to run               */
    OS_ENTER_CRITICAL();
    //任务超时判断
    if (OSTCBCur->OSTCBStat & OS_STAT_FLAG) {              /* Have we timed-out?                       */
        OS_FlagUnlink(&node);
        OSTCBCur->OSTCBStat = OS_STAT_RDY;                 /* Yes, make task ready-to-run              */
        OS_EXIT_CRITICAL();
        flags_cur           = (OS_FLAGS)0;
        *err                = OS_TIMEOUT;                  /* Indicate that we timed-out waiting       */
    } else {
        //清除使用到的标志位
        if (consume == 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 &= ~OSTCBCur->OSTCBFlagsRdy;
                     break;

#if OS_FLAG_WAIT_CLR_EN > 0
                case OS_FLAG_WAIT_CLR_ALL:
                case OS_FLAG_WAIT_CLR_ANY:                 /* Set   ONLY the flags we got              */
                     pgrp->OSFlagFlags |= OSTCBCur->OSTCBFlagsRdy;
                     break;
#endif
            }
        }
        //获取现在任务标志组中的标志  
        flags_cur = pgrp->OSFlagFlags;
        OS_EXIT_CRITICAL();
        *err      = OS_NO_ERR;                             /* Event(s) must have occurred              */
    }
    //返回
    return (flags_cur);
}

4.任务标志组的释放----遍历所有等待任务

OSFlagPost是遍历所有的等待任务，将满足事件标志组的，所有任务从等待列表移除，加入到就绪表。

OS_FLAGS OSFlagPost (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U opt, INT8U *err)
参数：
　　pgrp：事件标志组控制块
　　flags ：事件标志组
　　opt:
　　　　 OS_FLAG_CLR: 事件标志组中指定的位（flags）置0
　　　　OS_FLAG_SET :事件标志组中指定的位（flags）置1
　　err：获取错误信息的指针

OS_FLAGS  OSFlagPost (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U opt, INT8U *err)
{
#if OS_CRITICAL_METHOD == 3                          /* Allocate storage for CPU status register       */
    OS_CPU_SR     cpu_sr;
#endif
    OS_FLAG_NODE *pnode;
    BOOLEAN       sched;
    OS_FLAGS      flags_cur;
    OS_FLAGS      flags_rdy;

#if OS_ARG_CHK_EN > 0
    if (pgrp == (OS_FLAG_GRP *)0) {                  /* Validate 'pgrp'                                */
        *err = OS_FLAG_INVALID_PGRP;
        return ((OS_FLAGS)0);
    }
    if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {    /* Make sure we are pointing to an event flag grp */
        *err = OS_ERR_EVENT_TYPE;
        return ((OS_FLAGS)0);
    }
#endif
/*$PAGE*/
    OS_ENTER_CRITICAL();
    switch (opt) {
        //将事件标志组（pgrp->OSFlagFlags）中指定的位（flags） 置0
        case OS_FLAG_CLR:
             pgrp->OSFlagFlags &= ~flags;            /* Clear the flags specified in the group         */
             break;
        //将事件标志组（pgrp->OSFlagFlags）中指定的位（flags） 置1
        case OS_FLAG_SET:
             pgrp->OSFlagFlags |=  flags;            /* Set   the flags specified in the group         */
             break;
        //没有相应操作，报错返回
        default:
             OS_EXIT_CRITICAL();                     /* INVALID option                                 */
             *err = OS_FLAG_INVALID_OPT;
             return ((OS_FLAGS)0);
    }
    sched = FALSE;                                   /* Indicate that we don't need rescheduling       */
    //获取等待任务节点的表头指针
    pnode = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;
    //遍历所有等待任务
    while (pnode != (OS_FLAG_NODE *)0) {             /* Go through all tasks waiting on event flag(s)  */
        //该node管理的任务的等待类型
        switch (pnode->OSFlagNodeWaitType) {
            //事件标志组中所有事件都置1才唤醒
            case OS_FLAG_WAIT_SET_ALL:               /* See if all req. flags are set for current node */
                //获取该任务标志组关心的位
                 flags_rdy = pgrp->OSFlagFlags & pnode->OSFlagNodeFlags;
                 if (flags_rdy == pnode->OSFlagNodeFlags) {
                     if (OS_FlagTaskRdy(pnode, flags_rdy) == TRUE) { /* Make task RTR, event(s) Rx'd   */
                         sched = TRUE;                               /* When done we will reschedule   */
                     }
                 }
                 break;
            //事件标志组中所有事件 任一置1都唤醒
            case OS_FLAG_WAIT_SET_ANY:               /* See if any flag set                            */
                //获取该任务标志组关心的位
                 flags_rdy = pgrp->OSFlagFlags & pnode->OSFlagNodeFlags;
                 if (flags_rdy != (OS_FLAGS)0) {
                     if (OS_FlagTaskRdy(pnode, flags_rdy) == TRUE) { /* Make task RTR, event(s) Rx'd   */
                         sched = TRUE;                               /* When done we will reschedule   */
                     }
                 }
                 break;

#if OS_FLAG_WAIT_CLR_EN > 0
            //事件标志组中所有事件 所有置0才唤醒
            case OS_FLAG_WAIT_CLR_ALL:               /* See if all req. flags are set for current node */
                //获取该任务标志组关心的位
                 flags_rdy = ~pgrp->OSFlagFlags & pnode->OSFlagNodeFlags;
                 if (flags_rdy == pnode->OSFlagNodeFlags) {
                     if (OS_FlagTaskRdy(pnode, flags_rdy) == TRUE) { /* Make task RTR, event(s) Rx'd   */
                         sched = TRUE;                               /* When done we will reschedule   */
                     }
                 }
                 break;
            //事件标志组中所有事件 任一置0都唤醒
            case OS_FLAG_WAIT_CLR_ANY:               /* See if any flag set                            */
                //获取该任务标志组关心的位
                 flags_rdy = ~pgrp->OSFlagFlags & pnode->OSFlagNodeFlags;
                 if (flags_rdy != (OS_FLAGS)0) {
                     if (OS_FlagTaskRdy(pnode, flags_rdy) == TRUE) { /* Make task RTR, event(s) Rx'd   */
                         sched = TRUE;                               /* When done we will reschedule   */
                     }
                 }
                 break;
#endif
        }
        //下一个在等待节点上的任务
        pnode = (OS_FLAG_NODE *)pnode->OSFlagNodeNext; /* Point to next task waiting for event flag(s) */
    }
    OS_EXIT_CRITICAL();
    //系统调度
    if (sched == TRUE) {
        OS_Sched();
    }
    OS_ENTER_CRITICAL();
    //返回当前的事件标志组,如果因为OS_Sched()调度去执行了其它任务
    //这里的OSFlagFlags可能已经被其他任务consume属性复了位
    flags_cur = pgrp->OSFlagFlags;
    OS_EXIT_CRITICAL();
    *err      = OS_NO_ERR;
    return (flags_cur);
}