os_flag.c

完整的ucos实例

/* 
********************************************************************************************************* 
*                                                uC/OS-II 
*                                          The Real-Time Kernel 
*                                         EVENT FLAG  MANAGEMENT 
* 
*                          (c) Copyright 2001-2002, Jean J. Labrosse, Weston, FL 
*                                           All Rights Reserved 
* 
* File : OS_FLAG.C 
* By   : Jean J. Labrosse 
********************************************************************************************************* 
*/ 
 
#ifndef  OS_MASTER_FILE 
#include "INCLUDES.H" 
#endif 
 
#if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0) 
/* 
********************************************************************************************************* 
*                                            LOCAL PROTOTYPES 
********************************************************************************************************* 
*/ 
 
static  void     OS_FlagBlock(OS_FLAG_GRP *pgrp, OS_FLAG_NODE *pnode, OS_FLAGS flags, INT8U wait_type, INT16U timeout); 
static  BOOLEAN  OS_FlagTaskRdy(OS_FLAG_NODE *pnode, OS_FLAGS flags_rdy); 
 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                              CHECK THE STATUS OF FLAGS IN AN EVENT FLAG GROUP 
* 
* Description: This function is called to check the status of a combination of bits to be set or cleared 
*              in an event flag group.  Your application can check for ANY bit to be set/cleared or ALL 
*              bits to be set/cleared. 
* 
*              This call does not block if the desired flags are not present. 
* 
* 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 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. 
* 
*              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 'flags' to be clear (0) 
*                            OS_FLAG_WAIT_CLR_ANY   You will check ANY bit  in 'flags' to be clear (0) 
*                            OS_FLAG_WAIT_SET_ALL   You will check ALL bits in 'flags' to be set   (1) 
*                            OS_FLAG_WAIT_SET_ANY   You will check ANY bit  in 'flags' 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 
* 
*              err           is a pointer to an error code and can be: 
*                            OS_NO_ERR              No error 
*                            OS_ERR_EVENT_TYPE      You are not pointing to an event flag group 
*                            OS_FLAG_ERR_WAIT_TYPE  You didn't specify a proper 'wait_type' argument. 
*                            OS_FLAG_INVALID_PGRP   You passed a NULL pointer instead of the event flag 
*                                                   group handle. 
*                            OS_FLAG_ERR_NOT_RDY    The desired flags you are waiting for are not 
*                                                   available. 
* 
* Returns    : The state of the flags in the event flag group. 
* 
* Called from: Task or ISR 
********************************************************************************************************* 
*/ 
 
#if OS_FLAG_ACCEPT_EN > 0 
OS_FLAGS  OSFlagAccept (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT8U *err) 
{ 
#if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */ 
    OS_CPU_SR     cpu_sr; 
#endif 
    OS_FLAGS      flags_cur; 
    OS_FLAGS      flags_rdy; 
    BOOLEAN       consume; 
 
 
#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*/ 
    *err = OS_NO_ERR;                                      /* Assume NO error until proven otherwise.  */ 
    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      */ 
                 } 
             } else { 
                 *err  = OS_FLAG_ERR_NOT_RDY; 
             } 
             flags_cur = pgrp->OSFlagFlags;                /* Will return the state of the group       */ 
             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         */ 
                 } 
             } else { 
                 *err  = OS_FLAG_ERR_NOT_RDY; 
             } 
             flags_cur = pgrp->OSFlagFlags;                /* Will return the state of the group       */ 
             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        */ 
                 } 
             } else { 
                 *err  = OS_FLAG_ERR_NOT_RDY; 
             } 
             flags_cur = pgrp->OSFlagFlags;                /* Will return the state of the group       */ 
             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           */ 
                 } 
             } else { 
                 *err  = OS_FLAG_ERR_NOT_RDY; 
             } 
             flags_cur = pgrp->OSFlagFlags;                /* Will return the state of the group       */ 
             OS_EXIT_CRITICAL(); 
             break; 
#endif 
 
        default: 
             OS_EXIT_CRITICAL(); 
             flags_cur = (OS_FLAGS)0; 
             *err      = OS_FLAG_ERR_WAIT_TYPE; 
             break; 
    } 
    return (flags_cur); 
} 
#endif 
 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                           CREATE AN EVENT FLAG 
* 
* Description: This function is called to create an event flag group. 
* 
* Arguments  : flags         Contains the initial value to store in the event flag group. 
* 
*              err           is a pointer to an error code which will be returned to your application: 
*                               OS_NO_ERR                if the call was successful. 
*                               OS_ERR_CREATE_ISR        if you attempted to create an Event Flag from an 
*                                                        ISR. 
*                               OS_FLAG_GRP_DEPLETED     if there are no more event flag groups 
* 
* Returns    : A pointer to an event flag group or a NULL pointer if no more groups are available. 
* 
* Called from: Task ONLY 
********************************************************************************************************* 
*/ 
 
OS_FLAG_GRP  *OSFlagCreate (OS_FLAGS flags, INT8U *err) 
{ 
#if OS_CRITICAL_METHOD == 3                         /* Allocate storage for CPU status register        */ 
    OS_CPU_SR    cpu_sr; 
#endif 
    OS_FLAG_GRP *pgrp; 
 
 
    if (OSIntNesting > 0) {                         /* See if called from ISR ...                      */ 
        *err = OS_ERR_CREATE_ISR;                   /* ... can't CREATE from an ISR                    */ 
        return ((OS_FLAG_GRP *)0); 
    } 
    OS_ENTER_CRITICAL(); 
    pgrp = OSFlagFreeList;                          /* Get next free event flag                        */ 
    if (pgrp != (OS_FLAG_GRP *)0) {                 /* See if we have event flag groups available      */ 
                                                    /* Adjust free list                                */ 
        OSFlagFreeList       = (OS_FLAG_GRP *)OSFlagFreeList->OSFlagWaitList; 
        pgrp->OSFlagType     = OS_EVENT_TYPE_FLAG;  /* Set to event flag group type                    */ 
        pgrp->OSFlagFlags    = flags;               /* Set to desired initial value                    */ 
        pgrp->OSFlagWaitList = (void *)0;           /* Clear list of tasks waiting on flags            */ 
        OS_EXIT_CRITICAL(); 
        *err                 = OS_NO_ERR; 
    } else { 
        OS_EXIT_CRITICAL(); 
        *err                 = OS_FLAG_GRP_DEPLETED; 
    } 
    return (pgrp);                                  /* Return pointer to event flag group              */ 
} 
 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                     DELETE AN EVENT FLAG GROUP 
* 
* Description: This function deletes an event flag group and readies all tasks pending on the event flag 
*              group. 
* 
* Arguments  : pgrp          is a pointer to the desired event flag group. 
* 
*              opt           determines delete options as follows: 
*                            opt == OS_DEL_NO_PEND   Deletes the event flag group ONLY if no task pending 
*                            opt == OS_DEL_ALWAYS    Deletes the event flag group even if tasks are 
*                                                    waiting.  In this case, all the tasks pending will be 
*                                                    readied. 
* 
*              err           is a pointer to an error code that can contain one of the following values: 
*                            OS_NO_ERR               The call was successful and the event flag group was 
*                                                    deleted 
*                            OS_ERR_DEL_ISR          If you attempted to delete the event flag group from 
*                                                    an ISR 
*                            OS_FLAG_INVALID_PGRP    If 'pgrp' is a NULL pointer. 
*                            OS_ERR_EVENT_TYPE       If you didn't pass a pointer to an event flag group 
*                            OS_ERR_INVALID_OPT      An invalid option was specified 
*                            OS_ERR_TASK_WAITING     One or more tasks were waiting on the event flag 
*                                                    group. 
* 
* Returns    : pevent        upon error 
*              (OS_EVENT *)0 if the semaphore was successfully deleted. 
* 
* Note(s)    : 1) This function must be used with care.  Tasks that would normally expect the presence of 
*                 the event flag group MUST check the return code of OSFlagAccept() and OSFlagPend(). 
*              2) This call can potentially disable interrupts for a long time.  The interrupt disable 
*                 time is directly proportional to the number of tasks waiting on the event flag group. 
********************************************************************************************************* 
*/ 
 
#if OS_FLAG_DEL_EN > 0 
OS_FLAG_GRP  *OSFlagDel (OS_FLAG_GRP *pgrp, INT8U opt, INT8U *err) 
{ 
#if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */ 
    OS_CPU_SR     cpu_sr; 
#endif 
    BOOLEAN       tasks_waiting; 
    OS_FLAG_NODE *pnode; 
 
 
    if (OSIntNesting > 0) {                                /* See if called from ISR ...               */ 
        *err = OS_ERR_DEL_ISR;                             /* ... can't DELETE from an ISR             */ 
        return (pgrp); 
    } 
#if OS_ARG_CHK_EN > 0 
    if (pgrp == (OS_FLAG_GRP *)0) {                        /* Validate 'pgrp'                          */ 
        *err = OS_FLAG_INVALID_PGRP; 
        return (pgrp); 
    } 
    if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {          /* Validate event group type                */ 
        *err = OS_ERR_EVENT_TYPE; 
        return (pgrp); 
    } 
#endif 
    OS_ENTER_CRITICAL(); 
    if (pgrp->OSFlagWaitList != (void *)0) {               /* See if any tasks waiting on event flags  */ 
        tasks_waiting = TRUE;                              /* Yes                                      */ 
    } else { 
        tasks_waiting = FALSE;                             /* No                                       */ 
    } 
    switch (opt) { 
        case OS_DEL_NO_PEND:                               /* Delete group if no task waiting          */ 
             if (tasks_waiting == FALSE) { 
                 pgrp->OSFlagType     = OS_EVENT_TYPE_UNUSED; 
                 pgrp->OSFlagWaitList = (void *)OSFlagFreeList; /* Return group to free list           */ 
                 OSFlagFreeList       = pgrp; 
                 OS_EXIT_CRITICAL(); 
                 *err                 = OS_NO_ERR; 
                 return ((OS_FLAG_GRP *)0);                /* Event Flag Group has been deleted        */ 
             } else { 
                 OS_EXIT_CRITICAL();