scmain.c

psoc_usb的代码,用来小卡测试的.没事下下来

//-----------------------------------------------------------------------------
// File Name:		scmain program
// Description:		use ezusb to test smallcard
//
// Copyright:		Inventec Electronics(Tianjin) Co., Ltd.
// $Archive:        scmain.c
// $Date:           2007-12-06
// $Revision:       1.00
//
//-----------------------------------------------------------------------------
// Copyright 2006, [e-mail]
//-----------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include "scmain.h"
#include "cmdlist.h"
#include "serial.h"
#include "boards.h"

//------------------------------------------------------------------------------
//function prototype
//------------------------------------------------------------------------------
int do_handshake(void);
int do_select(void);
char *get_current_cmd(char * buff);
char *lookup_return_str(int ret_cmd);
int lookup_return_val(struct command_param *pm, char *cmd_str);
int (*lookup_command_func(struct command_name *pcmd,char *cmd_str))();

//------------------------------------------------------------------------------
//global variable
//------------------------------------------------------------------------------
//function pointer for blinking function
int (*fp_blinking)(unsigned char) = (int(*)(unsigned char))NULL;
//function pointer for select card entry
int (*fp_card_selected)(char*) = (int(*)(char *))NULL;


//------------------------------------------------------------------------------
//extern funtion prototype
//------------------------------------------------------------------------------
extern int do_show_help();

//------------------------------------------------------------------------------
//command function param
//------------------------------------------------------------------------------
const struct command_name xdata cmd_main[] = {
	{"HANDSHAKE", do_handshake},
	{"SELECT",    do_select},
	{0, 0}
};

const struct command_param xdata return_param[] = {
	{"ERROR :", RET_ERROR}, 
	{"OK :",    RET_OK}, 
	{"DONE :",  RET_DONE}, 
	{"PASS :",  RET_PASS}, 
	{"FAIL :",  RET_FAIL}, 
	{"ON :",    RET_ON}, 
	{"OFF :",   RET_OFF}, 
	{0, 0}
};

//------------------------------------------------------------------------------
//extern variable & function
//------------------------------------------------------------------------------
extern BYTE xdata g_in_buffer[];
extern WORD xdata g_in_buffer_len;
extern struct command_list *g_cmdlist;
extern struct command_list *g_retlist;

extern struct command_list *add_to_cmdlist(char * cmd);
extern void free_cmdlist();
extern struct command_list *add_to_retlist(char * cmd);
extern void free_retlist();


//--------------------------------------------------------------------------------
//strcmp function for no case
//--------------------------------------------------------------------------------
char mydef_toupper(char c)
{
    if (c>='a' && c<='z') {
        return(c&0xDF);
    }
    
    return c;
}

//--------------------------------------------------------------------------------
//strcmp function for no case
//--------------------------------------------------------------------------------
int mydef_strcasecmp(char *dst, char *src)
{
    char f,l;

    do {
        f = mydef_toupper(*(dst++));
        l = mydef_toupper(*(src++));
        //f = *(dst++);
        //l = *(src++);
        //f = mydef_toupper(f);
        //l = mydef_toupper(l);
    } while ( f && l && (f == l));
    
    return (f-l);    
}

//--------------------------------------------------------------------------------
//receive shakehands command,just return ok. 
//--------------------------------------------------------------------------------
int do_handshake()
{
    //PDEBUG("do_handshake:\r\n");
    return RET_OK;
}

//--------------------------------------------------------------------------------
//receive select card command 
//--------------------------------------------------------------------------------
int do_select()
{
    char cmd[MAX_CMD_LENGTH];
    int ret=0;
    
    //PDEBUG("do_select:\r\n");
    memset (cmd, '\0', sizeof (cmd));
    if (get_current_cmd(cmd)!=NULL){
        fp_card_selected = lookup_command_func(cmd_card_entry,cmd);
        if (fp_card_selected != NULL) {
            //so card select command
            ret = (*fp_card_selected)("SELECT");
            return(ret);            
        }
    }
    
    //clear select card
    fp_card_selected = (int(*)(char *))NULL;
    return RET_ERROR;
}

//--------------------------------------------------------------------------------
//lookup command
//--------------------------------------------------------------------------------
int (*lookup_command_func(struct command_name *pcmd,char *cmd_str))()
{
	struct command_name *bp;
	
	for (bp = pcmd; bp->command != NULL; bp++){
		if (mydef_strcasecmp(bp->command, cmd_str) == 0){
			return (bp->fn);
			//return(bp->fn());
		}
	}
	return ((int (*)()) NULL);
	//return (-1);
}

//--------------------------------------------------------------------------------
//lookup param
//--------------------------------------------------------------------------------
char *lookup_return_str(int ret_cmd)
{
	struct command_param  *rp;

	for (rp = return_param; rp->name; rp++){
		if (rp->val==ret_cmd){
			return (rp->name);
		}
    }
    
	return NULL;
}

/*
//--------------------------------------------------------------------------------
//lookup card name param
//--------------------------------------------------------------------------------
int lookup_return_val(struct command_param *pm, char *cmd_str)
{
	struct command_param  *rp;

	for (rp = pm; rp->name; rp++) {
		if (mydef_strcasecmp(rp->name, cmd_str) == 0) {
			return (rp->val);
		}
	}
	
	return (0);
}
*/

//--------------------------------------------------------------------------------
//return current command & move to next
//--------------------------------------------------------------------------------
char *get_current_cmd(char *buff)
{
    struct command_list *plist;
            
    if (g_cmdlist!=NULL){
        add_to_retlist(g_cmdlist->message);
        strcpy(buff,g_cmdlist->message);
        plist = g_cmdlist;
        g_cmdlist = g_cmdlist->next;
        free(plist);      
        return buff;
    }
    
    return(NULL);
}


//--------------------------------------------------------------------------------
//parse command come form serial input
//--------------------------------------------------------------------------------
int command_parse(char *command_str)
{
    char *cmd;
    int i,len;
    
    len = strlen(command_str);
    i=0;
    while(i<len){
        while ((command_str[i]==' ' || command_str[i]==0x0d || command_str[i]==0x0a) && i<len){
            i++;
        }
            
        cmd = &command_str[i];
        while (command_str[i]!=' ' && command_str[i]!=0x0d && command_str[i]!=0x0a && i<len){
            i++;
        }
        
        command_str[i]='\0';
        if (strlen(cmd)){
            add_to_cmdlist(cmd);
            command_str[i]=' ';
        }
    }

    return 0;
}


//--------------------------------------------------------------------------------
//exec command come form serial input
//--------------------------------------------------------------------------------
char *command_exec()
{
    char *ret_ptr = NULL;    //return message pointer;
    char cmd[MAX_CMD_LENGTH];
    int  (*cmd_func)();
    int  ret = RET_ERROR;
    
    memset(cmd, '\0', sizeof (cmd));
    if (get_current_cmd(cmd)!=NULL){
        cmd_func = lookup_command_func(cmd_main,cmd);
        if (cmd_func != NULL) {
            ret = (*cmd_func)();
            return(lookup_return_str(ret));
        }else{
            //do some card select
            if (fp_card_selected != NULL) {
                ret = (*fp_card_selected)(cmd);
            }
            return(lookup_return_str(ret));
        }
    }
    
    return NULL;
}

//--------------------------------------------------------------------------------
//process led blinking 
//--------------------------------------------------------------------------------
void sc_process_blinking()
{
    static unsigned char xdata blinkonoff;
    
    blinkonoff = !blinkonoff;
    if (fp_blinking != NULL) {
        (*fp_blinking)(blinkonoff);
    }
    
    return;
}                
     

//=============================================================================-
//main function
//=============================================================================-
int sc_main(char *cmd_buff,int size)
{
    struct command_list *plist;
    char *cmd_ret;
    
    if (size > BUFF_LENGTH) {
        size=BUFF_LENGTH-1;
    }
    if (size > 0) {
        cmd_buff[size] = '\0';   
    }
        
    //PDEBUG("command recieve: %s\r\n", cmd_buff);
    command_parse(cmd_buff);
    if (g_cmdlist != NULL) {
        //clear blinking
        fp_blinking=(int(*)(unsigned char))NULL;
        cmd_ret=command_exec();
    }
    //free command list 
    free_cmdlist();
    //PDEBUG("command return: %s\r\n", cmd_ret);
            
    //process return string
    if (cmd_ret != NULL){
        strcpy(g_in_buffer,cmd_ret);
        
        plist = g_retlist;
        while(plist != NULL && strlen(g_in_buffer) < BUFF_LENGTH-2){
            strcat(g_in_buffer,plist->message);
            strcat(g_in_buffer," ");
            plist = plist->next;
        }
        free_retlist();
        strcat(g_in_buffer,"\r\n");
    }            
    
    return strlen(g_in_buffer);
}