![](/media/cache/img/default_profile.jpg.50x50_q85.jpg)
CoOS Demonstrator adapted to mbed Hardware.
Diff: flag.c
- Revision:
- 0:57690853989a
diff -r 000000000000 -r 57690853989a flag.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/flag.c Fri Dec 03 19:45:30 2010 +0000 @@ -0,0 +1,712 @@ +/** + ******************************************************************************* + * @file flag.c + * @version V1.1.3 + * @date 2010.04.26 + * @brief Flag management implementation code of coocox CoOS kernel. + ******************************************************************************* + * @copy + * + * INTERNAL FILE,DON'T PUBLIC. + * + * <h2><center>© COPYRIGHT 2009 CooCox </center></h2> + ******************************************************************************* + */ + + + +/*---------------------------- Include ---------------------------------------*/ +#include <coocox.h> + +#if CFG_FLAG_EN > 0 +/*---------------------------- Variable Define -------------------------------*/ +#define FLAG_MAX_NUM 32 /*!< Define max flag number. */ +FCB FlagCrl = {0}; /*!< Flags list struct */ + + +/*---------------------------- Function Declare ------------------------------*/ +static void FlagBlock(P_FLAG_NODE pnode,U32 flags,U8 waitType); +static P_FLAG_NODE RemoveFromLink(P_FLAG_NODE pnode); + +/** + ******************************************************************************* + * @brief Create a flag + * @param[in] bAutoReset Reset mode,TRUE(Auto Reset) FLASE(Manual Reset). + * @param[in] bInitialState Initial state. + * @param[out] None + * @retval E_CREATE_FAIL Create flag fail. + * @retval others Create flag successful. + * + * @par Description + * @details This function use to create a event flag. + * @note + ******************************************************************************* + */ +OS_FlagID CoCreateFlag(BOOL bAutoReset,BOOL bInitialState) +{ + U8 i; + OsSchedLock(); + + for(i=0;i<FLAG_MAX_NUM;i++) + { + /* Assign a free flag control block */ + if((FlagCrl.flagActive&(1<<i)) == 0 ) + { + FlagCrl.flagActive |= (1<<i); /* Initialize active flag */ + FlagCrl.flagRdy |= (bInitialState<<i);/* Initialize ready flag */ + FlagCrl.resetOpt |= (bAutoReset<<i);/* Initialize reset option */ + OsSchedUnlock(); + return i ; /* Return Flag ID */ + } + } + OsSchedUnlock(); + + return E_CREATE_FAIL; /* There is no free flag control block*/ +} + + +/** + ******************************************************************************* + * @brief Delete a flag + * @param[in] id Flag ID. + * @param[in] opt Delete option. + * @param[out] None + * @retval E_CALL Error call in ISR. + * @retval E_INVALID_ID Invalid event ID. + * @retval E_TASK_WAITTING Tasks waitting for the event,delete fail. + * @retval E_OK Event deleted successful. + * + * @par Description + * @details This function is called to delete a event flag. + * @note + ******************************************************************************* + */ +StatusType CoDelFlag(OS_FlagID id,U8 opt) +{ + P_FLAG_NODE pnode; + P_FCB pfcb; + pfcb = &FlagCrl; + if(OSIntNesting > 0) /* If be called from ISR */ + { + return E_CALL; + } +#if CFG_PAR_CHECKOUT_EN >0 + if((pfcb->flagActive&(1<<id)) == 0) /* Flag is valid or not */ + { + return E_INVALID_ID; + } +#endif + OsSchedLock(); + pnode = pfcb->headNode; + + while(pnode != 0) /* Ready all tasks waiting for flags */ + { + if((pnode->waitFlags&(1<<id)) != 0) /* If no task is waiting on flags */ + { + if(opt == OPT_DEL_NO_PEND) /* Delete flag if no task waiting */ + { + OsSchedUnlock(); + return E_TASK_WAITING; + } + else if (opt == OPT_DEL_ANYWAY) /* Always delete the flag */ + { + if(pnode->waitType == OPT_WAIT_ALL) + { + /* If the flag is only required by NODE */ + if( pnode->waitFlags == (1<<id) ) + { + /* Remove the NODE from waiting list */ + pnode = RemoveFromLink(pnode); + continue; + } + else + { + pnode->waitFlags &= ~(1<<id); /* Update waitflags */ + } + } + else + { + pnode = RemoveFromLink(pnode); + continue; + } + } + } + pnode = pnode->nextNode; + } + + /* Remove the flag from the flags list */ + pfcb->flagActive &= ~(1<<id); + pfcb->flagRdy &= ~(1<<id); + pfcb->resetOpt &= ~(1<<id); + OsSchedUnlock(); + return E_OK; +} + + +/** + ******************************************************************************* + * @brief AcceptSingleFlag + * @param[in] id Flag ID. + * @param[out] None + * @retval E_INVALID_ID Invalid event ID. + * @retval E_FLAG_NOT_READY Flag is not in ready state. + * @retval E_OK The call was successful and your task owns the Flag. + * + * @par Description + * @details This fucntion is called to accept single flag + * @note + ******************************************************************************* + */ +StatusType CoAcceptSingleFlag(OS_FlagID id) +{ + P_FCB pfcb; + pfcb = &FlagCrl; +#if CFG_PAR_CHECKOUT_EN >0 + if(id >= FLAG_MAX_NUM) + { + return E_INVALID_ID; /* Invalid 'id',return error */ + } + if((pfcb->flagActive&(1<<id)) == 0) + { + return E_INVALID_ID; /* Flag is deactive,return error */ + } +#endif + if((pfcb->flagRdy&(1<<id)) != 0) /* If the required flag is set */ + { + OsSchedLock() + pfcb->flagRdy &= ~((FlagCrl.resetOpt)&(1<<id)); /* Clear the flag */ + OsSchedUnlock(); + return E_OK; + } + else /* If the required flag is not set */ + { + return E_FLAG_NOT_READY; + } +} + + +/** + ******************************************************************************* + * @brief AcceptMultipleFlags + * @param[in] flags Flags that waiting to active task. + * @param[in] waitType Flags wait type. + * @param[out] perr A pointer to error code. + * @retval 0 + * @retval springFlag + * + * @par Description + * @details This fucntion is called to accept multiple flags. + * @note + ******************************************************************************* + */ +U32 CoAcceptMultipleFlags(U32 flags,U8 waitType,StatusType *perr) +{ + U32 springFlag; + P_FCB pfcb; + pfcb = &FlagCrl; + +#if CFG_PAR_CHECKOUT_EN >0 + if((flags&pfcb->flagActive) != flags ) /* Judge flag is active or not? */ + { + *perr = E_INVALID_PARAMETER; /* Invalid flags */ + return 0; + } +#endif + + springFlag = flags & pfcb->flagRdy; + + OsSchedLock(); + /* If any required flags are set */ + if( (springFlag != 0) && (waitType == OPT_WAIT_ANY) ) + { + + pfcb->flagRdy &= ~(springFlag & pfcb->resetOpt); /* Clear the flags */ + OsSchedUnlock(); + *perr = E_OK; + return springFlag; + } + + /* If all required flags are set */ + if((springFlag == flags) && (waitType == OPT_WAIT_ALL)) + { + pfcb->flagRdy &= ~(springFlag&pfcb->resetOpt); /* Clear the flags */ + OsSchedUnlock(); + *perr = E_OK; + return springFlag; + } + OsSchedUnlock(); + *perr = E_FLAG_NOT_READY; + return 0; +} + + + + +/** + ******************************************************************************* + * @brief WaitForSingleFlag + * @param[in] id Flag ID. + * @param[in] timeout The longest time for writting flag. + * @param[out] None + * @retval E_CALL Error call in ISR. + * @retval E_INVALID_ID Invalid event ID. + * @retval E_TIMEOUT Flag wasn't received within 'timeout' time. + * @retval E_OK The call was successful and your task owns the Flag, + * or the event you are waiting for occurred. + * + * @par Description + * @details This function is called to wait for only one flag, + * (1) if parameter "timeout" == 0,waiting until flag be set; + * (2) when "timeout" != 0,if flag was set or wasn't set but timeout + * occured,the task will exit the waiting list,convert to READY + * or RUNNING state. + * @note + ******************************************************************************* + */ +StatusType CoWaitForSingleFlag(OS_FlagID id,U32 timeout) +{ + FLAG_NODE flagNode; + P_FCB pfcb; + P_OSTCB curTCB; + + if(OSIntNesting > 0) /* See if the caller is ISR */ + { + return E_CALL; + } + if(OSSchedLock != 0) /* Schedule is lock? */ + { + return E_OS_IN_LOCK; /* Yes,error return */ + } + +#if CFG_PAR_CHECKOUT_EN >0 + if(id >= FLAG_MAX_NUM) /* Judge id is valid or not? */ + { + return E_INVALID_ID; /* Invalid 'id' */ + } + if((FlagCrl.flagActive&(1<<id)) == 0 )/* Judge flag is active or not? */ + { + return E_INVALID_ID; /* Flag is deactive ,return error */ + } +#endif + + OsSchedLock(); + pfcb = &FlagCrl; + /* See if the required flag is set */ + if((pfcb->flagRdy&(1<<id)) != 0) /* If the required flag is set */ + { + pfcb->flagRdy &= ~((pfcb->resetOpt&(1<<id))); /* Clear the flag */ + OsSchedUnlock(); + } + else /* If the required flag is not set */ + { + curTCB = TCBRunning; + if(timeout == 0) /* If time-out is not configured */ + { + /* Block task until the required flag is set */ + FlagBlock (&flagNode,(1<<id),OPT_WAIT_ONE); + curTCB->state = TASK_WAITING; + TaskSchedReq = TRUE; + OsSchedUnlock(); + + /* The required flag is set and the task is in running state */ + curTCB->pnode = 0; + OsSchedLock(); + + /* Clear the required flag or not */ + pfcb->flagRdy &= ~((1<<id)&(pfcb->resetOpt)); + OsSchedUnlock(); + } + else /* If time-out is configured */ + { + /* Block task until the required flag is set or time-out occurs */ + FlagBlock(&flagNode,(1<<id),OPT_WAIT_ONE); + InsertDelayList(curTCB,timeout); + + OsSchedUnlock(); + if(curTCB->pnode == 0) /* If time-out occurred */ + { + return E_TIMEOUT; + } + else /* If flag is set */ + { + curTCB->pnode = 0; + OsSchedLock(); + + /* Clear the required flag or not */ + pfcb->flagRdy &= ~((1<<id)&(pfcb->resetOpt)); + OsSchedUnlock(); + } + } + } + return E_OK; +} + + +/** + ******************************************************************************* + * @brief WaitForMultipleFlags + * @param[in] flags Flags that waiting to active task. + * @param[in] waitType Flags wait type. + * @param[in] timeout The longest time for writting flag. + * @param[out] perr A pointer to error code. + * @retval 0 + * @retval springFlag + * + * @par Description + * @details This function is called to pend a task for waitting multiple flag. + * @note + ******************************************************************************* + */ +U32 CoWaitForMultipleFlags(U32 flags,U8 waitType,U32 timeout,StatusType *perr) +{ + U32 springFlag; + P_FCB pfcb; + FLAG_NODE flagNode; + P_OSTCB curTCB; + + + if(OSIntNesting > 0) /* If the caller is ISR */ + { + *perr = E_CALL; + return 0; + } + if(OSSchedLock != 0) /* Schedule is lock? */ + { + *perr = E_OS_IN_LOCK; + return 0; /* Yes,error return */ + } +#if CFG_PAR_CHECKOUT_EN >0 + if( (flags&FlagCrl.flagActive) != flags ) + { + *perr = E_INVALID_PARAMETER; /* Invalid 'flags' */ + return 0; + } +#endif + OsSchedLock(); + pfcb = &FlagCrl; + springFlag = flags & pfcb->flagRdy; + + /* If any required flags are set */ + if((springFlag != 0) && (waitType == OPT_WAIT_ANY)) + { + pfcb->flagRdy &= ~(springFlag & pfcb->resetOpt); /* Clear the flag */ + OsSchedUnlock(); + *perr = E_OK; + return springFlag; + } + + /* If all required flags are set */ + if( (springFlag == flags) && (waitType == OPT_WAIT_ALL) ) + { + pfcb->flagRdy &= ~(springFlag & pfcb->resetOpt); /* Clear the flags */ + OsSchedUnlock(); + *perr = E_OK; + return springFlag; + } + + curTCB = TCBRunning; + if(timeout == 0) /* If time-out is not configured */ + { + /* Block task until the required flag are set */ + FlagBlock(&flagNode,flags,waitType); + curTCB->state = TASK_WAITING; + TaskSchedReq = TRUE; + OsSchedUnlock(); + + curTCB->pnode = 0; + OsSchedLock(); + springFlag = flags & pfcb->flagRdy; + pfcb->flagRdy &= ~(springFlag & pfcb->resetOpt);/* Clear the flags */ + OsSchedUnlock(); + *perr = E_OK; + return springFlag; + } + else /* If time-out is configured */ + { + /* Block task until the required flag are set or time-out occurred */ + FlagBlock(&flagNode,flags,waitType); + InsertDelayList(curTCB,timeout); + + OsSchedUnlock(); + if(curTCB->pnode == 0) /* If time-out occurred */ + { + *perr = E_TIMEOUT; + return 0; + } + else /* If the required flags are set */ + { + curTCB->pnode = 0; + OsSchedLock(); + springFlag = flags & FlagCrl.flagRdy; + + /* Clear the required ready flags or not */ + pfcb->flagRdy &= ~(springFlag & pfcb->resetOpt); + OsSchedUnlock(); + *perr = E_OK; + return springFlag; + } + } +} + + +/** + ******************************************************************************* + * @brief Clear a Flag + * @param[in] id Flag ID. + * @param[out] None + * @retval E_OK Event deleted successful. + * @retval E_INVALID_ID Invalid event ID. + * + * @par Description + * @details This function is called to clear a flag. + * + * @note + ******************************************************************************* + */ +StatusType CoClearFlag(OS_FlagID id) +{ + P_FCB pfcb; + pfcb = &FlagCrl; +#if CFG_PAR_CHECKOUT_EN >0 + if(id >= FLAG_MAX_NUM) + { + return E_INVALID_ID; /* Invalid id */ + } + if((pfcb->flagActive&(1<<id)) == 0) + { + return E_INVALID_ID; /* Invalid flag */ + } +#endif + + pfcb->flagRdy &= ~(1<<id); /* Clear the flag */ + return E_OK; +} + + +/** + ******************************************************************************* + * @brief Set a flag + * @param[in] id Flag ID. + * @param[out] None + * @retval E_INVALID_ID Invalid event ID. + * @retval E_OK Event deleted successful. + * + * @par Description + * @details This function is called to set a flag. + * @note + ******************************************************************************* + */ +StatusType CoSetFlag(OS_FlagID id) +{ + P_FLAG_NODE pnode; + P_FCB pfcb; + pfcb = &FlagCrl; + +#if CFG_PAR_CHECKOUT_EN >0 + if(id >= FLAG_MAX_NUM) /* Flag is valid or not */ + { + return E_INVALID_ID; /* Invalid flag id */ + } + if((pfcb->flagActive&(1<<id)) == 0) + { + return E_INVALID_ID; /* Flag is not exist */ + } +#endif + + if((pfcb->flagRdy&(1<<id)) != 0) /* Flag had already been set */ + { + return E_OK; + } + + pfcb->flagRdy |= (1<<id); /* Update the flags ready list */ + + OsSchedLock(); + pnode = pfcb->headNode; + while(pnode != 0) + { + if(pnode->waitType == OPT_WAIT_ALL) /* Extract all the bits we want */ + { + if((pnode->waitFlags&pfcb->flagRdy) == pnode->waitFlags) + { + /* Remove the flag node from the wait list */ + pnode = RemoveFromLink(pnode); + if((pfcb->resetOpt&(1<<id)) != 0)/* If the flags is auto-reset*/ + { + break; + } + continue; + } + } + else /* Extract only the bits we want */ + { + if( (pnode->waitFlags & pfcb->flagRdy) != 0) + { + /* Remove the flag node from the wait list */ + pnode = RemoveFromLink(pnode); + if((pfcb->resetOpt&(1<<id)) != 0) + { + break; /* The flags is auto-reset */ + } + continue; + } + } + pnode = pnode->nextNode; + } + OsSchedUnlock(); + return E_OK; +} + + + +/** + ******************************************************************************* + * @brief Set a flag in ISR + * @param[in] id Flag ID. + * @param[out] None + * @retval E_INVALID_ID Invalid event ID. + * @retval E_OK Event deleted successful. + * + * @par Description + * @details This function is called in ISR to set a flag. + * @note + ******************************************************************************* + */ +#if CFG_MAX_SERVICE_REQUEST > 0 +StatusType isr_SetFlag(OS_FlagID id) +{ + if(OSSchedLock > 0) /* If scheduler is locked,(the caller is ISR) */ + { + /* Insert the request into service request queue */ + if(InsertInSRQ(FLAG_REQ,id,0) == FALSE) + { + return E_SEV_REQ_FULL; /* The service requst queue is full */ + } + else + { + return E_OK; + } + } + else + { + return(CoSetFlag(id)); /* The caller is not ISR, set the flag*/ + } +} +#endif + +/** + ******************************************************************************* + * @brief Block a task to wait a flag event + * @param[in] pnode A node that will link into flag waiting list. + * @param[in] flags Flag(s) that the node waiting for. + * @param[in] waitType Waiting type of the node. + * @param[out] None + * @retval None + * + * @par Description + * @details This function is called to block a task to wait a flag event. + * @note + ******************************************************************************* + */ +static void FlagBlock(P_FLAG_NODE pnode,U32 flags,U8 waitType) +{ + P_FCB pfcb; + pfcb = &FlagCrl; + + TCBRunning->pnode = pnode; + pnode->waitTask = TCBRunning; + pnode->waitFlags = flags; /* Save the flags that we need to wait for*/ + pnode->waitType = waitType; /* Save the type of wait */ + + if(pfcb->tailNode == 0) /* If this is the first NODE to insert? */ + { + pnode->nextNode = 0; + pnode->prevNode = 0; + pfcb->headNode = pnode; /* Insert the NODE to the head */ + } + else /* If it is not the first NODE to insert? */ + { + pfcb->tailNode->nextNode = pnode; /* Insert the NODE to the tail */ + pnode->prevNode = pfcb->tailNode; + pnode->nextNode = 0; + } + pfcb->tailNode = pnode; +} + + +/** + ******************************************************************************* + * @brief Remove a flag node from list + * @param[in] pnode A node that will remove from flag waiting list. + * @param[out] None + * @retval pnode Next node of the node that have removed out. + * + * @par Description + * @details This function is called to remove a flag node from the wait list. + * @note + ******************************************************************************* + */ +static P_FLAG_NODE RemoveFromLink(P_FLAG_NODE pnode) +{ + P_OSTCB ptcb; + + RemoveLinkNode(pnode); /* Remove the flag node from wait list. */ + ptcb = pnode->waitTask; + + /* The task in the delay list */ + if(ptcb->delayTick != INVALID_VALUE)/* If the task is in tick delay list */ + { + RemoveDelayList(ptcb); /* Remove the task from tick delay list */ + } + + ptcb->pnode = (void*)0xffffffff; + + if(ptcb == TCBRunning) + { + ptcb->state = TASK_RUNNING; + } + else + { + InsertToTCBRdyList(ptcb); /* Insert the task to ready list */ + } + return (pnode->nextNode); +} + +/** + ******************************************************************************* + * @brief Remove a flag node from list + * @param[in] pnode A node that will remove from flag waiting list. + * @param[out] None + * @retval None + * + * @par Description + * @details This function is called to remove a flag node from the wait list. + * @note + ******************************************************************************* + */ +void RemoveLinkNode(P_FLAG_NODE pnode) +{ + /* If only one NODE in the list*/ + if((pnode->nextNode == 0) && (pnode->prevNode == 0)) + { + FlagCrl.headNode = 0; + FlagCrl.tailNode = 0; + } + else if(pnode->nextNode == 0) /* If the NODE is tail */ + { + FlagCrl.tailNode = pnode->prevNode; + pnode->prevNode->nextNode = 0; + } + else if(pnode->prevNode == 0) /* If the NODE is head */ + { + FlagCrl.headNode = pnode->nextNode; + pnode->nextNode->prevNode = 0; + } + else /* The NODE is in the middle */ + { + pnode->nextNode->prevNode = pnode->prevNode; + pnode->prevNode->nextNode = pnode->nextNode; + } + pnode->waitTask->pnode = 0; +} + +#endif