os_flag.c

完整的ucos实例

                 *err                 = OS_ERR_TASK_WAITING; 
                 return (pgrp); 
             } 
 
        case OS_DEL_ALWAYS:                                /* Always delete the event flag group       */ 
             pnode = (OS_FLAG_NODE *)pgrp->OSFlagWaitList; 
             while (pnode != (OS_FLAG_NODE *)0) {          /* Ready ALL tasks waiting for flags        */ 
                 OS_FlagTaskRdy(pnode, (OS_FLAGS)0); 
                 pnode = (OS_FLAG_NODE *)pnode->OSFlagNodeNext; 
             } 
             pgrp->OSFlagType     = OS_EVENT_TYPE_UNUSED; 
             pgrp->OSFlagWaitList = (void *)OSFlagFreeList;/* Return group to free list                */ 
             OSFlagFreeList       = pgrp; 
             OS_EXIT_CRITICAL(); 
             if (tasks_waiting == TRUE) {                  /* Reschedule only if task(s) were waiting  */ 
                 OS_Sched();                               /* Find highest priority task ready to run  */ 
             } 
             *err = OS_NO_ERR; 
             return ((OS_FLAG_GRP *)0);                    /* Event Flag Group has been deleted        */ 
 
        default: 
             OS_EXIT_CRITICAL(); 
             *err = OS_ERR_INVALID_OPT; 
             return (pgrp); 
    } 
} 
#endif 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                        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. 
* 
* Arguments  : pgrp          is a pointer to the desired event flag group. 
* 
*              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. 
* 
*              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: 
* 
*                            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) 
* 
*                            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 
* 
*              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. 
* 
*              err           is a pointer to an error code and can be: 
*                            OS_NO_ERR              The desired bits have been set within the specified 
*                                                   'timeout'. 
*                            OS_ERR_PEND_ISR        If you tried to PEND from an ISR 
*                            OS_FLAG_INVALID_PGRP   If 'pgrp' is a NULL pointer. 
*                            OS_ERR_EVENT_TYPE      You are not pointing to an event flag group 
*                            OS_TIMEOUT             The bit(s) have not been set in the specified 
*                                                   'timeout'. 
*                            OS_FLAG_ERR_WAIT_TYPE  You didn't specify a proper 'wait_type' argument. 
* 
* Returns    : The new state of the flags in the event flag group when the task is resumed or, 
*              0 if a timeout or an error occurred. 
* 
* Called from: Task ONLY 
********************************************************************************************************* 
*/ 
 
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 
    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) { 
        case OS_FLAG_WAIT_SET_ALL:                         /* See if all required flags are set        */ 
             flags_rdy = pgrp->OSFlagFlags & flags;        /* Extract only the bits we want            */ 
             if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */ 
                 if (consume == TRUE) {                    /* See if we need to consume the flags      */ 
                     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; 
 
        case OS_FLAG_WAIT_SET_ANY: 
             flags_rdy = pgrp->OSFlagFlags & flags;        /* Extract only the bits we want            */ 
             if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag set                      */ 
                 if (consume == TRUE) {                    /* See if we need to consume the flags      */ 
                     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 
        case OS_FLAG_WAIT_CLR_ALL:                         /* See if all required flags are cleared    */ 
             flags_rdy = ~pgrp->OSFlagFlags & flags;       /* Extract only the bits we want            */ 
             if (flags_rdy == flags) {                     /* Must match ALL the bits that we want     */ 
                 if (consume == TRUE) {                    /* See if we need to consume the flags      */ 
                     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; 
 
        case OS_FLAG_WAIT_CLR_ANY: 
             flags_rdy = ~pgrp->OSFlagFlags & flags;       /* Extract only the bits we want            */ 
             if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag cleared                  */ 
                 if (consume == TRUE) {                    /* See if we need to consume the flags      */ 
                     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); 
} 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                         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. 
* 
*              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) 
* 
*                            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           indicates whether the flags will be: 
*                                set     (OS_FLAG_SET) or 
*                                cleared (OS_FLAG_CLR) 
* 
*              err           is a pointer to an error code and can be: 
*                            OS_NO_ERR              The call was successfull 
*                            OS_FLAG_INVALID_PGRP   You passed a NULL pointer 
*                            OS_ERR_EVENT_TYPE      You are not pointing to an event flag group 
*                            OS_FLAG_INVALID_OPT    You specified an invalid option 
* 
* Returns    : the new value of the event flags bits that are still set. 
* 
* 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. 
********************************************************************************************************* 
*/ 
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) { 
        case OS_FLAG_CLR: 
             pgrp->OSFlagFlags &= ~flags;            /* Clear the flags specified in the group         */ 
             break; 
 
        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)  */ 
        switch (pnode->OSFlagNodeWaitType) { 
            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) {