前言
这个关于事件标志组的文件，其实就是对下面两个结构体的操作，最核心的是对OSFlagWaitList与OSFlagFlags这两个字段的操作。
typedef struct os_flag_grp { /* Event Flag Group */
INT8U OSFlagType; /* Should be set to OS_EVENT_TYPE_FLAG */
void *OSFlagWaitList; /* Pointer to first NODE of task waiting on event flag */
OS_FLAGS OSFlagFlags; /* 8, 16 or 32 bit flags */
#if OS_FLAG_NAME_EN > 0u
INT8U *OSFlagName;
#endif
} OS_FLAG_GRP;
typedef struct os_flag_node { /* Event Flag Wait List Node */
void *OSFlagNodeNext; /* Pointer to next NODE in wait list */
void *OSFlagNodePrev; /* Pointer to previous NODE in wait list */
void *OSFlagNodeTCB; /* Pointer to TCB of waiting task */
void *OSFlagNodeFlagGrp; /* Pointer to Event Flag Group */
OS_FLAGS OSFlagNodeFlags; /* Event flag to wait on */
INT8U OSFlagNodeWaitType; /* Type of wait: */
/* OS_FLAG_WAIT_AND */
/* OS_FLAG_WAIT_ALL */
/* OS_FLAG_WAIT_OR */
/* OS_FLAG_WAIT_ANY */
} OS_FLAG_NODE;
/*事件标志组（已看）
*********************************************************************************************************
* uC/OS-II
* The Real-Time Kernel
* EVENT FLAG MANAGEMENT
*
* (c) Copyright 1992-2017; Micrium, Inc.; Weston; FL
* All Rights Reserved
*
* File : OS_FLAG.C
* By : Jean J. Labrosse
* Version : V2.92.13
*
* 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 Micrium 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.
*
* Knowledge of the source code may NOT be used to develop a similar product.
*
* Please help us continue to provide the embedded community with the finest software available.
* Your honesty is greatly appreciated.
*
* You can find our product's user manual, API reference, release notes and
* more information at https://doc.micrium.com.
* You can contact us at www.micrium.com.
*********************************************************************************************************
*/
#define MICRIUM_SOURCE
#ifndef OS_MASTER_FILE
#include <ucos_ii.h>
#endif
//如果允许使用事件标志组
#if (OS_FLAG_EN > 0u) && (OS_MAX_FLAGS > 0u)
/*
*********************************************************************************************************
* LOCAL PROTOTYPES（定义本地配置）
*********************************************************************************************************
*/
//定义文件内部函数
static void OS_FlagBlock(OS_FLAG_GRP *pgrp, OS_FLAG_NODE *pnode, OS_FLAGS flags, INT8U wait_type, INT32U timeout);
static BOOLEAN OS_FlagTaskRdy(OS_FLAG_NODE *pnode, OS_FLAGS flags_rdy, INT8U pend_stat);
/*
*********************************************************************************************************
* 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.
*flags是你希望检查的bit位的组合，你希望检查的bit位都放在一个flags中，例如，你的应用程序希望检查00000011
* 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_CONSUME，例如：等待事件标志组中的任一标志，然后在它就绪的时候就清空它，即将它消耗掉，所以你需要将wait_type设置为OS_FLAG_WAIT_SET_ANY + OS_FLAG_CONSUME。
* 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（可以从Task和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.
注意：1）重要提示，此函数的行为已从上一个版本更改。 函数现在返回已准备就绪的标志状态，而不是事件标志组的当前标志状态。
*********************************************************************************************************
*/
//是否允许无等待请求事件标志组
#if OS_FLAG_ACCEPT_EN > 0u
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 == 3u /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0u;
#endif
#ifdef OS_SAFETY_CRITICAL
if (perr == (INT8U *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return ((OS_FLAGS)0);
}
#endif
//参数检查
#if OS_ARG_CHK_EN > 0u
if (pgrp == (OS_FLAG_GRP *)0) { /* Validate 'pgrp' */
*perr = OS_ERR_FLAG_INVALID_PGRP;
return ((OS_FLAGS)0);
}
#endif
//检查ECB的类型，是否为事件标志组
if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) { /* Validate event block type */
*perr = OS_ERR_EVENT_TYPE;
return ((OS_FLAGS)0);
}
//查看是否是消费状态
//#define OS_FLAG_CONSUME 0x80u 10000000B
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;
}
//预设，是无错误的
*perr = OS_ERR_NONE; /* Assume NO error until proven otherwise. */
OS_ENTER_CRITICAL();//关中断，进入临界区
switch (wait_type) {
//如果是等待置1状态：
//等待flag中的所有类型都被置1
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 */
//如果是消费状态，则将标志去掉，置0
if (consume == OS_TRUE) { /* See if we need to consume the flags */
pgrp->OSFlagFlags &= (OS_FLAGS)~flags_rdy; /* Clear ONLY the flags we wanted */
}
} else {
*perr = OS_ERR_FLAG_NOT_RDY;
}
OS_EXIT_CRITICAL();
break;
//等待flag中只要有任一满足即可
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 &= (OS_FLAGS)~flags_rdy; /* Clear ONLY the flags we got */
}
} else {
*perr = OS_ERR_FLAG_NOT_RDY;
}
OS_EXIT_CRITICAL();
break;
//如果是等待清零状态
#if OS_FLAG_WAIT_CLR_EN > 0u
//等待flag中的所有标志位都清零
case OS_FLAG_WAIT_CLR_ALL: /* See if all required flags are cleared */
//如果标志位被置0了，取反后为1，在逐位相与，获得想要的flag位状态
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 */
//既然是等待清零，那么消费的话，就是全部置1即可
pgrp->OSFlagFlags |= flags_rdy; /* Set ONLY the flags that we wanted */
}
} else {
*perr = OS_ERR_FLAG_NOT_RDY;
}
OS_EXIT_CRITICAL();
break;
//等待flag中的任一标志位被置零
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;
}
//返回flag_rdy，它的意思就是当前的标志组内对应于flag目前所满足的状态。
return (flags_rdy);
}
#endif
/*
*********************************************************************************************************
* 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
* OS_ERR_ILLEGAL_CREATE_RUN_TIME if you tried to create an event flag after
* safety critical operation started.
*
* 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 == 3u /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0u;
#endif
#ifdef OS_SAFETY_CRITICAL
if (perr == (INT8U *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return ((OS_FLAG_GRP *)0);
}
#endif
#ifdef OS_SAFETY_CRITICAL_IEC61508
if (OSSafetyCriticalStartFlag == OS_TRUE) {
OS_SAFETY_CRITICAL_EXCEPTION();
*perr = OS_ERR_ILLEGAL_CREATE_RUN_TIME;
return ((OS_FLAG_GRP *)0);
}
#endif
//ISR程序中不允许创建事件标志组
if (OSIntNesting > 0u) { /* 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_EN > 0u
pgrp->OSFlagName = (INT8U *)(void *)"?";
#endif
OS_TRACE_FLAG_CREATE(pgrp, pgrp->OSFlagName);
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 */
}
/*
*********************************************************************************************************
* 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_ILLEGAL_DEL_RUN_TIME If you tried to delete an event flag after
* safety critical operation started.
* 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.（如果事件标志组被成功删除，则返回0指针）
*
* 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.
* 3) All tasks that were waiting for the event flag will be readied and returned an
* OS_ERR_PEND_ABORT if OSFlagDel() was called with OS_DEL_ALWAYS
1）必须谨慎使用此功能。 通常期望事件标志组存在的任务必须检查OSFlagAccept（）和OSFlagPend（）的返回码。
2）此调用可能会长时间禁用中断。 中断禁用时间与事件标志组上等待的任务数成正比。
3）如果使用OS_DEL_ALWAYS调用了OSFlagDel（），则将准备所有等待事件标志的任务并返回OS_ERR_PEND_ABORT
*********************************************************************************************************
*/
//检查是否允许事件标志组的删除
#if OS_FLAG_DEL_EN > 0u
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 == 3u /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0u;
#endif
#ifdef OS_SAFETY_CRITICAL
if (perr == (INT8U *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return ((OS_FLAG_GRP *)0);
}
#endif
#ifdef OS_SAFETY_CRITICAL_IEC61508
if (OSSafetyCriticalStartFlag == OS_TRUE) {
OS_SAFETY_CRITICAL_EXCEPTION();
*perr = OS_ERR_ILLEGAL_DEL_RUN_TIME;
return ((OS_FLAG_GRP *)0);
}
#endif
//参数检查
#if OS_ARG_CHK_EN > 0u
if (pgrp == (OS_FLAG_GRP *)0) { /* Validate 'pgrp' */
*perr = OS_ERR_FLAG_INVALID_PGRP;
return (pgrp);
}
#endif
OS_TRACE_FLAG_DEL_ENTER(pgrp, opt);
//ISR中禁止删除事件标志组
if (OSIntNesting > 0u) { /* See if called from ISR ... */
*perr = OS_ERR_DEL_ISR; /* ... can't DELETE from an ISR */
OS_TRACE_FLAG_DEL_EXIT(*perr);
return (pgrp);
}
//检查ECB的参数
if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) { /* Validate event group type */
*perr = OS_ERR_EVENT_TYPE;
OS_TRACE_FLAG_DEL_EXIT(*perr);
return (pgrp);
}
OS_ENTER_CRITICAL();//进入临界区关中断
if (pgrp->OSFlagWaitList != (void *)0) { /* See if any tasks waiting on event flags */
tasks_waiting = OS_TRUE; /* Yes */
} else {
tasks_waiting = OS_FALSE; /* No */
}
switch (opt) {
case OS_DEL_NO_PEND: /* Delete group if no task waiting */
if (tasks_waiting == OS_FALSE) {
#if OS_FLAG_NAME_EN > 0u
pgrp->OSFlagName = (INT8U *)(void *)"?";
#endif
pgrp->OSFlagType = OS_EVENT_TYPE_UNUSED;
//将事件标志组，插入到空闲列表中去
pgrp->OSFlagWaitList = (void *)OSFlagFreeList; /* Return group to free list */
pgrp->OSFlagFlags = (OS_FLAGS)0;
OSFlagFreeList = pgrp;
OS_EXIT_CRITICAL();
*perr = OS_ERR_NONE;
pgrp_return = (OS_FLAG_GRP *)0; /* Event Flag Group has been deleted */
} else {
OS_EXIT_CRITICAL();
*perr = OS_ERR_TASK_WAITING;
pgrp_return = pgrp;
}
break;
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_STAT_PEND_ABORT唤醒所有pnode指向的TCB
(void)OS_FlagTaskRdy(pnode, (OS_FLAGS)0, OS_STAT_PEND_ABORT);
pnode = (OS_FLAG_NODE *)pnode->OSFlagNodeNext;
}
//将事件标志组清空
#if OS_FLAG_NAME_EN > 0u
pgrp->OSFlagName = (INT8U *)(void *)"?";
#endif
pgrp->OSFlagType = OS_EVENT_TYPE_UNUSED;
pgrp->OSFlagWaitList = (void *)OSFlagFreeList;/* Return group to free list */
pgrp->OSFlagFlags = (OS_FLAGS)0;
OSFlagFreeList = pgrp;
OS_EXIT_CRITICAL();
//如果有任务在等待，这时候，感觉它的这个操作就很迷，调度是为了选择最高优先级，上面的函数，已经可以返回是否需要调度，为什么不接受一下，判断是否需要调度，
//真正是否需要调度难道不是根据是否有任务就绪来说的吗，这个仅仅依靠是否有任务在等待事件标志组，有时候会导致资源浪费吧
if (tasks_waiting == OS_TRUE) { /* Reschedule only if task(s) were waiting */
OS_Sched(); /* Find highest priority task ready to run */
}
*perr = OS_ERR_NONE;
pgrp_return = (OS_FLAG_GRP *)0; /* Event Flag Group has been deleted */
break;
default:
OS_EXIT_CRITICAL();
*perr = OS_ERR_INVALID_OPT;
pgrp_return = pgrp;
break;
}
OS_TRACE_FLAG_DEL_EXIT(*perr);
//如果成功删除，返回0指针，如果失败，返回事件标志组指针
return (pgrp_return);
}
#endif
/*
*********************************************************************************************************
* GET THE NAME OF AN EVENT FLAG GROUP（获取事件标志组的名字）
*
* Description: This function is used to obtain the name assigned to an event flag group
*这个函数用来获取一个事件标志组的名字
* Arguments : pgrp is a pointer to the event flag group.
*指向事件标志组的指针
* pname is pointer to a pointer to an ASCII string that will receive the name of the event flag
* group.
*用来保存事件标志组的名字的指向string类型的指针
* perr is a pointer to an error code that can contain one of the following values:
*
* OS_ERR_NONE if the requested task is resumed
* OS_ERR_EVENT_TYPE if 'pevent' is not pointing to an event flag group
* OS_ERR_PNAME_NULL You passed a NULL pointer for 'pname'
* OS_ERR_FLAG_INVALID_PGRP if you passed a NULL pointer for 'pgrp'
* OS_ERR_NAME_GET_ISR if you called this function from an ISR
*
* Returns : The length of the string or 0 if the 'pgrp' is a NULL pointer.
如果事件标志组是一个空指针，那么返回的字符串长度为0
*********************************************************************************************************
*/
//如果允许使用事件标志组的名字
#if OS_FLAG_NAME_EN > 0u
INT8U OSFlagNameGet (OS_FLAG_GRP *pgrp,
INT8U **pname,
INT8U *perr)
{
INT8U len;
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0u;
#endif
#ifdef OS_SAFETY_CRITICAL
if (perr == (INT8U *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return (0u);
}
#endif
//参数检查
#if OS_ARG_CHK_EN > 0u
if (pgrp == (OS_FLAG_GRP *)0) { /* Is 'pgrp' a NULL pointer? */
*perr = OS_ERR_FLAG_INVALID_PGRP;
return (0u);
}
if (pname == (INT8U **)0) { /* Is 'pname' a NULL pointer? */
*perr = OS_ERR_PNAME_NULL;
return (0u);
}
#endif
//ISR中不能调用此函数
if (OSIntNesting > 0u) { /* See if trying to call from an ISR */
*perr = OS_ERR_NAME_GET_ISR;
return (0u);
}
//这里一定要用临界区嘛？
//感觉只是获得名字而已啊，又没有涉及到修改之类的操作，难不成怕这时候把事件标志组给删除了
OS_ENTER_CRITICAL();//进入临界区，关中断
if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {
OS_EXIT_CRITICAL();
*perr = OS_ERR_EVENT_TYPE;
return (0u);
}
*pname = pgrp->OSFlagName;
len = OS_StrLen(*pname);
OS_EXIT_CRITICAL();
*perr = OS_ERR_NONE;
return (len);
}
#endif
/*
*********************************************************************************************************
* ASSIGN A NAME TO AN EVENT FLAG GROUP（为事件标志组指定一个名字）
*
* Description: This function assigns a name to an event flag group.
*这个函数用来给指定的事件标志组指定一个名字
* Arguments : pgrp is a pointer to the event flag group.
*指向事件标志组的指针
* pname is a pointer to an ASCII string that will be used as the name of the event flag
* group.
*指向事件标志组名字的指针
* perr is a pointer to an error code that can contain one of the following values:
*
* OS_ERR_NONE if the requested task is resumed
* OS_ERR_EVENT_TYPE if 'pevent' is not pointing to an event flag group
* OS_ERR_PNAME_NULL You passed a NULL pointer for 'pname'
* OS_ERR_FLAG_INVALID_PGRP if you passed a NULL pointer for 'pgrp'
* OS_ERR_NAME_SET_ISR if you called this function from an ISR
*
* Returns : None
*********************************************************************************************************
*/
//是否允许事件标志组使用名字
#if OS_FLAG_NAME_EN > 0u
void OSFlagNameSet (OS_FLAG_GRP *pgrp,
INT8U *pname,
INT8U *perr)
{
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0u;
#endif
#ifdef OS_SAFETY_CRITICAL
if (perr == (INT8U *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return;
}
#endif
//参数检查
#if OS_ARG_CHK_EN > 0u
if (pgrp == (OS_FLAG_GRP *)0) { /* Is 'pgrp' a NULL pointer? */
*perr = OS_ERR_FLAG_INVALID_PGRP;
return;
}
if (pname == (INT8U *)0) { /* Is 'pname' a NULL pointer? */
*perr = OS_ERR_PNAME_NULL;
return;
}
#endif
//ISR中不允许调用此函数
if (OSIntNesting > 0u) { /* See if trying to call from an ISR */
*perr = OS_ERR_NAME_SET_ISR;
return;
}
OS_ENTER_CRITICAL();//进入临界区，关中断
if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {
OS_EXIT_CRITICAL();
*perr = OS_ERR_EVENT_TYPE;
return;
}
pgrp->OSFlagName = pname;//注意，这里只是浅拷贝，不是深拷贝
OS_EXIT_CRITICAL();
OS_TRACE_EVENT_NAME_SET(pgrp, pname);
*perr = OS_ERR_NONE;
return;
}
#endif
/*
*********************************************************************************************************
* 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.
*调用此函数以等待在事件标志组中设置位的组合。 您的应用程序可以等待ANY位置1或ALL位置1。
* 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.
*flags用来指示你想等待的那个比特位，将你想等待的比特位在flags对应的位置一即可，例，你的应用程序想要使用0和1来表示等待，那么flags中需要为00000010
* 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.
*
* perr is a pointer to an error code and can be:
* OS_ERR_NONE The desired bits have been set within the specified
* 'timeout'.
* OS_ERR_PEND_ISR If you tried to PEND from an ISR
* OS_ERR_FLAG_INVALID_PGRP If 'pgrp' is a NULL pointer.
* OS_ERR_EVENT_TYPE You are not pointing to an event flag group
* OS_ERR_TIMEOUT The bit(s) have not been set in the specified
* 'timeout'.
* OS_ERR_PEND_ABORT The wait on the flag was aborted.
* OS_ERR_FLAG_WAIT_TYPE You didn't specify a proper 'wait_type' argument.
*
* 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 ONLY
*
* 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.
*********************************************************************************************************
*/
//等待一个事件标志组
OS_FLAGS OSFlagPend (OS_FLAG_GRP *pgrp,
OS_FLAGS flags,
INT8U wait_type,
INT32U timeout,
INT8U *perr)
{
OS_FLAG_NODE node;
//注意这里非常巧妙。因为只要一等待，此函数就是执行到一半，这种情况下局部变量是不会被取消的，当等待成功后，这个节点就没有用了
//所以这里非常巧妙地使用了局部变量的作用范围，当函数结束后，局部变量的空间被自动收回
OS_FLAGS flags_rdy;
INT8U result;
INT8U pend_stat;
BOOLEAN consume;
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0u;
#endif
#ifdef OS_SAFETY_CRITICAL
if (perr == (INT8U *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return ((OS_FLAGS)0);
}
#endif
//参数检查
#if OS_ARG_CHK_EN > 0u
if (pgrp == (OS_FLAG_GRP *)0) { /* Validate 'pgrp' */
*perr = OS_ERR_FLAG_INVALID_PGRP;
return ((OS_FLAGS)0);
}
#endif
OS_TRACE_FLAG_PEND_ENTER(pgrp, flags, timeout, wait_type);
//ISR中禁止调用此函数
if (OSIntNesting > 0u) { /* See if called from ISR ... */
*perr = OS_ERR_PEND_ISR; /* ... can't PEND from an ISR */
OS_TRACE_FLAG_PEND_EXIT(*perr);
return ((OS_FLAGS)0);
}
//调度器上锁的情况下禁止调用此函数
if (OSLockNesting > 0u) { /* See if called with scheduler locked ... */
*perr = OS_ERR_PEND_LOCKED; /* ... can't PEND when locked */
OS_TRACE_FLAG_PEND_EXIT(*perr);
return ((OS_FLAGS)0);
}
//检查事件标志组节点是否为事件标志组
if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) { /* Validate event block type */
*perr = OS_ERR_EVENT_TYPE;
OS_TRACE_FLAG_PEND_EXIT(*perr);
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 &= (INT8U)~(INT8U)OS_FLAG_CONSUME;
consume = OS_TRUE;
} else {
consume = OS_FALSE;
}
OS_ENTER_CRITICAL();//关中断，进入临界区
//根据不同的处理要求，进行不同的处理
switch (wait_type) {
//当所有期待的标志都被置1时，
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 */
//如果时消费的话，那么将对应的标志位置0
if (consume == OS_TRUE) { /* See if we need to consume the flags */
pgrp->OSFlagFlags &= (OS_FLAGS)~flags_rdy; /* Clear ONLY the flags we wanted */
}
//当前TCB的事件标志等待成功的标志
OSTCBCur->OSTCBFlagsRdy = flags_rdy; /* Save flags that were ready */
OS_EXIT_CRITICAL(); /* Yes, condition met, return to caller */
*perr = OS_ERR_NONE;
OS_TRACE_FLAG_PEND_EXIT(*perr);
return (flags_rdy);
} else { /* Block task until events occur or timeout */
//如果有的尚未被满足，那么就阻塞自己，等待timeout时常
OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
OS_EXIT_CRITICAL();
}
break;
//如果是等待任一位被置1
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 &= (OS_FLAGS)~flags_rdy; /* Clear ONLY the flags that we got */
}
OSTCBCur->OSTCBFlagsRdy = flags_rdy; /* Save flags that were ready */
OS_EXIT_CRITICAL(); /* Yes, condition met, return to caller */
*perr = OS_ERR_NONE;
OS_TRACE_FLAG_PEND_EXIT(*perr);
return (flags_rdy);
} 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 > 0u
//等待清空被置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 */
}
OSTCBCur->OSTCBFlagsRdy = flags_rdy; /* Save flags that were ready */
OS_EXIT_CRITICAL(); /* Yes, condition met, return to caller */
*perr = OS_ERR_NONE;
OS_TRACE_FLAG_PEND_EXIT(*perr);
return (flags_rdy);
} 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 = (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 */
}
OSTCBCur->OSTCBFlagsRdy = flags_rdy; /* Save flags that were ready */
OS_EXIT_CRITICAL(); /* Yes, condition met, return to caller */
*perr = OS_ERR_NONE;
OS_TRACE_FLAG_PEND_EXIT(*perr);
return (flags_rdy);
} 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_rdy = (OS_FLAGS)0;
*perr = OS_ERR_FLAG_WAIT_TYPE;
OS_TRACE_FLAG_PEND_EXIT(*perr);
return (flags_rdy);
}
//能够执行到这里的，都是需要调度的，也就是说都是请求阻塞等待的
//当所有操作都准备就绪的时候，执行一次调度
OS_Sched(); /* Find next HPT ready to run */
//关中断，进入临界区
//再次到这里的时候，就是已经等待完毕，查看等待状态
OS_ENTER_CRITICAL();
//等待失败的情况下，返回0指针
if (OSTCBCur->OSTCBStatPend != OS_STAT_PEND_OK) { /* Have we timed-out or aborted? */
pend_stat = OSTCBCur->OSTCBStatPend;
OSTCBCur->OSTCBStatPend = OS_STAT_PEND_OK;
//等待完毕，需要解除node与pgrp的关系
OS_FlagUnlink(&node);
OSTCBCur->OSTCBStat = OS_STAT_RDY; /* Yes, make task ready-to-run */
OS_EXIT_CRITICAL();
flags_rdy = (OS_FLAGS)0;
switch (pend_stat) {
case OS_STAT_PEND_ABORT:
*perr = OS_ERR_PEND_ABORT; /* Indicate that we aborted waiting */
break;
case OS_STAT_PEND_TO:
default:
*perr = OS_ERR_TIMEOUT; /* Indicate that we timed-out waiting */
break;
}
OS_TRACE_FLAG_PEND_EXIT(*perr);
return (flags_rdy);
}
//等待成功，返回对应的flags
flags_rdy = OSTCBCur->OSTCBFlagsRdy;
if (consume == OS_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 &= (OS_FLAGS)~flags_rdy;
break;
#if OS_FLAG_WAIT_CLR_EN > 0u
case OS_FLAG_WAIT_CLR_ALL:
case OS_FLAG_WAIT_CLR_ANY: /* Set ONLY the flags we got */
pgrp->OSFlagFlags |= flags_rdy;
break;
#endif
default:
OS_EXIT_CRITICAL();
*perr = OS_ERR_FLAG_WAIT_TYPE;
OS_TRACE_FLAG_PEND_EXIT(*perr);
return ((OS_FLAGS)0);
}
}
OS_EXIT_CRITICAL();//开中断，退出临界区
*perr = OS_ERR_NONE; /* Event(s) must have occurred */
OS_TRACE_FLAG_PEND_EXIT(*perr);
return (flags_rdy);
}
/*
*********************************************************************************************************
* GET FLAGS WHO CAUSED TASK TO BECOME READY（获取使任务变为就绪状态的标志位）
*
* Description: This function is called to obtain the flags that caused the task to become ready to run.
* In other words, this function allows you to tell "Who done it!".
*这个函数允许你获得使任务变为就绪态的标志位，换句话说，这个函数允许你问：那个事件发生了才导致任务变为就绪了？
* Arguments : None
*
* Returns : The flags that caused the task to be ready.
*
* Called from: Task ONLY（仅仅只能被任务调用）
*********************************************************************************************************
*/
OS_FLAGS OSFlagPendGetFlagsRdy (void)
{
OS_FLAGS flags;
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0u;
#endif
OS_ENTER_CRITICAL();
flags = OSTCBCur->OSTCBFlagsRdy;//返回此时TCB的的标志位
OS_EXIT_CRITICAL();
return (flags);
}
/*
*********************************************************************************************************
* 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'.
*这个函数用来将事件标志组对应的比特位置1或置0，比特位的置零或者一，使靠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:
*如果下面的opt选项为OS_FLAG_SET，那么在flags变量中被置为的比特位，都会对应的在事件标志组中被置位为1。比如，你要置位第0，4，5位，你需要传输的flags为00110001
* 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:
*如果下面的opt选项为OS_FLAG_CLR，那么在flags变量中被置为的比特位，都会对应的在事件标志组中被置位为0。比如，你要置位第0，4，5位，你需要传输的flags为00110001
* 0x31 (note, bit 0 is least significant bit)
*
* opt indicates whether the flags will be:（指示标志位是被置1还是置0）
* set (OS_FLAG_SET) or
* cleared (OS_FLAG_CLR)
*
* perr is a pointer to an error code and can be:
* OS_ERR_NONE The call was successfull
* OS_ERR_FLAG_INVALID_PGRP You passed a NULL pointer
* OS_ERR_EVENT_TYPE You are not pointing to an event flag group
* OS_ERR_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（可以被任务或者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 *perr)
{
OS_FLAG_NODE *pnode;
BOOLEAN sched;
OS_FLAGS flags_cur;
OS_FLAGS flags_rdy;
BOOLEAN rdy;
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0u;
#endif
#ifdef OS_SAFETY_CRITICAL
if (perr == (INT8U *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return ((OS_FLAGS)0);
}
#endif
//参数检查
#if OS_ARG_CHK_EN > 0u
if (pgrp == (OS_FLAG_GRP *)0) { /* Validate 'pgrp' */
*perr = OS_ERR_FLAG_INVALID_PGRP;
return ((OS_FLAGS)0);
}
#endif
OS_TRACE_FLAG_POST_ENTER(pgrp, flags, opt);
//确认事件标志组的标志，这个标志只有这一种，，，，
if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) { /* Make sure we are pointing to an event flag grp */
*perr = OS_ERR_EVENT_TYPE;
OS_TRACE_FLAG_POST_EXIT(*perr);
return ((OS_FLAGS)0);
}
OS_ENTER_CRITICAL();//关中断，进入临界区
//根据opt的不同，可以选择不同的模式
switch (opt) {
//对应位清零
case OS_FLAG_CLR:
pgrp->OSFlagFlags &= (OS_FLAGS)~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 */
*perr = OS_ERR_FLAG_INVALID_OPT;
OS_TRACE_FLAG_POST_EXIT(*perr);
return ((OS_FLAGS)0);
}
//预设不用调度
sched = OS_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) */
//对于每个pnode都查看其等待类型，来依次判断是否将TCB就绪
switch (pnode->OSFlagNodeWaitType) {
//节点中的等待标志都被置1
case OS_FLAG_WAIT_SET_ALL: /* See if all req. flags are set for current node */
//将当前事件标志组的标志与等待节点的等待标志进行逐位相与
flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & pnode->OSFlagNodeFlags);
//如果当前的标志满足了等待节点的要求，则唤醒
if (flags_rdy == pnode->OSFlagNodeFlags) { /* Make task RTR, event(s) Rx'd */
rdy = OS_FlagTaskRdy(pnode, flags_rdy, OS_STAT_PEND_OK);
if (rdy == OS_TRUE) {
sched = OS_TRUE; /* When done we will reschedule */
}
}
break;
//节点中的等待标志任一位被置1
case OS_FLAG_WAIT_SET_ANY: /* See if any flag set */
flags_rdy = (OS_FLAGS)(pgrp->OSFlagFlags & pnode->OSFlagNodeFlags);
if (flags_rdy != (OS_FLAGS)0) { /* Make task RTR, event(s) Rx'd */
rdy = OS_FlagTaskRdy(pnode, flags_rdy, OS_STAT_PEND_OK);
if (rdy == OS_TRUE) {
sched = OS_TRUE; /* When done we will reschedule */
}
}
break;
#if OS_FLAG_WAIT_CLR_EN > 0u
//节点中的等待标志所有位都被置0
case OS_FLAG_WAIT_CLR_ALL: /* See if all req. flags are set for current node */
flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & pnode->OSFlagNodeFlags;
if (flags_rdy == pnode->OSFlagNodeFlags) { /* Make task RTR, event(s) Rx'd */
rdy = OS_FlagTaskRdy(pnode, flags_rdy, OS_STAT_PEND_OK);
if (rdy == OS_TRUE) {
sched = OS_TRUE; /* When done we will reschedule */
}
}
break;
//节点中的等待标志任一位被置0
case OS_FLAG_WAIT_CLR_ANY: /* See if any flag set */
flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & pnode->OSFlagNodeFlags;
if (flags_rdy != (OS_FLAGS)0) { /* Make task RTR, event(s) Rx'd */
rdy = OS_FlagTaskRdy(pnode, flags_rdy, OS_STAT_PEND_OK);
if (rdy == OS_TRUE) {
sched = OS_TRUE; /* When done we will reschedule */
}
}
break;
#endif
default:
OS_EXIT_CRITICAL();
*perr = OS_ERR_FLAG_WAIT_TYPE;
OS_TRACE_FLAG_POST_EXIT(*perr);
return ((OS_FLAGS)0);
}
//指向下一个节点，进行判断
pnode = (OS_FLAG_NODE *)pnode->OSFlagNodeNext; /* Point to next task waiting for event flag(s) */
}
OS_EXIT_CRITICAL();
//如果有任务被唤醒了，就进行一次调度，这里就比上面的那个函数强一点，这里判断了，OS_FlagTaskRdy的返回值才进行调度，可以防止乱调度，资源浪费
//调度之前一定要开中断嘛？以前没注意过，如果在临界区内就直接调度了，调度函数也需要进入临界区，这就造成了中断嵌套啊，
if (sched == OS_TRUE) {
OS_Sched();
}
OS_ENTER_CRITICAL();
flags_cur = pgrp->OSFlagFlags;//当前事件标志组的标志位
OS_EXIT_CRITICAL();
*perr = OS_ERR_NONE;
OS_TRACE_FLAG_POST_EXIT(*perr);
return (flags_cur);
}
/*
*********************************************************************************************************
* QUERY EVENT FLAG（查询事件标志组）
*
* Description: This function is used to check the value of the event flag group.
*这个函数用来查询事件标志组的内容
* Arguments : pgrp is a pointer to the desired event flag group.
*指向事件标志组的指针
* perr is a pointer to an error code returned to the called:
* OS_ERR_NONE The call was successfull
* OS_ERR_FLAG_INVALID_PGRP You passed a NULL pointer
* OS_ERR_EVENT_TYPE You are not pointing to an event flag group
*
* Returns : The current value of the event flag group.
*当前事件标志组的内容
* Called From: Task or ISR（可以从任务或者ISR中调用）
*********************************************************************************************************
*/
//是否允许事件标志组查询
#if OS_FLAG_QUERY_EN > 0u
OS_FLAGS OSFlagQuery (OS_FLAG_GRP *pgrp,
INT8U *perr)
{
OS_FLAGS flags;
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0u;
#endif
#ifdef OS_SAFETY_CRITICAL
if (perr == (INT8U *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return ((OS_FLAGS)0);
}
#endif
//参数检查
#if OS_ARG_CHK_EN > 0u
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);
}
OS_ENTER_CRITICAL();//关中断，进入临界区
flags = pgrp->OSFlagFlags;//获取事件标志组的标志位
OS_EXIT_CRITICAL();
*perr = OS_ERR_NONE;
return (flags); /* Return the current value of the event flags */
}
#endif
/*
*********************************************************************************************************
* SUSPEND TASK UNTIL EVENT FLAG(s) RECEIVED OR TIMEOUT OCCURS（挂起一个任务，直到事件发生或者超时）
*
* Description: This function is internal to uC/OS-II and is used to put a task to sleep until the desired
* event flag bit(s) are set.
*这个函数是系统内部函数，用来将一个任务沉睡，知道它所期待的事件标志被置位
* Arguments : pgrp is a pointer to the desired event flag group.
*指向事件标志组的指针
* pnode is a pointer to a structure which contains data about the task waiting for
* event flag bit(s) to be set.
*是指向一个存储任务等待的相关信息的结构体指针
* 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 'mask' to be clear (0)
* OS_FLAG_WAIT_CLR_ANY You will check ANY bit in 'mask' to be clear (0)
* OS_FLAG_WAIT_SET_ALL You will check ALL bits in 'mask' to be set (1)
* OS_FLAG_WAIT_SET_ANY You will check ANY bit in 'mask' to be set (1)
*
* timeout is the desired amount of time that the task will wait for the event flag
* bit(s) to be set.
*
* Returns : none
*
* Called by : OSFlagPend() OS_FLAG.C
*
* Note(s) : This function is INTERNAL to uC/OS-II and your application should not call it.
*********************************************************************************************************
*/
static void OS_FlagBlock (OS_FLAG_GRP *pgrp,
OS_FLAG_NODE *pnode,
OS_FLAGS flags,
INT8U wait_type,
INT32U timeout)
{
OS_FLAG_NODE *pnode_next;
INT8U y;
//修改当前TCB的状态以及参数
OSTCBCur->OSTCBStat |= OS_STAT_FLAG;
OSTCBCur->OSTCBStatPend = OS_STAT_PEND_OK;
OSTCBCur->OSTCBDly = timeout; /* Store timeout in task's TCB */
#if OS_TASK_DEL_EN > 0u
OSTCBCur->OSTCBFlagNode = pnode; /* TCB to link to node */
#endif
//修改pnode的状态
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 */
//将当前pgrp等待列表的头节点向后移一位，注意这个为双向链表
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等待列表指针，指向新的头节点
pgrp->OSFlagWaitList = (void *)pnode;
//在就绪列表和就绪组中，取消就绪标志
y = OSTCBCur->OSTCBY; /* Suspend current task until flag(s) received */
OSRdyTbl[y] &= (OS_PRIO)~OSTCBCur->OSTCBBitX;
OS_TRACE_TASK_SUSPENDED(OSTCBCur);
if (OSRdyTbl[y] == 0x00u) {
OSRdyGrp &= (OS_PRIO)~OSTCBCur->OSTCBBitY;
}
}
/*
*********************************************************************************************************
* INITIALIZE THE EVENT FLAG MODULE（初始化事件标志组模块）
*
* Description: This function is called by uC/OS-II to initialize the event flag module. Your application
* MUST NOT call this function. In other words, this function is internal to uC/OS-II.
*这个函数被uC/OS-II调用，来初始化事件标志组模块，你的应用程序不可以调用此函数，换句话说，这个函数是系统内部函数
* Arguments : none
*
* Returns : none
*
* WARNING : You MUST NOT call this function from your code. This is an INTERNAL function to uC/OS-II.
注意：你不可以在你的程序中调用此函数，这是一个内部函数
*********************************************************************************************************
*/
void OS_FlagInit (void)
{
//查看事件标志组的个数，即最多允许有多少个事件标志组
#if OS_MAX_FLAGS == 1u//当只允许有一个事件标志组的时候
OSFlagFreeList = (OS_FLAG_GRP *)&OSFlagTbl[0]; /* Only ONE event flag group! */
OSFlagFreeList->OSFlagType = OS_EVENT_TYPE_UNUSED;
OSFlagFreeList->OSFlagWaitList = (void *)0;
OSFlagFreeList->OSFlagFlags = (OS_FLAGS)0;
#if OS_FLAG_NAME_EN > 0u
OSFlagFreeList->OSFlagName = (INT8U *)"?";
#endif
#endif
//如果事件标志组的允许数量大于1个
#if OS_MAX_FLAGS >= 2u
INT16U ix;
INT16U ix_next;
OS_FLAG_GRP *pgrp1;
OS_FLAG_GRP *pgrp2;
//按字节清空内存
OS_MemClr((INT8U *)&OSFlagTbl[0], sizeof(OSFlagTbl)); /* Clear the flag group table */
//这个for循环，只是处理ix所能达到的事件标志组，即【0，OS_MAX_FLAGS - 2u】，这时候就会剩下OS_MAX_FLAGS - 1u这个最后的节点，单独处理
for (ix = 0u; ix < (OS_MAX_FLAGS - 1u); ix++) { /* Init. list of free EVENT FLAGS */
ix_next = ix + 1u;
pgrp1 = &OSFlagTbl[ix];
pgrp2 = &OSFlagTbl[ix_next];
pgrp1->OSFlagType = OS_EVENT_TYPE_UNUSED;
pgrp1->OSFlagWaitList = (void *)pgrp2;
#if OS_FLAG_NAME_EN > 0u
pgrp1->OSFlagName = (INT8U *)(void *)"?"; /* Unknown name */
#endif
}
//对最后一个事件标志组进行处理
pgrp1 = &OSFlagTbl[ix];
pgrp1->OSFlagType = OS_EVENT_TYPE_UNUSED;
pgrp1->OSFlagWaitList = (void *)0;
#if OS_FLAG_NAME_EN > 0u
pgrp1->OSFlagName = (INT8U *)(void *)"?"; /* Unknown name */
#endif
//将空闲链表指针指向事件标志组的0号位
OSFlagFreeList = &OSFlagTbl[0];
#endif
}
/*
*********************************************************************************************************
* MAKE TASK READY-TO-RUN, EVENT(s) OCCURRED（当事件发生的时候，使等待任务就绪）
*
* Description: This function is internal to uC/OS-II and is used to make a task ready-to-run because the
* desired event flag bits have been set.
*这个函数是系统内部函数，在事件发生的时候，用来唤醒等待事件
* Arguments : pnode is a pointer to a structure which contains data about the task waiting for
* event flag bit(s) to be set.
*指向保存等待事件的任务的信息的结构体的指针
* flags_rdy contains the bit pattern of the event flags that cause the task to become
* ready-to-run.
*包含使任务变为就绪状态的事件标志的比特形式
* pend_stat is used to indicate the readied task's pending status:
*指示就绪任务的等待状态
*
* Returns : OS_TRUE If the task has been placed in the ready list and thus needs scheduling
* OS_FALSE The task is still not ready to run and thus scheduling is not necessary
*
* Called by : OSFlagsPost() OS_FLAG.C
*
* Note(s) : 1) This function assumes that interrupts are disabled.（调用这个函数的前提是中断已经被屏蔽了）
* 2) This function is INTERNAL to uC/OS-II and your application should not call it.（这个函数是系统内部函数，你的应用程序不能够调用它）
*********************************************************************************************************
*/
//静态函数，限定作用域
static BOOLEAN OS_FlagTaskRdy (OS_FLAG_NODE *pnode,//指向事件标志组节点
OS_FLAGS flags_rdy,
INT8U pend_stat)
{
OS_TCB *ptcb;
BOOLEAN sched;
//获得与事件标志组节点相关的TCB
ptcb = (OS_TCB *)pnode->OSFlagNodeTCB; /* Point to TCB of waiting task */
ptcb->OSTCBDly = 0u;//设置延迟时间为0
ptcb->OSTCBFlagsRdy = flags_rdy;//设置事件标志就绪状态
ptcb->OSTCBStat &= (INT8U)~(INT8U)OS_STAT_FLAG;//将此时TCB的状态去掉等待事件标志组的标志
ptcb->OSTCBStatPend = pend_stat;
//如果任务的状态此时是就绪态，那么可以上就绪表和组，进行一次调度
if (ptcb->OSTCBStat == OS_STAT_RDY) { /* Task now ready? */
OSRdyGrp |= ptcb->OSTCBBitY; /* Put task into ready list */
OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
OS_TRACE_TASK_READY(ptcb);
sched = OS_TRUE;
} else {
sched = OS_FALSE;
}
//将事件标志组节点从事件标志组中去掉
OS_FlagUnlink(pnode);
return (sched);//返回是否需要调度
}
/*
*********************************************************************************************************
* UNLINK EVENT FLAG NODE FROM WAITING LIST（从事件等待列表中断开与事件标志组节点的链接）
*
* Description: This function is internal to uC/OS-II and is used to unlink an event flag node from a
* list of tasks waiting for the event flag.
*这个函数是系统内部函数，用来断开事件标志组节点与事件等待列表的联系
* Arguments : pnode is a pointer to a structure which contains data about the task waiting for
* event flag bit(s) to be set.
*pnode是一个指针，该指针指向了一个结构体，该结构体包含了任务等待事件标志位被置位的相关信息
* Returns : none
*
* Called by : OS_FlagTaskRdy() OS_FLAG.C
* OSFlagPend() OS_FLAG.C
* OSTaskDel() OS_TASK.C
*
* Note(s) : 1) This function assumes that interrupts are disabled.//调用这个函数的前提是已经关闭中断
* 2) This function is INTERNAL to uC/OS-II and your application should not call it.//这个函数是内部函数，你的应用程序不能够调用它
*********************************************************************************************************
*/
/**
* TCB与pnode之间是双链表
* 事件等待组与pnode之间是双链表
*/
void OS_FlagUnlink (OS_FLAG_NODE *pnode)//传入事件标志组节点指针，此节点指针可以位于等待列表中的任意位置，但是要区别是否在表头
{
//是否允许删除
#if OS_TASK_DEL_EN > 0u
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 > 0u
ptcb = (OS_TCB *)pnode->OSFlagNodeTCB;
ptcb->OSTCBFlagNode = (OS_FLAG_NODE *)0;//断开事件标志组节点与TCB的链接
#endif
}
#endif
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
