core.c

还是arm7操作源码

        /* delete this task from the semaphore's pending task queue. */
        hsema = g_sysTcb[task].hPend;
        q_del(g_semaCB[hsema].pendTaskQ, (HANDLE)task);

        /* change task's state to ready. */
        g_sysTcb[task].hPend = NULL_HANDLE;
        g_sysTcb[task].state = OS_TASK_READY;
        q_add(g_readyTaskQueue, (HANDLE)task, g_sysTcb[task].runningPriority);

        g_sysTcb[task].bWaitTimeout = OS_TRUE;

        OS_LEAVE_CRITICAL();

        /* start the scheduler. */
        OSScheduler();
        break;

    case OS_TASK_SUSPEND:
        /* change task's suspendState to ready. */
        OS_ENTER_CRITICAL();

        g_sysTcb[task].bWaitTimeout = OS_TRUE;

        g_sysTcb[task].suspendState = OS_TASK_READY;
        g_sysTcb[task].hPend = NULL_HANDLE;
        g_sysTcb[task].delayTicks = 0;
        OS_LEAVE_CRITICAL();
        break;

    default:
        OS_error("OnSemTakeDone(): task [%d]'s state is invalid [%d]!!!\n", task, g_sysTcb[task].state);
        break;
    }
}

/******************************************************************************
Function    : void OnmsgQRecvPending(HANDLE handle, void * p)
Params      : handle - the task
            : p[0] - the msg queue which the task will pend on.
            : p[1] - waiting ticks for pending
            : 
            : 
Return      : N/A
Description : the  task tries to receive msg from its msg queue, but the msg
            : queue is empty, so it has to pend.
******************************************************************************/
void OnMsgQRecvPending(HANDLE handle, void * p)
{
    HTASK task;
    U32   delayTicks;

    task = (HTASK)handle;
    delayTicks = ((U32 *)p)[1];

    switch(g_sysTcb[task].state)
    {
    case OS_TASK_RUNNING:
        /* change the task's state to pending on msg queue receive. */
        OS_ENTER_CRITICAL();
        g_sysTcb[task].state = OS_TASK_PEND_ON_MSGQ_R;
        g_sysTcb[task].delayTicks = delayTicks;
        OS_LEAVE_CRITICAL();

        /* start the scheduler. */
        OSScheduler();
        break;

    default:
        OS_error("OnmsgQRecvPending(): task [%d]'s state is invalid [%d]!!!\n", task, g_sysTcb[task].state);
        break;
    }
}

/******************************************************************************
Function    : void OnMsgQRecvDone(HANDLE handle, void * p)
Params      : handle - the task.
            : p      - not used.
            : 
            : 
Return      : N/A
Description : the  task tries to receive msg from its msg queue and gets msg
            : successfully.
******************************************************************************/
void OnMsgQRecvDone(HANDLE handle, void * p)
{
    HTASK task;

    (void)p;
    task = (HTASK)handle;

    switch(g_sysTcb[task].state)
    {
    case OS_TASK_PEND_ON_MSGQ_R:
        /* change the task's state to ready. */
        OS_ENTER_CRITICAL();
        g_sysTcb[task].hPend = NULL_HANDLE;
        g_sysTcb[task].state = OS_TASK_READY;
        g_sysTcb[task].delayTicks = 0;

        g_sysTcb[task].bWaitTimeout = OS_FALSE;

        q_add(g_readyTaskQueue, (HANDLE)task, g_sysTcb[task].runningPriority);
        OS_LEAVE_CRITICAL();

        /* start the scheduler. */
        OSScheduler();
        break;

    case OS_TASK_SUSPEND:
        /* change the task's suspendState to ready. */
        OS_ENTER_CRITICAL();
        g_sysTcb[task].hPend = NULL_HANDLE;
        g_sysTcb[task].suspendState = OS_TASK_READY;
        g_sysTcb[task].delayTicks = 0;

        g_sysTcb[task].bWaitTimeout = OS_FALSE;
        OS_LEAVE_CRITICAL();
        break;

    default:
        OS_error("OnmsgQRecvDone(): task [%d]'s state is invalid [%d]!!!\n", task, g_sysTcb[task].state);
        break;
    }
}

/******************************************************************************
Function    : void OnMsgQRecvTimeout(HANDLE handle, void * p)
Params      : handle - the task which receiving msg from its msg queue.
            : p      - not used.
            : 
            : 
Return      : N/A
Description : a task tries to receive msg from its msg queue, but timeout.
            : 
******************************************************************************/
void OnMsgQRecvTimeout(HANDLE handle, void * p)
{
    HTASK task;

    (void)p;
    task = (HTASK)handle;

    switch(g_sysTcb[task].state)
    {
    case OS_TASK_PEND_ON_MSGQ_R:
        OS_ENTER_CRITICAL();

        /* change the task's state to ready. */
        g_sysTcb[task].hPend = NULL_HANDLE;
        g_sysTcb[task].state = OS_TASK_READY;
        q_add(g_readyTaskQueue, (HANDLE)task, g_sysTcb[task].runningPriority);

        g_sysTcb[task].bWaitTimeout = OS_TRUE;

        OS_LEAVE_CRITICAL();

        /* start the scheduler. */
        OSScheduler();
        break;

    default:
        OS_error("OnmsgQRecvTimeout(): task [%d]'s state is invalid [%d]!!!\n", task, g_sysTcb[task].state);
        break;
    }
}

/******************************************************************************
Function    : void OnMsgQSendPending(HANDLE handle, void * p)
Params      : handle - the task which sending message.
            : p[0] - the msg queue which the task will pend on.
            : p[1] - waiting ticks for pending
            : 
            : 
Return      : N/A
Description : sending msg to a task, but the dest task's msg queue is full, so
            : the sender has to enter pending state.
******************************************************************************/
void OnMsgQSendPending(HANDLE handle, void * p)
{
    HTASK task;
    HMSGQ hmsgQ;
    U32   delayTicks;

    task = (HTASK)handle;
    hmsgQ = ((U32*)p)[0];
    delayTicks = ((U32 *)p)[1];

    switch(g_sysTcb[task].state)
    {
    case OS_TASK_RUNNING:
        /* change the task's state to pending on msg queue send. */
        OS_ENTER_CRITICAL();
        g_sysTcb[task].state = OS_TASK_PEND_ON_MSGQ_S;
        g_sysTcb[task].hPend = (HANDLE)hmsgQ;
        g_sysTcb[task].delayTicks = delayTicks;
        OS_LEAVE_CRITICAL();

        /* start the scheduler. */
        OSScheduler();
        break;

    default:
        OS_error("OnmsgQSendPending(): task [%d]'s state is invalid [%d]!!!\n", task, g_sysTcb[task].state);
        break;
    }
}
/******************************************************************************
Function    : void OnMsgQSendDone(HANDLE handle, void * p)
Params      : handle - the task which send message.
            : p      - not used.
            : 
            : 
Return      : N/A
Description : sending message successfully.
            : 
******************************************************************************/
void OnMsgQSendDone(HANDLE handle, void * p)
{
    HTASK task;

    (void)p;
    task = (HTASK)handle;

    switch(g_sysTcb[task].state)
    {
    case OS_TASK_PEND_ON_MSGQ_S:
        /* change the task's state to ready. */
        OS_ENTER_CRITICAL();
        g_sysTcb[task].hPend = NULL_HANDLE;
        g_sysTcb[task].state = OS_TASK_READY;
        g_sysTcb[task].delayTicks = 0;

        q_add(g_readyTaskQueue, (HANDLE)task, g_sysTcb[task].runningPriority);
        OS_LEAVE_CRITICAL();

        /* start the scheduler. */
        OSScheduler();
        break;

    case OS_TASK_SUSPEND:
        /* change the task's state to ready. */
        OS_ENTER_CRITICAL();
        g_sysTcb[task].hPend = NULL_HANDLE;
        g_sysTcb[task].suspendState = OS_TASK_READY;
        g_sysTcb[task].delayTicks = 0;
        OS_LEAVE_CRITICAL();
        break;

    default:
        OS_error("OnmsgQSendDone(): task [%d]'s state is invalid [%d]!!!\n", task, g_sysTcb[task].state);
        break;
    }
}
/******************************************************************************
Function    : void OnMsgQSendTimeout(HANDLE handle, void * p)
Params      : handle - the task which sending message.
            : p      - not used.
            : 
            : 
Return      : N/A
Description : sending message to a task timeout.
            : 
******************************************************************************/
void OnMsgQSendTimeout(HANDLE handle, void * p)
{
    HTASK task;
    HMSGQ hmsgq;

    (void)p;
    task = (HTASK)handle;

    switch(g_sysTcb[task].state)
    {
    case OS_TASK_PEND_ON_MSGQ_S:
        OS_ENTER_CRITICAL();

        /* delete this task from the dest msg queue's pending task queue. */
        hmsgq = g_sysTcb[task].hPend;
        q_del(g_msgQCB[hmsgq].pendTaskQ, (HANDLE)task);

        /* change the task's state to ready. */
        g_sysTcb[task].hPend = NULL_HANDLE;
        g_sysTcb[task].state = OS_TASK_READY;
        OS_LEAVE_CRITICAL();

        /* start the scheduler. */
        OSScheduler();
        break;

    default:
        OS_error("OnMsgQSendTimeout(): task [%d]'s state is invalid [%d]!!!\n", task, g_sysTcb[task].state);
        break;
    }
}

/******************************************************************************
Function    : void OnTaskDelay (HANDLE handle, void * p)
Params      : handle - the task
            : p      - the delay ticks.
            : 
            : 
Return      : N/A
Description : delay some ticks, or add the task to ready task queue directly if
            : the delay ticks is zero.
******************************************************************************/
void OnTaskDelay (HANDLE handle, void * p)
{
    HTASK task;
    U32 delayTicks;

    task = (HTASK)handle;
    delayTicks = (U32)p;

    switch(g_sysTcb[task].state)
    {
    case OS_TASK_RUNNING:
        if (delayTicks == 0)
        {
            /* add to ready task queue again. */
            OS_ENTER_CRITICAL();
            g_sysTcb[task].state = OS_TASK_READY;
            q_add(g_readyTaskQueue, (HANDLE)task, g_sysTcb[task].runningPriority);
            OS_LEAVE_CRITICAL();
        }
        else
        {
            /* change to delay state. */
            OS_ENTER_CRITICAL();
            g_sysTcb[task].state = OS_TASK_DELAY;
            g_sysTcb[task].delayTicks = delayTicks;
            OS_LEAVE_CRITICAL();
        }
        OSScheduler();
        break;
    default:
        OS_error("OnTaskDelay(): task [%s]'s state is invalid [%d]!!!\n", task, g_sysTcb[task].state);
        break;
    }
}

/******************************************************************************
Function    : void OnTaskDelayTimeout (HANDLE handle, void * p)
Params      : handle - the task
            : p      - not used.
            : 
            : 
Return      : N/A
Description : taskDelay() timeout.
            : 
******************************************************************************/
void OnTaskDelayTimeout (HANDLE handle, void * p)
{
    HTASK task;

    task = (HTASK)handle;

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

        OSScheduler();
        break;

    default:
        OS_error("OnTaskDelay(): task [%s]'s state is invalid [%d]!!!\n", task, g_sysTcb[task].state);
        break;
    }
}