task.c

介绍ROCK OS操作系统.一般用于汽车电子,类似OCVX.里面是个DEMO文档,内附说明.

        return OS_FAIL;
    }

#if DUMP_TASK_FSM != 0
    /* dump the task fsm. */
    OS_ENTER_CRITICAL();
    taskFsmDump(g_taskFsm, task, g_sysTcb[task].state, T_TRIG_SUSPEND, (void *)taskSuspend);
    OS_LEAVE_CRITICAL();
#endif

    /* remove it from ready task queue if its state is ready. */
    if (g_sysTcb[task].state == OS_TASK_READY)
    {
        OS_ENTER_CRITICAL();
        q_del(g_readyTaskQueue, (HANDLE)task);
        OS_LEAVE_CRITICAL();
    }

    /* change task to suspend state. */
    OS_ENTER_CRITICAL();
    g_sysTcb[task].suspendState = g_sysTcb[task].state;
    g_sysTcb[task].state = OS_TASK_SUSPEND;
    OS_LEAVE_CRITICAL();

    /* run another task. */
    OSScheduler();

    return OS_SUCCESS;
}
/******************************************************************************
Function    : STATUS taskWakeup (HTASK task)
Params      : task - the task
            : 
            : 
            : 
Return      : OS_SUCCESS or OS_FAIL
Description : wakeup a task. It should only be called by another task.
            : i.e. param 'task' should diff with current task.
******************************************************************************/
STATUS taskWakeup (HTASK task)
{
    /* params check. */
    if (task >= MAX_SYS_TASK)
    {
        OS_error("taskWakeup(): task id [%d] out of range!!!\n", task);
        return OS_FAIL;
    }

    if (g_sysTcb[task].state == OS_TASK_FREE)
    {
        OS_error("taskWakeup(): task [%d] is free!!!\n", task);
        return OS_FAIL;
    }

    if (g_sysTcb[task].state != OS_TASK_SUSPEND)
    {
        return OS_SUCCESS;
    }

#if DUMP_TASK_FSM != 0
    /* dump the task fsm. */
    OS_ENTER_CRITICAL();
    taskFsmDump(g_taskFsm, task, g_sysTcb[task].state, T_TRIG_WAKEUP, (void *)taskWakeup);
    OS_LEAVE_CRITICAL();
#endif

    switch(g_sysTcb[task].suspendState)
    {
    case OS_TASK_RUNNING:
    case OS_TASK_READY:
        /* change task to ready state and add it to ready task queue. */
        OS_ENTER_CRITICAL();
        g_sysTcb[task].state = OS_TASK_READY;
        q_add(g_readyTaskQueue, (HANDLE)task, g_sysTcb[task].runningPriority);
        OS_LEAVE_CRITICAL();

        /* run another task if nessary. */
        OSScheduler();
        break;

    case OS_TASK_PEND_ON_MSGQ_R:
    case OS_TASK_PEND_ON_MSGQ_S:
    case OS_TASK_PEND_ON_SEMA:
    case OS_TASK_DELAY:
        OS_ENTER_CRITICAL();
        g_sysTcb[task].state = g_sysTcb[task].suspendState;
        OS_LEAVE_CRITICAL();
        break;

    default:
        break;
    }

    return OS_SUCCESS;
}

/******************************************************************************
Function    : STATUS taskSetPriority (HTASK task, U16 priority)
Params      : task     - the task
            : priority - the new priority.
            : 
            : 
Return      : OS_SUCCESS or OS_FAIL
Description : set a task's new priority manually.
******************************************************************************/
STATUS taskSetPriority (HTASK task, U16 priority)
{
    /* params check. */
    if (task >= MAX_SYS_TASK)
    {
        OS_error("taskSetPriority(): task id [%d] out of range!!!\n", task);
        return OS_FAIL;
    }

    if (g_sysTcb[task].state == OS_TASK_FREE)
    {
        OS_error("taskSetPriority(): task [%d] is free!!!\n", task);
        return OS_FAIL;
    }

#if DUMP_TASK_FSM != 0
    /* dump the task fsm. */
    OS_ENTER_CRITICAL();
    taskFsmDump(g_taskFsm, task, g_sysTcb[task].state, T_TRIG_PRIO_CHANGE_MAN, (void *)taskSetPriority);
    OS_LEAVE_CRITICAL();
#endif

    /* change the task's native priority. */
    OS_ENTER_CRITICAL();
    g_sysTcb[task].priority = priority;
    if (g_sysTcb[task].priority < g_sysTcb[task].runningPriority)
    {
        g_sysTcb[task].runningPriority = g_sysTcb[task].priority;
    }

    if (g_sysTcb[task].state == OS_TASK_READY)
    {
        q_del (g_readyTaskQueue, (HANDLE)task);
        q_add (g_readyTaskQueue, (HANDLE)task, g_sysTcb[task].runningPriority);
    }
    OS_LEAVE_CRITICAL();

    /* run another task if nessary. */
    OSScheduler();
    return OS_SUCCESS;
}

/******************************************************************************
Function    : STATUS taskSetPriorityAuto (HTASK task, U16 priority)
Params      : task     - the task
            : priority - the new priority.
            : 
            : 
Return      : OS_SUCCESS or OS_FAIL
Description : set a task's new running priority automatically.
******************************************************************************/
STATUS taskSetPriorityAuto (HTASK task)
{
    return OS_SUCCESS;
}

/******************************************************************************
Function    : STATUS taskLock()
Params      : N/A.
            : 
            : 
            : 
Return      : OS_SUCCESS or OS_FAIL
Description : lock current running task. 
            : 
******************************************************************************/
STATUS taskLock()
{
    if (g_OSRunning != OS_PHASE_SCHEDULING)
    {
        return OS_SUCCESS;
    }

    if ((g_runningTcb->option&OPT_TASK_LOCK) == 0)
    {
        OS_ENTER_CRITICAL();
        g_runningTcb->lockDepth++;
        OS_LEAVE_CRITICAL();
    }

    return OS_SUCCESS;
}

/******************************************************************************
Function    : STATUS taskUnlock()
Params      : 
            : 
            : 
            : 
Return      : OS_SUCCESS or OS_FAIL
Description : unlock current running task.
            : 
******************************************************************************/
STATUS taskUnlock()
{
    if (g_OSRunning != OS_PHASE_SCHEDULING)
    {
        return OS_SUCCESS;
    }

    if ((g_runningTcb->option&OPT_TASK_LOCK) == 0)
    {
        OS_ENTER_CRITICAL();
        g_runningTcb->lockDepth--;
        OS_LEAVE_CRITICAL();

        OSScheduler();
    }

    return OS_SUCCESS;
}

/******************************************************************************
Function    : HTASK taskSelf(void)
Params      : N/A
            : 
            : 
            : 
Return      : the task's self id(HTASK).
Description : This function is called when task want to know its self htask.
            : 
******************************************************************************/
HTASK taskIdSelf()
{
    return g_runningTask;
}

/******************************************************************************
Function    : U16 taskPriorityCurrent(void)
Params      : N/A
            : 
            : 
            : 
Return      : the task's priority.
Description : This function is called when task want to know its self priority.
            : 
******************************************************************************/
U16 taskPrioritySelf()
{
    return g_runningTcb->priority;
}

/******************************************************************************
Function    : U16 taskRunningPrioritySelf(void)
Params      : N/A
            : 
            : 
            : 
Return      : the current task's priority.
Description : This function is called when task want to know its own's running
            :  priority.
******************************************************************************/
U16 taskRunningPrioritySelf()
{
    return g_runningTcb->runningPriority;
}

/******************************************************************************
Function    : U16 taskPriority(void)
Params      : task - the task
            : 
            : 
            : 
Return      : the task's priority.
Description : This function is called when task want to know someone's priority.
            : 
******************************************************************************/
U16 taskPriority(HTASK task)
{
    /* params check. */
    if (task >= MAX_SYS_TASK)
    {
        OS_error("taskPriority(): task id [%d] out of range!!!\n", task);
        return (U16)(-1);
    }

    if (g_sysTcb[task].state == OS_TASK_FREE)
    {
        OS_error("taskPriority(): task [%d] is free!!!\n", task);
        return (U16)(-1);
    }

    return g_sysTcb[task].priority;
}

/******************************************************************************
Function    : U16 taskPriorityCurrent(void)
Params      : N/A
            : 
            : 
            : 
Return      : the task's priority.
Description : This function is called when task want to know someone's running
            : priority.
******************************************************************************/
U16 taskRunningPriority(HTASK task)
{
    /* params check. */
    if (task >= MAX_SYS_TASK)
    {
        OS_error("taskRunningPriority(): task id [%d] out of range!!!\n", task);
        return (U16)(-1);
    }

    if (g_sysTcb[task].state == OS_TASK_FREE)
    {
        OS_error("taskRunningPriority(): task [%d] is free!!!\n", task);
        return (U16)(-1);
    }

    return g_sysTcb[task].runningPriority;
}

/******************************************************************************
Function    : const char * taskName(HTASK task)
Params      : task - the task
            : 
            : 
            : 
Return      : the name buffer of the task.
Description : this function is called when a task wants to know the name of
            : someone task.
******************************************************************************/
const char * taskName(HTASK task)
{
    /* params check. */
    if (task >= MAX_SYS_TASK)
    {
        OS_error("taskName(): task id [%d] out of range!!!\n", task);
        return NULL;
    }

    return &g_sysTcb[task].name[0];
}