case 't':
             OSView_TxStoINT8U(cmd0);
             OSView_CmdGetTaskInfo();
             break;

        case 'l':
             OSView_TxStoINT8U(cmd0);
             OSView_CmdGetTaskList();
             break;

        case 'S':
             OSView_TxStoINT8U(cmd0);
             OSView_CmdTickStep();
             break;

        case 'T':
             OSView_TxStoINT8U(cmd0);
             OSView_CmdTrace();
             break;

        case 'b':
             OSView_TxStoINT8U(cmd0);
             OSView_CmdMemRdINT8U();
             break;

        case 'w':
             OSView_TxStoINT8U(cmd0);
             OSView_CmdMemRdINT16U();
             break;

        case 0:
             OSView_TxStoINT8U(cmd0);
             OSView_CmdMemRdINT32U();
             break;

        case '1':
             OSView_TxStoINT8U(cmd0);
             OSView_CmdMemWrINT8U();
             break;

        case '2':
             OSView_TxStoINT8U(cmd0);
             OSView_CmdMemWrINT16U();
             break;

        case '4':
             OSView_TxStoINT8U(cmd0);
             OSView_CmdMemWrINT32U();
             break;

        default:
             break;
    }
    return (OSView_TxBufCnt);
}

/*$PAGE*/
/*
*********************************************************************************************************
*                                       uC/OS-View COMMAND HANDLER
*                                         (Send to Application)
*
* Description: This routine transfers a character to the application.
*********************************************************************************************************
*/

static  void  OSView_CmdSendToApp (void)
{
    INT8U  rx_data;


    rx_data = OSView_RxGetINT8U();                               /* Read data typed at terminal                */
    if ((void *)OSView_TerminalRxCallbackFnct != (void *)0) {    /* See if callback is defined                 */
        (*OSView_TerminalRxCallbackFnct)(rx_data);               /* Pass character received to application     */
    }
}


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

static  void  OSView_CmdGetSysInfo (void)
{
    INT8U   s[OS_VIEW_CPU_NAME_SIZE+1];
    INT8U   i;
    INT32U  stk_base;
    INT32U  stk_size;
    INT32U  time;


    time = OSTimeGet();                                     /* Send current value of tick counter              */
    OSView_TxStoINT32U(time);
    OSView_TxStoPtr(OSTCBCur);                              /* Current task's OS_TCB                           */
    OSView_TxStoINT16U(OS_VERSION);                         /* Send uC/OS-II's version number                  */
    OSView_TxStoINT8U(1);                                   /* Indicate profiling information will be sent     */

    for (i = 0; i < OS_VIEW_CPU_NAME_SIZE; i++) {           /* Clear buffer to help with debug.                */
        s[i] = 0x00;
    }
    OSView_GetCPUName(s);                                   /* Get Processor Name in string 's'                */
    OSView_TxStoStr(s, OS_VIEW_CPU_NAME_SIZE);

    stk_base = OSView_GetIntStkBase();                      /* Interrupt stack base from port specific file    */
    OSView_TxStoINT32U(stk_base);

    stk_size = OSView_GetIntStkSize();                      /* Interrupt stack size from port specific file    */
    OSView_TxStoINT32U(stk_size);
}

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

static  void  OSView_CmdGetTaskList (void)
{
    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(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((INT8U *)"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)
{
#if OS_TICK_STEP_EN > 0
    INT8U sub_cmd;


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

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

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

/*
*********************************************************************************************************
*                                       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 rx_data)
{
    OSView_RxCtr++;
    switch (OSView_RxState) {
        case OS_VIEW_RX_STATE_SD0:                          /* waiting for start first  start delimiter (SD0)  */
             if (rx_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 (rx_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 ((rx_data == 0x00) | (rx_data > OS_VIEW_RX_BUF_SIZE)) {
                 OSView_RxState  = OS_VIEW_RX_STATE_SD0;    /* Can not handle this size ...                    */
             } else {