μC/OS-II—Event flag group management 1 (os_flag.c)

Directory

• • Event flag group creation
  • event flag group delete
  • Event flag group get/wait

• When a task needs to be synchronized with multiple events, an event flag group is used.
• An event flag is a binary signal, and an event flag group is a combination of several binary signals.
• Synchronization tasks using event flag groups are divided into independent synchronization and correlation synchronization.

Event flag group creation

• flags: The initial value of the event flag group.

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
\t
if (perr == (INT8U *)0)
{<!-- -->
OS_SAFETY_CRITICAL_EXCEPTION();
return ((OS_FLAG_GRP *)0);
}
\t
#endif
#ifdef OS_SAFETY_CRITICAL_IEC61508
\t
if (OSSafetyCriticalStartFlag == OS_TRUE)
{<!-- -->
OS_SAFETY_CRITICAL_EXCEPTION();
return ((OS_FLAG_GRP *)0);
}
\t
#endif
\t
if (OSIntNesting > 0u) /* See if called from ISR ... */
{<!-- -->
*perr = OS_ERR_CREATE_ISR; /* ... can't CREATE from an ISR */
return ((OS_FLAG_GRP *)0);
}
\t
OS_ENTER_CRITICAL();
pgrp = OSFlagFreeList; /* Get next free event flag */
\t
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_EXIT_CRITICAL();
*perr = OS_ERR_NONE;
}
\t
else
{<!-- -->
OS_EXIT_CRITICAL();
*perr = OS_ERR_FLAG_GRP_DEPLETED;
}
\t
return (pgrp); /* Return pointer to event flag group */
}

Event flag group deletion

#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
\t
if (perr == (INT8U *)0)
{<!-- -->
OS_SAFETY_CRITICAL_EXCEPTION();
return ((OS_FLAG_GRP *)0);
}
\t
#endif
#if OS_ARG_CHK_EN > 0u
\t
if (pgrp == (OS_FLAG_GRP *)0) /* Validate 'pgrp' */
{<!-- -->
*perr = OS_ERR_FLAG_INVALID_PGRP;
return (pgrp);
}
\t
#endif
\t
if (OSIntNesting > 0u) /* See if called from ISR ... */
{<!-- -->
*perr = OS_ERR_DEL_ISR; /* ... can't DELETE from an ISR */
return (pgrp);
}
\t
if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) /* Validate event group type */
{<!-- -->
*perr = OS_ERR_EVENT_TYPE;
return (pgrp);
}
\t
OS_ENTER_CRITICAL();
\t
if (pgrp->OSFlagWaitList != (void *)0) /* See if any tasks waiting on event flags */
{<!-- -->
tasks_waiting = OS_TRUE; /* Yes */
}
\t
else
{<!-- -->
tasks_waiting = OS_FALSE; /* No */
}
\t
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 */
}
\t\t\t
else
{<!-- -->
OS_EXIT_CRITICAL();
*perr = OS_ERR_TASK_WAITING;
pgrp_return = pgrp;
}
\t\t\t
break;
\t\t\t
case OS_DEL_ALWAYS: /* Always delete the event flag group */
pnode = (OS_FLAG_NODE *)pgrp->OSFlagWaitList;
\t\t\t
while (pnode != (OS_FLAG_NODE *)0) /* Ready ALL tasks waiting for flags */
{<!-- -->
(void)OS_FlagTaskRdy (pnode, (OS_FLAGS)0, OS_STAT_PEND_ABORT);
pnode = (OS_FLAG_NODE *)pnode->OSFlagNodeNext;
}
\t\t\t
#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();
\t\t\t
if (tasks_waiting == OS_TRUE) /* Reschedule only if task(s) were waiting */
{<!-- -->
OS_Sched(); /* Find highest priority task ready to run */
}
\t\t\t
*perr = OS_ERR_NONE;
pgrp_return = (OS_FLAG_GRP *)0; /* Event Flag Group has been deleted */
break;
\t\t\t
default:
OS_EXIT_CRITICAL();
*perr = OS_ERR_INVALID_OPT;
pgrp_return = pgrp;
break;
}
\t
return (pgrp_return);
}
#endif

Event flag group get/wait

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
\t
if (perr == (INT8U *)0)
{<!-- -->
OS_SAFETY_CRITICAL_EXCEPTION();
return ((OS_FLAGS)0);
}
\t
#endif
#if OS_ARG_CHK_EN > 0u
\t
if (pgrp == (OS_FLAG_GRP *)0) /* Validate 'pgrp' */
{<!-- -->
*perr = OS_ERR_FLAG_INVALID_PGRP;
return ((OS_FLAGS)0);
}
\t
#endif
\t
if (OSIntNesting > 0u) /* See if called from ISR ... */
{<!-- -->
*perr = OS_ERR_PEND_ISR; /* ... can't PEND from an ISR */
return ((OS_FLAGS)0);
}
\t
if (OSLockNesting > 0u) /* See if called with scheduler locked ... */
{<!-- -->
*perr = OS_ERR_PEND_LOCKED; /* ... can't PEND when locked */
return ((OS_FLAGS)0);
}
\t
if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) /* Validate event block type */
{<!-- -->
*perr = OS_ERR_EVENT_TYPE;
return ((OS_FLAGS)0);
}
\t
result = (INT8U) (wait_type & amp; OS_FLAG_CONSUME);
\t
if (result != (INT8U)0) /* See if we need to consume the flags */
{<!-- -->
wait_type &= (INT8U)~ (INT8U)OS_FLAG_CONSUME;
consume = OS_TRUE;
}
\t
else
{<!-- -->
consume = OS_FALSE;
}
\t
/*$PAGE*/
OS_ENTER_CRITICAL();
\t
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 */
\t\t\t
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 & amp;= (OS_FLAGS)~flags_rdy; /* Clear ONLY the flags we wanted */
}
\t\t\t\t
OSTCBCur->OSTCBFlagsRdy = flags_rdy; /* Save flags that were ready */
OS_EXIT_CRITICAL(); /* Yes, condition met, return to caller */
*perr = OS_ERR_NONE;
return (flags_rdy);
}
\t\t\t
else /* Block task until events occur or timeout */
{<!-- -->
OS_FlagBlock (pgrp, & node, flags, wait_type, timeout);
OS_EXIT_CRITICAL();
}
\t\t\t
break;
\t\t\t
case OS_FLAG_WAIT_SET_ANY:
flags_rdy = (OS_FLAGS) (pgrp->OSFlagFlags & flags); /* Extract only the bits we want */
\t\t\t
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 & amp;= (OS_FLAGS)~flags_rdy; /* Clear ONLY the flags that we got */
}
\t\t\t\t
OSTCBCur->OSTCBFlagsRdy = flags_rdy; /* Save flags that were ready */
OS_EXIT_CRITICAL(); /* Yes, condition met, return to caller */
*perr = OS_ERR_NONE;
return (flags_rdy);
}
\t\t\t
else /* Block task until events occur or timeout */
{<!-- -->
OS_FlagBlock (pgrp, & node, flags, wait_type, timeout);
OS_EXIT_CRITICAL();
}
\t\t\t
break;
#if OS_FLAG_WAIT_CLR_EN > 0u
\t\t\t
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 */
\t\t\t
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 */
}
\t\t\t\t
OSTCBCur->OSTCBFlagsRdy = flags_rdy; /* Save flags that were ready */
OS_EXIT_CRITICAL(); /* Yes, condition met, return to caller */
*perr = OS_ERR_NONE;
return (flags_rdy);
}
\t\t\t
else /* Block task until events occur or timeout */
{<!-- -->
OS_FlagBlock (pgrp, & node, flags, wait_type, timeout);
OS_EXIT_CRITICAL();
}
\t\t\t
break;
\t\t\t
case OS_FLAG_WAIT_CLR_ANY:
flags_rdy = (OS_FLAGS)~pgrp->OSFlagFlags & flags; /* Extract only the bits we want */
\t\t\t
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 */
}
\t\t\t\t
OSTCBCur->OSTCBFlagsRdy = flags_rdy; /* Save flags that were ready */
OS_EXIT_CRITICAL(); /* Yes, condition met, return to caller */
*perr = OS_ERR_NONE;
return (flags_rdy);
}
\t\t\t
else /* Block task until events occur or timeout */
{<!-- -->
OS_FlagBlock (pgrp, & node, flags, wait_type, timeout);
OS_EXIT_CRITICAL();
}
\t\t\t
break;
#endif
\t\t\t
default:
OS_EXIT_CRITICAL();
flags_rdy = (OS_FLAGS)0;
*perr = OS_ERR_FLAG_WAIT_TYPE;
return (flags_rdy);
}
\t
/*$PAGE*/
OS_Sched(); /* Find next HPT ready to run */
OS_ENTER_CRITICAL();
\t
if (OSTCBCur->OSTCBStatPend != OS_STAT_PEND_OK) /* Have we timed-out or aborted? */
{<!-- -->
pend_stat = OSTCBCur->OSTCBStatPend;
OSTCBCur->OSTCBStatPend = OS_STAT_PEND_OK;
OS_FlagUnlink ( & amp;node);
OSTCBCur->OSTCBStat = OS_STAT_RDY; /* Yes, make task ready-to-run */
OS_EXIT_CRITICAL();
flags_rdy = (OS_FLAGS)0;
\t\t
switch(pend_stat)
{<!-- -->
case OS_STAT_PEND_ABORT:
*perr = OS_ERR_PEND_ABORT; /* Indicate that we aborted waiting */
break;
\t\t\t\t
case OS_STAT_PEND_TO:
default:
*perr = OS_ERR_TIMEOUT; /* Indicate that we timed-out waiting */
break;
}
\t\t
return (flags_rdy);
}
\t
flags_rdy = OTCBCur->OSTCBFlagsRdy;
\t
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 & amp;= (OS_FLAGS)~flags_rdy;
break;
#if OS_FLAG_WAIT_CLR_EN > 0u
\t\t\t\t
case OS_FLAG_WAIT_CLR_ALL:
case OS_FLAG_WAIT_CLR_ANY: /* Set ONLY the flags we got */
pgrp->OSFlagFlags |= flags_rdy;
break;
#endif
\t\t\t\t
default:
OS_EXIT_CRITICAL();
*perr = OS_ERR_FLAG_WAIT_TYPE;
return ((OS_FLAGS)0);
}
}
\t
OS_EXIT_CRITICAL();
*perr = OS_ERR_NONE; /* Event(s) must have occurred */
return (flags_rdy);
}