os_flag.src

UCOS在51上的移植,绝对经典！可以较少开发人员的工作量

;                  }
;              } 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)LG_REENTRANT
; {
; #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)LG_REENTRANT
; {
; #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();
;                  *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)LG_REENTRANT
; {
; #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'                          */