os_view.c

keil 下的ucOS移植程序。移植平台AT91SAM7S64.

{
    INT8U   prio;
    OS_TCB *ptcb;


    OSView_TxStoINT8U('t');                                 /* Identifier for data type                        */
    for (prio = 0; prio <= OS_LOWEST_PRIO; prio++) {
        ptcb = OSTCBPrioTbl[prio];
        if (ptcb != (OS_TCB *)0 && ptcb != (OS_TCB *)1) {   /* Does task exist? (Not a Mutex reserved task)    */
            OSView_TxStoINT32U((INT32U)ptcb);               /* Yes, send the task's TCB address                */
        }
    }
}

/*
*********************************************************************************************************
*                                       uC/OS-View COMMAND HANDLER
*                                         (Get Task Information)
*********************************************************************************************************
*/

static  void  OSView_CmdGetTaskInfo (void)
{
    OS_TCB  *ptcb;
    INT32U   cycles;
    INT8U    stat;


    ptcb   = (OS_TCB *)OSView_RxGetINT32U();                         /* Get the desired task's TCB address     */
    cycles = OSView_TimeGetCycles();                                 /* Get timestamp                          */
    OSView_TxStoINT32U(cycles);
    if (ptcb != (OS_TCB *)0 && ptcb != (OS_TCB *)1) {                /* Make sure we have a valid TCB pointer  */
        if (ptcb == OSTCBCur) {
            ptcb->OSTCBCyclesTot  += cycles - ptcb->OSTCBCyclesStart;
            ptcb->OSTCBCyclesStart = cycles;
        }
        OSView_TxStoStr((char *)ptcb->OSTCBTaskName, OS_TASK_NAME_SIZE - 1); /* Task name                              */
        OSView_TxStoINT8U(ptcb->OSTCBPrio);                          /* Prio                                   */
        stat = OSView_CmdGetTaskInfo_TCBStat(ptcb);                  /* Task status                            */
        OSView_TxStoINT8U(stat);
        OSView_TxStoINT32U((INT32U)ptcb->OSTCBEventPtr);             /* Pointer to event task is waiting for.  */
        OSView_TxStoINT32U((INT32U)ptcb->OSTCBDly);                  /* Timeout (i.e. ticks of delayed task)   */
        OSView_TxStoINT32U(ptcb->OSTCBCyclesTot);                    /* ExecTime                               */
        OSView_TxStoINT32U(ptcb->OSTCBCtxSwCtr);                     /* NumActivations                         */

        OSView_TxStoINT32U((INT32U)ptcb->OSTCBStkBase);              /* Stack base address                     */
        OSView_TxStoINT32U(ptcb->OSTCBStkSize * sizeof(OS_STK));     /* Stack size (in #bytes)                 */
        OSView_TxStoINT32U(ptcb->OSTCBStkUsed);                      /* Number of bytes used                   */
        OSView_TxStoINT32U((INT32U)ptcb->OSTCBStkPtr);               /* Current stack pointer address          */
    } else {
        OSView_CmdGetTaskInfo_InvalidTask();
    }
    OSView_TxStoINT16U((INT16U)OSTimeGet());
}

/*$PAGE*/
/*
*********************************************************************************************************
*                                       uC/OS-View COMMAND HANDLER
*                                             (Invalid Task)
*********************************************************************************************************
*/

static  void  OSView_CmdGetTaskInfo_InvalidTask (void)
{
    OSView_TxStoStr("INVALID TASK!", 30);                   /* Task name                                       */
    OSView_TxStoINT8U(0);                                   /* Prio                                            */
    OSView_TxStoINT8U(0);                                   /* Stat                                            */
    OSView_TxStoINT32U(0);                                  /* Data                                            */
    OSView_TxStoINT32U(0);                                  /* Timeout                                         */
    OSView_TxStoINT32U(0);                                  /* StackBase                                       */
    OSView_TxStoINT32U(0);                                  /* StackSize                                       */
    OSView_TxStoINT32U(0);                                  /* #Bytes used on stack                            */
    OSView_TxStoINT32U(0);                                  /* Current SP address                              */
    OSView_TxStoINT32U(0);                                  /* ExecTime                                        */
    OSView_TxStoINT32U(0);                                  /* NumActivations                                  */
}

/*
*********************************************************************************************************
*                                       uC/OS-View COMMAND HANDLER
*                                         (Get ptcb->OSTCBStat)
*********************************************************************************************************
*/

static  INT8U  OSView_CmdGetTaskInfo_TCBStat (OS_TCB *ptcb)
{
    INT8U stat;


    if (ptcb->OSTCBStat != OS_STAT_RDY) {
        stat = ptcb->OSTCBStat;
    } else {
        if (ptcb->OSTCBDly > 0) {                           /* Task status                                     */
            stat = 0xF0;
        } else {
            stat = ptcb->OSTCBStat;
        }
    }
    return (stat);
}

/*$PAGE*/
/*
*********************************************************************************************************
*                                       uC/OS-View COMMAND HANDLER
*                                              (Memory)
*********************************************************************************************************
*/

static  void  OSView_CmdMemRdINT8U (void)
{
    INT32U addr;
    INT8U  nbytes;


    addr   = OSView_RxGetINT32U();
    nbytes = OSView_RxGetINT8U();
    while (nbytes--) {
        OSView_TxStoINT8U(*(INT8U *)addr);
        addr++;
    }
}


static  void  OSView_CmdMemRdINT16U (void)
{
    INT32U addr;
    INT8U  nbytes;


    addr   = OSView_RxGetINT32U();
    nbytes = OSView_RxGetINT8U();
    while (nbytes--) {
        OSView_TxStoINT16U(*(INT16U *)addr);
        addr += 2;
    }
}


static  void  OSView_CmdMemRdINT32U (void)
{
    INT32U addr;
    INT8U  nbytes;


    addr   = OSView_RxGetINT32U();
    nbytes = OSView_RxGetINT8U();
    while (nbytes--) {
        OSView_TxStoINT32U(*(INT32U *)addr);
        addr += 4;
    }
}

/*$PAGE*/
/*
*********************************************************************************************************
*                                       uC/OS-View COMMAND HANDLER
*                                           (Write Functions)
*********************************************************************************************************
*/

static  void  OSView_CmdMemWrINT8U (void)
{
    INT8U *p;


    p    = (INT8U *)OSView_RxGetINT32U();
    (*p) = OSView_RxGetINT8U();
}


static  void  OSView_CmdMemWrINT16U (void)
{
    INT16U *p;


    p    = (INT16U *)OSView_RxGetINT32U();
    (*p) = OSView_RxGetINT16U();
}


static  void  OSView_CmdMemWrINT32U (void)
{
    INT32U *p;


    p    = (INT32U *)OSView_RxGetINT32U();
    (*p) = OSView_RxGetINT32U();
}

/*$PAGE*/
/*
*********************************************************************************************************
*                                       uC/OS-View COMMAND HANDLER
*                                          (Tick Step command)
*********************************************************************************************************
*/

static  void  OSView_CmdTickStep (void)
{
    INT8U sub_cmd;


    sub_cmd = OSView_RxGetINT8U();
    switch (sub_cmd) {
        case 0:                                             /* Enable stepping                                 */
             OSTickStepState = OS_TICK_STEP_DIS;
             break;

        case 1:                                             /* Disable stepping, let tick ISR handle the ticks */
             OSTickStepState = OS_TICK_STEP_WAIT;
             break;

        case 2:                                             /* Simulate the occurrence of one tick             */
             OSTickStepState = OS_TICK_STEP_ONCE;
             break;
    }
}

/*
*********************************************************************************************************
*                                       uC/OS-View COMMAND HANDLER
*                                             (Trace command)
*
* Note(s): Command not currently supported.
*********************************************************************************************************
*/

static  void  OSView_CmdTrace (void)
{
}

/*$PAGE*/
/*
*********************************************************************************************************
*                                              Rx Handler
*
* Description: This routine is called from the Rx interrupt service handler.
*********************************************************************************************************
*/

void  OSView_RxHandler (INT8U data)
{
    INT16U  len;


    switch (OSView_RxState) {
        case OS_VIEW_RX_STATE_SD0:                          /* waiting for start first  start delimiter (SD0)  */
             if (data == OS_VIEW_PROTOCOL_RX_SD0) {
                 OSView_RxState = OS_VIEW_RX_STATE_SD1;
                 OSView_RxBufClr();
             }
             break;

        case OS_VIEW_RX_STATE_SD1:                          /* waiting for start second start delimiter (SD1)  */
             if (data == OS_VIEW_PROTOCOL_RX_SD1) {
                 OSView_RxState = OS_VIEW_RX_STATE_LEN;
             } else {
                 OSView_RxState = OS_VIEW_RX_STATE_SD0;
             }
             break;

        case OS_VIEW_RX_STATE_LEN:                          /* waiting for 'len' byte                          */
             if ((data == 0x00) | (data > OS_VIEW_RX_BUF_SIZE)) {
                 OSView_RxState  = OS_VIEW_RX_STATE_SD0;    /* Can not handle this size ...                    */
             } else {
                 OSView_RxChkSum    = data;
                 OSView_RxRemainLen = data;
                 OSView_RxState     = OS_VIEW_RX_STATE_DATA;
             }
             break;

        case OS_VIEW_RX_STATE_DATA:                         /* waiting for data                                */
             OSView_RxStoINT8U(data);
             OSView_RxChkSum += data;
             if (--OSView_RxRemainLen == 0) {
                 OSView_RxState = OS_VIEW_RX_STATE_CHKSUM;
             }
             break;

        case OS_VIEW_RX_STATE_CHKSUM:                       /* waiting for checksum                            */
             OSView_RxChkSum += data;
             if (OSView_RxChkSum == 0x00) {
                 OSView_RxState = OS_VIEW_RX_STATE_ED;
             } else {
                 OSView_RxState = OS_VIEW_RX_STATE_SD0;
             }
             break;

        case OS_VIEW_RX_STATE_ED:
             if (data == OS_VIEW_PROTOCOL_RX_ED) {          /* End delimiter ?                                 */
                 OSView_RxPktCtr++;
                 len = OSView_CmdParsePkt();                /* Yes, we have a whole packet!                    */
                 if (len > 0) {
                     OSView_TxLen = len;
                     OSView_TxStart();
                 }
             }
             OSView_RxState = OS_VIEW_RX_STATE_SD0;
             break;
    }