?? os_flag.c
字號:
/*
*********************************************************************************************************
* uC/OS-II
* The Real-Time Kernel
* EVENT FLAG MANAGEMENT
*
* (c) Copyright 2001-2007, Jean J. Labrosse, Weston, FL
* All Rights Reserved
*
* File : OS_FLAG.C
* By : Jean J. Labrosse
* Version : V2.85
*
* LICENSING TERMS:
* ---------------
* uC/OS-II is provided in source form for FREE evaluation, for educational use or for peaceful research.
* If you plan on using uC/OS-II in a commercial product you need to contact Micri祄 to properly license
* its use in your product. We provide ALL the source code for your convenience and to help you experience
* uC/OS-II. The fact that the source is provided does NOT mean that you can use it without paying a
* licensing fee.
*********************************************************************************************************
*/
#ifndef OS_MASTER_FILE
#include <ucos_ii.h>
#endif
#if (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
*
* perr is a pointer to an error code and can be:
* OS_ERR_NONE No error
* OS_ERR_EVENT_TYPE You are not pointing to an event flag group
* OS_ERR_FLAG_WAIT_TYPE You didn't specify a proper 'wait_type' argument.
* OS_ERR_FLAG_INVALID_PGRP You passed a NULL pointer instead of the event flag
* group handle.
* OS_ERR_FLAG_NOT_RDY The desired flags you are waiting for are not
* available.
*
* Returns : The flags in the event flag group that made the task ready or, 0 if a timeout or an error
* occurred.
*
* Called from: Task or ISR
*
* 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.
*********************************************************************************************************
*/
#if OS_FLAG_ACCEPT_EN > 0
OS_FLAGS OSFlagAccept (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT8U *perr)
{
OS_FLAGS flags_rdy;
INT8U result;
BOOLEAN consume;
#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0;
#endif
#if OS_ARG_CHK_EN > 0
if (perr == (INT8U *)0) { /* Validate 'perr' */
return ((OS_FLAGS)0);
}
if (pgrp == (OS_FLAG_GRP *)0) { /* Validate 'pgrp' */
*perr = OS_ERR_FLAG_INVALID_PGRP;
return ((OS_FLAGS)0);
}
#endif
if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) { /* Validate event block type */
*perr = OS_ERR_EVENT_TYPE;
return ((OS_FLAGS)0);
}
result = (INT8U)(wait_type & OS_FLAG_CONSUME);
if (result != (INT8U)0) { /* See if we need to consume the flags */
wait_type &= ~OS_FLAG_CONSUME;
consume = OS_TRUE;
} else {
consume = OS_FALSE;
}
/*$PAGE*/
*perr = OS_ERR_NONE; /* 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 = (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; /* Clear ONLY the flags that we wanted */
}
} else {
*perr = OS_ERR_FLAG_NOT_RDY;
}
OS_EXIT_CRITICAL();
break;
case OS_FLAG_WAIT_SET_ANY:
flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & flags); /* Extract only the bits we want */
if (flags_rdy != (OS_FLAGS)0) { /* See if any flag set */
if (consume == OS_TRUE) { /* See if we need to consume the flags */
pgrp->OSFlagFlags &= ~flags_rdy; /* Clear ONLY the flags that we got */
}
} else {
*perr = OS_ERR_FLAG_NOT_RDY;
}
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 = (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 */
}
} else {
*perr = OS_ERR_FLAG_NOT_RDY;
}
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 */
}
} else {
*perr = OS_ERR_FLAG_NOT_RDY;
}
OS_EXIT_CRITICAL();
break;
#endif
default:
OS_EXIT_CRITICAL();
flags_rdy = (OS_FLAGS)0;
*perr = OS_ERR_FLAG_WAIT_TYPE;
break;
}
return (flags_rdy);
}
#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.
*
* perr is a pointer to an error code which will be returned to your application:
* OS_ERR_NONE if the call was successful.
* OS_ERR_CREATE_ISR if you attempted to create an Event Flag from an
* ISR.
* OS_ERR_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 *perr)
{
OS_FLAG_GRP *pgrp;
#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0;
#endif
#if OS_ARG_CHK_EN > 0
if (perr == (INT8U *)0) { /* Validate 'perr' */
return ((OS_FLAG_GRP *)0);
}
#endif
if (OSIntNesting > 0) { /* See if called from ISR ... */
*perr = 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 */
#if OS_FLAG_NAME_SIZE > 1
pgrp->OSFlagName[0] = '?';
pgrp->OSFlagName[1] = OS_ASCII_NUL;
#endif
OS_EXIT_CRITICAL();
*perr = OS_ERR_NONE;
} else {
OS_EXIT_CRITICAL();
*perr = OS_ERR_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.
*
* perr is a pointer to an error code that can contain one of the following values:
* OS_ERR_NONE 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_ERR_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 : pgrp upon error
* (OS_EVENT *)0 if the event flag group 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 *perr)
{
BOOLEAN tasks_waiting;
OS_FLAG_NODE *pnode;
OS_FLAG_GRP *pgrp_return;
#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0;
#endif
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -