cmd.c

ucos2.83在LPC2148上的例子

/****************************************************************************

****************************************************************************/


#define CMD_GLOBALS

#include <includes.h>


#define  APP_TASK_CMD_PRIO            8
#define  APP_TASK_CMD_STK_SIZE      500

OS_STK   AppTaskCMDStk[APP_TASK_CMD_STK_SIZE];




/*
*********************************************************************************************************
*                                                VARIABLES
*********************************************************************************************************
*/
static CMD cmd_cb;

static char *cmd_reqs_name[] =
{
    CMD_REQUEST_STRING
};

/************************************************************************
*Author:
*Name:        CMDTask
*Description:  
*Parameter:
*Return:      
*Note:         
*************************************************************************/

static INT8U CmdTemp2[MaxQueBufSize+1];
static void CMDTask (void *p_arg)
{
	INT8U err;
	CMD_REQUEST request;
    CMD_INPUT input;
    CMD_OUTPUT output;
	
	(void)p_arg;

	CMDInit(&cmd_cb);
	
	
    while (1)
    {
    	
    	LED_Off(0);
      	OSTimeDlyHMSM(0, 0, 1, 0);
      	LED_On(0);
      	OSTimeDlyHMSM(0, 0, 1, 0);
      	
      	/*
        // Retrieve next request for work
		
        OSSemPend( event_cmd, 0, &err );
        
        request = cmd_cb.request;
        input = cmd_cb.in;
        output = cmd_cb.out;

        printf("REQ: %s\n", cmd_reqs_name[request]);

        // Handle request
        switch (request)
        {
        	case CMD_GET_TIME:
        		SendTimeRtc();
				DelayNS(50);
            																break;
        	case CMD_SET_TIME:
        		printf("set time done\n");
             	DelayNS(50);
            																break;
            case CMD_LED_ON:
            	LED_On(0);
            	printf("LED On\n");
            	CmdTemp2[2] = 4;
				PushQue(&ShellQue, CmdTemp2, MaxQueBufSize);
            	DelayNS(50);
           	 																break;
            case CMD_LED_OFF:
            	LED_Off(0);
            	printf("LED Off\n");
            																break;
            default:
            																break;
        }
        // Send Output to DBGmon
        //put_output(&output);
    */
    }
}

/****************************************************************************
*  CMDTaskStart()
* 功能：
* 入口参数：无
* 出口参数：无
****************************************************************************/

CMD_EXT INT8U CMDTaskStart(void)
{
	INT8U      err;
	OSTaskCreateExt(CMDTask,
                    (void *)0,
                    (OS_STK *)&AppTaskCMDStk[APP_TASK_CMD_STK_SIZE - 1],
                    APP_TASK_CMD_PRIO,
                    APP_TASK_CMD_PRIO,
                    (OS_STK *)&AppTaskCMDStk[0],
                    APP_TASK_CMD_STK_SIZE,
                    (void *)0,
                    OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);

#if OS_TASK_NAME_SIZE > 13

    OSTaskNameSet(APP_TASK_CMD_PRIO, (INT8U*)"CMD", &err);  
    
#endif
	return err;

}

/****************************************************************************
*  SetCMD()
* 功能：
* 入口参数：无
* 出口参数：无
****************************************************************************/
void SetCMD(CMD * cmd_cb)
{
/*	
	cmd_cb -> response = response;
	cmd_cb -> request = 
	(cmd_cb ->IN)
	(cmd_cb ->OUT)
	cmd_cb ->base = 
	cmd_cb ->size = 
*/	
}

void CMDCallBack(INT8U * buf, CMD * cmd_cb)
{
	/*	
	cmd_cb -> response = response;
	cmd_cb -> request = 
	(cmd_cb ->IN)
	(cmd_cb ->OUT)
	cmd_cb ->base = 
	cmd_cb ->size = 
*/	
}


/****************************************************************************

****************************************************************************/
/*
static void GetRequest(CMD_REQUEST *request,  CMD_INPUT *input)
{
	INT32U state=0;
	
	CMD_REQUEST save_request;

    if (!request || !input)
    {
        return;
    }
    if (cmd_cb.request == CMD_NONE )
    {
    	memcpy(input, &cmd_cb.in, sizeof(CMD_INPUT));
    }
    
    while (1)
    {
        switch(state)
        {
         case 0:

            // Make sure we say we're ready for a new request
            if (cmd_cb.response != CMD_IDLE && cmd_cb.request == CMD_NONE)
            {
                // Set idle so new requests can appear
                cmd_cb.response = CMD_IDLE;
                printf("now idle...\n");
            }

            if (cmd_cb.response == CMD_IDLE)
            {
                // Set idle so new requests can appear
                printf("wait req...\n");
                state = 1;
            }
            break;

        case 1:
            // Check for request
            if (cmd_cb.response == CMD_IDLE && cmd_cb.request != CMD_NONE)
            {
                printf("req received...%s\n", cmd_reqs_name[cmd_cb.request]);
                save_request = cmd_cb.request;

                if (save_request != CMD_CANCEL)
                {
                    memset(&cmd_cb.out, 0, sizeof(CMD_OUTPUT));
                    cmd_cb.response = CMD_BUSY;
                }
                else
                {
                    cmd_cb.response = CMD_CANCEL_BUSY;
                }
                state = 2;
            }
            break;

        case 2:
            // Check for clearing of request
            if ((cmd_cb.response == CMD_BUSY || cmd_cb.response == CMD_CANCEL_BUSY) && cmd_cb.request == CMD_NONE)
            {
                printf("req cleared...\n");

                *request = save_request;
                memcpy(input, &cmd_cb.in, sizeof(CMD_INPUT));
                return;
            }
            break;
        }
        
        OSTimeDlyHMSM(0, 0, 0, 500);
    }
}
*/
/************************************************************************
*Author:
*Name:        GetCancel
*Description: This function checks for a cancel request.
*Parameter:
*Return:      Returns TRUE if a cancel is received, FALSE otherwise
*Note:        This is required for DBGmon communication.
*************************************************************************/
/*
static INT32U GetCancel(void)
{
    INT32U state=0;
    INT32U result = 0;

    while (state != 2)
    {
        switch(state)
        {
        case 0:
            // We need to also handle the cancel request when we're idle.
            if (cmd_cb.request == CMD_CANCEL)
            {
                cmd_cb.response = CMD_CANCEL_BUSY;
                printf("cancel received...\n");
                state = 1;
            }
            break;
        case 1:
            // Wait for cancel request to be cleared
            if (cmd_cb.response == CMD_CANCEL_BUSY && cmd_cb.request == CMD_NONE)
            {
                state = 2;
            }
            break;
        }
        // Relinquish thread for the rest of the system
        OSTimeDlyHMSM(0, 0, 0, 500);

        // Break if we've received or haven't received the cancel request
        if (state == 2 || state == 0)
        {
            break;
        }
    }

    if (state == 2)
    {
        result = 1;
    }

    return result;
}
*/